pprog 0.0.1

An LLM pair programming server with web interface
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

mod inference;
mod chat;
mod tree;
mod tooler;
mod config;
mod server;

use std::fs::OpenOptions;
use std::io::Write;

use clap::{CommandFactory, Parser, Subcommand};
use config::ProjectConfig;
use env_logger::{Builder, Target};
use tree::GitTree;

#[derive(Parser)]
#[command(author, version, about, long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Option<Commands>,
}

#[derive(Subcommand)]
enum Commands {
    #[command(about = "Initialize config for project")]
    Init,
    #[command(about = "Start the API server")]
    Serve {
        #[arg(short, long, default_value = "127.0.0.1")]
        host: String,
        #[arg(short, long, default_value_t = 8080)]
        port: u16,
    },
}

fn setup_logger() -> Result<(), anyhow::Error> {
    let home_dir = dirs::home_dir().expect("Failed to get home directory");
    let pprog_dir = home_dir.join(".pprog");
    if !pprog_dir.exists() {
        std::fs::create_dir_all(&pprog_dir).expect("Failed to create .pprog directory");
    }
    let log_file_path = pprog_dir.join("log");

    let file = OpenOptions::new()
        .create(true)
        .write(true)
        .truncate(true)
        .open(&log_file_path)?;

    let mut builder = Builder::from_default_env();
    builder
        .target(Target::Pipe(Box::new(file)))
        .format_timestamp_secs()
        .filter_level(log::LevelFilter::Info)
        .init();

    Ok(())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let cli = Cli::parse();
    setup_logger()?;

    match &cli.command {
        Some(Commands::Init) => {
            if let Err(e) = ProjectConfig::init() {
                eprintln!("Failed to initialize project: {}", e);
            } else {
                let git_root = match GitTree::get_git_root() {
                    Ok(p) => p,
                    Err(e) => {
                        eprintln!("Git root not found: {}.  Please setup git before initializing.", e);
                        std::process::exit(1);
                    }
                };

                let gitignore_path = git_root.join(".gitignore");
                let mut gitignore_contents = String::new();

                if gitignore_path.exists() {
                    gitignore_contents = std::fs::read_to_string(&gitignore_path).unwrap();
                }

                if !gitignore_contents.contains("pprog.toml") {
                    println!("Adding config to .gitignore.");
                    let mut gitignore = std::fs::OpenOptions::new()
                        .write(true)
                        .append(true)
                        .create(true)
                        .open(gitignore_path)
                        .unwrap();

                    writeln!(gitignore, r#"
# pprog config
pprog.toml
"#)?;
                }

                println!("Init successful.");
            }
        }
        Some(Commands::Serve { host, port }) => {
            server::start_server(host.clone(), *port).await?;
        }
        None => {
            let mut cmd = Cli::command();
            cmd.print_help()?;
        }
    }

    Ok(())
}