komando 0.1.0

A command line utility to better organize and keep track of your commands.
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

// use std::process::Command;
use std::env;
use std::path::Path;
use std::fs;
use std::path::PathBuf;
use std::io::{self, Write};

const SHELL_FUNCTION: &str = r#"
komando() {
    history > /tmp/last_commands.txt
    RUST_PROGRAM="./target/debug/komando_exec"
    if [ -x "$RUST_PROGRAM" ]; then
        OUTPUT=$("$RUST_PROGRAM" "$@" 2>&1 1>/dev/tty)
        
        if [ -z "$OUTPUT" ]; then
            return
        fi

        # Check if the output contains a semicolon
        if ! echo "$OUTPUT" | grep -q ";"; then
            echo "$OUTPUT"
            return
        fi

        IFS=';' read -r DIR CMD <<< "$OUTPUT"
        echo ""
        echo "=========== Edit the command and then hit 'Enter' ==========="
        echo "Directory: $DIR"
        echo "Command:"
        
        read -e -i "$CMD" COMMAND
        echo ""
        
        if [ -n "$COMMAND" ]; then
            echo "Executing '$COMMAND'..."
            cd "$DIR" && eval "$COMMAND"
        fi
    else
        echo "Error: Komando executable not found"
    fi
}
"#;

fn setup_shell_integration() -> std::io::Result<()> {
    // Detect shell type
    let shell = env::var("SHELL").unwrap_or_else(|_| String::from("/bin/bash"));
    let rc_file = if shell.contains("zsh") {
        PathBuf::from(env::var("HOME").map_err(|e| io::Error::new(io::ErrorKind::Other, e))?).join(".zshrc")
    } else {
        PathBuf::from(env::var("HOME").map_err(|e| io::Error::new(io::ErrorKind::Other, e))?).join(".bashrc")
    };

    // Check if integration is already set up
    if let Ok(content) = fs::read_to_string(&rc_file) {
        println!("cargo:warning=Checking for komando() in {}", rc_file.display());
        if content.contains("komando()") {
            println!("cargo:warning=Content: {}", content);
            println!("cargo:warning=Shell integration already set up");
            return Ok(());
        }
    }

    // Add shell function to rc file
    let mut file = fs::OpenOptions::new()
        .append(true)
        .open(rc_file)?;
    writeln!(file, "\n# Komando shell integration")?;
    writeln!(file, "{}", SHELL_FUNCTION)?;
    println!("cargo:warning=Shell integration installed. Please restart your shell or run 'source ~/.bashrc' (or ~/.zshrc)");

    Ok(())
}

fn main() {
    println!("cargo:rerun-if-changed=build.rs");
    
    // Run pre-install setup
    if env::var("CARGO_CFG_TARGET_OS").unwrap() == "linux" {
        // Create necessary directories
        let home_dir = env::var("HOME").unwrap();
        let config_dir = Path::new(&home_dir).join(".config").join("komando");
        
        std::fs::create_dir_all(&config_dir).unwrap_or_else(|err| {
            println!("cargo:warning=Failed to create config directory: {}", err);
        });
    }

    setup_shell_integration().unwrap_or_else(|err| {
        println!("cargo:warning=Failed to set up shell integration: {}", err);
    });
    
    println!("cargo:warning=Pre-install setup completed");
}