loom_core/agent/

mod.rs

pub mod claude_code;

use std::path::Path;

use anyhow::Result;

use crate::config::Config;
use crate::manifest::WorkspaceManifest;

/// A file to be written into the workspace by an agent generator.
#[derive(Debug)]
pub struct GeneratedFile {
    /// Path relative to the workspace root.
    pub relative_path: String,
    /// File content.
    pub content: String,
}

/// A per-repo config entry that matched a manifest repo during agent file generation.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MatchedRepoConfig {
    pub repo: String,
    pub workflow: crate::config::Workflow,
}

impl std::fmt::Display for MatchedRepoConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "Matched config for '{}' (workflow: {})",
            self.repo, self.workflow
        )
    }
}

/// Trait for generating agent configuration files in a workspace.
pub trait AgentGenerator {
    /// Human-readable name for this generator (e.g., "claude-code").
    fn name(&self) -> &str;

    /// Generate files for the given workspace.
    fn generate(&self, manifest: &WorkspaceManifest, config: &Config)
    -> Result<Vec<GeneratedFile>>;
}

/// Run all enabled agent generators and write their files into the workspace.
///
/// Called after workspace composition changes (new, add, remove, partial down).
pub fn generate_agent_files(
    config: &Config,
    ws_path: &Path,
    manifest: &WorkspaceManifest,
) -> Result<Vec<MatchedRepoConfig>> {
    // Validate preset exists (stale preset check)
    if let Some(ref preset_name) = manifest.preset {
        crate::config::validate_preset_exists(&config.agents.claude_code.presets, preset_name)?;
    }

    // Collect applied repo configs and debug-log non-matches
    let mut applied = Vec::new();
    for repo in &manifest.repos {
        if let Some(repo_config) = config.repos.get(&repo.name) {
            applied.push(MatchedRepoConfig {
                repo: repo.name.clone(),
                workflow: repo_config.workflow,
            });
        }
    }
    for repo_key in config.repos.keys() {
        if !manifest.repos.iter().any(|r| r.name == *repo_key) {
            tracing::debug!(
                repo = %repo_key,
                "config entry does not match any workspace repo, skipping"
            );
        }
    }

    for agent_name in &config.agents.enabled {
        let generator: Box<dyn AgentGenerator> = match agent_name.as_str() {
            "claude-code" => Box::new(claude_code::ClaudeCodeGenerator),
            other => {
                tracing::warn!(agent = other, "unknown agent, skipping");
                continue;
            }
        };

        // Clean up legacy and conditional files before regeneration
        if agent_name == "claude-code" {
            let legacy = ws_path.join(".claude/settings.local.json");
            if legacy.exists() {
                std::fs::remove_file(&legacy)?;
            }
            // Remove stale .mcp.json if MCP servers were removed from config
            let mcp_json = ws_path.join(".mcp.json");
            if mcp_json.exists() {
                std::fs::remove_file(&mcp_json)?;
            }
        }

        let files = generator.generate(manifest, config)?;
        for file in &files {
            // Guard against path traversal and absolute paths in relative_path
            crate::config::validate_no_path_traversal(
                &file.relative_path,
                &format!("agent '{agent_name}' relative path"),
            )?;
            let full_path = ws_path.join(&file.relative_path);
            if let Some(parent) = full_path.parent() {
                std::fs::create_dir_all(parent)?;
            }
            std::fs::write(&full_path, &file.content)?;
        }
    }

    Ok(applied)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::config::{
        AgentsConfig, DefaultsConfig, RegistryConfig, RepoConfig, UpdateConfig, Workflow,
        WorkspaceConfig,
    };
    use crate::manifest::RepoManifestEntry;
    use std::collections::BTreeMap;
    use std::path::PathBuf;

    #[test]
    fn test_generate_agent_files_writes_files() {
        let dir = tempfile::tempdir().unwrap();
        let ws_path = dir.path().join("my-ws");
        std::fs::create_dir_all(&ws_path).unwrap();

        let config = Config {
            registry: RegistryConfig {
                scan_roots: vec![],
                scan_depth: 2,
            },
            workspace: WorkspaceConfig {
                root: dir.path().to_path_buf(),
            },
            sync: None,
            terminal: None,
            editor: None,
            defaults: DefaultsConfig::default(),
            groups: BTreeMap::new(),
            repos: BTreeMap::new(),
            specs: None,
            agents: AgentsConfig {
                enabled: vec!["claude-code".to_string()],
                ..Default::default()
            },
            update: UpdateConfig::default(),
        };

        let manifest = WorkspaceManifest {
            name: "my-ws".to_string(),
            branch: None,
            created: chrono::Utc::now(),
            base_branch: None,
            preset: None,
            repos: vec![RepoManifestEntry {
                name: "dsp-api".to_string(),
                original_path: PathBuf::from("/code/dasch-swiss/dsp-api"),
                worktree_path: ws_path.join("dsp-api"),
                branch: "loom/my-ws".to_string(),
                remote_url: "git@github.com:dasch-swiss/dsp-api.git".to_string(),
            }],
        };

        generate_agent_files(&config, &ws_path, &manifest).unwrap();

        assert!(ws_path.join("CLAUDE.md").exists());
        assert!(ws_path.join(".claude/settings.json").exists());
    }

    #[test]
    fn test_generate_agent_files_removes_legacy_settings() {
        let dir = tempfile::tempdir().unwrap();
        let ws_path = dir.path().join("my-ws");
        let legacy_path = ws_path.join(".claude/settings.local.json");
        std::fs::create_dir_all(legacy_path.parent().unwrap()).unwrap();
        std::fs::write(&legacy_path, "{}").unwrap();
        assert!(legacy_path.exists());

        let config = Config {
            registry: RegistryConfig {
                scan_roots: vec![],
                scan_depth: 2,
            },
            workspace: WorkspaceConfig {
                root: dir.path().to_path_buf(),
            },
            sync: None,
            terminal: None,
            editor: None,
            defaults: DefaultsConfig::default(),
            groups: BTreeMap::new(),
            repos: BTreeMap::new(),
            specs: None,
            agents: AgentsConfig {
                enabled: vec!["claude-code".to_string()],
                ..Default::default()
            },
            update: UpdateConfig::default(),
        };

        let manifest = WorkspaceManifest {
            name: "my-ws".to_string(),
            branch: None,
            created: chrono::Utc::now(),
            base_branch: None,
            preset: None,
            repos: vec![],
        };

        generate_agent_files(&config, &ws_path, &manifest).unwrap();

        // Legacy file should be removed
        assert!(!legacy_path.exists());
        // New file should exist
        assert!(ws_path.join(".claude/settings.json").exists());
    }

    #[test]
    fn test_generate_agent_files_unknown_agent_skipped() {
        let dir = tempfile::tempdir().unwrap();
        let ws_path = dir.path().join("my-ws");
        std::fs::create_dir_all(&ws_path).unwrap();

        let config = Config {
            registry: RegistryConfig {
                scan_roots: vec![],
                scan_depth: 2,
            },
            workspace: WorkspaceConfig {
                root: dir.path().to_path_buf(),
            },
            sync: None,
            terminal: None,
            editor: None,
            defaults: DefaultsConfig::default(),
            groups: BTreeMap::new(),
            repos: BTreeMap::new(),
            specs: None,
            agents: AgentsConfig {
                enabled: vec!["unknown-agent".to_string()],
                ..Default::default()
            },
            update: UpdateConfig::default(),
        };

        let manifest = WorkspaceManifest {
            name: "my-ws".to_string(),
            branch: None,
            created: chrono::Utc::now(),
            base_branch: None,
            preset: None,
            repos: vec![],
        };

        // Should not error, just skip
        generate_agent_files(&config, &ws_path, &manifest).unwrap();

        // No files written
        assert!(!ws_path.join("CLAUDE.md").exists());
    }

    /// Helper: test the path traversal guard in isolation.
    fn is_safe_relative_path(path: &str) -> bool {
        use std::path::{Component, Path};
        let p = Path::new(path);
        !p.is_absolute() && !p.components().any(|c| c == Component::ParentDir)
    }

    #[test]
    fn test_path_traversal_guard() {
        // Safe paths
        assert!(is_safe_relative_path("CLAUDE.md"));
        assert!(is_safe_relative_path(".claude/settings.json"));

        // Path traversal with ..
        assert!(!is_safe_relative_path("../etc/passwd"));
        assert!(!is_safe_relative_path("foo/../../bar"));

        // Absolute paths
        assert!(!is_safe_relative_path("/etc/passwd"));
        assert!(!is_safe_relative_path("/tmp/evil"));
    }

    #[test]
    fn test_generate_agent_files_no_agents() {
        let dir = tempfile::tempdir().unwrap();
        let ws_path = dir.path().join("my-ws");
        std::fs::create_dir_all(&ws_path).unwrap();

        let config = Config {
            registry: RegistryConfig {
                scan_roots: vec![],
                scan_depth: 2,
            },
            workspace: WorkspaceConfig {
                root: dir.path().to_path_buf(),
            },
            sync: None,
            terminal: None,
            editor: None,
            defaults: DefaultsConfig::default(),
            groups: BTreeMap::new(),
            repos: BTreeMap::new(),
            specs: None,
            agents: AgentsConfig {
                enabled: vec![],
                ..Default::default()
            },
            update: UpdateConfig::default(),
        };

        let manifest = WorkspaceManifest {
            name: "my-ws".to_string(),
            branch: None,
            created: chrono::Utc::now(),
            base_branch: None,
            preset: None,
            repos: vec![],
        };

        generate_agent_files(&config, &ws_path, &manifest).unwrap();
    }

    #[test]
    fn test_applied_repo_configs_when_matching() {
        let dir = tempfile::tempdir().unwrap();
        let ws_path = dir.path().join("my-ws");
        std::fs::create_dir_all(&ws_path).unwrap();

        let mut repos = BTreeMap::new();
        repos.insert(
            "pkm".to_string(),
            RepoConfig {
                workflow: Workflow::Push,
            },
        );
        repos.insert(
            "loom".to_string(),
            RepoConfig {
                workflow: Workflow::Pr,
            },
        );

        let config = Config {
            registry: RegistryConfig {
                scan_roots: vec![],
                scan_depth: 2,
            },
            workspace: WorkspaceConfig {
                root: dir.path().to_path_buf(),
            },
            sync: None,
            terminal: None,
            editor: None,
            defaults: DefaultsConfig::default(),
            groups: BTreeMap::new(),
            repos,
            specs: None,
            agents: AgentsConfig {
                enabled: vec!["claude-code".to_string()],
                ..Default::default()
            },
            update: UpdateConfig::default(),
        };

        let manifest = WorkspaceManifest {
            name: "my-ws".to_string(),
            branch: None,
            created: chrono::Utc::now(),
            base_branch: None,
            preset: None,
            repos: vec![
                RepoManifestEntry {
                    name: "pkm".to_string(),
                    original_path: PathBuf::from("/code/subotic/pkm"),
                    worktree_path: ws_path.join("pkm"),
                    branch: "loom/my-ws".to_string(),
                    remote_url: "git@github.com:subotic/pkm.git".to_string(),
                },
                RepoManifestEntry {
                    name: "loom".to_string(),
                    original_path: PathBuf::from("/code/subotic/loom"),
                    worktree_path: ws_path.join("loom"),
                    branch: "loom/my-ws".to_string(),
                    remote_url: "git@github.com:subotic/loom.git".to_string(),
                },
            ],
        };

        let matched = generate_agent_files(&config, &ws_path, &manifest).unwrap();
        assert_eq!(matched.len(), 2);
        let by_name: std::collections::HashMap<_, _> =
            matched.iter().map(|m| (m.repo.as_str(), m)).collect();
        assert_eq!(by_name["pkm"].workflow, Workflow::Push);
        assert_eq!(by_name["loom"].workflow, Workflow::Pr);
    }

    #[test]
    fn test_applied_repo_configs_empty_when_no_match() {
        let dir = tempfile::tempdir().unwrap();
        let ws_path = dir.path().join("my-ws");
        std::fs::create_dir_all(&ws_path).unwrap();

        let mut repos = BTreeMap::new();
        repos.insert(
            "other-repo".to_string(),
            RepoConfig {
                workflow: Workflow::Pr,
            },
        );

        let config = Config {
            registry: RegistryConfig {
                scan_roots: vec![],
                scan_depth: 2,
            },
            workspace: WorkspaceConfig {
                root: dir.path().to_path_buf(),
            },
            sync: None,
            terminal: None,
            editor: None,
            defaults: DefaultsConfig::default(),
            groups: BTreeMap::new(),
            repos,
            specs: None,
            agents: AgentsConfig {
                enabled: vec!["claude-code".to_string()],
                ..Default::default()
            },
            update: UpdateConfig::default(),
        };

        let manifest = WorkspaceManifest {
            name: "my-ws".to_string(),
            branch: None,
            created: chrono::Utc::now(),
            base_branch: None,
            preset: None,
            repos: vec![RepoManifestEntry {
                name: "dsp-api".to_string(),
                original_path: PathBuf::from("/code/dasch-swiss/dsp-api"),
                worktree_path: ws_path.join("dsp-api"),
                branch: "loom/my-ws".to_string(),
                remote_url: "git@github.com:dasch-swiss/dsp-api.git".to_string(),
            }],
        };

        let matched = generate_agent_files(&config, &ws_path, &manifest).unwrap();
        assert!(matched.is_empty());
    }

    #[test]
    fn test_applied_repo_configs_mixed() {
        let dir = tempfile::tempdir().unwrap();
        let ws_path = dir.path().join("my-ws");
        std::fs::create_dir_all(&ws_path).unwrap();

        let mut repos = BTreeMap::new();
        repos.insert(
            "pkm".to_string(),
            RepoConfig {
                workflow: Workflow::Push,
            },
        );
        repos.insert(
            "unrelated".to_string(),
            RepoConfig {
                workflow: Workflow::Pr,
            },
        );

        let config = Config {
            registry: RegistryConfig {
                scan_roots: vec![],
                scan_depth: 2,
            },
            workspace: WorkspaceConfig {
                root: dir.path().to_path_buf(),
            },
            sync: None,
            terminal: None,
            editor: None,
            defaults: DefaultsConfig::default(),
            groups: BTreeMap::new(),
            repos,
            specs: None,
            agents: AgentsConfig {
                enabled: vec!["claude-code".to_string()],
                ..Default::default()
            },
            update: UpdateConfig::default(),
        };

        let manifest = WorkspaceManifest {
            name: "my-ws".to_string(),
            branch: None,
            created: chrono::Utc::now(),
            base_branch: None,
            preset: None,
            repos: vec![
                RepoManifestEntry {
                    name: "pkm".to_string(),
                    original_path: PathBuf::from("/code/subotic/pkm"),
                    worktree_path: ws_path.join("pkm"),
                    branch: "loom/my-ws".to_string(),
                    remote_url: "git@github.com:subotic/pkm.git".to_string(),
                },
                RepoManifestEntry {
                    name: "dsp-api".to_string(),
                    original_path: PathBuf::from("/code/dasch-swiss/dsp-api"),
                    worktree_path: ws_path.join("dsp-api"),
                    branch: "loom/my-ws".to_string(),
                    remote_url: "git@github.com:dasch-swiss/dsp-api.git".to_string(),
                },
            ],
        };

        let matched = generate_agent_files(&config, &ws_path, &manifest).unwrap();
        // Only "pkm" matches — "unrelated" is in config but not in manifest,
        // and "dsp-api" is in manifest but not in config.
        assert_eq!(matched.len(), 1);
        assert_eq!(matched[0].repo, "pkm");
        assert_eq!(matched[0].workflow, Workflow::Push);
    }
}