mi6_cli/commands/

log.rs

use std::collections::HashMap;
use std::io::Read;
use std::path::Path;

use anyhow::{Context, Result};
use chrono::Utc;
use mi6_core::{
    Config, EventBuilder, EventType, FrameworkAdapter, ParsedHookInput, Storage, default_adapter,
    detect_all_frameworks, detect_framework, get_adapter, get_branch_info, get_github_repo,
    get_local_git_dir, is_branch_changing_command,
};

use crate::process::{ClaudeProcessInfo, find_claude_process, get_parent_pid};

/// Result of running the log command.
pub struct LogResult {
    /// Transcript path to scan, if available
    pub transcript_path: Option<String>,
    /// Machine ID for transcript parsing
    pub machine_id: String,
    /// Session ID for potential backfill operations
    pub session_id: String,
}

/// Run the log command. This must be fast (<10ms) and never block the calling framework.
///
/// Returns information needed for optional transcript scanning.
pub fn run_log<S: Storage>(
    storage: &S,
    event_type_arg: Option<String>,
    json_payload: Option<String>,
    framework_name: Option<String>,
) -> Result<LogResult> {
    // Determine the framework adapter:
    // 1. Use explicit --framework flag if provided
    // 2. Otherwise, try to auto-detect from environment variables
    // 3. Fall back to default (claude)
    let adapter: &dyn FrameworkAdapter = if let Some(ref name) = framework_name {
        get_adapter(name).ok_or_else(|| anyhow::anyhow!("unknown framework: {}", name))?
    } else {
        // Warn if multiple frameworks detected (to stderr, doesn't affect hook)
        let detected = detect_all_frameworks();
        if detected.len() > 1 {
            let names: Vec<_> = detected.iter().map(|a| a.name()).collect();
            eprintln!(
                "mi6: warning: multiple frameworks detected ({}), using {}",
                names.join(", "),
                detected[0].name()
            );
        }
        detect_framework().unwrap_or_else(default_adapter)
    };

    // Handle argument parsing:
    // - Claude/Gemini: `mi6 ingest event SessionStart` with JSON on stdin
    // - Codex: `mi6 ingest event --framework codex '{"type":"agent-turn-complete",...}'`
    //
    // Codex passes JSON as the only positional arg, which clap captures as event_type_arg.
    // We detect this by checking if event_type_arg looks like JSON (starts with '{').
    let (actual_event_type, json_str) = if let Some(ref arg) = event_type_arg {
        if arg.trim().starts_with('{') {
            // First positional arg is JSON (Codex format) - extract event type from it
            (None, arg.clone())
        } else {
            // First positional arg is event type (Claude/Gemini format)
            let json = if let Some(payload) = json_payload {
                payload
            } else {
                let mut stdin_data = String::new();
                std::io::stdin()
                    .read_to_string(&mut stdin_data)
                    .context("failed to read stdin")?;
                stdin_data
            };
            (Some(arg.clone()), json)
        }
    } else {
        // No positional args - read JSON from stdin
        let mut stdin_data = String::new();
        std::io::stdin()
            .read_to_string(&mut stdin_data)
            .context("failed to read stdin")?;
        (None, stdin_data)
    };

    // Parse the hook JSON
    let hook_data: serde_json::Value = if json_str.trim().is_empty() {
        serde_json::json!({})
    } else {
        serde_json::from_str(&json_str).context("failed to parse hook JSON")?
    };

    // Determine event type:
    // 1. Use explicit CLI argument if provided
    // 2. Otherwise extract from JSON payload's "type" field (Codex CLI format)
    // 3. Fall back to "Unknown" if neither available
    let event_type_str = if let Some(ref et) = actual_event_type {
        et.clone()
    } else {
        // Extract from JSON "type" field (Codex CLI format)
        hook_data
            .get("type")
            .and_then(|v| v.as_str())
            .map_or_else(|| "Unknown".to_string(), String::from)
    };

    // Map the event type using the adapter (handles framework-specific event names)
    let event_type: EventType = adapter.map_event_type(&event_type_str);

    // Use adapter to parse hook input into normalized fields
    let parsed = adapter.parse_hook_input(&event_type_str, &hook_data);

    // Extract session_id (required field, default to "unknown")
    let session_id = parsed
        .session_id
        .clone()
        .unwrap_or_else(|| "unknown".to_string());

    // Find framework process for SessionStart OR frameworks without SessionStart events.
    // This walks up the process tree to find the actual framework process PID.
    //
    // Note: For Cursor, the PID is captured for display purposes but is NOT used for
    // liveness detection (handled in builder.rs). Cursor is an IDE where multiple
    // conversation sessions share the same process, so PID-based liveness doesn't work.
    //
    // Codex and Cursor don't have SessionStart events, so we capture the process info
    // on every event to ensure we get the PID on the first event.
    let process_info =
        if event_type == EventType::SessionStart || matches!(adapter.name(), "codex" | "cursor") {
            find_claude_process()
        } else {
            None
        };

    // Capture PID - use cached process info for SessionStart, parent PID otherwise
    let pid = process_info
        .as_ref()
        .map(|info| info.pid)
        .or_else(get_parent_pid);

    // Build payload: merge hook JSON with environment variables and process info
    let payload = build_payload(hook_data, &event_type, process_info.as_ref())?;

    // Load config and get machine_id
    let config = Config::load().unwrap_or_default();
    let machine_id = config.machine_id();

    // Get timestamp for both git context upsert and event
    let now = Utc::now();
    let timestamp_ms = now.timestamp_millis();

    // Capture git context BEFORE inserting the event.
    // This ensures github_repo is set before branch parsing, so that when
    // issue/PR numbers are extracted from the branch name, they're associated
    // with the correct repository. If the repo changes, issue/PR are cleared first.
    upsert_git_context_if_available(
        storage,
        &session_id,
        &machine_id,
        adapter.name(),
        timestamp_ms,
        &parsed,
    );

    // Create and insert event
    let mut builder = EventBuilder::new(&machine_id, event_type.clone(), session_id.clone())
        .framework(adapter.name())
        .timestamp(now)
        .tool_use_id_opt(parsed.tool_use_id.clone())
        .spawned_agent_id_opt(parsed.spawned_agent_id.clone())
        .tool_name_opt(parsed.tool_name.clone())
        .subagent_type_opt(parsed.subagent_type.clone())
        .permission_mode_opt(parsed.permission_mode.clone())
        .transcript_path_opt(parsed.transcript_path.clone())
        .model_opt(parsed.model.clone())
        .duration_ms_opt(parsed.duration_ms)
        .pid_opt(pid)
        .cwd_opt(parsed.cwd.clone())
        .payload(payload)
        .source("hook");

    // Add token fields if present (for OpenCode ApiRequest events)
    if let (Some(input), Some(output)) = (parsed.tokens_input, parsed.tokens_output) {
        builder = builder.tokens(input, output);
    }
    if let (Some(read), Some(write)) = (parsed.tokens_cache_read, parsed.tokens_cache_write) {
        builder = builder.cache_tokens(read, write);
    }
    if let Some(cost) = parsed.cost_usd {
        builder = builder.cost(cost);
    }

    let event = builder.build();

    storage.insert(&event).context("failed to insert event")?;

    // Capture git branch info for relevant event types (branch changes, SessionStart)
    capture_git_branch_if_needed(storage, &event_type, &session_id, &parsed);

    // Opportunistic GC (~1.2% of calls: 3/256)
    if rand::random::<u8>() < 3 {
        let _ = storage.gc(config.history_duration());
    }

    // Output hook response for frameworks with blocking hooks (e.g., Cursor)
    // This must be written to stdout for the framework to receive it
    if let Some(response) = adapter.hook_response(&event_type_str) {
        println!("{}", response);
    }

    // Return info for optional transcript scanning
    Ok(LogResult {
        transcript_path: parsed.transcript_path.clone(),
        machine_id,
        session_id,
    })
}

/// Build the payload JSON by merging hook data with environment variables
fn build_payload(
    mut hook_data: serde_json::Value,
    event_type: &EventType,
    process_info: Option<&ClaudeProcessInfo>,
) -> Result<String> {
    // Environment variables to capture
    let env_vars = [
        ("CLAUDE_PROJECT_DIR", "project_dir"),
        ("CLAUDE_FILE_PATHS", "file_paths"),
        ("CLAUDE_TOOL_INPUT", "tool_input_env"),
        ("CLAUDE_TOOL_OUTPUT", "tool_output_env"),
        ("CLAUDE_NOTIFICATION", "notification_env"),
        ("CLAUDE_CODE_REMOTE", "remote"),
        ("CLAUDE_ENV_FILE", "env_file"),
    ];

    // Ensure we have an object to work with
    if !hook_data.is_object() {
        hook_data = serde_json::json!({ "_raw": hook_data });
    }

    let Some(obj) = hook_data.as_object_mut() else {
        // We just ensured it's an object above, so this is unreachable
        return Ok(serde_json::to_string(&hook_data)?);
    };

    // Add environment variables to the payload
    let mut env_data: HashMap<String, String> = HashMap::new();
    for (env_var, key) in env_vars {
        if let Ok(value) = std::env::var(env_var) {
            env_data.insert(key.to_string(), value);
        }
    }

    if !env_data.is_empty() {
        obj.insert("_env".to_string(), serde_json::to_value(env_data)?);
    }

    // For SessionStart, add process info to payload (using cached info)
    if *event_type == EventType::SessionStart
        && let Some(info) = process_info
    {
        obj.insert(
            "_claude_process".to_string(),
            serde_json::json!({
                "pid": info.pid,
                "comm": info.comm
            }),
        );
    }

    Ok(serde_json::to_string(&hook_data)?)
}

/// Upsert git context (local_git_dir and github_repo) for the session.
///
/// This is called BEFORE the event is inserted to ensure git context is set
/// before branch parsing. When github_repo changes, issue/PR numbers are cleared
/// because they're only meaningful in the context of a specific repository.
///
/// The function is designed to be fast (~50µs with direct file access) and never fail -
/// errors are silently ignored since git info is supplementary data.
fn upsert_git_context_if_available<S: Storage>(
    storage: &S,
    session_id: &str,
    machine_id: &str,
    framework: &str,
    timestamp_ms: i64,
    parsed: &ParsedHookInput,
) {
    if let Some(ref cwd) = parsed.cwd {
        let cwd_path = Path::new(cwd);

        // Capture git directory path and GitHub repo
        let local_git_dir = get_local_git_dir(cwd_path);
        let github_repo = get_github_repo(cwd_path);

        if local_git_dir.is_some() || github_repo.is_some() {
            let _ = storage.upsert_session_git_context(
                session_id,
                machine_id,
                framework,
                timestamp_ms,
                local_git_dir.as_deref(),
                github_repo.as_deref(),
            );
        }
    }
}

/// Capture git branch info for specific event types.
///
/// Handles:
/// - SessionStart: Captures initial git branch
/// - PostToolUse (Bash): Detects git branch-changing commands and updates branch info
///
/// Branch parsing extracts issue/PR numbers from branch names like:
/// - `feature/issue-123` -> github_issue: 123
/// - `fix/GH-456` -> github_issue: 456
/// - `pr-789` -> github_pr: 789
fn capture_git_branch_if_needed<S: Storage>(
    storage: &S,
    event_type: &EventType,
    session_id: &str,
    parsed: &ParsedHookInput,
) {
    match event_type {
        EventType::SessionStart => {
            if let Some(ref cwd) = parsed.cwd {
                let cwd_path = Path::new(cwd);

                // Capture initial git branch from session's cwd
                if let Some(git_info) = get_branch_info(cwd_path) {
                    let _ = storage.update_session_git_info(session_id, &git_info);
                }
            }
        }
        EventType::PostToolUse => {
            // Check if this is a Bash tool call with a git branch-changing command
            if parsed.tool_name.as_deref() == Some("Bash") {
                // Get command from CLAUDE_TOOL_INPUT environment variable
                if let Ok(tool_input) = std::env::var("CLAUDE_TOOL_INPUT")
                    && let Some(cmd) = extract_bash_command(&tool_input)
                    && is_branch_changing_command(&cmd)
                    && let Some(ref cwd) = parsed.cwd
                    && let Some(git_info) = get_branch_info(Path::new(cwd))
                {
                    let _ = storage.update_session_git_info(session_id, &git_info);
                }
            }
        }
        _ => {}
    }
}

/// Extract the bash command from tool_input.
///
/// The tool_input can be either:
/// - Raw command string
/// - JSON object with a "command" field
fn extract_bash_command(tool_input: &str) -> Option<String> {
    // First try to parse as JSON
    if let Ok(json) = serde_json::from_str::<serde_json::Value>(tool_input)
        && let Some(cmd) = json.get("command").and_then(|v| v.as_str())
    {
        return Some(cmd.to_string());
    }
    // Otherwise, assume it's a raw command
    Some(tool_input.to_string())
}