sessionwiki 0.34.4

//! Golden-file tests for the session adapters.
//!
//! These guard the most fragile part of the project: parsing three different
//! JSONL/JSON schemas that drift between tool versions. Each fixture under
//! `tests/fixtures/<tool>/` is a small, realistic session including the edge
//! cases the parsers are supposed to handle (boilerplate dropping, subagent
//! detection, malformed lines, multi-block content, skipped roles).
//!
//! When a tool changes its format, a fixture from the new version plus an
//! assertion here is the cleanest possible bug report and regression test.

use sessionwiki::adapters;
use sessionwiki::model::Session;
use std::path::PathBuf;

fn fixture(rel: &str) -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("tests/fixtures")
        .join(rel)
}

fn parse(tool: &str, rel: &str) -> Session {
    let adapter = adapters::by_name(tool).expect("adapter exists");
    adapters::parse_session(adapter.as_ref(), &fixture(rel)).expect("parse succeeds")
}

fn roles(s: &Session) -> Vec<&'static str> {
    s.messages.iter().map(|m| m.role.label()).collect()
}

#[test]
fn claude_main_session() {
    let s = parse(
        "claude-code",
        "claude-code/proj-a/0a000000-0000-4000-8000-000000000001.jsonl",
    );

    // Title comes from the summary line, not the first user message.
    assert_eq!(s.title, "Fix CORS preflight failing on /auth routes");
    assert_eq!(s.tool, "claude-code");
    assert_eq!(s.project, "/home/dev/proj-a");
    assert!(!s.subagent);

    // A malformed line and the isMeta:true boilerplate user turn are dropped;
    // the shared pass folds each tool call and result into one Tool message.
    assert_eq!(
        roles(&s),
        [
            "user",
            "assistant",
            "tool",
            "tool",
            "tool",
            "tool",
            "assistant"
        ]
    );
    assert_eq!(s.messages[2].text, "→ Bash(rg -n cors src/) ⇒ ok · 1 line");
    assert_eq!(
        s.messages[3].text,
        "→ Edit(/home/dev/proj-a/src/middleware/mod.rs) ⇒ error · 2 lines — Edit failed"
    );
    assert_eq!(
        s.messages[4].text,
        "→ Edit(/home/dev/proj-a/src/middleware/mod.rs) ⇒ pending"
    );
    assert_eq!(
        s.messages[5].text,
        "→ Write(/home/dev/proj-a/tests/cors_preflight.rs) ⇒ ok · 5 lines"
    );
    assert!(matches!(
        &s.messages[5].tool,
        Some(sessionwiki::model::ToolEvent::Summary(summary))
            if summary.output.as_deref().is_some_and(|output| output.lines().count() == 5)
    ));

    // The dropped boilerplate must not leak into any message.
    assert!(s
        .messages
        .iter()
        .all(|m| !m.text.contains("harness boilerplate")));

    // First user prompt and final assistant message survive intact.
    assert!(s.messages[0].text.contains("Preflight requests"));
    assert!(s.messages.iter().any(|m| m.text.contains("14 tests pass")));

    // Provenance: Edit/Write file_path is extracted, the repeated edit to
    // mod.rs is de-duplicated, and the read-only Bash call contributes nothing.
    assert_eq!(
        s.touched,
        [
            "/home/dev/proj-a/src/middleware/mod.rs",
            "/home/dev/proj-a/tests/cors_preflight.rs"
        ]
    );

    assert_eq!(
        s.started.map(|t| t.to_rfc3339()),
        Some("2026-06-09T14:01:00+00:00".to_string())
    );
}

#[test]
fn claude_subagent_is_flagged() {
    let s = parse(
        "claude-code",
        "claude-code/proj-a/0a000000-0000-4000-8000-000000000001/subagents/agent-deadbeef.jsonl",
    );
    assert!(s.subagent, "files under /subagents/ must be flagged");
    assert_eq!(roles(&s), ["user", "assistant"]);
    assert_eq!(s.title, "Search the codebase for all CORS references.");
}

#[test]
fn claude_ai_title_precedes_first_user_message() {
    let s = parse(
        "claude-code",
        "claude-code/proj-a/0a000000-0000-4000-8000-000000000002.jsonl",
    );

    assert_eq!(s.title, "Repair synthetic schema drift");
    assert_eq!(roles(&s), ["user"]);
}

#[test]
fn codex_session_with_schema_variants() {
    let s = parse(
        "codex",
        "codex/rollout-2026-06-11T13-00-00-019eb9b2-1466-7e93-8b85-5b596295e96b.jsonl",
    );

    assert_eq!(s.tool, "codex");
    assert_eq!(s.project, "/home/dev/api-server");
    assert_eq!(s.title, "Write property-based tests for the rate limiter.");

    // environment_context boilerplate and reasoning are dropped; function
    // calls and their outputs become one compact Tool message each, while both
    // response_item and event_msg message shapes parse.
    assert_eq!(
        roles(&s),
        ["user", "tool", "tool", "assistant", "user", "assistant"]
    );
    assert!(s
        .messages
        .iter()
        .all(|m| !m.text.contains("environment_context")));
    assert_eq!(s.messages[1].text, "→ shell(cargo test) ⇒ pending");
    assert!(s.messages[2]
        .text
        .starts_with("→ shell(apply_patch *** Begin Patch"));
    assert!(s.messages[2].text.ends_with(" ⇒ ok · 1 line"));
    assert!(s
        .messages
        .iter()
        .all(|message| !message.text.contains("10000 cases passed")));
    let Some(sessionwiki::model::ToolEvent::Summary(summary)) = &s.messages[2].tool else {
        panic!("the apply_patch call should retain the anonymous structured result");
    };
    assert_eq!(summary.output.as_deref(), Some("10000 cases passed"));
    assert_eq!(
        sessionwiki::tool_summary::render_output(summary, 8 * 1024, 80).as_deref(),
        Some("```text\n10000 cases passed\n```")
    );
    assert!(s.messages.iter().any(|m| m.text.contains("2.1M ops/sec")));

    // Provenance: apply_patch file headers (Update File / Add File) are pulled
    // from the call arguments even though the patch is double-JSON-escaped.
    assert_eq!(
        s.touched,
        ["src/rate_limiter.rs", "tests/rate_limiter_props.rs"]
    );
}

#[test]
fn codex_deduplicates_user_message_schema_variants() {
    let s = parse(
        "codex",
        "codex/rollout-2026-07-13T07-05-40-duplicate-user.jsonl",
    );

    assert_eq!(roles(&s), ["user"]);
    assert_eq!(s.messages[0].text, "Explain the synthetic parser failure.");
}

#[test]
fn codex_drops_current_agents_instructions_boilerplate() {
    let s = parse(
        "codex",
        "codex/rollout-2026-07-13T16-06-13-agents-instructions.jsonl",
    );

    assert_eq!(s.title, "Fix the synthetic parser.");
    assert_eq!(roles(&s), ["user"]);
    assert!(s
        .messages
        .iter()
        .all(|message| !message.text.starts_with("# AGENTS.md instructions")));
}

#[test]
fn codex_keeps_genuinely_repeated_prompts() {
    // Each prompt arrives in BOTH shapes (event_msg + response_item); the
    // dedup must cancel per PAIR, so a user who sends "continue" twice still
    // indexes two user messages - not one.
    let s = parse(
        "codex",
        "codex/rollout-2026-07-13T08-00-00-repeated-prompt.jsonl",
    );

    assert_eq!(roles(&s), ["user", "assistant", "user"]);
    assert_eq!(s.messages[0].text, "continue");
    assert_eq!(s.messages[2].text, "continue");
}

#[test]
fn codex_parses_legacy_bare_messages() {
    let s = parse(
        "codex",
        "codex/rollout-2025-08-25T00-04-27-bare-message.jsonl",
    );

    assert_eq!(roles(&s), ["user", "assistant"]);
    assert_eq!(s.title, "Parse the legacy synthetic rollout.");
}

#[test]
fn codex_indexes_custom_tool_calls_and_their_patched_paths() {
    let s = parse(
        "codex",
        "codex/rollout-2026-07-13T16-05-05-custom-tool-call.jsonl",
    );

    assert_eq!(roles(&s), ["user", "tool"]);
    assert_eq!(
        s.messages[1].text,
        "→ apply_patch(src/synthetic.rs) ⇒ pending"
    );
    assert_eq!(s.touched, ["src/synthetic.rs"]);
}

#[test]
fn codex_structured_tool_calls_and_results_are_summarized() {
    let s = parse(
        "codex",
        "codex/rollout-2026-10-06T12-00-00-structured-tools.jsonl",
    );

    let tool_lines: Vec<_> = s
        .messages
        .iter()
        .filter(|message| message.role.label() == "tool")
        .map(|message| message.text.as_str())
        .collect();
    assert_eq!(
        tool_lines,
        [
            "→ shell(cargo check) ⇒ ok · 1 line",
            "→ shell(cargo test) ⇒ error · 2 lines — error[E0425]: unresolved synthetic name",
            "→ shell(print-many) ⇒ ok · 10 lines",
            "→ apply_patch(src/codex_synthetic.rs) ⇒ ok · 2 lines",
            "→ shell(printf block output) ⇒ ok · 2 lines",
            "→ shell(older-result) ⇒ ok · 1 line",
            "→ shell(echo pending) ⇒ pending",
            "→ exec_command(git status --short && echo \"done\") ⇒ ok · 2 lines",
            "→ exec_command(pwd; rg -n needle missing.rs) ⇒ error · 3 lines — /home/dev/proj",
        ]
    );
    assert!(tool_lines.iter().all(|line| !line.contains(" {")));
    assert_eq!(s.touched, ["src/codex_synthetic.rs"]);
}

#[test]
fn codex_plain_text_command_results_carry_their_exit_codes() {
    let s = parse(
        "codex",
        "codex/rollout-2026-05-06T12-00-00-text-results.jsonl",
    );

    let tool_lines: Vec<_> = s
        .messages
        .iter()
        .filter(|message| message.role.label() == "tool")
        .map(|message| message.text.as_str())
        .collect();
    assert_eq!(
        tool_lines,
        [
            "→ exec_command(cargo test) ⇒ error · 2 lines — error[E0425]: unresolved synthetic name",
            "→ exec_command(cargo check) ⇒ ok · 1 line",
            "→ exec_command(sleep 30) ⇒ error · 1 line — timed out after 10s",
            "→ exec_command(pwd) ⇒ ok · 1 line",
        ]
    );
}

/// An MCP tool's failure is stated only in the `mcp_tool_call_end` event
/// (`isError`, or an `Err` result); the `function_call_output` beside it is
/// plain text, so the call read as ok.
#[test]
fn codex_mcp_tool_failures_are_marked_as_errors() {
    let s = parse(
        "codex",
        "codex/rollout-2026-05-07T12-00-00-mcp-errors.jsonl",
    );
    let tool_lines: Vec<_> = s
        .messages
        .iter()
        .filter(|message| message.role.label() == "tool")
        .map(|message| message.text.as_str())
        .collect();
    assert_eq!(tool_lines.len(), 3, "{tool_lines:?}");
    assert!(tool_lines[0].contains("⇒ error"), "{}", tool_lines[0]);
    assert!(tool_lines[1].contains("⇒ ok"), "{}", tool_lines[1]);
    assert!(tool_lines[2].contains("⇒ error"), "{}", tool_lines[2]);
}

/// Some Codex rollouts record an MCP call only as its `mcp_tool_call_end`
/// event, with no `function_call` or output beside it. Those calls were not
/// indexed at all. A call that also has a `function_call` is not repeated.
#[test]
fn codex_mcp_calls_recorded_only_as_events_are_indexed() {
    let s = parse(
        "codex",
        "codex/rollout-2026-07-08T12-00-00-mcp-events-only.jsonl",
    );
    let tool_lines: Vec<_> = s
        .messages
        .iter()
        .filter(|message| message.role.label() == "tool")
        .map(|message| message.text.as_str())
        .collect();
    assert_eq!(
        tool_lines,
        [
            "→ navigate(https://example.invalid/a) ⇒ ok · 2 lines",
            "→ navigate(https://example.invalid/b) ⇒ error · 1 line — tool call failed: timeout",
            "→ navigate(https://example.invalid/c) ⇒ ok · 1 line",
        ]
    );
}

#[test]
fn gemini_session() {
    let s = parse(
        "gemini",
        "gemini/myproject/chats/session-2026-06-08T10-00-abcd1234.json",
    );

    assert_eq!(s.tool, "gemini");
    assert_eq!(s.project, "myproject");
    // String content and array-of-blocks content both parse; unknown role
    // ("system") is skipped.
    assert_eq!(roles(&s), ["user", "assistant"]);
    assert!(s.messages[0].text.contains("iframe"));
    assert!(s.messages[1].text.contains("1급 스코프")); // CJK survives intact
    assert_eq!(
        s.ended.map(|t| t.to_rfc3339()),
        Some("2026-06-08T10:00:30+00:00".to_string())
    );
}

#[test]
fn gemini_tool_calls_and_results_are_summarized() {
    let s = parse(
        "gemini",
        "gemini/myproject/chats/session-2026-06-08T11-00-tools.json",
    );

    let tool_lines: Vec<_> = s
        .messages
        .iter()
        .filter(|message| message.role.label() == "tool")
        .map(|message| message.text.as_str())
        .collect();
    assert_eq!(
        tool_lines,
        [
            "→ run_shell_command(cargo test) ⇒ ok · 1 line",
            "→ run_shell_command(cargo test --broken) ⇒ error · 1 line — permission denied",
            "→ read_file(src/lib.rs) ⇒ ok · 12 lines",
            "→ list_files(src) ⇒ ok · 1 line",
        ]
    );
    assert_eq!(
        roles(&s),
        [
            "user",
            "assistant",
            "tool",
            "tool",
            "tool",
            "tool",
            "assistant"
        ]
    );
}

#[test]
fn opencode_multi_file_session() {
    // OpenCode splits a session across session/message/part JSON files; the
    // adapter is handed the session file and joins the rest from the store.
    let s = parse("opencode", "opencode/storage/session/proj1/ses_aaa.json");

    assert_eq!(s.tool, "opencode");
    assert_eq!(s.title, "Add retry to the HTTP client"); // from session.title
    assert_eq!(s.project, "/home/dev/myapp"); // session.directory
    assert!(!s.subagent);

    // reasoning parts are dropped; text parts and tool parts are folded into
    // compact summaries in id order; the malformed part file is skipped; the
    // patch part contributes no message (only provenance).
    assert_eq!(
        roles(&s),
        ["user", "assistant", "tool", "tool", "tool", "tool"]
    );
    assert!(s.messages[0]
        .text
        .contains("retry with exponential backoff"));
    assert!(s
        .messages
        .iter()
        .any(|m| m.text.contains("3-attempt retry")));
    assert!(s
        .messages
        .iter()
        .all(|m| !m.text.contains("thinking about"))); // reasoning dropped
    let tool_lines: Vec<_> = s
        .messages
        .iter()
        .filter(|m| m.text.starts_with("→ "))
        .map(|m| m.text.as_str())
        .collect();
    assert_eq!(
        tool_lines,
        [
            "→ edit(/home/dev/myapp/src/http/client.ts) ⇒ ok · 1 line",
            "→ bash(false) ⇒ error · 2 lines — Command failed: exit 1",
            "→ read(README.md) ⇒ ok · 10 lines",
            "→ read(config.json) ⇒ pending"
        ]
    );

    // Provenance: edit tool's state.input.filePath + the patch's files list.
    assert_eq!(
        s.touched,
        [
            "/home/dev/myapp/src/http/client.ts",
            "/home/dev/myapp/src/util.ts"
        ]
    );

    // epoch-millis timestamp is parsed (not an RFC3339 string).
    assert_eq!(
        s.started,
        chrono::DateTime::from_timestamp_millis(1718630400000)
    );
}

#[test]
fn cline_xml_and_native_tool_edits() {
    // Cline keeps each task as api_conversation_history.json (the Anthropic
    // Messages array) plus ui_messages.json (timestamps + the title).
    let s = parse(
        "cline",
        "cline/tasks/1749477660000/api_conversation_history.json",
    );

    assert_eq!(s.tool, "cline");
    assert_eq!(s.title, "Add a hello function to src/main.py"); // ui_messages say:"task"
    assert_eq!(s.project, "/home/dev/app"); // from <environment_details>
    assert!(!s.subagent);

    // The <task>/<environment_details> wrappers are stripped; legacy XML and
    // native calls/results become compact Tool messages.
    assert_eq!(
        roles(&s),
        [
            "user",
            "assistant",
            "tool",
            "assistant",
            "tool",
            "tool",
            "tool",
            "assistant"
        ]
    );
    assert_eq!(
        s.messages[2].text,
        "→ write_to_file(src/main.py) ⇒ ok · 1 line"
    );
    assert_eq!(
        s.messages[4].text,
        "→ write_to_file(tests/test_main.py) ⇒ ok · 1 line"
    );
    assert_eq!(
        s.messages[5].text,
        "→ execute_command(cargo test) ⇒ error · 2 lines — Error: cargo test failed"
    );
    assert_eq!(
        s.messages[6].text,
        "→ read_file(src/output.txt) ⇒ ok · 10 lines"
    );
    assert_eq!(s.messages[0].text, "Add a hello function to src/main.py");
    assert!(s
        .messages
        .iter()
        .all(|m| !m.text.contains("environment_details")));
    assert!(s.messages.iter().all(|m| !m.text.contains("] Result:")));
    assert!(s
        .messages
        .iter()
        .all(|m| !m.text.contains("successfully saved")));

    // Provenance from BOTH the XML <write_to_file><path> and the native
    // tool_use input.path.
    assert_eq!(s.touched, ["src/main.py", "tests/test_main.py"]);

    assert_eq!(
        s.started,
        chrono::DateTime::from_timestamp_millis(1749477660000)
    );
    assert_eq!(
        s.ended,
        chrono::DateTime::from_timestamp_millis(1749477700000)
    );
}

#[test]
fn gajae_jsonl_session() {
    // gajae-code (and upstream Pi) store one JSONL transcript per session: a
    // header line then message lines, with toolCall/arguments content blocks.
    let s = parse(
        "gajae-code",
        "gajae-code/--home--dev--proj--/2025-12-09T00-53-29-825Z_ffae836b-9420-4060-ac13-7745215f90ff.jsonl",
    );

    assert_eq!(s.tool, "gajae-code");
    assert_eq!(s.title, "refactor the parser"); // header title
    assert_eq!(s.project, "/home/dev/proj"); // header cwd
    assert!(!s.subagent);

    // thinking blocks dropped; tool calls/results fold into compact summaries;
    // the malformed line is skipped without panicking.
    assert_eq!(
        roles(&s),
        [
            "user",
            "assistant",
            "tool",
            "assistant",
            "tool",
            "assistant",
            "tool",
            "assistant",
            "tool",
            "assistant"
        ]
    );
    assert!(s
        .messages
        .iter()
        .all(|m| !m.text.contains("considering the structure")));
    let tool_lines: Vec<_> = s
        .messages
        .iter()
        .filter(|m| m.text.starts_with("→ "))
        .map(|m| m.text.as_str())
        .collect();
    assert_eq!(
        tool_lines,
        [
            "→ write(src/parse.ts) ⇒ ok · 1 line",
            "→ read(config.ts) ⇒ pending",
            "→ ast_edit({\"paths\":[\"src/parse.ts\",\"src/helper.ts\"]}) ⇒ ok · 10 lines",
            "→ edit(src/parse.ts) ⇒ error · 2 lines — Edit failed"
        ]
    );

    // Provenance: write (arguments.path) + ast_edit (arguments.paths[]) with the
    // repeat de-duplicated; read is excluded.
    assert_eq!(s.touched, ["src/parse.ts", "src/helper.ts"]);

    // started = header RFC3339; ended = last entry's RFC3339.
    assert_eq!(
        s.started.map(|t| t.to_rfc3339()),
        Some("2025-12-09T00:53:29.825+00:00".to_string())
    );
    assert_eq!(
        s.ended.map(|t| t.to_rfc3339()),
        Some("2025-12-09T00:53:40+00:00".to_string())
    );
}

#[test]
fn continue_session_with_tool_edit() {
    let s = parse(
        "continue",
        "continue/sessions/5f1d2c9a-8b34-4e21-9d6e-7a0c1b2e3f44.json",
    );

    assert_eq!(s.tool, "continue");
    assert_eq!(s.title, "Add retry to the HTTP client");
    assert_eq!(s.project, "/home/alex/projects/acme-api");
    assert!(!s.subagent);

    assert_eq!(
        roles(&s),
        [
            "user",
            "assistant",
            "tool",
            "assistant",
            "tool",
            "assistant",
            "tool"
        ]
    );
    assert_eq!(
        s.messages[2].text,
        "→ edit_existing_file(src/http.ts) ⇒ ok · 1 line"
    );
    assert_eq!(
        s.messages[4].text,
        "→ run_command(cargo test) ⇒ error · 2 lines — Error: cargo test failed"
    );
    assert_eq!(
        s.messages[6].text,
        "→ read_file(logs/test-output.txt) ⇒ ok · 10 lines"
    );

    // Provenance from toolCallStates[].parsedArgs.filepath.
    assert_eq!(s.touched, ["src/http.ts"]);

    // The session file has no timestamps; started comes from sessions.json's
    // dateCreated (epoch-ms as a string); there is no reliable ended.
    assert_eq!(
        s.started,
        chrono::DateTime::from_timestamp_millis(1718600000000)
    );
    assert_eq!(s.ended, None);
}

#[test]
fn gptme_session() {
    let s = parse(
        "gptme",
        "gptme/fix-cors-bug-20260608-abcd/conversation.jsonl",
    );

    assert_eq!(s.tool, "gptme");
    // Project label is the session directory name (the slug), not a cwd.
    assert_eq!(s.project, "fix-cors-bug-20260608-abcd");

    // Pinned system-prompt line and bare system role are both dropped;
    // the malformed JSON line is silently skipped.
    assert_eq!(roles(&s), ["user", "assistant", "user", "assistant"]);

    // Naive timestamp fallback (no UTC offset) is parsed and assumed UTC.
    assert_eq!(
        s.started,
        chrono::DateTime::parse_from_rfc3339("2026-06-08T10:00:01Z")
            .ok()
            .map(|t| t.with_timezone(&chrono::Utc))
    );

    // Title comes from first user message.
    assert!(s.messages[0].text.contains("CORS preflight"));
}

#[test]
fn gptme_markdown_tool_calls_are_summarized_without_inferred_error_status() {
    let s = parse("gptme", "gptme/tool-summary/conversation.jsonl");

    let tool_lines: Vec<_> = s
        .messages
        .iter()
        .filter(|message| message.role.label() == "tool")
        .map(|message| message.text.as_str())
        .collect();
    assert_eq!(
        tool_lines,
        [
            "→ shell(cargo test) ⇒ ok · 1 line",
            // gptme stores this failure as ordinary system text, without an
            // explicit result status; keep is_error=false instead of guessing.
            "→ shell(cargo test --broken) ⇒ ok · 1 line",
            "→ shell(seq 1 12) ⇒ ok · 12 lines",
        ]
    );
    assert_eq!(roles(&s), ["user", "tool", "tool", "tool", "assistant"]);
}

#[test]
fn gptme_malformed_lines_do_not_panic() {
    // A fixture with a bad line must not panic — it is silently skipped.
    let adapter = adapters::by_name("gptme").unwrap();
    let result = adapter.parse(&fixture(
        "gptme/fix-cors-bug-20260608-abcd/conversation.jsonl",
    ));
    assert!(result.is_ok());
}

#[test]
fn missing_file_errors_without_panicking() {
    let adapter = adapters::by_name("codex").unwrap();
    assert!(adapter
        .parse(&fixture("codex/does-not-exist.jsonl"))
        .is_err());
}

#[test]
fn aider_golden() {
    // aider is a shared store: drive parse_key with `<path>\u{1f}<run-index>`.
    let path = fixture("aider/myrepo/.aider.chat.history.md");
    let adapter = adapters::by_name("aider").unwrap();
    let s = adapters::parse_session_key(
        adapter.as_ref(),
        &format!("{}\u{1f}0", path.to_string_lossy()),
    )
    .unwrap();
    assert_eq!(s.tool, "aider");
    assert_eq!(s.title, "add a retry to the webhook");
    let roles: Vec<&str> = s.messages.iter().map(|m| m.role.label()).collect();
    assert_eq!(roles, vec!["user", "assistant", "tool"]);
    assert_eq!(s.touched, vec!["src/webhook.py", "src/retry.py"]); // dry-run ignored
    assert!(s.started.is_some());
    assert!(s.messages.iter().all(|m| m.ts.is_none()));
    // a bad run index errors, never panics
    assert!(adapter
        .parse_key(&format!("{}\u{1f}99", path.to_string_lossy()))
        .is_err());
}

#[test]
fn every_adapter_is_addressable_by_name() {
    for tool in [
        "claude-code",
        "codex",
        "gemini",
        "opencode",
        "cline",
        "roo-code",
        "kilo-code",
        "gajae-code",
        "continue",
        "gptme",
        "aider",
    ] {
        assert!(adapters::by_name(tool).is_some(), "{tool} should resolve");
    }
    assert!(adapters::by_name("nonexistent").is_none());
}

#[test]
fn gemini_project_is_the_recorded_root_not_the_store_slug() {
    // Gemini CLI names the store dir with a short slug and records the real
    // directory in `.project_root` next to `chats/`.
    let dir = tempfile::tempdir().unwrap();
    let store = dir.path().join("myproject");
    std::fs::create_dir_all(store.join("chats")).unwrap();
    let chat = store.join("chats/session-2026-06-08T10-00-abcd1234.json");
    std::fs::copy(
        fixture("gemini/myproject/chats/session-2026-06-08T10-00-abcd1234.json"),
        &chat,
    )
    .unwrap();
    std::fs::write(store.join(".project_root"), "/work/myproject\n").unwrap();

    let s = adapters::by_name("gemini").unwrap().parse(&chat).unwrap();
    assert_eq!(s.project, "/work/myproject");

    // A row an older version indexed with the slug is corrected on open.
    let data = tempfile::tempdir().unwrap();
    std::env::set_var("SESSIONWIKI_DATA", data.path());
    let conn = sessionwiki::index::open().unwrap();
    conn.execute(
        "INSERT INTO files(path, mtime, size, session_id, tool, project, title, started, msg_count, kind)
         VALUES (?1, 0, 0, 'g-1', 'gemini', 'myproject', 't', '2026-06-08T10:00:00+00:00', 2, 'main')",
        [chat.to_string_lossy()],
    )
    .unwrap();
    conn.execute("DELETE FROM meta WHERE key = 'gemini_project_upto'", [])
        .unwrap();
    drop(conn);
    let conn = sessionwiki::index::open().unwrap();
    let project: String = conn
        .query_row(
            "SELECT project FROM files WHERE session_id = 'g-1'",
            [],
            |r| r.get(0),
        )
        .unwrap();
    std::env::remove_var("SESSIONWIKI_DATA");
    assert_eq!(project, "/work/myproject");
}

#[test]
fn prodex_consult_task_becomes_a_two_message_session() {
    let s = parse(
        "prodex",
        "prodex/repo-a/.bridge/tasks/task_20260707_090000_gpt-pro-consult.json",
    );
    assert_eq!(s.tool, "prodex");
    // sha256("task_20260707_090000_gpt-pro-consult")[..12] - the uniform
    // short-id shape every tool gets in the index.
    assert_eq!(s.id, "567f374d7a70");
    // The question is the title - prodex auto-titles every consult
    // "GPT Pro consult", which would make a list of them indistinguishable.
    assert!(s.title.starts_with("Should the retry loop"), "{}", s.title);
    assert_eq!(roles(&s), ["user", "assistant"]);
    assert!(s.messages[0].text.contains("exponential backoff"), "prompt");
    // The full pro-consult artifact wins over the truncated summary.
    assert!(
        s.messages[1].text.contains("thundering herds"),
        "artifact text used as the answer: {}",
        s.messages[1].text
    );
    assert!(s.started.is_some(), "claimed_at parsed");
    // Project = the repo that owns the .bridge.
    assert!(s.project.ends_with("repo-a"), "{}", s.project);
}

#[test]
fn prodex_pending_task_is_a_one_message_session() {
    let s = parse(
        "prodex",
        "prodex/repo-a/.bridge/tasks/task_20260707_100000_open-question.json",
    );
    assert_eq!(roles(&s), ["user"]);
    assert!(s.started.is_some(), "falls back to the id timestamp");
}

#[test]
fn prodex_thread_url_comes_from_the_bridge_session() {
    let task = fixture("prodex/repo-a/.bridge/tasks/task_20260707_090000_gpt-pro-consult.json");
    let url = sessionwiki::adapters::prodex_thread_url(&task);
    assert_eq!(
        url.as_deref(),
        Some("https://chatgpt.com/c/aaaa1111-2222-3333-4444-555566667777")
    );
    // A non-chatgpt URL in a tampered file is never surfaced.
    let dir = tempfile::tempdir().unwrap();
    let tasks = dir.path().join(".bridge/tasks");
    let sessions = dir.path().join(".bridge/sessions");
    std::fs::create_dir_all(&tasks).unwrap();
    std::fs::create_dir_all(&sessions).unwrap();
    let t = tasks.join("task_x.json");
    std::fs::write(&t, "{}").unwrap();
    std::fs::write(
        sessions.join("s.json"),
        r#"{"thread":"file:///etc/passwd"}"#,
    )
    .unwrap();
    assert_eq!(sessionwiki::adapters::prodex_thread_url(&t), None);
}

// The crash path the durable ledger exists for: the answer artifact was
// written but the result JSON was not. The answer must still be indexed.
#[test]
fn prodex_artifact_without_result_is_still_the_answer() {
    let s = parse(
        "prodex",
        "prodex/repo-a/.bridge/tasks/task_20260707_110000_crash-path.json",
    );
    assert_eq!(roles(&s), ["user", "assistant"]);
    assert!(
        s.messages[1].text.contains("logical shards"),
        "{}",
        s.messages[1].text
    );
}

// AUDIT-HIGH: a crafted/corrupt task id with a multibyte char at a slice
// boundary must not panic (an uncaught parse panic aborts the WHOLE indexer -
// one bad .bridge file would brick every list/search/scan).
#[test]
fn prodex_multibyte_task_id_never_panics() {
    let dir = tempfile::tempdir().unwrap();
    let tasks = dir.path().join(".bridge/tasks");
    std::fs::create_dir_all(&tasks).unwrap();
    let p = tasks.join("bad.json");
    std::fs::write(
        &p,
        r#"{"id":"task_12345é7_123456","title":"t","prompt":"p"}"#,
    )
    .unwrap();
    let adapter = sessionwiki::adapters::by_name("prodex").unwrap();
    let s = adapters::parse_session(adapter.as_ref(), &p).expect("parse must not panic");
    assert!(
        s.started.is_none(),
        "unparseable stamp -> None, not a crash"
    );
}