agent-status 2.1.0

use crate::agents::AgentName;

/// One generated extension/settings file: the filename to write it as and the
/// content to fill it with. Returned by [`build_extension`] for agents that
/// support a per-launch file-loaded integration (Claude Code's `--settings`,
/// pi's and omp's `-e <path>`).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ExtensionFile {
    pub filename: String,
    pub content: String,
}

/// Build the extension/settings file an alias-installed agent loads at launch.
///
/// Every [`AgentName`] variant has a branch (the match is exhaustive), so the
/// caller always gets an [`ExtensionFile`]. `claude-code` uses `--settings
/// <file>`, `pi` and `oh-my-pi` use `-e <file>`, and `opencode`'s
/// in-process plugin file can be copied once. The `filename` member is the
/// basename to write as (`claude-code.json`, `oh-my-pi.ts`, `pi.ts`,
/// `opencode.ts`); the `content` member is the file body.
#[must_use]
pub fn build_extension(bin_path: &str, agent: AgentName) -> ExtensionFile {
    match agent {
        AgentName::ClaudeCode => ExtensionFile {
            filename: "claude-code.json".to_string(),
            content: build_claude_code_settings(bin_path),
        },
        AgentName::OhMyPi => ExtensionFile {
            filename: "oh-my-pi.ts".to_string(),
            content: build_oh_my_pi_extension(bin_path),
        },
        AgentName::Pi => ExtensionFile {
            filename: "pi.ts".to_string(),
            content: build_pi_extension(bin_path),
        },
        AgentName::Opencode => ExtensionFile {
            filename: "opencode.ts".to_string(),
            content: build_opencode_extension(bin_path),
        },
    }
}

fn build_claude_code_settings(bin_path: &str) -> String {
    let set_notify = format!("{bin_path} set --agent claude-code notify");
    let set_done = format!("{bin_path} set --agent claude-code done");
    let set_working = format!("{bin_path} set --agent claude-code working");
    let set_idle = format!("{bin_path} set --agent claude-code idle");
    let clear = format!("{bin_path} clear --agent claude-code");

    // Intentionally NOT subscribing to Claude Code's `Notification` hook:
    // it fires for several matchers, including `idle_prompt` (a periodic
    // "Claude is waiting for your input" reminder fired on a timer) and
    // `permission_prompt` (which duplicates `PermissionRequest`). Wiring
    // `Notification → notify` would spuriously flip a freshly-cleared
    // (`/clear`) session back to `notify` after the idle reminder fires.
    // `PermissionRequest` fires first for tool-permission gates and is
    // the canonical, deterministic signal.
    // `PostToolUse` closes the post-approval gap: after a `PermissionRequest`
    // is approved, Claude Code emits no hook for the approval itself. Without
    // `PostToolUse → working` the row would stay stuck at `notify` until the
    // next `PreToolUse` or `Stop` — which can be many seconds away if the
    // agent is just thinking. `PostToolUse` fires for every tool call (not
    // just permission-gated ones), so it's a no-op transition in the normal
    // case and a fix in the approved-permission case. A denied permission
    // does not fire `PostToolUse`, so the row legitimately stays at `notify`
    // until the agent retries (next `PreToolUse`) or gives up (`Stop`).
    let value = serde_json::json!({
        "hooks": {
            "PermissionRequest": [{"hooks": [{"type": "command", "command": set_notify}]}],
            "Stop":              [{"hooks": [{"type": "command", "command": set_done}]}],
            "UserPromptSubmit":  [{"hooks": [{"type": "command", "command": &set_working}]}],
            "PreToolUse":        [{"hooks": [{"type": "command", "command": &set_working}]}],
            "PostToolUse":       [{"hooks": [{"type": "command", "command": set_working}]}],
            "SessionStart":      [{"hooks": [{"type": "command", "command": set_idle}]}],
            "SessionEnd":        [{"hooks": [{"type": "command", "command": clear}]}],
        }
    });
    serde_json::to_string_pretty(&value).expect("serde_json::Value always serializes")
}

fn build_oh_my_pi_extension(bin_path: &str) -> String {
    let template = include_str!("../../extensions/oh-my-pi.ts");
    let serialized = serde_json::to_string(bin_path).expect("path serializes");
    let replacement = format!("const BIN = {serialized};");
    template.replacen(TS_BIN_RESOLUTION_LINE, &replacement, 1)
}

fn build_pi_extension(bin_path: &str) -> String {
    let template = include_str!("../../extensions/pi.ts");
    let serialized = serde_json::to_string(bin_path).expect("path serializes");
    let replacement = format!("const BIN = {serialized};");
    template.replacen(TS_BIN_RESOLUTION_LINE, &replacement, 1)
}

fn build_opencode_extension(bin_path: &str) -> String {
    let template = include_str!("../../extensions/opencode.ts");
    let serialized = serde_json::to_string(bin_path).expect("path serializes");
    let replacement = format!("const BIN = {serialized};");
    template.replacen(TS_BIN_RESOLUTION_LINE, &replacement, 1)
}

/// The exact BIN-resolution line shared by `extensions/oh-my-pi.ts`,
/// `extensions/pi.ts`, and `extensions/opencode.ts`. Matched
/// verbatim by `str::replacen` so the embedded template can be specialized
/// with an absolute path. If this line drifts in the .ts source, the
/// substitution silently no-ops and the file keeps its env-fallback resolution
/// at runtime — still functional, just not alias-optimized.
const TS_BIN_RESOLUTION_LINE: &str =
    "const BIN = process.env.AGENT_STATUS_BIN ?? \"agent-status\";";

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

    #[test]
    fn build_extension_returns_extension_for_claude_code() {
        let ext = build_extension("/x/agent-status", AgentName::ClaudeCode);
        assert_eq!(ext.filename, "claude-code.json");
        let parsed: serde_json::Value = serde_json::from_str(&ext.content).unwrap();
        assert!(parsed.get("hooks").is_some(), "missing top-level hooks key");
    }

    #[test]
    fn build_extension_claude_code_wires_all_hook_events() {
        let ext = build_extension("/x/agent-status", AgentName::ClaudeCode);
        for event in [
            "PermissionRequest",
            "Stop",
            "UserPromptSubmit",
            "PreToolUse",
            "PostToolUse",
            "SessionStart",
            "SessionEnd",
        ] {
            assert!(ext.content.contains(event), "missing hook event {event}");
        }
    }

    #[test]
    fn build_extension_claude_code_does_not_subscribe_to_notification() {
        // Notification fires on a timer for `idle_prompt` ("Claude is
        // waiting for your input"), which would spuriously flip a
        // freshly-cleared (`/clear`) session from `idle` back to
        // `notify`. PermissionRequest covers the legitimate permission
        // case. See the comment in `build_claude_code_settings`.
        let ext = build_extension("/x/agent-status", AgentName::ClaudeCode);
        let parsed: serde_json::Value = serde_json::from_str(&ext.content).unwrap();
        assert!(
            parsed.pointer("/hooks/Notification").is_none(),
            "should not subscribe to Notification; got: {}",
            ext.content,
        );
    }

    #[test]
    fn build_extension_claude_code_uses_set_and_clear_correctly() {
        let ext = build_extension("/path/to/agent-status", AgentName::ClaudeCode);
        assert!(ext.content.contains("set --agent claude-code notify"));
        assert!(ext.content.contains("set --agent claude-code done"));
        assert!(ext.content.contains("clear --agent claude-code"));
        assert!(ext.content.contains("/path/to/agent-status"));
    }

    #[test]
    fn build_extension_escapes_unsafe_chars_in_bin_path() {
        let ext = build_extension(
            r#"/x/has"quote\and-backslash/agent-status"#,
            AgentName::ClaudeCode,
        );
        let parsed: serde_json::Value = serde_json::from_str(&ext.content).unwrap();
        let command = parsed
            .pointer("/hooks/PermissionRequest/0/hooks/0/command")
            .and_then(serde_json::Value::as_str)
            .expect("PermissionRequest command string");
        assert!(command.contains(r#"has"quote\and-backslash"#), "got: {command}");
    }

    #[test]
    fn build_extension_returns_pi_extension() {
        let ext = build_extension("/abs/path/agent-status", AgentName::Pi);
        assert_eq!(ext.filename, "pi.ts");
        assert!(
            ext.content.contains(r#"const BIN = "/abs/path/agent-status";"#),
            "missing substituted BIN; got:\n{}",
            ext.content,
        );
        assert!(
            !ext.content.contains("process.env.AGENT_STATUS_BIN ??"),
            "env-fallback line should have been replaced",
        );
        assert!(ext.content.contains("export default function"));
    }

    #[test]
    fn build_extension_pi_extension_json_escapes_bin_path() {
        let ext = build_extension(
            r#"/x/has"quote\and-backslash/agent-status"#,
            AgentName::Pi,
        );
        assert!(
            ext.content.contains(r#"const BIN = "/x/has\"quote\\and-backslash/agent-status";"#),
            "BIN line not escaped correctly; got:\n{}",
            ext.content,
        );
    }

    #[test]
    fn build_extension_pi_extension_wires_all_parity_events() {
        // The pi bridge must keep parity with the Claude Code hook set:
        // notify (ask tool + approval prediction), the tool_call /
        // tool_execution_end gap-closers, and stale-row cleanup on
        // in-process session switches. See extensions/pi.ts.
        let ext = build_extension("/x/agent-status", AgentName::Pi);
        for event in [
            "session_start",
            "session_shutdown",
            "session_switch",
            "session_branch",
            "before_agent_start",
            "tool_execution_start",
            "tool_call",
            "tool_execution_end",
            "agent_end",
        ] {
            assert!(
                ext.content.contains(&format!("pi.on(\"{event}\"")),
                "missing pi event subscription {event}",
            );
        }
        assert!(
            ext.content.contains("\"notify\""),
            "bridge never emits notify",
        );
    }

    #[test]
    fn build_extension_returns_opencode_extension() {
        let ext = build_extension("/abs/path/agent-status", AgentName::Opencode);
        assert_eq!(ext.filename, "opencode.ts");
        assert!(
            ext.content.contains(r#"const BIN = "/abs/path/agent-status";"#),
            "missing substituted BIN; got:\n{}",
            ext.content,
        );
        assert!(
            !ext.content.contains("process.env.AGENT_STATUS_BIN ??"),
            "env-fallback line should have been replaced",
        );
        assert!(ext.content.contains("AgentStatusPlugin"));
    }

    #[test]
    fn build_extension_opencode_extension_json_escapes_bin_path() {
        let ext = build_extension(
            r#"/x/has"quote\and-backslash/agent-status"#,
            AgentName::Opencode,
        );
        assert!(
            ext.content.contains(r#"const BIN = "/x/has\"quote\\and-backslash/agent-status";"#),
            "BIN line not escaped correctly; got:\n{}",
            ext.content,
        );
    }

    #[test]
    fn build_extension_claude_code_user_prompt_submit_sets_working() {
        let ext = build_extension("/path/agent-status", AgentName::ClaudeCode);
        let parsed: serde_json::Value = serde_json::from_str(&ext.content).unwrap();
        let cmd = parsed
            .pointer("/hooks/UserPromptSubmit/0/hooks/0/command")
            .and_then(serde_json::Value::as_str)
            .expect("UserPromptSubmit command");
        assert!(
            cmd.contains("set --agent claude-code working"),
            "got: {cmd}",
        );
    }

    #[test]
    fn build_extension_claude_code_pre_tool_use_sets_working() {
        let ext = build_extension("/path/agent-status", AgentName::ClaudeCode);
        let parsed: serde_json::Value = serde_json::from_str(&ext.content).unwrap();
        let cmd = parsed
            .pointer("/hooks/PreToolUse/0/hooks/0/command")
            .and_then(serde_json::Value::as_str)
            .expect("PreToolUse command");
        assert!(
            cmd.contains("set --agent claude-code working"),
            "got: {cmd}",
        );
    }

    #[test]
    fn build_extension_claude_code_post_tool_use_sets_working() {
        // PostToolUse fires after every tool call (including those gated by
        // PermissionRequest). It transitions the row out of `notify` once
        // an approved tool finishes, since Claude Code emits no hook for
        // permission approval itself.
        let ext = build_extension("/path/agent-status", AgentName::ClaudeCode);
        let parsed: serde_json::Value = serde_json::from_str(&ext.content).unwrap();
        let cmd = parsed
            .pointer("/hooks/PostToolUse/0/hooks/0/command")
            .and_then(serde_json::Value::as_str)
            .expect("PostToolUse command");
        assert!(
            cmd.contains("set --agent claude-code working"),
            "got: {cmd}",
        );
    }

    #[test]
    fn build_extension_claude_code_permission_request_sets_notify() {
        // PermissionRequest fires when Claude Code shows a tool-permission dialog
        // (after PreToolUse, before the user clicks Yes/No). Without this hook the
        // PreToolUse-emitted `working` state stays until the user resolves the
        // dialog — so the tmux indicator and agent-switcher would silently miss
        // the "needs you now" transition.
        let ext = build_extension("/path/agent-status", AgentName::ClaudeCode);
        let parsed: serde_json::Value = serde_json::from_str(&ext.content).unwrap();
        let cmd = parsed
            .pointer("/hooks/PermissionRequest/0/hooks/0/command")
            .and_then(serde_json::Value::as_str)
            .expect("PermissionRequest command");
        assert!(
            cmd.contains("set --agent claude-code notify"),
            "got: {cmd}",
        );
    }

    #[test]
    fn build_extension_claude_code_session_start_sets_idle() {
        // SessionStart registers the session as `idle` so every Claude session
        // appears in the switcher from the moment it starts — even before the
        // user has typed their first prompt. Clearing on SessionStart (the
        // previous behavior) made the row invisible until UserPromptSubmit or
        // PreToolUse fired.
        let ext = build_extension("/path/agent-status", AgentName::ClaudeCode);
        let parsed: serde_json::Value = serde_json::from_str(&ext.content).unwrap();
        let cmd = parsed
            .pointer("/hooks/SessionStart/0/hooks/0/command")
            .and_then(serde_json::Value::as_str)
            .expect("SessionStart command");
        assert!(
            cmd.contains("set --agent claude-code idle"),
            "got: {cmd}",
        );
    }

    #[test]
    fn build_extension_claude_code_session_end_still_clears() {
        // SessionEnd is the only lifecycle event that should remove the row.
        let ext = build_extension("/path/agent-status", AgentName::ClaudeCode);
        let parsed: serde_json::Value = serde_json::from_str(&ext.content).unwrap();
        let cmd = parsed
            .pointer("/hooks/SessionEnd/0/hooks/0/command")
            .and_then(serde_json::Value::as_str)
            .expect("SessionEnd command");
        assert!(
            cmd.contains("clear --agent claude-code"),
            "SessionEnd should still clear; got: {cmd}",
        );
    }

    #[test]
    fn build_extension_returns_oh_my_pi_extension() {
        let ext = build_extension("/abs/path/agent-status", AgentName::OhMyPi);
        assert_eq!(ext.filename, "oh-my-pi.ts");
        assert!(
            ext.content.contains(r#"const BIN = "/abs/path/agent-status";"#),
            "missing substituted BIN; got:\n{}",
            ext.content,
        );
        assert!(
            !ext.content.contains("process.env.AGENT_STATUS_BIN ??"),
            "env-fallback line should have been replaced",
        );
        assert!(ext.content.contains("export default function"));
    }

    #[test]
    fn build_extension_oh_my_pi_extension_json_escapes_bin_path() {
        let ext = build_extension(
            r#"/x/has"quote\and-backslash/agent-status"#,
            AgentName::OhMyPi,
        );
        assert!(
            ext.content.contains(r#"const BIN = "/x/has\"quote\\and-backslash/agent-status";"#),
            "BIN line not escaped correctly; got:\n{}",
            ext.content,
        );
    }

    #[test]
    fn build_extension_oh_my_pi_wires_claude_code_parity_events() {
        // The bridge must subscribe to every event in the parity mapping —
        // including ask→notify and the switch/branch row cleanup.
        let ext = build_extension("/x/agent-status", AgentName::OhMyPi);
        for event in [
            "session_start",
            "session_switch",
            "session_branch",
            "session_shutdown",
            "before_agent_start",
            "tool_execution_start",
            "tool_execution_end",
            "agent_end",
        ] {
            assert!(
                ext.content.contains(&format!("omp.on(\"{event}\"")),
                "bridge missing subscription for {event}",
            );
        }
        assert!(
            ext.content.contains(r#""set", "notify""#),
            "bridge never sets notify (ask-tool mapping missing)",
        );
    }
}