mur_core/model/

cli_provider.rs

//! CLI Provider — use authenticated CLI tools (claude, gemini, auggie) as AI backends.
//!
//! Spawns CLI tools in print mode (`-p`) and reads stdout, avoiding the need for API keys.

use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use std::path::{Path, PathBuf};
use std::time::Duration;
use tokio::process::Command;

/// Configuration for a single CLI provider.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CliProviderConfig {
    /// Display name (e.g., "claude-cli").
    pub name: String,
    /// Path to the binary.
    pub binary: String,
    /// Arguments before the prompt (e.g., ["-p"]).
    #[serde(default)]
    pub args: Vec<String>,
    /// Timeout in seconds (default: 120).
    #[serde(default = "default_timeout")]
    pub timeout_secs: u64,
}

fn default_timeout() -> u64 {
    120
}

/// A CLI-based AI provider that spawns external tools.
#[derive(Debug, Clone)]
pub struct CliProvider {
    pub config: CliProviderConfig,
}

impl CliProvider {
    /// Create a new CLI provider from config.
    pub fn new(config: CliProviderConfig) -> Self {
        Self { config }
    }

    /// Create from individual fields.
    pub fn from_parts(name: &str, binary: &str, args: Vec<&str>) -> Self {
        Self {
            config: CliProviderConfig {
                name: name.to_string(),
                binary: binary.to_string(),
                args: args.into_iter().map(|s| s.to_string()).collect(),
                timeout_secs: default_timeout(),
            },
        }
    }

    /// Check if the binary exists and is accessible.
    pub fn is_available(&self) -> bool {
        Path::new(&self.config.binary).exists()
    }

    /// Call the CLI tool with a prompt and return the response.
    pub async fn call(&self, prompt: &str) -> Result<String> {
        if !self.is_available() {
            anyhow::bail!(
                "CLI provider '{}' binary not found at: {}",
                self.config.name,
                self.config.binary
            );
        }

        let mut cmd = Command::new(&self.config.binary);
        for arg in &self.config.args {
            cmd.arg(arg);
        }
        cmd.arg(prompt);

        // Suppress stderr noise, capture stdout
        cmd.stderr(std::process::Stdio::piped());
        cmd.stdout(std::process::Stdio::piped());

        let timeout = Duration::from_secs(self.config.timeout_secs);

        let output = tokio::time::timeout(timeout, cmd.output())
            .await
            .context(format!(
                "CLI provider '{}' timed out after {}s",
                self.config.name, self.config.timeout_secs
            ))?
            .context(format!(
                "Failed to execute CLI provider '{}'",
                self.config.name
            ))?;

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr);
            anyhow::bail!(
                "CLI provider '{}' exited with {}: {}",
                self.config.name,
                output.status,
                stderr.trim()
            );
        }

        let stdout = String::from_utf8(output.stdout)
            .context("CLI provider output is not valid UTF-8")?;

        Ok(stdout.trim().to_string())
    }

    /// Detect all known CLI tools on the system.
    pub fn detect_all() -> Vec<CliProvider> {
        let home = dirs::home_dir().unwrap_or_default();
        let npm_global = home.join(".npm-global/bin");

        let known_tools: Vec<(&str, Vec<PathBuf>, Vec<&str>)> = vec![
            (
                "claude-cli",
                vec![
                    npm_global.join("claude"),
                    PathBuf::from("/usr/local/bin/claude"),
                    PathBuf::from("/opt/homebrew/bin/claude"),
                ],
                vec!["-p"],
            ),
            (
                "gemini-cli",
                vec![
                    npm_global.join("gemini"),
                    PathBuf::from("/usr/local/bin/gemini"),
                    PathBuf::from("/opt/homebrew/bin/gemini"),
                ],
                vec!["-p"],
            ),
            (
                "auggie-cli",
                vec![
                    npm_global.join("auggie"),
                    PathBuf::from("/usr/local/bin/auggie"),
                ],
                vec![],
            ),
        ];

        let mut providers = Vec::new();
        for (name, paths, args) in known_tools {
            for path in paths {
                if path.exists() {
                    providers.push(CliProvider::from_parts(
                        name,
                        path.to_str().unwrap_or_default(),
                        args.clone(),
                    ));
                    break; // Use first found path
                }
            }
        }

        providers
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_cli_provider_config_deserialize() {
        let toml = r#"
            name = "claude-cli"
            binary = "/usr/local/bin/claude"
            args = ["-p"]
            timeout_secs = 60
        "#;
        let config: CliProviderConfig = toml::from_str(toml).unwrap();
        assert_eq!(config.name, "claude-cli");
        assert_eq!(config.binary, "/usr/local/bin/claude");
        assert_eq!(config.args, vec!["-p"]);
        assert_eq!(config.timeout_secs, 60);
    }

    #[test]
    fn test_cli_provider_config_defaults() {
        let toml = r#"
            name = "test"
            binary = "/bin/echo"
        "#;
        let config: CliProviderConfig = toml::from_str(toml).unwrap();
        assert!(config.args.is_empty());
        assert_eq!(config.timeout_secs, 120);
    }

    #[test]
    fn test_is_available_with_echo() {
        let provider = CliProvider::from_parts("test", "/bin/echo", vec![]);
        assert!(provider.is_available());
    }

    #[test]
    fn test_is_available_missing() {
        let provider = CliProvider::from_parts("test", "/nonexistent/binary", vec![]);
        assert!(!provider.is_available());
    }

    #[tokio::test]
    async fn test_call_echo() {
        let provider = CliProvider::from_parts("echo", "/bin/echo", vec![]);
        let result = provider.call("hello world").await.unwrap();
        assert_eq!(result, "hello world");
    }

    #[tokio::test]
    async fn test_call_missing_binary() {
        let provider = CliProvider::from_parts("test", "/nonexistent/binary", vec![]);
        assert!(provider.call("test").await.is_err());
    }

    #[test]
    fn test_detect_all_runs() {
        // Just verify it doesn't panic
        let providers = CliProvider::detect_all();
        // On CI this might find nothing, on dev machines it might find tools
        for p in &providers {
            assert!(!p.config.name.is_empty());
            assert!(p.is_available());
        }
    }
}