elliot-stack 1.0.18 → 1.0.20

package/skills/estack-read-claude-session-history/scripts/tests/test_json_format.py

@@ -0,0 +1,201 @@
+"""Tests for --format json across modes."""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+
+def _run_cli(cli_path, *args, env_overrides=None):
+    env = dict(os.environ)
+    env["PYTHONIOENCODING"] = "utf-8"
+    if env_overrides:
+        env.update(env_overrides)
+    return subprocess.run(
+        [sys.executable, str(cli_path), *args],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        env=env,
+    )
+
+
+def _json(r):
+    assert r.returncode == 0, r.stderr
+    return json.loads(r.stdout)
+
+
+def test_last_json(cli_path, fixtures_dir):
+    data = _json(_run_cli(
+        cli_path, "--file", str(fixtures_dir / "basic-session.jsonl"),
+        "--mode", "last", "--format", "json",
+    ))
+    assert isinstance(data, list)
+    assert data[-1]["n_from_end"] == 1
+    assert "Here is help" in data[-1]["text"]
+
+
+def test_json_alias_flag(cli_path, fixtures_dir):
+    data = _json(_run_cli(
+        cli_path, "--file", str(fixtures_dir / "basic-session.jsonl"),
+        "--mode", "last", "--json",
+    ))
+    assert isinstance(data, list)
+
+
+def test_advisor_json(cli_path, fixtures_dir):
+    data = _json(_run_cli(
+        cli_path, "--file", str(fixtures_dir / "with-advisor.jsonl"),
+        "--mode", "advisor", "--format", "json",
+    ))
+    assert data == ["The advisor says do X then Y."]
+
+
+def test_pre_compact_json(cli_path, fixtures_dir):
+    data = _json(_run_cli(
+        cli_path, "--file", str(fixtures_dir / "with-compact.jsonl"),
+        "--mode", "pre-compact", "--format", "json",
+    ))
+    assert data["found_compact"] is True
+    assert any("First answer" in m["text"] for m in data["messages"])
+
+
+def test_dump_json(cli_path, fixtures_dir):
+    data = _json(_run_cli(
+        cli_path, "--file", str(fixtures_dir / "basic-session.jsonl"),
+        "--mode", "dump", "--format", "json",
+    ))
+    assert isinstance(data, list)
+    assert data[0]["role"] == "user"
+
+
+def test_debug_json(cli_path, fixtures_dir):
+    data = _json(_run_cli(
+        cli_path, "--file", str(fixtures_dir / "with-advisor.jsonl"),
+        "--mode", "debug", "--format", "json",
+    ))
+    assert data["advisor_blocks"] == 1
+    assert "entry_types" in data
+
+
+def test_brief_json(cli_path, fixtures_dir):
+    data = _json(_run_cli(
+        cli_path, "--file", str(fixtures_dir / "tool-zoo.jsonl"),
+        "--mode", "brief", "--format", "json",
+    ))
+    assert data["exists"] is True
+    assert data["tool_counts"]["Bash"] == 1
+    assert isinstance(data["files_touched"], list)
+
+
+def test_changelog_json(cli_path, fixtures_dir):
+    data = _json(_run_cli(
+        cli_path, "--file", str(fixtures_dir / "tool-zoo.jsonl"),
+        "--mode", "changelog", "--format", "json",
+    ))
+    assert len(data) == 9
+    assert data[0]["tool"] == "Bash"
+    assert "input" not in data[0]
+
+
+def test_tool_calls_json_includes_input(cli_path, fixtures_dir):
+    data = _json(_run_cli(
+        cli_path, "--file", str(fixtures_dir / "tool-zoo.jsonl"),
+        "--mode", "tool-calls", "--format", "json", "--tool", "Bash",
+    ))
+    assert len(data) == 1
+    assert data[0]["input"]["command"] == "ls -la /tmp"
+
+
+def test_file_edits_json(cli_path, fixtures_dir):
+    data = _json(_run_cli(
+        cli_path, "--file", str(fixtures_dir / "tool-zoo.jsonl"),
+        "--mode", "file-edits", "--format", "json",
+    ))
+    paths = [row["path"] for row in data]
+    assert any("foo.py" in p for p in paths)
+
+
+def test_subagent_finals_json(cli_path, fixtures_dir):
+    data = _json(_run_cli(
+        cli_path, "--file", str(fixtures_dir / "subagent-parent.jsonl"),
+        "--mode", "subagent-finals", "--format", "json",
+    ))
+    assert data[0]["agentType"] == "Explore"
+    assert "Found it" in data[0]["text"]
+
+
+def test_search_json_single_file(cli_path, fixtures_dir):
+    data = _json(_run_cli(
+        cli_path, "--file", str(fixtures_dir / "basic-session.jsonl"),
+        "--mode", "search", "--query", "help", "--format", "json",
+    ))
+    assert len(data) == 1
+    assert data[0]["role"] == "assistant"
+
+
+def test_list_json(cli_path, fixtures_dir, tmp_path):
+    fake_root = tmp_path / "projects"
+    fake_proj = fake_root / "C--fake-proj"
+    fake_proj.mkdir(parents=True)
+    shutil.copy(fixtures_dir / "basic-session.jsonl", fake_proj / "abc.jsonl")
+    data = _json(_run_cli(
+        cli_path, "--root", str(fake_root), "--all-projects",
+        "--mode", "list", "--format", "json",
+    ))
+    assert len(data) == 1
+    assert data[0]["uuid"] == "abc"
+
+
+def test_journal_json(cli_path, fixtures_dir, tmp_path):
+    fake_root = tmp_path / "projects"
+    fake_proj = fake_root / "C--fake-proj"
+    fake_proj.mkdir(parents=True)
+    shutil.copy(fixtures_dir / "tool-zoo.jsonl", fake_proj / "def.jsonl")
+    data = _json(_run_cli(
+        cli_path, "--root", str(fake_root), "--all-projects",
+        "--mode", "journal", "--since", "2020-01-01", "--format", "json",
+    ))
+    assert data[0]["uuid"] == "def"
+    assert data[0]["tool_counts"]["Bash"] == 1
+
+
+def test_count_json(cli_path, fixtures_dir, tmp_path):
+    fake_root = tmp_path / "projects"
+    fake_proj = fake_root / "C--fake-proj"
+    fake_proj.mkdir(parents=True)
+    shutil.copy(fixtures_dir / "basic-session.jsonl", fake_proj / "abc.jsonl")
+    data = _json(_run_cli(
+        cli_path, "--root", str(fake_root), "--all-projects",
+        "--mode", "count", "--query", "help", "--format", "json",
+    ))
+    assert data == {"sessions": 1, "messages": 2, "matches": 1}
+
+
+def test_count_text_unchanged(cli_path, fixtures_dir, tmp_path):
+    fake_root = tmp_path / "projects"
+    fake_proj = fake_root / "C--fake-proj"
+    fake_proj.mkdir(parents=True)
+    shutil.copy(fixtures_dir / "basic-session.jsonl", fake_proj / "abc.jsonl")
+    r = _run_cli(
+        cli_path, "--root", str(fake_root), "--all-projects",
+        "--mode", "count", "--query", "help",
+    )
+    assert r.returncode == 0
+    assert r.stdout.strip() == "1"
+    assert "1 sessions" in r.stderr
+
+
+def test_diff_json(cli_path, fixtures_dir):
+    data = _json(_run_cli(
+        cli_path, "--mode", "diff",
+        "--file-a", str(fixtures_dir / "basic-session.jsonl"),
+        "--file-b", str(fixtures_dir / "with-thinking.jsonl"),
+        "--format", "json",
+    ))
+    sources = {m["source"] for m in data["messages"]}
+    assert sources == {"A", "B"}

package/skills/estack-read-claude-session-history/scripts/tests/test_modes.py

@@ -0,0 +1,199 @@
+"""End-to-end CLI tests via subprocess.run.
+
+Exercises mode dispatch + argument parsing. Library-level behavior is
+covered by the unit tests in test_paths/parser/tools/search/subagents.
+"""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+
+def _run_cli(cli_path, *args, env_overrides=None):
+    env = dict(os.environ)
+    env["PYTHONIOENCODING"] = "utf-8"
+    if env_overrides:
+        env.update(env_overrides)
+    return subprocess.run(
+        [sys.executable, str(cli_path), *args],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        env=env,
+    )
+
+
+def test_help(cli_path):
+    r = _run_cli(cli_path, "--help")
+    assert r.returncode == 0
+    assert "--mode" in r.stdout
+
+
+def test_last_mode(cli_path, fixtures_dir):
+    r = _run_cli(cli_path, "--file", str(fixtures_dir / "basic-session.jsonl"), "--mode", "last")
+    assert r.returncode == 0
+    assert "Here is help" in r.stdout
+
+
+def test_advisor_mode(cli_path, fixtures_dir):
+    r = _run_cli(cli_path, "--file", str(fixtures_dir / "with-advisor.jsonl"), "--mode", "advisor")
+    assert r.returncode == 0
+    assert "advisor" in r.stdout.lower()
+
+
+def test_pre_compact_mode(cli_path, fixtures_dir):
+    r = _run_cli(cli_path, "--file", str(fixtures_dir / "with-compact.jsonl"), "--mode", "pre-compact")
+    assert r.returncode == 0
+    assert "Pre-compact" in r.stdout or "First answer" in r.stdout
+
+
+def test_debug_mode(cli_path, fixtures_dir):
+    r = _run_cli(cli_path, "--file", str(fixtures_dir / "basic-session.jsonl"), "--mode", "debug")
+    assert r.returncode == 0
+    assert "Entry type distribution" in r.stdout
+
+
+def test_brief_mode(cli_path, fixtures_dir):
+    r = _run_cli(cli_path, "--file", str(fixtures_dir / "tool-zoo.jsonl"), "--mode", "brief")
+    assert r.returncode == 0
+    body = r.stdout
+    # 6 lines expected
+    assert "intent:" in body
+    assert "last:" in body
+    assert "edits:" in body
+    assert "tools:" in body
+    assert "subagents:" in body
+
+
+def test_brief_with_include_subagents(cli_path, fixtures_dir):
+    r = _run_cli(
+        cli_path, "--file", str(fixtures_dir / "subagent-parent.jsonl"),
+        "--mode", "brief", "--include-subagents",
+    )
+    assert r.returncode == 0
+    assert "subagent" in r.stdout.lower()
+    assert "Found it" in r.stdout
+
+
+def test_changelog(cli_path, fixtures_dir):
+    r = _run_cli(cli_path, "--file", str(fixtures_dir / "tool-zoo.jsonl"), "--mode", "changelog")
+    assert r.returncode == 0
+    assert "Bash" in r.stdout
+    assert "Read" in r.stdout
+
+
+def test_file_edits(cli_path, fixtures_dir):
+    r = _run_cli(cli_path, "--file", str(fixtures_dir / "tool-zoo.jsonl"), "--mode", "file-edits")
+    assert r.returncode == 0
+    assert "foo.py" in r.stdout
+    assert "bar.py" in r.stdout
+
+
+def test_tool_calls(cli_path, fixtures_dir):
+    r = _run_cli(cli_path, "--file", str(fixtures_dir / "tool-zoo.jsonl"), "--mode", "tool-calls")
+    assert r.returncode == 0
+    assert "Bash" in r.stdout
+
+
+def test_tool_calls_filter(cli_path, fixtures_dir):
+    r = _run_cli(
+        cli_path, "--file", str(fixtures_dir / "tool-zoo.jsonl"),
+        "--mode", "tool-calls", "--tool", "Bash",
+    )
+    assert r.returncode == 0
+    assert "Bash" in r.stdout
+    assert "Glob" not in r.stdout
+
+
+def test_subagent_list(cli_path, fixtures_dir):
+    r = _run_cli(
+        cli_path, "--file", str(fixtures_dir / "subagent-parent.jsonl"),
+        "--mode", "subagent-list",
+    )
+    assert r.returncode == 0
+    assert "agent-xyz123" in r.stdout
+
+
+def test_subagent_finals(cli_path, fixtures_dir):
+    r = _run_cli(
+        cli_path, "--file", str(fixtures_dir / "subagent-parent.jsonl"),
+        "--mode", "subagent-finals",
+    )
+    assert r.returncode == 0
+    assert "Found it" in r.stdout
+
+
+def test_diff_mode(cli_path, fixtures_dir):
+    r = _run_cli(
+        cli_path, "--mode", "diff",
+        "--file-a", str(fixtures_dir / "basic-session.jsonl"),
+        "--file-b", str(fixtures_dir / "with-thinking.jsonl"),
+    )
+    assert r.returncode == 0
+    assert "A>" in r.stdout
+    assert "B>" in r.stdout
+
+
+def test_lookup_no_match(cli_path, fixtures_dir, tmp_path):
+    # Point --root at an empty dir so lookup definitely misses
+    r = _run_cli(cli_path, "--root", str(tmp_path), "--mode", "lookup", "--uuid", "nope")
+    assert r.returncode == 1
+
+
+def test_list_legacy_format(cli_path, fixtures_dir, tmp_path):
+    # Build a fake project root + cwd that matches encoding
+    fake_root = tmp_path / "projects"
+    fake_proj = fake_root / "C--fake-proj"
+    fake_proj.mkdir(parents=True)
+    shutil.copy(fixtures_dir / "basic-session.jsonl", fake_proj / "abc.jsonl")
+    r = _run_cli(cli_path, "--root", str(fake_root), "--cwd", "C:\\fake\\proj", "--list")
+    assert r.returncode == 0
+    assert "abc.jsonl" in r.stdout
+
+
+def test_exclude_current(cli_path, fixtures_dir, tmp_path):
+    fake_root = tmp_path / "projects"
+    fake_proj = fake_root / "C--fake-proj"
+    fake_proj.mkdir(parents=True)
+    shutil.copy(fixtures_dir / "basic-session.jsonl", fake_proj / "abc.jsonl")
+    shutil.copy(fixtures_dir / "tool-zoo.jsonl", fake_proj / "def.jsonl")
+    r = _run_cli(
+        cli_path, "--root", str(fake_root), "--cwd", "C:\\fake\\proj",
+        "--mode", "list", "--exclude-current",
+        env_overrides={"CLAUDE_SESSION_ID": "abc"},
+    )
+    assert r.returncode == 0
+    assert "def" in r.stdout
+    assert "abc" not in r.stdout
+
+
+def test_dump_large_file_degrades(cli_path, fixtures_dir, tmp_path):
+    # Build a 6MB padded fixture by writing many valid lines
+    big = tmp_path / "big.jsonl"
+    line = '{"type":"user","timestamp":"2026-05-01T10:00:00Z","message":{"role":"user","content":"'
+    pad = "x" * 1000 + '"}}\n'
+    with open(big, "w", encoding="utf-8") as f:
+        # Each line ~1KB → write ~7000 to hit 6MB+
+        for _ in range(7000):
+            f.write(line + pad)
+    r = _run_cli(cli_path, "--file", str(big), "--mode", "dump")
+    assert r.returncode == 0
+    assert "degraded" in r.stderr.lower()
+
+
+def test_dump_large_file_force(cli_path, tmp_path):
+    big = tmp_path / "big.jsonl"
+    line = '{"type":"user","timestamp":"2026-05-01T10:00:00Z","message":{"role":"user","content":"'
+    pad = "x" * 1000 + '"}}\n'
+    with open(big, "w", encoding="utf-8") as f:
+        for _ in range(7000):
+            f.write(line + pad)
+    r = _run_cli(cli_path, "--file", str(big), "--mode", "dump", "--force-dump")
+    assert r.returncode == 0
+    # No degrade note when forced
+    assert "degraded" not in r.stderr.lower()

package/skills/estack-read-claude-session-history/scripts/tests/test_parser.py

@@ -0,0 +1,195 @@
+"""Tests for lib.parser."""
+
+import json
+from datetime import datetime
+from pathlib import Path
+
+import pytest
+
+from lib import parser as PR
+
+
+def _load(fixtures_dir, name):
+    return PR.parse_lines(fixtures_dir / name)
+
+
+def test_parse_basic(fixtures_dir):
+    lines = _load(fixtures_dir, "basic-session.jsonl")
+    assert len(lines) == 2
+    assert lines[0]["type"] == "user"
+
+
+def test_get_messages_basic(fixtures_dir):
+    lines = _load(fixtures_dir, "basic-session.jsonl")
+    msgs = PR.get_messages(lines)
+    assert len(msgs) == 2
+    assert msgs[0]["role"] == "user"
+    assert msgs[1]["role"] == "assistant"
+
+
+def test_compact_marker_single(fixtures_dir):
+    lines = _load(fixtures_dir, "with-compact.jsonl")
+    msgs = PR.get_messages(lines)
+    compact = [m for m in msgs if m["is_compact"]]
+    assert len(compact) == 1
+
+
+def test_compact_marker_multiple(fixtures_dir):
+    lines = _load(fixtures_dir, "multi-compact.jsonl")
+    msgs = PR.get_messages(lines)
+    compact = [m for m in msgs if m["is_compact"]]
+    assert len(compact) == 2
+
+
+def test_compact_marker_absent(fixtures_dir):
+    lines = _load(fixtures_dir, "basic-session.jsonl")
+    msgs = PR.get_messages(lines)
+    assert all(not m["is_compact"] for m in msgs)
+
+
+def test_extract_text_blocks_string():
+    assert PR.extract_text_blocks("hello") == ["hello"]
+
+
+def test_extract_text_blocks_empty_string():
+    assert PR.extract_text_blocks("") == []
+    assert PR.extract_text_blocks("   ") == []
+
+
+def test_extract_text_blocks_array():
+    blocks = [{"type": "text", "text": "hi"}, {"type": "tool_use", "name": "X"}]
+    assert PR.extract_text_blocks(blocks) == ["hi"]
+
+
+def test_extract_text_blocks_with_thinking():
+    blocks = [
+        {"type": "thinking", "thinking": "reasoning..."},
+        {"type": "text", "text": "answer"},
+    ]
+    out = PR.extract_text_blocks(blocks, include_thinking=True)
+    assert any("THINKING" in t for t in out)
+    assert "answer" in out
+
+
+def test_extract_text_blocks_with_tool_use():
+    blocks = [{"type": "tool_use", "name": "Bash", "input": {"command": "ls"}}]
+    out = PR.extract_text_blocks(blocks, include_tool_use=True)
+    assert any("TOOL_USE Bash" in t for t in out)
+
+
+def test_extract_advisor():
+    blocks = [{"type": "advisor_tool_result", "content": {"text": "advice"}}]
+    out = PR.extract_text_blocks(blocks)
+    assert any("[ADVISOR]" in t for t in out)
+    assert any("advice" in t for t in out)
+
+
+def test_classify_entry_user():
+    obj = {"type": "user", "message": {"role": "user", "content": "hi"}}
+    assert PR.classify_entry(obj) == "user"
+
+
+def test_classify_entry_compact():
+    obj = {
+        "type": "user",
+        "message": {"role": "user", "content": PR.COMPACT_MARKER + " more"},
+    }
+    assert PR.classify_entry(obj) == "compact"
+
+
+def test_classify_entry_assistant():
+    obj = {"type": "assistant", "message": {"role": "assistant", "content": []}}
+    assert PR.classify_entry(obj) == "assistant"
+
+
+def test_classify_entry_noise():
+    obj = {"type": "ai-title", "aiTitle": "X"}
+    assert PR.classify_entry(obj) == "title"
+
+
+def test_all_noise_fixture_yields_no_messages(fixtures_dir):
+    lines = _load(fixtures_dir, "all-noise.jsonl")
+    msgs = PR.get_messages(lines)
+    assert msgs == []
+
+
+def test_filter_by_role(fixtures_dir):
+    lines = _load(fixtures_dir, "basic-session.jsonl")
+    msgs = PR.get_messages(lines)
+    user_only = PR.filter_by_role(msgs, "user")
+    assert all(m["role"] == "user" for m in user_only)
+    assert len(user_only) == 1
+
+
+def test_filter_by_time(fixtures_dir):
+    lines = _load(fixtures_dir, "time-spread.jsonl")
+    msgs = PR.get_messages(lines)
+    since = datetime(2026, 5, 1)
+    filtered = PR.filter_by_time(msgs, since=since, until=None)
+    assert all(
+        PR._parse_timestamp(m["timestamp"]).replace(tzinfo=None) >= since
+        for m in filtered if m["timestamp"]
+    )
+
+
+def test_truncated_line_dropped(fixtures_dir, capsys):
+    # Should not raise, and warning should be on stderr
+    lines = _load(fixtures_dir, "truncated.jsonl")
+    # 2 valid + 1 truncated = 2 valid records
+    assert len(lines) == 2
+
+
+def test_unicode_roundtrip(fixtures_dir):
+    lines = _load(fixtures_dir, "unicode.jsonl")
+    msgs = PR.get_messages(lines)
+    user_text = msgs[0]["texts"][0]
+    assert "🌍" in user_text or "你好" in user_text
+
+
+def test_infer_status_clean(fixtures_dir):
+    lines = _load(fixtures_dir, "basic-session.jsonl")
+    mtime = (fixtures_dir / "basic-session.jsonl").stat().st_mtime
+    status = PR.infer_status(lines, mtime, current_session_id=None, session_uuid=None)
+    assert status == "clean"
+
+
+def test_infer_status_pending_user(fixtures_dir):
+    lines = _load(fixtures_dir, "pending-user.jsonl")
+    mtime = (fixtures_dir / "pending-user.jsonl").stat().st_mtime
+    status = PR.infer_status(lines, mtime, current_session_id=None, session_uuid=None)
+    assert status == "pending-user"
+
+
+def test_infer_status_interrupted(fixtures_dir):
+    lines = _load(fixtures_dir, "interrupted.jsonl")
+    mtime = (fixtures_dir / "interrupted.jsonl").stat().st_mtime
+    status = PR.infer_status(lines, mtime, current_session_id=None, session_uuid=None)
+    assert status == "interrupted"
+
+
+def test_infer_status_active(fixtures_dir):
+    import time
+    # Touch the fixture to make it fresh, then set CLAUDE_SESSION_ID to its stem
+    f = fixtures_dir / "basic-session.jsonl"
+    mtime = time.time()
+    lines = _load(fixtures_dir, "basic-session.jsonl")
+    status = PR.infer_status(
+        lines, mtime, current_session_id="basic-session", session_uuid="basic-session"
+    )
+    assert status == "active"
+
+
+def test_session_summary_fields(fixtures_dir):
+    s = PR.session_summary(fixtures_dir / "tool-zoo.jsonl")
+    assert s["exists"]
+    assert s["msg_count"] > 0
+    assert "Bash" in s["tool_counts"]
+    assert "Read" in s["tool_counts"]
+
+
+def test_parse_lines_cache(fixtures_dir):
+    f = fixtures_dir / "basic-session.jsonl"
+    a = PR.parse_lines(f)
+    b = PR.parse_lines(f)
+    # Same object thanks to cache
+    assert a is b