mai_cli/cli/

install_cmd.rs

use crate::core::{InstallScope, MaiConfig, Pack, PackMetadata, PackType, Version, VersionReq};
use crate::error::{Error, Result};
use crate::storage::{Registry, XdgPaths};
use clap::Args;
use std::path::PathBuf;

#[derive(Debug, Args)]
pub struct InstallCommand {
    /// Pack to install (format: name[@version] or type/name[@version])
    /// Version supports: exact (1.2.3), latest, caret (^1.2.3), tilde (~1.2.3), ranges (>=1.0.0, <2.0.0)
    pub pack: String,

    /// Tool to install for (uses active tool if not specified)
    #[arg(short, long)]
    pub tool: Option<String>,

    /// Install globally (user-wide) instead of locally (project-specific)
    #[arg(short = 'g', long, default_value = "false")]
    pub global: bool,

    /// Pack description
    #[arg(long)]
    pub description: Option<String>,

    /// Pack source URL
    #[arg(long)]
    pub source: Option<String>,
}

impl InstallCommand {
    pub fn run(&self) -> Result<()> {
        let scope = if self.global {
            InstallScope::Global
        } else {
            InstallScope::Local
        };

        // Determine paths based on scope
        let paths = if scope == InstallScope::Global {
            XdgPaths::new()
        } else {
            // For local installation, find project root
            let project_root = find_project_root()?;
            XdgPaths::local(&project_root)
        };

        // Ensure directories exist
        crate::storage::ensure_dirs(&paths)?;

        let config_path = paths.config_file();

        let mut config = if config_path.exists() {
            let content = std::fs::read_to_string(&config_path)?;
            toml::from_str::<MaiConfig>(&content).unwrap_or_default()
        } else {
            MaiConfig::new()
        };

        let (pack_name, version_req, pack_type) = self.parse_pack()?;
        let tool = self
            .tool
            .clone()
            .or_else(|| config.active_tool().map(String::from))
            .unwrap_or_else(|| "default".to_string());

        // Resolve version using semver logic
        let registry = Registry::new(&paths);
        let available_versions =
            self.get_available_versions(&registry, &tool, &pack_name, pack_type)?;
        let version = self.resolve_version(&version_req, &available_versions)?;

        // Build metadata
        let mut metadata = PackMetadata::new();
        if let Some(ref desc) = self.description {
            metadata = metadata.with_description(desc);
        }
        if let Some(ref source) = self.source {
            metadata = metadata.with_source_url(source);
        }

        let pack = Pack::new(&pack_name, pack_type, version)
            .with_tool(&tool)
            .with_metadata(metadata)
            .with_scope(scope);

        registry.install_pack(&tool, &pack)?;

        config
            .tools
            .entry(tool.clone())
            .or_default()
            .installed_packs
            .push(pack.clone());

        let content = toml::to_string_pretty(&config)?;
        std::fs::write(&config_path, content)?;

        println!("✓ Installed: {} ({})", pack.id(), scope);
        Ok(())
    }

    fn get_available_versions(
        &self,
        registry: &Registry,
        tool: &str,
        pack_name: &str,
        pack_type: PackType,
    ) -> Result<Vec<Version>> {
        // Get all versions of this pack from the registry
        let all_packs = registry.list_packs(Some(tool), None)?;
        let versions: Vec<Version> = all_packs
            .iter()
            .filter(|p| p.name == pack_name && p.pack_type == pack_type)
            .map(|p| p.version.clone())
            .collect();

        // If no existing versions, return a default set for demonstration
        // In Phase 3, this would query a remote registry
        if versions.is_empty() {
            Ok(vec![
                Version::new(1, 0, 0),
                Version::new(1, 1, 0),
                Version::new(1, 2, 0),
                Version::new(2, 0, 0),
            ])
        } else {
            Ok(versions)
        }
    }

    fn resolve_version(&self, req: &VersionReq, available: &[Version]) -> Result<Version> {
        match req {
            VersionReq::Latest => {
                // Select the highest version
                available
                    .iter()
                    .max()
                    .cloned()
                    .ok_or_else(|| Error::parse_error("No versions available"))
            }
            _ => {
                // Use semver selection logic
                req.select_best(available).cloned().ok_or_else(|| {
                    Error::parse_error(format!("No version matches requirement: {}", req))
                })
            }
        }
    }

    fn parse_pack(&self) -> Result<(String, VersionReq, PackType)> {
        let mut parts = self.pack.splitn(2, '@');
        let name_part = parts.next().unwrap();
        let version_str = parts.next().unwrap_or("latest");

        let (pack_type, name) = if let Some((t, n)) = name_part.split_once('/') {
            let pack_type = match t.to_lowercase().as_str() {
                "skill" => PackType::Skill,
                "command" => PackType::Command,
                "mcp" => PackType::Mcp,
                _ => PackType::Skill,
            };
            (pack_type, n.to_string())
        } else {
            (PackType::Skill, name_part.to_string())
        };

        let version_req = VersionReq::parse(version_str)
            .map_err(|e| Error::parse_error(format!("Invalid version requirement: {}", e)))?;

        Ok((name, version_req, pack_type))
    }
}

/// Find the project root directory (directory containing mai.toml or .git)
fn find_project_root() -> Result<PathBuf> {
    let current = std::env::current_dir()?;

    let mut current = current.as_path();
    while let Some(parent) = current.parent() {
        if current.join("mai.toml").exists() || current.join(".git").exists() {
            return Ok(current.to_path_buf());
        }
        current = parent;
    }

    // If no project root found, use current directory
    Ok(std::env::current_dir()?)
}