casting_cli/

utils.rs

/// Utility functions for tool binary and configuration management
use std::path::PathBuf;
use std::process::Command;

/// Find the binary path of a tool using the `which` command
pub fn find_tool_binary(tool_name: &str) -> anyhow::Result<String> {
    let output = Command::new("which").arg(tool_name).output()?;

    if !output.status.success() {
        anyhow::bail!("Tool '{}' not found in PATH", tool_name);
    }

    let path = String::from_utf8(output.stdout)?.trim().to_string();

    Ok(path)
}

/// Get help output from a tool by running `--help`
pub fn get_tool_help(tool_name: &str) -> anyhow::Result<String> {
    let output = Command::new(tool_name).arg("--help").output()?;

    // --help は多くの場合 exit code 0 だが、一部のツールは 1 を返すこともある
    // stdout が空なら stderr を試す
    let mut help = String::from_utf8(output.stdout)?;

    if help.is_empty() {
        help = String::from_utf8(output.stderr)?;
    }

    if help.is_empty() {
        anyhow::bail!("Failed to get help output from '{}'", tool_name);
    }

    Ok(help)
}

/// Get the configuration directory path for a specific tool
pub fn get_tool_config_dir(tool_name: &str) -> anyhow::Result<PathBuf> {
    let home = std::env::var("HOME")?;
    let config_dir = PathBuf::from(home)
        .join(".casting")
        .join("tools")
        .join(tool_name);
    Ok(config_dir)
}

/// Generate aliases for a tool name (especially useful for Expert types with multi-word names)
///
/// For "UX Designer":
/// - `ux_designer` (snake_case)
/// - `uxd` (initials)
pub fn generate_aliases(tool_name: &str) -> Vec<String> {
    let mut aliases = Vec::new();

    // Only generate aliases for multi-word names
    if !tool_name.contains(' ') {
        return aliases;
    }

    let words: Vec<&str> = tool_name.split_whitespace().collect();

    // 1. snake_case version: "UX Designer" -> "ux_designer"
    let snake_case: String = words
        .iter()
        .map(|w| w.to_lowercase())
        .collect::<Vec<_>>()
        .join("_");
    aliases.push(snake_case);

    // 2. initials version: "UX Designer" -> "uxd"
    // For all-uppercase words (acronyms like "UX", "API"), use all chars
    // For normal words, use first char only
    let initials: String = words
        .iter()
        .flat_map(|w| {
            let is_acronym = w.len() > 1 && w.chars().all(|c| c.is_uppercase());
            if is_acronym {
                // "UX" -> "ux"
                w.to_lowercase().chars().collect::<Vec<_>>()
            } else {
                // "Designer" -> "d"
                w.chars()
                    .next()
                    .map(|c| c.to_lowercase().collect::<Vec<_>>())
                    .unwrap_or_default()
            }
        })
        .collect();

    // Only add initials if different from snake_case and at least 2 chars
    if initials.len() >= 2 && !aliases.contains(&initials) {
        aliases.push(initials);
    }

    aliases
}

/// Get all existing tool names and aliases to check for conflicts
pub fn get_all_tool_identifiers() -> anyhow::Result<std::collections::HashSet<String>> {
    use crate::tool_config::{setup_config_migrator, ToolConfig};
    use std::fs;

    let mut identifiers = std::collections::HashSet::new();

    let home = std::env::var("HOME")?;
    let tools_dir = PathBuf::from(home).join(".casting").join("tools");

    if !tools_dir.exists() {
        return Ok(identifiers);
    }

    let migrator = setup_config_migrator()?;

    for entry in fs::read_dir(&tools_dir)? {
        let entry = entry?;
        let path = entry.path();

        if path.is_dir() {
            let config_path = path.join("config.json");
            if config_path.exists() {
                let config_str = fs::read_to_string(&config_path)?;
                if let Ok(config) =
                    migrator.load_with_fallback::<ToolConfig>("tool_config", &config_str)
                {
                    // Add tool name (lowercase for comparison)
                    identifiers.insert(config.tool_name.to_lowercase());
                    // Add all aliases
                    for alias in config.aliases {
                        identifiers.insert(alias.to_lowercase());
                    }
                }
            }
        }
    }

    Ok(identifiers)
}

/// Generate non-conflicting aliases for a tool name
pub fn generate_unique_aliases(tool_name: &str) -> anyhow::Result<Vec<String>> {
    let candidates = generate_aliases(tool_name);
    let existing = get_all_tool_identifiers()?;

    let unique: Vec<String> = candidates
        .into_iter()
        .filter(|alias| !existing.contains(&alias.to_lowercase()))
        .collect();

    Ok(unique)
}

/// Resolve a tool identifier (name or alias) to the actual tool name
pub fn resolve_tool_name(identifier: &str) -> anyhow::Result<Option<String>> {
    use crate::tool_config::{setup_config_migrator, ToolConfig};
    use std::fs;

    let home = std::env::var("HOME")?;
    let tools_dir = PathBuf::from(home).join(".casting").join("tools");

    if !tools_dir.exists() {
        return Ok(None);
    }

    // First, check if it's a direct tool name (directory exists)
    let direct_path = tools_dir.join(identifier);
    if direct_path.exists() && direct_path.is_dir() {
        return Ok(Some(identifier.to_string()));
    }

    // Otherwise, search through all configs for alias match
    let migrator = setup_config_migrator()?;
    let identifier_lower = identifier.to_lowercase();

    for entry in fs::read_dir(&tools_dir)? {
        let entry = entry?;
        let path = entry.path();

        if path.is_dir() {
            let config_path = path.join("config.json");
            if config_path.exists() {
                let config_str = fs::read_to_string(&config_path)?;
                if let Ok(config) =
                    migrator.load_with_fallback::<ToolConfig>("tool_config", &config_str)
                {
                    // Check aliases
                    for alias in &config.aliases {
                        if alias.to_lowercase() == identifier_lower {
                            return Ok(Some(config.tool_name));
                        }
                    }
                }
            }
        }
    }

    Ok(None)
}

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

    #[test]
    fn test_generate_aliases_multi_word() {
        // "UX Designer" -> ["ux_designer", "uxd"]
        let aliases = generate_aliases("UX Designer");
        assert_eq!(aliases.len(), 2);
        assert_eq!(aliases[0], "ux_designer");
        assert_eq!(aliases[1], "uxd");
    }

    #[test]
    fn test_generate_aliases_three_words() {
        // "Senior Software Engineer" -> ["senior_software_engineer", "sse"]
        let aliases = generate_aliases("Senior Software Engineer");
        assert_eq!(aliases.len(), 2);
        assert_eq!(aliases[0], "senior_software_engineer");
        assert_eq!(aliases[1], "sse");
    }

    #[test]
    fn test_generate_aliases_single_word_returns_empty() {
        // Single word tools (like CLI tools) don't need aliases
        let aliases = generate_aliases("git");
        assert!(aliases.is_empty());
    }

    #[test]
    fn test_generate_aliases_acronym_preserved() {
        // "API Gateway" -> ["api_gateway", "apig"]
        // API is an acronym (all uppercase), so all chars are used
        let aliases = generate_aliases("API Gateway");
        assert_eq!(aliases[0], "api_gateway");
        assert_eq!(aliases[1], "apig");
    }

    #[test]
    fn test_generate_aliases_handles_extra_whitespace() {
        // Extra spaces should be handled by split_whitespace
        let aliases = generate_aliases("UX  Designer");
        assert_eq!(aliases.len(), 2);
        assert_eq!(aliases[0], "ux_designer");
        assert_eq!(aliases[1], "uxd");
    }

    #[test]
    fn test_generate_aliases_multiple_acronyms() {
        // "AI ML Expert" -> ["ai_ml_expert", "aimle"]
        // AI and ML are acronyms (all uppercase), so all chars are used
        let aliases = generate_aliases("AI ML Expert");
        assert_eq!(aliases.len(), 2);
        assert_eq!(aliases[0], "ai_ml_expert");
        assert_eq!(aliases[1], "aimle");
    }

    #[test]
    fn test_generate_aliases_long_name() {
        // "Chief Technology Officer" -> ["chief_technology_officer", "cto"]
        let aliases = generate_aliases("Chief Technology Officer");
        assert_eq!(aliases.len(), 2);
        assert_eq!(aliases[0], "chief_technology_officer");
        assert_eq!(aliases[1], "cto");
    }
}