feat(windows): fix interface issues and command execution (#136)

* feat(windows): refactor command execute

* feat(windows): update tool manager to support windows

* fix(windows): fix prompt input issues

* fix: clippy issues

* fix(windows): fix non-exe mcp spawning

* test(windows): add command parsing tests

* fix(windows): fixes for clippy and tests

* fix(windows): fix transport test

* fix(windows): clippy fixes

Author: cwoolum

crates/chat-cli/src/cli/chat/hooks.rs

@@ -295,13 +295,24 @@ impl HookExecutor {
     async fn execute_inline_hook(&self, hook: &Hook) -> Result<String> {
         let command = hook.command.as_ref().ok_or_else(|| eyre!("no command specified"))?;
 
+        #[cfg(unix)]
         let command_future = tokio::process::Command::new("bash")
             .arg("-c")
             .arg(command)
             .stdin(Stdio::piped())
             .stdout(Stdio::piped())
             .stderr(Stdio::piped())
             .output();
+
+        #[cfg(windows)]
+        let command_future = tokio::process::Command::new("cmd")
+            .arg("/C")
+            .arg(command)
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .output();
+
         let timeout = Duration::from_millis(hook.timeout_ms);
 
         // Run with timeout
@@ -544,14 +555,47 @@ mod tests {
     #[tokio::test]
     async fn test_max_output_size() {
         let mut executor = HookExecutor::new();
-        let mut hook = Hook::new_inline_hook(
-            HookTrigger::PerPrompt,
-            "for i in {1..1000}; do echo $i; done".to_string(),
-        );
+
+        // Use different commands based on OS
+        #[cfg(unix)]
+        let command = "for i in {1..1000}; do echo $i; done";
+
+        #[cfg(windows)]
+        let command = "for /L %i in (1,1,1000) do @echo %i";
+
+        let mut hook = Hook::new_inline_hook(HookTrigger::PerPrompt, command.to_string());
         hook.max_output_size = 100;
 
         let results = executor.run_hooks(vec![&hook], None::<&mut Stdout>).await;
 
         assert!(results[0].1.len() <= hook.max_output_size + " ... truncated".len());
     }
+
+    #[tokio::test]
+    async fn test_os_specific_command_execution() {
+        let mut executor = HookExecutor::new();
+
+        // Create a simple command that outputs the shell name
+        #[cfg(unix)]
+        let command = "echo $SHELL";
+
+        #[cfg(windows)]
+        let command = "echo %ComSpec%";
+
+        let hook = Hook::new_inline_hook(HookTrigger::PerPrompt, command.to_string());
+
+        let results = executor.run_hooks(vec![&hook], None::<&mut Stdout>).await;
+
+        assert_eq!(results.len(), 1, "Command execution should succeed");
+
+        // Verify output contains expected shell information
+        #[cfg(unix)]
+        assert!(results[0].1.contains("/"), "Unix shell path should contain '/'");
+
+        #[cfg(windows)]
+        assert!(
+            results[0].1.to_lowercase().contains("cmd.exe") || results[0].1.to_lowercase().contains("command.com"),
+            "Windows shell path should contain cmd.exe or command.com"
+        );
+    }
 }

crates/chat-cli/src/cli/chat/mod.rs

@@ -8,6 +8,7 @@ mod message;
 mod parse;
 mod parser;
 mod prompt;
+mod prompt_parser;
 mod server_messenger;
 #[cfg(unix)]
 mod skim_integration;
@@ -1378,7 +1379,7 @@ impl ChatContext {
     /// Read input from the user.
     async fn prompt_user(
         &mut self,
-        database: &Database,
+        #[cfg_attr(windows, allow(unused_variables))] database: &Database,
         mut tool_uses: Option<Vec<QueuedTool>>,
         pending_tool_index: Option<usize>,
         skip_printing_tools: bool,
@@ -1532,8 +1533,36 @@ impl ChatContext {
             },
             Command::Execute { command } => {
                 queue!(self.output, style::Print('\n'))?;
-                std::process::Command::new("bash").args(["-c", &command]).status().ok();
-                queue!(self.output, style::Print('\n'))?;
+
+                // Use platform-appropriate shell
+                let result = if cfg!(target_os = "windows") {
+                    std::process::Command::new("cmd").args(["/C", &command]).status()
+                } else {
+                    std::process::Command::new("bash").args(["-c", &command]).status()
+                };
+
+                // Handle the result and provide appropriate feedback
+                match result {
+                    Ok(status) => {
+                        if !status.success() {
+                            queue!(
+                                self.output,
+                                style::SetForegroundColor(Color::Yellow),
+                                style::Print(format!("Command exited with status: {}\n", status)),
+                                style::SetForegroundColor(Color::Reset)
+                            )?;
+                        }
+                    },
+                    Err(e) => {
+                        queue!(
+                            self.output,
+                            style::SetForegroundColor(Color::Red),
+                            style::Print(format!("Failed to execute command: {}\n", e)),
+                            style::SetForegroundColor(Color::Reset)
+                        )?;
+                    },
+                }
+
                 ChatState::PromptUser {
                     tool_uses: None,
                     pending_tool_index: None,

crates/chat-cli/src/cli/chat/prompt.rs

@@ -1,6 +1,5 @@
 use std::borrow::Cow;
 
-use crossterm::style::Stylize;
 use eyre::Result;
 use rustyline::completion::{
     Completer,
@@ -35,6 +34,8 @@ use rustyline::{
 };
 use winnow::stream::AsChar;
 
+pub use super::prompt_parser::generate_prompt;
+use super::prompt_parser::parse_prompt_components;
 use crate::database::Database;
 use crate::database::settings::Setting;
 
@@ -81,16 +82,6 @@ pub const COMMANDS: &[&str] = &[
     "/load",
 ];
 
-pub fn generate_prompt(current_profile: Option<&str>, warning: bool) -> String {
-    let warning_symbol = if warning { "!".red().to_string() } else { "".to_string() };
-    let profile_part = current_profile
-        .filter(|&p| p != "default")
-        .map(|p| format!("[{p}] ").cyan().to_string())
-        .unwrap_or_default();
-
-    format!("{profile_part}{warning_symbol}{}", "> ".magenta())
-}
-
 /// Complete commands that start with a slash
 fn complete_command(word: &str, start: usize) -> (usize, Vec<String>) {
     (
@@ -265,6 +256,34 @@ impl Highlighter for ChatHelper {
     fn highlight_char(&self, _line: &str, _pos: usize, _kind: CmdKind) -> bool {
         false
     }
+
+    fn highlight_prompt<'b, 's: 'b, 'p: 'b>(&'s self, prompt: &'p str, _default: bool) -> Cow<'b, str> {
+        use crossterm::style::Stylize;
+
+        // Parse the plain text prompt to extract profile and warning information
+        // and apply colors using crossterm's ANSI escape codes
+        if let Some(components) = parse_prompt_components(prompt) {
+            let mut result = String::new();
+
+            // Add profile part if present
+            if let Some(profile) = components.profile {
+                result.push_str(&format!("[{}] ", profile).cyan().to_string());
+            }
+
+            // Add warning symbol if present
+            if components.warning {
+                result.push_str(&"!".red().to_string());
+            }
+
+            // Add the prompt symbol
+            result.push_str(&"> ".magenta().to_string());
+
+            Cow::Owned(result)
+        } else {
+            // If we can't parse the prompt, return it as-is
+            Cow::Borrowed(prompt)
+        }
+    }
 }
 
 pub fn rl(
@@ -306,28 +325,10 @@ pub fn rl(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-
-    #[test]
-    fn test_generate_prompt() {
-        // Test default prompt (no profile)
-        assert_eq!(generate_prompt(None, false), "> ".magenta().to_string());
-        // Test default prompt with warning
-        assert_eq!(generate_prompt(None, true), format!("{}{}", "!".red(), "> ".magenta()));
-        // Test default profile (should be same as no profile)
-        assert_eq!(generate_prompt(Some("default"), false), "> ".magenta().to_string());
-        // Test custom profile
-        assert_eq!(
-            generate_prompt(Some("test-profile"), false),
-            format!("{}{}", "[test-profile] ".cyan(), "> ".magenta())
-        );
-        // Test another custom profile with warning
-        assert_eq!(
-            generate_prompt(Some("dev"), true),
-            format!("{}{}{}", "[dev] ".cyan(), "!".red(), "> ".magenta())
-        );
-    }
+    use crossterm::style::Stylize;
+    use rustyline::highlight::Highlighter;
 
+    use super::*;
     #[test]
     fn test_chat_completer_command_completion() {
         let (prompt_request_sender, _) = std::sync::mpsc::channel::<Option<String>>();
@@ -368,4 +369,87 @@ mod tests {
         // Verify no completions are returned for regular text
         assert!(completions.is_empty());
     }
+
+    #[test]
+    fn test_highlight_prompt_basic() {
+        let (prompt_request_sender, _) = std::sync::mpsc::channel::<Option<String>>();
+        let (_, prompt_response_receiver) = std::sync::mpsc::channel::<Vec<String>>();
+        let helper = ChatHelper {
+            completer: ChatCompleter::new(prompt_request_sender, prompt_response_receiver),
+            hinter: (),
+            validator: MultiLineValidator,
+        };
+
+        // Test basic prompt highlighting
+        let highlighted = helper.highlight_prompt("> ", true);
+
+        assert_eq!(highlighted, "> ".magenta().to_string());
+    }
+
+    #[test]
+    fn test_highlight_prompt_with_warning() {
+        let (prompt_request_sender, _) = std::sync::mpsc::channel::<Option<String>>();
+        let (_, prompt_response_receiver) = std::sync::mpsc::channel::<Vec<String>>();
+        let helper = ChatHelper {
+            completer: ChatCompleter::new(prompt_request_sender, prompt_response_receiver),
+            hinter: (),
+            validator: MultiLineValidator,
+        };
+
+        // Test warning prompt highlighting
+        let highlighted = helper.highlight_prompt("!> ", true);
+
+        assert_eq!(highlighted, format!("{}{}", "!".red(), "> ".magenta()));
+    }
+
+    #[test]
+    fn test_highlight_prompt_with_profile() {
+        let (prompt_request_sender, _) = std::sync::mpsc::channel::<Option<String>>();
+        let (_, prompt_response_receiver) = std::sync::mpsc::channel::<Vec<String>>();
+        let helper = ChatHelper {
+            completer: ChatCompleter::new(prompt_request_sender, prompt_response_receiver),
+            hinter: (),
+            validator: MultiLineValidator,
+        };
+
+        // Test profile prompt highlighting
+        let highlighted = helper.highlight_prompt("[test-profile] > ", true);
+
+        assert_eq!(highlighted, format!("{}{}", "[test-profile] ".cyan(), "> ".magenta()));
+    }
+
+    #[test]
+    fn test_highlight_prompt_with_profile_and_warning() {
+        let (prompt_request_sender, _) = std::sync::mpsc::channel::<Option<String>>();
+        let (_, prompt_response_receiver) = std::sync::mpsc::channel::<Vec<String>>();
+        let helper = ChatHelper {
+            completer: ChatCompleter::new(prompt_request_sender, prompt_response_receiver),
+            hinter: (),
+            validator: MultiLineValidator,
+        };
+
+        // Test profile + warning prompt highlighting
+        let highlighted = helper.highlight_prompt("[dev] !> ", true);
+        // Should have cyan profile + red warning + cyan bold prompt
+        assert_eq!(
+            highlighted,
+            format!("{}{}{}", "[dev] ".cyan(), "!".red(), "> ".magenta())
+        );
+    }
+
+    #[test]
+    fn test_highlight_prompt_invalid_format() {
+        let (prompt_request_sender, _) = std::sync::mpsc::channel::<Option<String>>();
+        let (_, prompt_response_receiver) = std::sync::mpsc::channel::<Vec<String>>();
+        let helper = ChatHelper {
+            completer: ChatCompleter::new(prompt_request_sender, prompt_response_receiver),
+            hinter: (),
+            validator: MultiLineValidator,
+        };
+
+        // Test invalid prompt format (should return as-is)
+        let invalid_prompt = "invalid prompt format";
+        let highlighted = helper.highlight_prompt(invalid_prompt, true);
+        assert_eq!(highlighted, invalid_prompt);
+    }
 }