wrote the tool to use rhai scripts as commands, and wrote a basic cli as

an example.

src/funcs.rs

@@ -0,0 +1,85 @@
+use crate::*;
+use std::error::Error;
+use std::io::Write;
+use std::thread;
+
+pub fn get_user_input(prompt: &str) -> Result<String, Box<dyn Error>> {
+    println!("{}", prompt);
+    let mut response = String::new();
+    std::io::stdin().read_line(&mut response)?;
+    return Ok(response.trim().to_string());
+}
+
+pub fn cli(mut state: AppState, main_rx: Receiver<ToolMessage>) {
+    println!("Starting tetanus CLI...");
+    let (input_tx, input_rx) = channel::<String>();
+    thread::spawn(move || {
+        let stdin = io::stdin();
+        let mut input_buffer = String::new();
+        loop {
+            input_buffer.clear();
+            if stdin.read_line(&mut input_buffer).is_ok() {
+                let trimmed = input_buffer.trim().to_string();
+                if !trimmed.is_empty() {
+                    if input_tx.send(trimmed).is_err() {
+                        break;
+                    }
+                }
+            }
+        }
+    });
+    print!("tetanus> ");
+    let _ = io::stdout().flush();
+    loop {
+        while let Ok(msg) = main_rx.try_recv() {
+            match msg {
+                ToolMessage::Output(txt) => {
+                    println!("\n[result] {}", txt);
+                    state.log.push(txt.clone());
+                    state.output.push(txt.clone());
+                }
+                _ => {}
+            }
+        }
+        while let Ok(user_input) = input_rx.try_recv() {
+            state.curent_intput = user_input.clone();
+            state.history.push(user_input.clone());
+            match user_input.as_str() {
+                "exit" | "quit" => {
+                    println!("shutting down...");
+                    return;
+                }
+                "reload-modules" => {
+                    println!("reloadling modules...");
+                    state.initialize_modules();
+                }
+                "help" => {
+                    println!("\nAvailable Built-In & Custom Script Modules:");
+                    for (name, cmd) in &state.module_loader.commands {
+                        println!("  - {:<15} (Outputs: {})", name, cmd.output_type);
+                        if !cmd.help.is_empty() {
+                            println!("    Help: {}", cmd.help.trim());
+                        }
+                    }
+                    println!();
+                }
+                // Everything else gets dynamically routed to your Rhai engine execution matrix!
+                command_name => {
+                    if state.module_loader.commands.contains_key(command_name) {
+                        println!(
+                            "[Worker] Dispatching script '{}' to Rayon engine layer...",
+                            command_name
+                        );
+                        if let Err(e) = state.execute_command(command_name, None) {
+                            eprintln!("[Error] Failed running script: {}", e);
+                        }
+                    } else {
+                        println!("[Error] Command '{}' unrecognized.", command_name);
+                    }
+                }
+            }
+            print!("tetanus> ");
+            let _ = io::stdout().flush();
+        }
+    }
+}