pmsh 0.0.1

A custom shell written in Rust
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

mod builtins;
mod colors;
mod executor;
mod functions;
mod history;
mod parser;
mod path_utils;
mod ui;
mod variables;

use history::HistoryManager;
use repl::{LineEditor, ReadlineEvent, RealExecutor};
use rustyline::error::ReadlineError;
use rustyline::{history::DefaultHistory, Editor};
mod autocomplete;
mod completion_registry;
mod repl;

use autocomplete::PmshHelper;
use functions::Functions;

fn main() {
    // Initialize history manager
    let history_mgr = HistoryManager::new().unwrap_or_else(|e| {
        eprintln!("Warning: Could not initialize history: {}", e);
        HistoryManager::default()
    });

    // Load existing history
    let mut command_history = history_mgr.load().unwrap_or_default();

    let args: Vec<String> = std::env::args().collect();

    if args.len() > 1 {
        // Script execution mode
        let script_path = &args[1];
        let contents = std::fs::read_to_string(script_path).unwrap_or_else(|e| {
            eprintln!("Error reading script {}: {}", script_path, e);
            std::process::exit(1);
        });

        // Dummy editor for script execution (no history needed)
        struct ScriptEditor;
        impl LineEditor for ScriptEditor {
            fn readline(&mut self, _prompt: &str) -> ReadlineEvent {
                ReadlineEvent::Eof
            }
            fn add_history_entry(&mut self, _entry: &str) {}
        }

        let _editor = ScriptEditor;
        let mut oldpwd: Option<String> = None;
        let executor = RealExecutor {};
        let mut vars = variables::Variables::new();
        let mut functions = Functions::new();

        use crate::parser::Command;
        match Command::parse_script(&contents) {
            Ok(pipelines) => {
                for pipeline in pipelines {
                    if !repl::execute_pipeline_struct(
                        &pipeline,
                        &history_mgr,
                        &mut command_history,
                        &executor,
                        &mut oldpwd,
                        &mut vars,
                        &mut functions,
                    ) {
                        break;
                    }
                }
            }
            Err(e) => {
                eprintln!("Error parsing script: {}", e);
                std::process::exit(1);
            }
        }
    } else {
        // Interactive REPL mode
        let mut oldpwd: Option<String> = None;
        let executor = RealExecutor {};
        let mut vars = variables::Variables::new();
        let mut functions = Functions::new();

        // Try to source ~/.pmshrc if it exists
        if let Ok(home) = std::env::var("HOME") {
            let mut home_dir = std::path::PathBuf::from(home);
            home_dir.push(".pmshrc");
            if home_dir.exists() {
                if let Ok(contents) = std::fs::read_to_string(&home_dir) {
                    use crate::parser::Command;
                    if let Ok(pipelines) = Command::parse_script(&contents) {
                        for pipeline in pipelines {
                            repl::execute_pipeline_struct(
                                &pipeline,
                                &history_mgr,
                                &mut command_history,
                                &executor,
                                &mut oldpwd,
                                &mut vars,
                                &mut functions,
                            );
                        }
                    } else {
                        eprintln!("pmsh: error parsing ~/.pmshrc");
                    }
                }
            }
        }

        // This gets us the line editor with history
        let config = rustyline::Config::builder()
            .completion_type(rustyline::CompletionType::List)
            .build();
        let mut rl: Editor<PmshHelper, DefaultHistory> =
            Editor::with_config(config).expect("Failed to create editor");
        rl.set_helper(Some(PmshHelper::new()));

        // Load history into rustyline
        for entry in &command_history {
            let _ = rl.add_history_entry(entry.as_str());
        }

        // Wrap the rustyline editor as a LineEditor implementation
        struct RustyEditor {
            inner: Editor<PmshHelper, DefaultHistory>,
        }
        impl LineEditor for RustyEditor {
            fn readline(&mut self, prompt: &str) -> ReadlineEvent {
                match self.inner.readline(prompt) {
                    Ok(line) => ReadlineEvent::Line(line),
                    Err(ReadlineError::Interrupted) => ReadlineEvent::Interrupted,
                    Err(ReadlineError::Eof) => ReadlineEvent::Eof,
                    Err(_e) => ReadlineEvent::Other,
                }
            }

            fn add_history_entry(&mut self, entry: &str) {
                let _ = self.inner.add_history_entry(entry);
            }
        }

        let mut editor = RustyEditor { inner: rl };

        // Run the refactored REPL loop
        repl::run_repl_with_state(
            &mut editor,
            &history_mgr,
            &mut command_history,
            &executor,
            oldpwd,
            vars,
            functions,
        );
    }
}