mi6_cli/commands/

status.rs

//! Status command - show mi6 setup and data information.

use std::collections::HashMap;
use std::path::Path;
use std::process::Command;

use anyhow::{Context, Result};
use serde::Serialize;

use mi6_core::{Config, all_adapters};

use super::upgrade::InstallMethod;
use crate::display::{bold_green, bold_red, bold_white, bold_yellow, dark_grey, format_bytes};

/// Status output structure for JSON serialization
#[derive(Serialize)]
struct StatusOutput {
    version: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    commit: Option<String>,
    frameworks: HashMap<String, FrameworkStatus>,
    data: DataStatus,
}

#[derive(Serialize)]
struct FrameworkStatus {
    activated: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    enabled_via: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    config_path: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    verified: Option<VerificationResult>,
}

/// Result of hook verification
#[derive(Clone, Serialize)]
struct VerificationResult {
    /// Whether hooks are responding
    responding: bool,
    /// Human-readable status message
    message: String,
}

#[derive(Serialize)]
struct DataStatus {
    storage_bytes: u64,
    storage_human: String,
    path: String,
}

/// Get the total size of a directory in bytes
fn get_dir_size(path: &Path) -> std::io::Result<u64> {
    let mut total = 0;

    if path.is_file() {
        return Ok(path.metadata()?.len());
    }

    if path.is_dir() {
        for entry in std::fs::read_dir(path)? {
            let entry = entry?;
            let path = entry.path();
            if path.is_file() {
                total += path.metadata()?.len();
            } else if path.is_dir() {
                total += get_dir_size(&path)?;
            }
        }
    }

    Ok(total)
}

/// Get git commit information (short hash)
fn get_git_commit() -> Option<String> {
    // Compile-time env var (set by build.rs or CI)
    option_env!("MI6_GIT_COMMIT").map(String::from)
}

/// Get the enablement method description for a framework.
fn get_enablement_method(name: &str) -> &'static str {
    if name == "claude" {
        "plugin"
    } else {
        "config hooks"
    }
}

/// Verify that hooks can invoke mi6 successfully.
///
/// This tests the hook path by running `mi6 ingest event --ping`,
/// which verifies that:
/// 1. mi6 is in PATH (what hooks actually use)
/// 2. mi6 can be executed
/// 3. The command returns successfully
///
/// We use PATH lookup (`Command::new("mi6")`) rather than `current_exe()`
/// because hooks invoke `mi6` via PATH, not the currently-running binary.
/// This accurately reflects what hooks will experience at runtime.
fn verify_hooks() -> VerificationResult {
    // Use PATH lookup since that's what hooks use to invoke mi6
    let result = Command::new("mi6")
        .args(["ingest", "event", "--ping"])
        .stdin(std::process::Stdio::null())
        .stdout(std::process::Stdio::piped())
        .stderr(std::process::Stdio::null())
        .output();

    match result {
        Ok(output) if output.status.success() => {
            let stdout = String::from_utf8_lossy(&output.stdout);
            if stdout.trim() == "pong" {
                VerificationResult {
                    responding: true,
                    message: "hooks responding".to_string(),
                }
            } else {
                VerificationResult {
                    responding: false,
                    message: "unexpected response".to_string(),
                }
            }
        }
        Ok(_) => VerificationResult {
            responding: false,
            message: "command failed".to_string(),
        },
        Err(e) => {
            let message = if e.kind() == std::io::ErrorKind::NotFound {
                "mi6 not in PATH".to_string()
            } else {
                format!("error: {}", e)
            };
            VerificationResult {
                responding: false,
                message,
            }
        }
    }
}

/// Run the mi6 status command.
pub fn run_status_command(json: bool, verbose: bool, check: bool) -> Result<()> {
    // Gather data
    let version = env!("CARGO_PKG_VERSION").to_string();
    let commit = get_git_commit();

    // Run verification once if --check is enabled (applies to all enabled frameworks)
    let verification = if check { Some(verify_hooks()) } else { None };

    let mut frameworks = HashMap::new();
    for adapter in all_adapters() {
        let activated = adapter.has_mi6_hooks(false, false);
        let enabled_via = if activated {
            Some(get_enablement_method(adapter.name()).to_string())
        } else {
            None
        };
        let config_path = if activated {
            // For Claude, show the actual plugin directory path instead of marketplace URL
            if adapter.name() == "claude" {
                Config::mi6_dir()
                    .ok()
                    .map(|d| d.join("claude-plugin").display().to_string())
            } else {
                adapter
                    .settings_path(false, false)
                    .ok()
                    .map(|p| p.display().to_string())
            }
        } else {
            None
        };

        // Only include verification for enabled frameworks
        let verified = if activated {
            verification.clone()
        } else {
            None
        };

        frameworks.insert(
            adapter.name().to_string(),
            FrameworkStatus {
                activated,
                enabled_via,
                config_path,
                verified,
            },
        );
    }

    let db_path = mi6_core::Config::db_path().context("failed to determine database path")?;
    let storage_bytes = if db_path.exists() {
        get_dir_size(&db_path).unwrap_or(0)
    } else {
        0
    };

    if json {
        // JSON output
        let output = StatusOutput {
            version,
            commit,
            frameworks,
            data: DataStatus {
                storage_bytes,
                storage_human: format_bytes(storage_bytes),
                path: db_path.display().to_string(),
            },
        };
        println!("{}", serde_json::to_string_pretty(&output)?);
    } else {
        // Human-readable output
        print!("mi6 {}", bold_white(&version));
        if let Some(ref c) = commit {
            print!(" ({})", bold_white(c));
        }
        println!();

        // Show installation method in verbose mode
        if verbose {
            println!();
            let method_str = match InstallMethod::detect() {
                Ok(method) => method.name().to_string(),
                Err(_) => "unknown".to_string(),
            };
            println!(
                "{} {}",
                dark_grey("mi6 installation method:"),
                bold_white(&method_str)
            );
        }
        println!();

        // Show mi6 directory
        let mi6_dir = Config::mi6_dir().context("failed to determine mi6 directory")?;
        println!(
            "{} {}",
            dark_grey("mi6 directory:"),
            bold_white(&mi6_dir.display().to_string())
        );
        println!();

        // Framework status table
        let adapters: Vec<_> = all_adapters();
        let framework_width = adapters
            .iter()
            .map(|a| a.display_name().len())
            .max()
            .unwrap_or(10)
            .max("Framework".len());
        let status_width = 13; // "NOT INSTALLED" is the longest
        let method_width = 12; // "config hooks" is the longest
        let otel_width = 4; // "OTEL" header width
        let verified_width = if check { 20 } else { 0 }; // "hooks not responding" is the longest
        let sep = dark_grey("  │  ");

        // Print header
        if check {
            println!(
                "{:<fw$}{}{:<sw$}{}{:<mw$}{}OTEL{}Verified",
                "Framework",
                sep,
                "Status",
                sep,
                "Method",
                sep,
                sep,
                fw = framework_width,
                sw = status_width,
                mw = method_width
            );
        } else {
            println!(
                "{:<fw$}{}{:<sw$}{}{:<mw$}{}OTEL",
                "Framework",
                sep,
                "Status",
                sep,
                "Method",
                sep,
                fw = framework_width,
                sw = status_width,
                mw = method_width
            );
        }

        // Print separator line
        if check {
            println!(
                "{}",
                dark_grey(&format!(
                    "{}──┼──{}──┼──{}──┼──{}──┼──{}",
                    "─".repeat(framework_width),
                    "─".repeat(status_width),
                    "─".repeat(method_width),
                    "─".repeat(otel_width),
                    "─".repeat(verified_width)
                ))
            );
        } else {
            println!(
                "{}",
                dark_grey(&format!(
                    "{}──┼──{}──┼──{}──┼──{}",
                    "─".repeat(framework_width),
                    "─".repeat(status_width),
                    "─".repeat(method_width),
                    "─".repeat(otel_width)
                ))
            );
        }

        // Track if any framework has failing verification
        let mut has_verification_failure = false;

        // Print rows
        for adapter in &adapters {
            let status_info = frameworks.get(adapter.name());
            let enabled = status_info.is_some_and(|f| f.activated);
            let installed = adapter.is_installed();

            // Pad text before applying colors (ANSI codes break format width)
            let (status, method, otel, verified_str) = if enabled {
                let method = status_info
                    .and_then(|f| f.enabled_via.as_ref())
                    .cloned()
                    .unwrap_or_default();
                // Use trait method for OTEL detection
                let otel_str = match adapter.otel_support() {
                    mi6_core::framework::OtelSupport::Enabled => "yes",
                    mi6_core::framework::OtelSupport::Disabled => "no",
                    mi6_core::framework::OtelSupport::Unsupported => "n/a",
                };

                // Get verification status if check mode
                let verified = if check {
                    if let Some(v) = status_info.and_then(|f| f.verified.as_ref()) {
                        if v.responding {
                            bold_green(&v.message)
                        } else {
                            has_verification_failure = true;
                            bold_yellow(&format!("{} (!)", v.message))
                        }
                    } else {
                        "-".to_string()
                    }
                } else {
                    String::new()
                };

                (
                    bold_green(&format!("{:<sw$}", "ENABLED", sw = status_width)),
                    method,
                    otel_str,
                    verified,
                )
            } else if !installed {
                (
                    dark_grey(&format!("{:<sw$}", "NOT INSTALLED", sw = status_width)),
                    "-".to_string(),
                    "n/a",
                    if check {
                        "-".to_string()
                    } else {
                        String::new()
                    },
                )
            } else {
                (
                    bold_red(&format!("{:<sw$}", "NOT ENABLED", sw = status_width)),
                    "-".to_string(),
                    "n/a",
                    if check {
                        "-".to_string()
                    } else {
                        String::new()
                    },
                )
            };

            if check {
                println!(
                    "{:<fw$}{}{}{}{:<mw$}{}{}{}{}",
                    adapter.display_name(),
                    sep,
                    status,
                    sep,
                    method,
                    sep,
                    otel,
                    sep,
                    verified_str,
                    fw = framework_width,
                    mw = method_width
                );
            } else {
                println!(
                    "{:<fw$}{}{}{}{:<mw$}{}{}",
                    adapter.display_name(),
                    sep,
                    status,
                    sep,
                    method,
                    sep,
                    otel,
                    fw = framework_width,
                    mw = method_width
                );
            }
        }
        println!();

        // Show warning if verification failed
        if check && has_verification_failure {
            println!(
                "{}",
                bold_yellow("Warning: Some hooks are configured but not responding.")
            );
            println!("  - Check that mi6 is in your PATH");
            println!("  - Run: which mi6");
            println!();
        }

        // Show verbose section: Relevant Framework Files
        if verbose {
            // Collect enabled frameworks with their config paths from the already-computed data
            let enabled_with_paths: Vec<_> = adapters
                .iter()
                .filter_map(|a| {
                    frameworks.get(a.name()).and_then(|f| {
                        if f.activated {
                            f.config_path.as_ref().map(|p| (a.name(), p.as_str()))
                        } else {
                            None
                        }
                    })
                })
                .collect();

            if !enabled_with_paths.is_empty() {
                println!("{}", bold_white("Relevant Framework Files"));
                for (name, path) in enabled_with_paths {
                    println!("- {}: {}", name, path);
                }
                println!();
            }
        }

        println!(
            "{}{}{}{}{}",
            dark_grey("(modify using "),
            bold_white("mi6 enable <framework>"),
            dark_grey(" or "),
            bold_white("mi6 disable <framework>"),
            dark_grey(")")
        );
    }

    Ok(())
}