csess 0.8.1

use assert_cmd::Command;
use predicates::prelude::*;
use std::fs;

fn seed(root: &std::path::Path, dir: &str, file: &str, cwd: &str, prompt: &str) {
    let proj = root.join(dir);
    fs::create_dir_all(&proj).unwrap();
    let line = format!(
        "{{\"type\":\"user\",\"cwd\":\"{cwd}\",\"timestamp\":\"2026-06-16T01:00:00.000Z\",\"message\":{{\"role\":\"user\",\"content\":\"{prompt}\"}}}}\n"
    );
    fs::write(proj.join(file), line).unwrap();
}

fn setup() -> tempfile::TempDir {
    let root = tempfile::tempdir().unwrap();
    seed(
        root.path(),
        "-home-sibin-my-works-demo",
        "11111111-aaaa-bbbb-cccc-dddddddddddd.jsonl",
        "/home/sibin/my-works/demo",
        "Build the thing",
    );
    // dashed sibling: loose pre-filter includes it, cwd verify must drop it
    seed(
        root.path(),
        "-home-sibin-my-works-demo-backup",
        "22222222-aaaa-bbbb-cccc-dddddddddddd.jsonl",
        "/home/sibin/my-works/demo-backup",
        "Sibling session",
    );
    root
}

#[test]
fn lists_sessions_as_table() {
    let root = setup();
    Command::cargo_bin("csess")
        .unwrap()
        .args([
            "/home/sibin/my-works/demo",
            "--projects-dir",
            root.path().to_str().unwrap(),
        ])
        .assert()
        .success()
        .stdout(predicate::str::contains("Build the thing"))
        .stdout(predicate::str::contains("11111111"))
        .stdout(predicate::str::contains("Sibling session").not());
}

#[test]
fn json_output_is_valid() {
    let root = setup();
    let out = Command::cargo_bin("csess")
        .unwrap()
        .args([
            "/home/sibin/my-works/demo",
            "--json",
            "--projects-dir",
            root.path().to_str().unwrap(),
        ])
        .assert()
        .success()
        .get_output()
        .stdout
        .clone();
    let v: serde_json::Value = serde_json::from_slice(&out).unwrap();
    assert_eq!(v["schema_version"], 3);
    assert_eq!(v["sessions"][0]["name"], "Build the thing");
    assert_eq!(v["sessions"].as_array().unwrap().len(), 1);
}

#[test]
fn show_prints_transcript() {
    let root = setup();
    Command::cargo_bin("csess")
        .unwrap()
        .args([
            "/home/sibin/my-works/demo",
            "--show",
            "11111111",
            "--projects-dir",
            root.path().to_str().unwrap(),
        ])
        .assert()
        .success()
        .stdout(predicate::str::contains("## user"))
        .stdout(predicate::str::contains("Build the thing"));
}

#[test]
fn show_json_has_messages_with_timestamps() {
    let root = setup();
    let out = Command::cargo_bin("csess")
        .unwrap()
        .args([
            "/home/sibin/my-works/demo",
            "--show",
            "11111111",
            "--json",
            "--projects-dir",
            root.path().to_str().unwrap(),
        ])
        .assert()
        .success()
        .get_output()
        .stdout
        .clone();
    let v: serde_json::Value = serde_json::from_slice(&out).unwrap();
    assert_eq!(v["schema_version"], 3);
    assert_eq!(v["session_id"], "11111111-aaaa-bbbb-cccc-dddddddddddd");
    assert_eq!(v["messages"][0]["role"], "user");
    assert_eq!(v["messages"][0]["entry_type"], "user");
    assert_eq!(v["messages"][0]["content"], "Build the thing");
    assert_eq!(v["messages"][0]["timestamp"], "2026-06-16T01:00:00Z");
}

#[test]
fn show_json_passes_through_tool_result_sidecar() {
    // A tool_result user line carries a top-level `toolUseResult` sidecar
    // (structuredPatch for Edit). csess must pass it through verbatim on the
    // message's `tool_use_result` field so a UI can render the diff.
    let root = tempfile::tempdir().unwrap();
    let proj = root.path().join("-home-sibin-my-works-demo");
    fs::create_dir_all(&proj).unwrap();
    let line = r#"{"type":"user","cwd":"/home/sibin/my-works/demo","timestamp":"2026-06-16T01:00:00.000Z","toolUseResult":{"filePath":"/home/sibin/my-works/demo/a.txt","structuredPatch":[{"oldStart":1,"oldLines":1,"newStart":1,"newLines":2,"lines":["-old","+new1","+new2"]}]},"message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"toolu_x","content":"ok"}]}}
"#;
    fs::write(
        proj.join("11111111-aaaa-bbbb-cccc-dddddddddddd.jsonl"),
        line,
    )
    .unwrap();

    let out = Command::cargo_bin("csess")
        .unwrap()
        .args([
            "/home/sibin/my-works/demo",
            "--show",
            "11111111",
            "--json",
            "--projects-dir",
            root.path().to_str().unwrap(),
        ])
        .assert()
        .success()
        .get_output()
        .stdout
        .clone();
    let v: serde_json::Value = serde_json::from_slice(&out).unwrap();
    let patch = &v["messages"][0]["tool_use_result"]["structuredPatch"][0];
    assert_eq!(patch["newLines"], 2);
    assert_eq!(patch["lines"][1], "+new1");
}

#[test]
fn show_json_passes_through_meta_and_user_type() {
    // A genuine external turn + a skill-load isMeta echo + the resume pair. csess
    // drops only the `<synthetic>` reply; both isMeta turns (skill echo AND the
    // "Continue…" line) survive tagged is_meta:true, and userType passes through
    // verbatim so a consumer classifies/suppresses them itself.
    let root = tempfile::tempdir().unwrap();
    let proj = root.path().join("-home-sibin-my-works-demo");
    fs::create_dir_all(&proj).unwrap();
    let lines = concat!(
        "{\"type\":\"user\",\"userType\":\"external\",\"cwd\":\"/home/sibin/my-works/demo\",\"timestamp\":\"2026-06-16T01:00:00.000Z\",\"message\":{\"role\":\"user\",\"content\":\"real prompt\"}}\n",
        "{\"type\":\"user\",\"isMeta\":true,\"cwd\":\"/home/sibin/my-works/demo\",\"timestamp\":\"2026-06-16T01:01:00.000Z\",\"message\":{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Base directory for this skill: /x\"}]}}\n",
        "{\"type\":\"user\",\"isMeta\":true,\"cwd\":\"/home/sibin/my-works/demo\",\"timestamp\":\"2026-06-16T01:02:00.000Z\",\"message\":{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Continue from where you left off.\"}]}}\n",
        "{\"type\":\"assistant\",\"cwd\":\"/home/sibin/my-works/demo\",\"timestamp\":\"2026-06-16T01:03:00.000Z\",\"message\":{\"role\":\"assistant\",\"model\":\"<synthetic>\",\"content\":[{\"type\":\"text\",\"text\":\"No response requested.\"}]}}\n",
    );
    fs::write(
        proj.join("11111111-aaaa-bbbb-cccc-dddddddddddd.jsonl"),
        lines,
    )
    .unwrap();

    let out = Command::cargo_bin("csess")
        .unwrap()
        .args([
            "/home/sibin/my-works/demo",
            "--show",
            "11111111",
            "--json",
            "--projects-dir",
            root.path().to_str().unwrap(),
        ])
        .assert()
        .success()
        .get_output()
        .stdout
        .clone();
    let v: serde_json::Value = serde_json::from_slice(&out).unwrap();
    let msgs = v["messages"].as_array().unwrap();
    // genuine turn + skill-load meta + "Continue…" meta survive; only the
    // `<synthetic>` reply is dropped.
    assert_eq!(msgs.len(), 3);
    assert_eq!(msgs[0]["is_meta"], false);
    assert_eq!(msgs[0]["user_type"], "external");
    assert_eq!(msgs[1]["is_meta"], true); // skill-load echo
    assert_eq!(msgs[2]["is_meta"], true); // "Continue from where you left off."
}

#[test]
fn show_limit_returns_last_n_messages() {
    let root = tempfile::tempdir().unwrap();
    let proj = root.path().join("-home-sibin-my-works-demo");
    fs::create_dir_all(&proj).unwrap();
    let mut lines = String::new();
    for i in 0..5 {
        lines.push_str(&format!(
            "{{\"type\":\"user\",\"cwd\":\"/home/sibin/my-works/demo\",\"timestamp\":\"2026-06-16T01:0{i}:00.000Z\",\"message\":{{\"role\":\"user\",\"content\":\"msg{i}\"}}}}\n"
        ));
    }
    fs::write(
        proj.join("11111111-aaaa-bbbb-cccc-dddddddddddd.jsonl"),
        lines,
    )
    .unwrap();

    let out = Command::cargo_bin("csess")
        .unwrap()
        .args([
            "/home/sibin/my-works/demo",
            "--show",
            "11111111",
            "--json",
            "-n",
            "2",
            "--projects-dir",
            root.path().to_str().unwrap(),
        ])
        .assert()
        .success()
        .get_output()
        .stdout
        .clone();
    let v: serde_json::Value = serde_json::from_slice(&out).unwrap();
    let msgs = v["messages"].as_array().unwrap();
    assert_eq!(msgs.len(), 2);
    assert_eq!(msgs[0]["content"], "msg3");
    assert_eq!(msgs[1]["content"], "msg4");
}

#[test]
fn show_before_returns_messages_older_than_cursor() {
    let root = tempfile::tempdir().unwrap();
    let proj = root.path().join("-home-sibin-my-works-demo");
    fs::create_dir_all(&proj).unwrap();
    let mut lines = String::new();
    for i in 0..5 {
        lines.push_str(&format!(
            "{{\"type\":\"user\",\"uuid\":\"u{i}\",\"cwd\":\"/home/sibin/my-works/demo\",\"timestamp\":\"2026-06-16T01:0{i}:00.000Z\",\"message\":{{\"role\":\"user\",\"content\":\"msg{i}\"}}}}\n"
        ));
    }
    fs::write(
        proj.join("11111111-aaaa-bbbb-cccc-dddddddddddd.jsonl"),
        lines,
    )
    .unwrap();

    // cursor at msg3 → only the strictly-older msg0..=msg2 remain; -n 2 keeps the last two of those
    let out = Command::cargo_bin("csess")
        .unwrap()
        .args([
            "/home/sibin/my-works/demo",
            "--show",
            "11111111",
            "--before",
            "u3",
            "--json",
            "-n",
            "2",
            "--projects-dir",
            root.path().to_str().unwrap(),
        ])
        .assert()
        .success()
        .get_output()
        .stdout
        .clone();
    let v: serde_json::Value = serde_json::from_slice(&out).unwrap();
    let msgs = v["messages"].as_array().unwrap();
    assert_eq!(msgs.len(), 2);
    assert_eq!(msgs[0]["content"], "msg1");
    assert_eq!(msgs[1]["content"], "msg2");
}

#[test]
fn role_and_grep_filter_messages() {
    let root = tempfile::tempdir().unwrap();
    let proj = root.path().join("-home-sibin-my-works-demo");
    fs::create_dir_all(&proj).unwrap();
    let lines = concat!(
        "{\"type\":\"user\",\"cwd\":\"/home/sibin/my-works/demo\",\"timestamp\":\"2026-06-16T01:00:00.000Z\",\"message\":{\"role\":\"user\",\"content\":\"please fix the parser\"}}\n",
        "{\"type\":\"assistant\",\"cwd\":\"/home/sibin/my-works/demo\",\"timestamp\":\"2026-06-16T01:01:00.000Z\",\"message\":{\"role\":\"assistant\",\"content\":\"done with the parser\"}}\n",
    );
    fs::write(
        proj.join("11111111-aaaa-bbbb-cccc-dddddddddddd.jsonl"),
        lines,
    )
    .unwrap();
    let pd = root.path().to_str().unwrap();

    // --role user: only the user message survives
    let out = Command::cargo_bin("csess")
        .unwrap()
        .args([
            "/home/sibin/my-works/demo",
            "--show",
            "11111111",
            "--role",
            "user",
            "--json",
            "--projects-dir",
            pd,
        ])
        .assert()
        .success()
        .get_output()
        .stdout
        .clone();
    let v: serde_json::Value = serde_json::from_slice(&out).unwrap();
    let msgs = v["messages"].as_array().unwrap();
    assert_eq!(msgs.len(), 1);
    assert_eq!(msgs[0]["role"], "user");

    // cross-session --grep (no --show): session appears with only matching messages
    let out = Command::cargo_bin("csess")
        .unwrap()
        .args([
            "/home/sibin/my-works/demo",
            "--grep",
            "fix",
            "--json",
            "--projects-dir",
            pd,
        ])
        .assert()
        .success()
        .get_output()
        .stdout
        .clone();
    let v: serde_json::Value = serde_json::from_slice(&out).unwrap();
    let matches = v["matches"].as_array().unwrap();
    assert_eq!(matches.len(), 1);
    let mm = matches[0]["messages"].as_array().unwrap();
    assert_eq!(mm.len(), 1);
    assert_eq!(mm[0]["content"], "please fix the parser");
}

#[test]
fn show_json_broken_pipe_exits_clean() {
    // A reader that hangs up mid-transcript (head, less quit, a lazy-load UI)
    // must not make csess panic on the broken pipe — it should exit cleanly.
    use std::io::Read;
    use std::process::{Command, Stdio};

    let root = tempfile::tempdir().unwrap();
    let proj = root.path().join("-home-sibin-my-works-demo");
    fs::create_dir_all(&proj).unwrap();
    // >64KB of output so the child is still writing when we drop the read end
    // (a single small write could fit the pipe buffer and finish before we hang up).
    let mut lines = String::new();
    for i in 0..1500 {
        lines.push_str(&format!(
            "{{\"type\":\"user\",\"cwd\":\"/home/sibin/my-works/demo\",\"timestamp\":\"2026-06-16T01:00:00.000Z\",\"message\":{{\"role\":\"user\",\"content\":\"message number {i} padded out with text to make each line reasonably long\"}}}}\n"
        ));
    }
    fs::write(
        proj.join("11111111-aaaa-bbbb-cccc-dddddddddddd.jsonl"),
        lines,
    )
    .unwrap();

    let mut child = Command::new(assert_cmd::cargo::cargo_bin("csess"))
        .args([
            "/home/sibin/my-works/demo",
            "--show",
            "11111111",
            "--json",
            "--projects-dir",
            root.path().to_str().unwrap(),
        ])
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .unwrap();

    // read a tiny prefix, then hang up by dropping the read end
    {
        let mut out = child.stdout.take().unwrap();
        let mut buf = [0u8; 64];
        let _ = out.read(&mut buf);
    }

    let output = child.wait_with_output().unwrap();
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(
        !stderr.contains("panicked"),
        "csess panicked on broken pipe: {stderr}"
    );
    assert!(
        output.status.success(),
        "expected clean exit on broken pipe, got {:?}",
        output.status
    );
}

#[test]
fn show_no_match_exits_2() {
    let root = setup();
    Command::cargo_bin("csess")
        .unwrap()
        .args([
            "/home/sibin/my-works/demo",
            "--show",
            "nope-no-such",
            "--projects-dir",
            root.path().to_str().unwrap(),
        ])
        .assert()
        .code(2);
}

#[test]
fn missing_projects_dir_exits_2() {
    Command::cargo_bin("csess")
        .unwrap()
        .args(["/tmp/whatever", "--projects-dir", "/nonexistent/path/xyz"])
        .assert()
        .code(2);
}

#[test]
fn after_cursor_pages_the_session_list() {
    let root = tempfile::tempdir().unwrap();
    let dir = "-home-sibin-my-works-page";
    let cwd = "/home/sibin/my-works/page";
    // names "aaa"/"bbb"/"ccc" so `--sort name` gives a deterministic order
    seed(
        root.path(),
        dir,
        "aaaaaaaa-0000-0000-0000-000000000001.jsonl",
        cwd,
        "aaa",
    );
    seed(
        root.path(),
        dir,
        "bbbbbbbb-0000-0000-0000-000000000002.jsonl",
        cwd,
        "bbb",
    );
    seed(
        root.path(),
        dir,
        "cccccccc-0000-0000-0000-000000000003.jsonl",
        cwd,
        "ccc",
    );

    // page 1: first 2 by name
    Command::cargo_bin("csess")
        .unwrap()
        .args([
            cwd,
            "--sort",
            "name",
            "-n",
            "2",
            "--projects-dir",
            root.path().to_str().unwrap(),
        ])
        .assert()
        .success()
        .stdout(predicate::str::contains("aaa"))
        .stdout(predicate::str::contains("bbb"))
        .stdout(predicate::str::contains("ccc").not());

    // page 2: everything after the cursor (bbb's id) — just ccc
    Command::cargo_bin("csess")
        .unwrap()
        .args([
            cwd,
            "--sort",
            "name",
            "-n",
            "2",
            "--after",
            "bbbbbbbb-0000-0000-0000-000000000002",
            "--projects-dir",
            root.path().to_str().unwrap(),
        ])
        .assert()
        .success()
        .stdout(predicate::str::contains("ccc"))
        .stdout(predicate::str::contains("aaa").not())
        .stdout(predicate::str::contains("bbb").not());
}