intent_engine/setup/

claude_code.rs

//! Claude Code setup module

use super::common::*;
use super::{ConnectivityResult, SetupModule, SetupOptions, SetupResult, SetupScope};
use crate::error::{IntentError, Result};
use serde_json::json;
use std::env;
use std::fs;
use std::path::{Path, PathBuf};

pub struct ClaudeCodeSetup;

impl ClaudeCodeSetup {
    /// Get the user-level .claude directory
    fn get_user_claude_dir() -> Result<PathBuf> {
        let home = get_home_dir()?;
        Ok(home.join(".claude"))
    }

    /// Get the project-level .claude directory
    fn get_project_claude_dir() -> Result<PathBuf> {
        let current_dir = env::current_dir().map_err(IntentError::IoError)?;
        Ok(current_dir.join(".claude"))
    }

    /// Create Claude Code settings JSON configuration
    ///
    /// Generates the hooks configuration for SessionStart event.
    /// This configuration is shared between user-level and project-level setups.
    ///
    /// # Arguments
    /// * `hook_path` - Absolute path to the SessionStart hook script
    fn create_claude_settings(hook_path: &Path) -> serde_json::Value {
        json!({
            "hooks": {
                "SessionStart": [{
                    "hooks": [{
                        "type": "command",
                        "command": hook_path.to_string_lossy()
                    }]
                }]
            }
        })
    }

    /// Common setup logic for hooks and settings
    ///
    /// Sets up the session-start hook script and settings.json in the given Claude directory.
    /// This function is shared between user-level and project-level setup.
    ///
    /// # Arguments
    /// * `claude_dir` - The .claude directory (user-level or project-level)
    /// * `opts` - Setup options (includes force flag)
    /// * `files_modified` - Mutable vector to track modified files
    fn setup_hooks_and_settings(
        claude_dir: &Path,
        opts: &SetupOptions,
        files_modified: &mut Vec<PathBuf>,
    ) -> Result<()> {
        let hooks_dir = claude_dir.join("hooks");
        let hook_script = hooks_dir.join("session-start.sh");

        // Create hooks directory
        fs::create_dir_all(&hooks_dir).map_err(IntentError::IoError)?;
        println!("✓ Created {}", hooks_dir.display());

        // Check if hook script already exists
        if hook_script.exists() && !opts.force {
            return Err(IntentError::InvalidInput(format!(
                "Hook script already exists: {}. Use --force to overwrite",
                hook_script.display()
            )));
        }

        // Install session-start hook script
        let hook_content = include_str!("../../templates/session-start.sh");
        fs::write(&hook_script, hook_content).map_err(IntentError::IoError)?;
        set_executable(&hook_script)?;
        files_modified.push(hook_script.clone());
        println!("✓ Installed {}", hook_script.display());

        // Setup settings.json with absolute paths
        let settings_file = claude_dir.join("settings.json");
        let hook_abs_path = resolve_absolute_path(&hook_script)?;

        // Check if settings file already exists
        if settings_file.exists() && !opts.force {
            return Err(IntentError::InvalidInput(format!(
                "Settings file already exists: {}. Use --force to overwrite",
                settings_file.display()
            )));
        }

        let settings = Self::create_claude_settings(&hook_abs_path);

        write_json_config(&settings_file, &settings)?;
        files_modified.push(settings_file.clone());
        println!("✓ Created {}", settings_file.display());

        Ok(())
    }

    /// Setup for user-level installation
    fn setup_user_level(&self, opts: &SetupOptions) -> Result<SetupResult> {
        let mut files_modified = Vec::new();

        println!("📦 Setting up user-level Claude Code integration...\n");

        // Setup hooks and settings in user-level .claude directory
        let claude_dir = Self::get_user_claude_dir()?;
        Self::setup_hooks_and_settings(&claude_dir, opts, &mut files_modified)?;

        // Setup MCP configuration
        let mcp_result = self.setup_mcp_config(opts, &mut files_modified)?;

        Ok(SetupResult {
            success: true,
            message: "User-level Claude Code setup complete!".to_string(),
            files_modified,
            connectivity_test: Some(mcp_result),
        })
    }

    /// Setup MCP server configuration
    fn setup_mcp_config(
        &self,
        opts: &SetupOptions,
        files_modified: &mut Vec<PathBuf>,
    ) -> Result<ConnectivityResult> {
        let config_path = if let Some(ref path) = opts.config_path {
            path.clone()
        } else {
            let home = get_home_dir()?;
            home.join(".claude.json")
        };

        // Find binary
        let binary_path = find_ie_binary()?;
        println!("✓ Found binary: {}", binary_path.display());

        // Read or create config
        let mut config = read_json_config(&config_path)?;

        // Check if already configured
        if let Some(mcp_servers) = config.get("mcpServers") {
            if mcp_servers.get("intent-engine").is_some() && !opts.force {
                return Ok(ConnectivityResult {
                    passed: false,
                    details: "intent-engine already configured in MCP config".to_string(),
                });
            }
        }

        // Add intent-engine configuration
        if config.get("mcpServers").is_none() {
            config["mcpServers"] = json!({});
        }

        config["mcpServers"]["intent-engine"] = json!({
            "command": binary_path.to_string_lossy(),
            "args": ["mcp-server"],
            "description": "Strategic intent and task workflow management"
        });

        write_json_config(&config_path, &config)?;
        files_modified.push(config_path.clone());
        println!("✓ Updated {}", config_path.display());

        Ok(ConnectivityResult {
            passed: true,
            details: format!("MCP configured at {}", config_path.display()),
        })
    }

    /// Setup for project-level installation
    fn setup_project_level(&self, opts: &SetupOptions) -> Result<SetupResult> {
        println!("📦 Setting up project-level Claude Code integration...\n");
        println!("⚠️  Note: Project-level setup is for advanced users.");
        println!("    MCP config will still be in ~/.claude.json (user-level)\n");

        let mut files_modified = Vec::new();

        // Setup hooks and settings in project-level .claude directory
        let claude_dir = Self::get_project_claude_dir()?;
        Self::setup_hooks_and_settings(&claude_dir, opts, &mut files_modified)?;

        // MCP config still goes to user-level
        let mcp_result = self.setup_mcp_config(opts, &mut files_modified)?;

        Ok(SetupResult {
            success: true,
            message: "Project-level setup complete!".to_string(),
            files_modified,
            connectivity_test: Some(mcp_result),
        })
    }
}

impl SetupModule for ClaudeCodeSetup {
    fn name(&self) -> &str {
        "claude-code"
    }

    fn setup(&self, opts: &SetupOptions) -> Result<SetupResult> {
        match opts.scope {
            SetupScope::User => self.setup_user_level(opts),
            SetupScope::Project => self.setup_project_level(opts),
            SetupScope::Both => {
                // First user-level, then project-level
                let user_result = self.setup_user_level(opts)?;
                let project_result = self.setup_project_level(opts)?;

                // Combine results
                let mut files = user_result.files_modified;
                files.extend(project_result.files_modified);

                Ok(SetupResult {
                    success: true,
                    message: "User and project setup complete!".to_string(),
                    files_modified: files,
                    connectivity_test: user_result.connectivity_test,
                })
            },
        }
    }

    fn test_connectivity(&self) -> Result<ConnectivityResult> {
        // Test 1: Can we execute session-restore?
        println!("Testing session-restore command...");
        let output = std::process::Command::new("ie")
            .args(["session-restore", "--workspace", "."])
            .output();

        match output {
            Ok(result) => {
                if result.status.success() {
                    Ok(ConnectivityResult {
                        passed: true,
                        details: "session-restore command executed successfully".to_string(),
                    })
                } else {
                    let stderr = String::from_utf8_lossy(&result.stderr);
                    Ok(ConnectivityResult {
                        passed: false,
                        details: format!("session-restore failed: {}", stderr),
                    })
                }
            },
            Err(e) => Ok(ConnectivityResult {
                passed: false,
                details: format!("Failed to execute session-restore: {}", e),
            }),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::path::PathBuf;
    use tempfile::TempDir;

    // ========== create_claude_settings tests ==========

    #[test]
    fn test_create_claude_settings_structure() {
        let hook_path = PathBuf::from("/tmp/session-start.sh");

        let settings = ClaudeCodeSetup::create_claude_settings(&hook_path);

        // Verify hooks key exists
        assert!(settings.get("hooks").is_some());

        // Verify SessionStart hook
        let hooks = &settings["hooks"];
        assert!(hooks.get("SessionStart").is_some());
        let session_start = &hooks["SessionStart"];
        assert!(session_start.is_array());
        assert_eq!(session_start.as_array().unwrap().len(), 1);
    }

    #[test]
    fn test_create_claude_settings_session_start_hook() {
        let hook_path = PathBuf::from("/home/user/.claude/hooks/session-start.sh");

        let settings = ClaudeCodeSetup::create_claude_settings(&hook_path);

        let session_start = &settings["hooks"]["SessionStart"][0];
        assert!(session_start.get("hooks").is_some());

        let hooks_array = session_start["hooks"].as_array().unwrap();
        assert_eq!(hooks_array.len(), 1);

        let hook = &hooks_array[0];
        assert_eq!(hook["type"], "command");
        assert_eq!(hook["command"], "/home/user/.claude/hooks/session-start.sh");
    }

    // ========== Directory path tests ==========

    #[test]
    fn test_get_user_claude_dir() {
        // This test depends on HOME environment variable
        let result = ClaudeCodeSetup::get_user_claude_dir();
        assert!(result.is_ok());

        let dir = result.unwrap();
        assert!(dir.ends_with(".claude"));
    }

    #[test]
    fn test_get_project_claude_dir() {
        let result = ClaudeCodeSetup::get_project_claude_dir();
        assert!(result.is_ok());

        let dir = result.unwrap();
        assert!(dir.ends_with(".claude"));
    }

    #[test]
    fn test_claude_code_setup_name() {
        let setup = ClaudeCodeSetup;
        assert_eq!(setup.name(), "claude-code");
    }

    // ========== JSON structure validation tests ==========

    #[test]
    fn test_create_claude_settings_paths_preserved() {
        // Test with special characters in path
        let hook_path = PathBuf::from("/home/user name/with spaces/.claude/hooks/session-start.sh");

        let settings = ClaudeCodeSetup::create_claude_settings(&hook_path);

        // Paths should be preserved as strings
        let session_start_cmd = settings["hooks"]["SessionStart"][0]["hooks"][0]["command"]
            .as_str()
            .unwrap();
        assert!(session_start_cmd.contains("with spaces"));
    }

    // ========== File system tests with tempdir ==========

    #[test]
    fn test_setup_hooks_and_settings_creates_directories() {
        let temp_dir = TempDir::new().unwrap();
        let claude_dir = temp_dir.path().join(".claude");

        let opts = SetupOptions {
            force: false,
            scope: SetupScope::User,
            config_path: None,
        };
        let mut files_modified = Vec::new();

        let result =
            ClaudeCodeSetup::setup_hooks_and_settings(&claude_dir, &opts, &mut files_modified);

        assert!(result.is_ok());

        // Verify directories created
        assert!(claude_dir.join("hooks").exists());

        // Verify hook script created and executable
        let hook_script = claude_dir.join("hooks/session-start.sh");
        assert!(hook_script.exists());

        // Verify settings.json created
        let settings_file = claude_dir.join("settings.json");
        assert!(settings_file.exists());

        // Verify files tracked
        assert_eq!(files_modified.len(), 2);
    }

    #[test]
    fn test_setup_hooks_and_settings_force_overwrites() {
        let temp_dir = TempDir::new().unwrap();
        let claude_dir = temp_dir.path().join(".claude");

        // First setup without force
        let opts = SetupOptions {
            force: false,
            scope: SetupScope::User,
            config_path: None,
        };
        let mut files_modified = Vec::new();
        ClaudeCodeSetup::setup_hooks_and_settings(&claude_dir, &opts, &mut files_modified).unwrap();

        // Second setup without force should fail
        let result =
            ClaudeCodeSetup::setup_hooks_and_settings(&claude_dir, &opts, &mut files_modified);
        assert!(result.is_err());

        // Third setup with force should succeed
        let opts_force = SetupOptions {
            force: true,
            scope: SetupScope::User,
            config_path: None,
        };
        let mut files_modified2 = Vec::new();
        let result = ClaudeCodeSetup::setup_hooks_and_settings(
            &claude_dir,
            &opts_force,
            &mut files_modified2,
        );
        assert!(result.is_ok());
    }

    #[test]
    fn test_setup_hooks_and_settings_hook_content() {
        let temp_dir = TempDir::new().unwrap();
        let claude_dir = temp_dir.path().join(".claude");

        let opts = SetupOptions {
            force: false,
            scope: SetupScope::User,
            config_path: None,
        };
        let mut files_modified = Vec::new();

        ClaudeCodeSetup::setup_hooks_and_settings(&claude_dir, &opts, &mut files_modified).unwrap();

        // Read and verify hook script content
        let hook_script = claude_dir.join("hooks/session-start.sh");
        let content = std::fs::read_to_string(&hook_script).unwrap();

        // Should contain shebang and ie command
        assert!(content.contains("#!/"));
        assert!(content.contains("ie ") || content.contains("session-restore"));
    }

    #[test]
    fn test_setup_hooks_and_settings_json_valid() {
        let temp_dir = TempDir::new().unwrap();
        let claude_dir = temp_dir.path().join(".claude");

        let opts = SetupOptions {
            force: false,
            scope: SetupScope::User,
            config_path: None,
        };
        let mut files_modified = Vec::new();

        ClaudeCodeSetup::setup_hooks_and_settings(&claude_dir, &opts, &mut files_modified).unwrap();

        // Read and parse settings.json
        let settings_file = claude_dir.join("settings.json");
        let content = std::fs::read_to_string(&settings_file).unwrap();
        let settings: serde_json::Value = serde_json::from_str(&content).unwrap();

        // Verify structure
        assert!(settings.get("hooks").is_some());
        assert!(settings["hooks"].get("SessionStart").is_some());
    }

    #[test]
    fn test_setup_mcp_config_creates_new_file() {
        let temp_dir = TempDir::new().unwrap();
        let config_path = temp_dir.path().join(".claude.json");

        let opts = SetupOptions {
            force: false,
            scope: SetupScope::User,
            config_path: Some(config_path.clone()),
        };
        let mut files_modified = Vec::new();

        let setup = ClaudeCodeSetup;
        let result = setup.setup_mcp_config(&opts, &mut files_modified);

        assert!(result.is_ok());
        assert!(config_path.exists());

        // Verify content
        let content = std::fs::read_to_string(&config_path).unwrap();
        let config: serde_json::Value = serde_json::from_str(&content).unwrap();
        assert!(config["mcpServers"]["intent-engine"].is_object());
    }

    #[test]
    fn test_setup_mcp_config_preserves_existing() {
        let temp_dir = TempDir::new().unwrap();
        let config_path = temp_dir.path().join(".claude.json");

        // Create existing config with other servers
        let existing_config = json!({
            "mcpServers": {
                "other-server": {
                    "command": "other-cmd"
                }
            }
        });
        std::fs::write(
            &config_path,
            serde_json::to_string_pretty(&existing_config).unwrap(),
        )
        .unwrap();

        let opts = SetupOptions {
            force: true,
            scope: SetupScope::User,
            config_path: Some(config_path.clone()),
        };
        let mut files_modified = Vec::new();

        let setup = ClaudeCodeSetup;
        setup.setup_mcp_config(&opts, &mut files_modified).unwrap();

        // Verify both servers exist
        let content = std::fs::read_to_string(&config_path).unwrap();
        let config: serde_json::Value = serde_json::from_str(&content).unwrap();
        assert!(config["mcpServers"]["other-server"].is_object());
        assert!(config["mcpServers"]["intent-engine"].is_object());
    }

    #[test]
    fn test_setup_mcp_config_no_force_skips_existing() {
        let temp_dir = TempDir::new().unwrap();
        let config_path = temp_dir.path().join(".claude.json");

        // Create existing config with intent-engine
        let existing_config = json!({
            "mcpServers": {
                "intent-engine": {
                    "command": "old-cmd"
                }
            }
        });
        std::fs::write(
            &config_path,
            serde_json::to_string_pretty(&existing_config).unwrap(),
        )
        .unwrap();

        let opts = SetupOptions {
            force: false,
            scope: SetupScope::User,
            config_path: Some(config_path.clone()),
        };
        let mut files_modified = Vec::new();

        let setup = ClaudeCodeSetup;
        let result = setup.setup_mcp_config(&opts, &mut files_modified).unwrap();

        // Should return false (already configured)
        assert!(!result.passed);
        assert!(result.details.contains("already configured"));
    }
}