sqlmodel-console 0.2.2

//! Agent Compatibility Test Suite
//!
//! This module verifies that console output maintains compatibility with AI coding
//! agents (Claude Code, Codex, Cursor, Aider, Gemini, etc.) by testing:
//!
//! 1. Stream separation (stdout for data, stderr for decorations)
//! 2. Plain mode output has no ANSI escape codes
//! 3. Agent detection works correctly for all known agents
//! 4. Output format is machine-parseable
//! 5. Force override flags work as expected
//!
//! # Running Tests
//!
//! These tests manipulate environment variables and must be run single-threaded:
//!
//! ```bash
//! cargo test -p sqlmodel-console --test agent_compat -- --test-threads=1
//! ```

use sqlmodel_console::{OutputMode, SqlModelConsole};
use std::env;

// ============================================================================
// Environment Variable Helpers
// ============================================================================

/// All environment variables that affect output mode detection.
const MODE_VARS: &[&str] = &[
    // SQLModel explicit overrides
    "SQLMODEL_PLAIN",
    "SQLMODEL_JSON",
    "SQLMODEL_RICH",
    // Standard conventions
    "NO_COLOR",
    "CI",
    "TERM",
    // Agent markers
    "CLAUDE_CODE",
    "CODEX_CLI",
    "CODEX_SESSION",
    "CURSOR_SESSION",
    "CURSOR_EDITOR",
    "AIDER_MODEL",
    "AIDER_REPO",
    "AGENT_MODE",
    "AI_AGENT",
    "GITHUB_COPILOT",
    "COPILOT_SESSION",
    "CONTINUE_SESSION",
    "CODY_AGENT",
    "CODY_SESSION",
    "WINDSURF_SESSION",
    "CODEIUM_AGENT",
    "GEMINI_CLI",
    "GEMINI_SESSION",
    "CODEWHISPERER_SESSION",
    "AMAZON_Q_SESSION",
];

/// Wrapper for env::set_var (unsafe in Rust 2024 edition).
///
/// # Safety
/// Tests must be run with `--test-threads=1` for safety.
#[allow(unsafe_code)]
fn set_var(key: &str, value: &str) {
    unsafe { env::set_var(key, value) };
}

/// Wrapper for env::remove_var (unsafe in Rust 2024 edition).
#[allow(unsafe_code)]
fn remove_var(key: &str) {
    unsafe { env::remove_var(key) };
}

/// RAII guard for clean environment state.
struct EnvGuard {
    saved: Vec<(&'static str, Option<String>)>,
}

impl EnvGuard {
    fn new() -> Self {
        let saved = MODE_VARS
            .iter()
            .map(|&var| (var, env::var(var).ok()))
            .collect();

        // Clear all mode-affecting vars
        for &var in MODE_VARS {
            remove_var(var);
        }

        Self { saved }
    }
}

impl Drop for EnvGuard {
    fn drop(&mut self) {
        // Restore original values
        for &(var, ref val) in &self.saved {
            match val {
                Some(v) => set_var(var, v),
                None => remove_var(var),
            }
        }
    }
}

// ============================================================================
// Agent Detection Tests
// ============================================================================

/// Test that Claude Code environment is detected correctly.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_claude_code() {
    let _guard = EnvGuard::new();
    set_var("CLAUDE_CODE", "1");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that OpenAI Codex CLI is detected correctly.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_codex_cli() {
    let _guard = EnvGuard::new();
    set_var("CODEX_CLI", "1");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that Codex session marker is detected.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_codex_session() {
    let _guard = EnvGuard::new();
    set_var("CODEX_SESSION", "session-123");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that Cursor IDE is detected correctly.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_cursor_session() {
    let _guard = EnvGuard::new();
    set_var("CURSOR_SESSION", "abc123");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that Cursor editor marker is detected.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_cursor_editor() {
    let _guard = EnvGuard::new();
    set_var("CURSOR_EDITOR", "1");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that Aider is detected via AIDER_MODEL.
#[test]
#[ignore = "requires --test-threads=1 due to env var race conditions"]
fn test_detects_aider_model() {
    let _guard = EnvGuard::new();
    set_var("AIDER_MODEL", "gpt-4");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that Aider is detected via AIDER_REPO.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_aider_repo() {
    let _guard = EnvGuard::new();
    set_var("AIDER_REPO", "/path/to/repo");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that generic AGENT_MODE marker is detected.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_agent_mode() {
    let _guard = EnvGuard::new();
    set_var("AGENT_MODE", "1");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that generic AI_AGENT marker is detected.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_ai_agent() {
    let _guard = EnvGuard::new();
    set_var("AI_AGENT", "1");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that GitHub Copilot is detected.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_github_copilot() {
    let _guard = EnvGuard::new();
    set_var("GITHUB_COPILOT", "1");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that Copilot session marker is detected.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_copilot_session() {
    let _guard = EnvGuard::new();
    set_var("COPILOT_SESSION", "sess-456");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that Continue.dev is detected.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_continue_session() {
    let _guard = EnvGuard::new();
    set_var("CONTINUE_SESSION", "cont-789");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that Sourcegraph Cody agent marker is detected.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_cody_agent() {
    let _guard = EnvGuard::new();
    set_var("CODY_AGENT", "1");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that Cody session marker is detected.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_cody_session() {
    let _guard = EnvGuard::new();
    set_var("CODY_SESSION", "cody-abc");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that Windsurf/Codeium is detected via WINDSURF_SESSION.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_windsurf_session() {
    let _guard = EnvGuard::new();
    set_var("WINDSURF_SESSION", "ws-123");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that Codeium agent is detected.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_codeium_agent() {
    let _guard = EnvGuard::new();
    set_var("CODEIUM_AGENT", "1");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that Google Gemini CLI is detected.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_gemini_cli() {
    let _guard = EnvGuard::new();
    set_var("GEMINI_CLI", "1");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that Gemini session marker is detected.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_gemini_session() {
    let _guard = EnvGuard::new();
    set_var("GEMINI_SESSION", "gem-xyz");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that Amazon CodeWhisperer is detected.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_codewhisperer() {
    let _guard = EnvGuard::new();
    set_var("CODEWHISPERER_SESSION", "cw-123");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that Amazon Q is detected.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_detects_amazon_q() {
    let _guard = EnvGuard::new();
    set_var("AMAZON_Q_SESSION", "q-456");
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that no agent is detected in clean environment.
#[test]
fn test_no_agent_when_clean() {
    let _guard = EnvGuard::new();
    assert!(!OutputMode::is_agent_environment());
}

// ============================================================================
// Environment Variable Precedence Tests
// ============================================================================

/// Test that SQLMODEL_RICH overrides agent detection.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_force_rich_in_agent_environment() {
    let _guard = EnvGuard::new();
    set_var("CLAUDE_CODE", "1");
    set_var("SQLMODEL_RICH", "1");
    // Despite being in agent environment, SQLMODEL_RICH forces rich mode
    assert_eq!(OutputMode::detect(), OutputMode::Rich);
}

/// Test that SQLMODEL_PLAIN takes priority over agent detection.
#[test]
fn test_plain_override_with_agent() {
    let _guard = EnvGuard::new();
    set_var("CLAUDE_CODE", "1");
    set_var("SQLMODEL_PLAIN", "1");
    // Both want plain, should be plain
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that SQLMODEL_PLAIN takes priority over SQLMODEL_RICH.
#[test]
fn test_plain_beats_rich_override() {
    let _guard = EnvGuard::new();
    set_var("SQLMODEL_PLAIN", "1");
    set_var("SQLMODEL_RICH", "1");
    // PLAIN is checked first
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that SQLMODEL_PLAIN takes priority over SQLMODEL_JSON.
#[test]
fn test_plain_beats_json_override() {
    let _guard = EnvGuard::new();
    set_var("SQLMODEL_PLAIN", "1");
    set_var("SQLMODEL_JSON", "1");
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that SQLMODEL_JSON comes after PLAIN but before RICH.
#[test]
fn test_json_beats_rich_override() {
    let _guard = EnvGuard::new();
    set_var("SQLMODEL_JSON", "1");
    set_var("SQLMODEL_RICH", "1");
    // JSON is checked before RICH
    assert_eq!(OutputMode::detect(), OutputMode::Json);
}

/// Test that NO_COLOR standard convention works.
#[test]
fn test_no_color_causes_plain() {
    let _guard = EnvGuard::new();
    set_var("NO_COLOR", ""); // Mere presence triggers it
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that CI environment causes plain mode.
#[test]
fn test_ci_causes_plain() {
    let _guard = EnvGuard::new();
    set_var("CI", "true");
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that TERM=dumb causes plain mode.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_dumb_terminal_causes_plain() {
    let _guard = EnvGuard::new();
    set_var("TERM", "dumb");
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

/// Test that multiple agent markers don't cause issues.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_multiple_agents_detected() {
    let _guard = EnvGuard::new();
    set_var("CLAUDE_CODE", "1");
    set_var("CODEX_CLI", "1");
    set_var("CURSOR_SESSION", "test");
    // Should still detect agent environment
    assert!(OutputMode::is_agent_environment());
    assert_eq!(OutputMode::detect(), OutputMode::Plain);
}

// ============================================================================
// Plain Mode Output Tests (No ANSI Codes)
// ============================================================================

/// Test that plain mode console doesn't produce ANSI codes.
#[test]
fn test_plain_mode_console_no_ansi() {
    let console = SqlModelConsole::with_mode(OutputMode::Plain);
    assert!(console.is_plain());
    assert!(!console.mode().supports_ansi());
}

/// Test that JSON mode also doesn't support ANSI.
#[test]
fn test_json_mode_no_ansi() {
    let console = SqlModelConsole::with_mode(OutputMode::Json);
    assert!(console.is_json());
    assert!(!console.mode().supports_ansi());
}

/// Test that only Rich mode supports ANSI.
#[test]
fn test_only_rich_supports_ansi() {
    assert!(!OutputMode::Plain.supports_ansi());
    assert!(OutputMode::Rich.supports_ansi());
    assert!(!OutputMode::Json.supports_ansi());
}

/// Test that markup stripping removes ANSI-style tags.
#[test]
fn test_strip_markup_removes_style_tags() {
    use sqlmodel_console::console::strip_markup;

    // Basic tags
    assert_eq!(strip_markup("[bold]text[/]"), "text");
    assert_eq!(strip_markup("[red]error[/]"), "error");
    assert_eq!(strip_markup("[green]success[/]"), "success");

    // Compound styles
    assert_eq!(strip_markup("[bold red]warning[/]"), "warning");
    assert_eq!(strip_markup("[red on white]highlighted[/]"), "highlighted");

    // Nested tags
    assert_eq!(strip_markup("[bold][italic]nested[/][/]"), "nested");

    // Multiple tags in sequence
    assert_eq!(strip_markup("[red]a[/] [blue]b[/]"), "a b");
}

/// Test that strip_markup preserves non-markup brackets.
///
/// The strip_markup function considers a tag to be markup if:
/// 1. It starts with '/' (closing tags)
/// 2. It contains a space (compound styles)
/// 3. It has 2+ alphabetic characters (style names)
///
/// Therefore:
/// - `[0]`, `[i]`, `[1]` are preserved (numeric/single letter)
/// - `[key]`, `[idx]` are stripped (2+ letters = looks like markup)
#[test]
fn test_strip_markup_preserves_array_indices() {
    use sqlmodel_console::console::strip_markup;

    // Numeric indices should be preserved
    assert_eq!(strip_markup("array[0]"), "array[0]");
    assert_eq!(strip_markup("array[123]"), "array[123]");

    // Single-letter indices should be preserved
    assert_eq!(strip_markup("items[i]"), "items[i]");
    assert_eq!(strip_markup("matrix[n]"), "matrix[n]");

    // Mixed alphanumeric with digits are preserved
    assert_eq!(strip_markup("data[x1]"), "data[x1]");
    assert_eq!(strip_markup("arr[i2]"), "arr[i2]");

    // Function calls with numeric indices
    assert_eq!(strip_markup("get_item(arr[0])"), "get_item(arr[0])");

    // Note: [key], [idx] etc. with 2+ letters ARE stripped because they
    // look like markup tags. This is by design - real code rarely uses
    // such identifiers in brackets, while [bold], [red] are common markup.
}

/// Test that plain output has no escape sequences.
#[test]
fn test_plain_output_no_escape_sequences() {
    // Common ANSI escape sequences to check for
    let ansi_patterns = [
        "\x1b[",    // CSI sequence start
        "\x1b]",    // OSC sequence start
        "\x1bP",    // DCS sequence start
        "\x1b\\",   // ST (string terminator)
        "\u{009b}", // C1 CSI
    ];

    // Create plain console and check method contracts
    let console = SqlModelConsole::with_mode(OutputMode::Plain);

    // The console contract is that plain mode won't emit ANSI codes
    // We verify the mode settings here
    assert!(console.is_plain());
    assert!(!console.mode().supports_ansi());

    // Test the mode enum directly
    for pattern in ansi_patterns {
        let mode_str = OutputMode::Plain.as_str();
        assert!(
            !mode_str.contains(pattern),
            "Mode string should not contain ANSI: {mode_str}"
        );
    }
}

// ============================================================================
// Machine Parseability Tests
// ============================================================================

/// Test that plain mode strings are parseable.
#[test]
fn test_plain_mode_strings_parseable() {
    let console = SqlModelConsole::with_mode(OutputMode::Plain);

    // Mode string is simple ASCII
    assert_eq!(console.mode().as_str(), "plain");
    assert!(console.mode().as_str().is_ascii());
}

/// Test that JSON mode produces valid JSON.
#[test]
fn test_json_mode_produces_valid_json() {
    #[derive(serde::Serialize)]
    struct TestData {
        name: String,
        count: i32,
        active: bool,
    }

    let data = TestData {
        name: "test".to_string(),
        count: 42,
        active: true,
    };

    let json = serde_json::to_string(&data).unwrap();

    // Should be valid JSON
    let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
    assert_eq!(parsed["name"], "test");
    assert_eq!(parsed["count"], 42);
    assert_eq!(parsed["active"], true);
}

/// Test that JSON mode string is correct.
#[test]
fn test_json_mode_string() {
    assert_eq!(OutputMode::Json.as_str(), "json");
    assert!(OutputMode::Json.is_structured());
}

/// Test mode display implementations.
#[test]
fn test_mode_display() {
    assert_eq!(format!("{}", OutputMode::Plain), "plain");
    assert_eq!(format!("{}", OutputMode::Rich), "rich");
    assert_eq!(format!("{}", OutputMode::Json), "json");
}

// ============================================================================
// Console Constructor Tests
// ============================================================================

/// Test that console auto-detection works.
#[test]
fn test_console_auto_detection() {
    let _guard = EnvGuard::new();
    set_var("CLAUDE_CODE", "1");

    let console = SqlModelConsole::new();
    // Should detect agent and use plain mode
    assert!(console.is_plain());
}

/// Test that console respects explicit mode.
#[test]
fn test_console_explicit_mode() {
    let console = SqlModelConsole::with_mode(OutputMode::Rich);
    assert!(console.is_rich());

    let console = SqlModelConsole::with_mode(OutputMode::Plain);
    assert!(console.is_plain());

    let console = SqlModelConsole::with_mode(OutputMode::Json);
    assert!(console.is_json());
}

/// Test that console mode can be changed.
#[test]
fn test_console_set_mode() {
    let mut console = SqlModelConsole::with_mode(OutputMode::Rich);
    assert!(console.is_rich());

    console.set_mode(OutputMode::Plain);
    assert!(console.is_plain());

    console.set_mode(OutputMode::Json);
    assert!(console.is_json());
}

// ============================================================================
// Edge Cases
// ============================================================================

/// Test truthy value detection for env vars.
#[test]
fn test_truthy_values() {
    let _guard = EnvGuard::new();

    // Various truthy values
    for truthy in ["1", "true", "TRUE", "True", "yes", "YES", "on", "ON"] {
        remove_var("SQLMODEL_PLAIN");
        set_var("SQLMODEL_PLAIN", truthy);
        assert_eq!(
            OutputMode::detect(),
            OutputMode::Plain,
            "Failed for truthy value: {truthy}"
        );
    }
}

/// Test falsy value detection for env vars.
#[test]
#[ignore = "flaky: env var race conditions in parallel tests"]
fn test_falsy_values() {
    // Falsy values should NOT trigger plain mode (without other indicators)
    // Note: In test environment (non-TTY), we get Plain anyway,
    // so we test the RICH override instead
    for falsy in ["0", "false", "FALSE", "no", "NO", "off", "OFF", ""] {
        // Create fresh guard for each iteration to avoid parallel test interference
        let _guard = EnvGuard::new();
        set_var("SQLMODEL_PLAIN", falsy);
        set_var("SQLMODEL_RICH", "1"); // Force rich to check if PLAIN was triggered

        let mode = OutputMode::detect();
        // If PLAIN was falsely triggered, we'd get Plain. We should get Rich.
        assert_eq!(
            mode,
            OutputMode::Rich,
            "SQLMODEL_PLAIN={falsy} should not trigger plain mode"
        );
    }
}

/// Test that empty agent marker is still detected (presence matters).
#[test]
#[ignore = "flaky: depends on environment variables not being set by CI/agent context"]
fn test_agent_marker_presence_not_value() {
    let _guard = EnvGuard::new();

    // Empty value should still trigger detection (presence test)
    set_var("CLAUDE_CODE", "");
    assert!(OutputMode::is_agent_environment());
}

/// Test default mode enum value.
#[test]
fn test_output_mode_default() {
    assert_eq!(OutputMode::default(), OutputMode::Rich);
}

/// Test mode predicate methods.
#[test]
fn test_mode_predicates() {
    // is_plain
    assert!(OutputMode::Plain.is_plain());
    assert!(!OutputMode::Rich.is_plain());
    assert!(!OutputMode::Json.is_plain());

    // is_rich
    assert!(!OutputMode::Plain.is_rich());
    assert!(OutputMode::Rich.is_rich());
    assert!(!OutputMode::Json.is_rich());

    // is_structured
    assert!(!OutputMode::Plain.is_structured());
    assert!(!OutputMode::Rich.is_structured());
    assert!(OutputMode::Json.is_structured());
}

/// Test that console default equals new.
#[test]
fn test_console_default_equals_new() {
    let _guard = EnvGuard::new();

    let c1 = SqlModelConsole::default();
    let c2 = SqlModelConsole::new();

    assert_eq!(c1.mode(), c2.mode());
    assert_eq!(c1.get_plain_width(), c2.get_plain_width());
}

// ============================================================================
// Documentation Tests
// ============================================================================

/// Document expected behavior for all agents.
///
/// This test serves as living documentation of which agents are supported
/// and how they are detected.
///
/// # Note
///
/// This test is marked `#[ignore]` because it iterates through many agents
/// in a single test function, making it susceptible to environment variable
/// race conditions when run in parallel with other tests.
///
/// Individual agent detection is covered by dedicated tests (e.g.,
/// `test_detects_claude_code`, `test_detects_codex_cli`, etc.).
///
/// To run this test specifically:
/// ```bash
/// cargo test -p sqlmodel-console --test agent_compat test_documented_agent_support -- --ignored --test-threads=1
/// ```
#[test]
#[ignore = "requires --test-threads=1 due to env var race conditions"]
fn test_documented_agent_support() {
    struct AgentInfo {
        name: &'static str,
        env_var: &'static str,
        example_value: &'static str,
    }

    let agents = [
        AgentInfo {
            name: "Claude Code",
            env_var: "CLAUDE_CODE",
            example_value: "1",
        },
        AgentInfo {
            name: "OpenAI Codex CLI",
            env_var: "CODEX_CLI",
            example_value: "1",
        },
        AgentInfo {
            name: "Cursor IDE",
            env_var: "CURSOR_SESSION",
            example_value: "session-id",
        },
        AgentInfo {
            name: "Aider",
            env_var: "AIDER_MODEL",
            example_value: "gpt-4",
        },
        AgentInfo {
            name: "GitHub Copilot",
            env_var: "GITHUB_COPILOT",
            example_value: "1",
        },
        AgentInfo {
            name: "Continue.dev",
            env_var: "CONTINUE_SESSION",
            example_value: "sess-123",
        },
        AgentInfo {
            name: "Sourcegraph Cody",
            env_var: "CODY_AGENT",
            example_value: "1",
        },
        AgentInfo {
            name: "Windsurf/Codeium",
            env_var: "WINDSURF_SESSION",
            example_value: "ws-123",
        },
        AgentInfo {
            name: "Google Gemini CLI",
            env_var: "GEMINI_CLI",
            example_value: "1",
        },
        AgentInfo {
            name: "Amazon CodeWhisperer",
            env_var: "CODEWHISPERER_SESSION",
            example_value: "cw-123",
        },
        AgentInfo {
            name: "Amazon Q",
            env_var: "AMAZON_Q_SESSION",
            example_value: "q-456",
        },
    ];

    for agent in agents {
        let _guard = EnvGuard::new();
        set_var(agent.env_var, agent.example_value);

        assert!(
            OutputMode::is_agent_environment(),
            "{} should be detected via {} env var",
            agent.name,
            agent.env_var
        );

        assert_eq!(
            OutputMode::detect(),
            OutputMode::Plain,
            "{} should trigger plain mode",
            agent.name
        );
    }
}