mi6_cli/commands/

enable.rs

//! Enable command - install mi6 hooks for AI coding frameworks.

use std::path::PathBuf;

use anyhow::{Context, Result, bail};

use mi6_core::{ConfigFormat, InitOptions, json_to_toml_string, preview_enable};
use mi6_otel_server::{find_available_port, is_mi6_server, is_server_running};

use crate::display::StderrColors;

/// Result of running enable - used by the binary to determine what storage to create.
pub struct EnableResult {
    pub should_init_db: bool,
    pub db_path: Option<PathBuf>,
}

/// CLI options for the enable command.
pub struct EnableCliOptions {
    pub frameworks: Vec<String>,
    pub local: bool,
    pub settings_local: bool,
    pub print: bool,
    pub db_only: bool,
    pub hooks_only: bool,
    pub otel: bool,
    pub otel_port: u16,
    pub no_otel: bool,
}

/// Run the enable command.
pub fn run_enable(cli: EnableCliOptions) -> Result<EnableResult> {
    let colors = StderrColors::new();
    let auto_detecting = cli.frameworks.is_empty();

    let opts = InitOptions::for_frameworks(cli.frameworks)
        .local(cli.local)
        .settings_local(cli.settings_local)
        .otel(cli.otel)
        .otel_port(cli.otel_port)
        .remove_otel(cli.no_otel)
        .db_only(cli.db_only)
        .hooks_only(cli.hooks_only);

    let mut result = EnableResult {
        should_init_db: !cli.hooks_only,
        db_path: None,
    };

    if !cli.hooks_only {
        result.db_path =
            Some(mi6_core::Config::db_path().context("failed to determine database path")?);
    }

    // Check for port collision if otel is enabled
    if cli.otel && is_server_running(cli.otel_port) && !is_mi6_server(cli.otel_port) {
        let available_port = find_available_port(cli.otel_port.saturating_add(1));
        bail!(
            "port {} is in use by another service\n\n\
             Try using a different port:\n  \
             mi6 enable --otel --otel-port {}",
            cli.otel_port,
            available_port
        );
    }

    // Handle print mode
    if cli.print {
        let previews = preview_enable(&opts).map_err(map_enable_error)?;
        for preview in previews {
            match preview.config_format {
                ConfigFormat::Json => {
                    println!(
                        "{}",
                        serde_json::to_string_pretty(&preview.hooks_config)
                            .context("failed to serialize hooks")?
                    );
                }
                ConfigFormat::Toml => {
                    println!(
                        "{}",
                        json_to_toml_string(&preview.hooks_config)
                            .context("failed to serialize hooks")?
                    );
                }
            }
        }
        return Ok(result);
    }

    // Install hooks unless db_only
    if !cli.db_only {
        let enable_result = mi6_core::enable(opts).map_err(map_enable_error)?;

        if auto_detecting && !enable_result.frameworks.is_empty() {
            let names: Vec<&str> = enable_result
                .frameworks
                .iter()
                .map(|f| f.name.as_str())
                .collect();
            eprintln!(
                "{}Detected frameworks:{} {}",
                colors.cyan,
                colors.reset,
                names.join(", ")
            );
        }

        // Check if we have partial failures (some succeeded, some failed)
        let has_failures = !enable_result.failures.is_empty();
        let has_successes = !enable_result.frameworks.is_empty();

        if has_failures && has_successes {
            // Display summary format for partial success
            display_partial_success_summary(
                &enable_result,
                &colors,
                cli.settings_local,
                cli.otel,
                cli.otel_port,
            );
        } else if has_successes {
            // All succeeded - display normal output
            for framework in &enable_result.frameworks {
                eprintln!(
                    "Enabling mi6 for {}... {}done{}",
                    framework.name, colors.green, colors.reset
                );
                // Claude uses plugin-based installation, other frameworks use hooks in config files
                let install_label = if framework.name == "claude" {
                    "Installed plugin to:"
                } else {
                    "Installed hooks to:"
                };
                eprintln!(
                    "  {} {}{}{}",
                    install_label,
                    colors.bold,
                    framework.settings_path.display(),
                    colors.reset
                );
            }

            if cli.settings_local {
                for framework in &enable_result.frameworks {
                    eprintln!(
                        "  {}Note:{} Add '{}' to your project's .gitignore",
                        colors.yellow,
                        colors.reset,
                        framework.settings_path.display()
                    );
                }
            }

            if cli.otel {
                eprintln!(
                    "  {}OpenTelemetry configured{} on port {} for automatic token tracking.",
                    colors.cyan, colors.reset, cli.otel_port
                );
            }
        }

        // If there were failures, return an error after displaying the summary
        if has_failures {
            let failed_names: Vec<&str> = enable_result
                .failures
                .iter()
                .map(|f| f.name.as_str())
                .collect();
            let count = enable_result.failures.len();
            let framework_word = if count == 1 {
                "framework"
            } else {
                "frameworks"
            };
            bail!(
                "{} {} failed. Fix the errors and retry with: mi6 enable {}",
                count,
                framework_word,
                failed_names.join(" ")
            );
        }
    }

    Ok(result)
}

/// Display summary output for partial success scenario.
fn display_partial_success_summary(
    enable_result: &mi6_core::EnableResult,
    colors: &StderrColors,
    settings_local: bool,
    otel: bool,
    otel_port: u16,
) {
    // Display enabled frameworks
    eprintln!();
    eprintln!("{}Enabled:{}", colors.green, colors.reset);
    for framework in &enable_result.frameworks {
        let install_label = if framework.name == "claude" {
            "plugin"
        } else {
            "hooks"
        };
        eprintln!(
            "  {}  -> {} ({})",
            framework.name,
            framework.settings_path.display(),
            install_label
        );
    }

    // Display failed frameworks
    eprintln!();
    eprintln!("{}Failed:{}", colors.red, colors.reset);
    for failure in &enable_result.failures {
        eprintln!("  {}  -> {}", failure.name, failure.error);
    }
    eprintln!();

    // Display notes
    if settings_local {
        for framework in &enable_result.frameworks {
            eprintln!(
                "{}Note:{} Add '{}' to your project's .gitignore",
                colors.yellow,
                colors.reset,
                framework.settings_path.display()
            );
        }
    }

    if otel && !enable_result.frameworks.is_empty() {
        eprintln!(
            "{}OpenTelemetry configured{} on port {} for automatic token tracking.",
            colors.cyan, colors.reset, otel_port
        );
    }
}

fn map_enable_error(e: mi6_core::EnableError) -> anyhow::Error {
    use mi6_core::EnableError;
    match e {
        EnableError::NoFrameworks { supported } => {
            anyhow::anyhow!(
                "No supported AI coding frameworks detected.\n\
                 Supported frameworks: {}\n\
                 Install one first, or specify explicitly: mi6 enable claude",
                supported.join(", ")
            )
        }
        EnableError::UnknownFramework(name) => {
            anyhow::anyhow!("unknown framework: {}", name)
        }
        other => anyhow::anyhow!("{}", other),
    }
}