elliot-stack 1.0.18 → 1.0.19

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

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

@@ -0,0 +1,133 @@
+"""Tests for lib.paths."""
+
+import os
+from datetime import datetime, timedelta
+from pathlib import Path
+
+import pytest
+
+from lib import paths as P
+
+
+def test_encode_cwd_basic():
+    assert P.encode_cwd("C:\\Users\\foo\\bar") == "C--Users-foo-bar"
+
+
+def test_encode_cwd_spaces():
+    assert P.encode_cwd("C:\\Users\\2supe\\Other Claude Code") == "C--Users-2supe-Other-Claude-Code"
+
+
+def test_encode_cwd_mixed_slashes():
+    assert P.encode_cwd("C:/Users/foo bar") == "C--Users-foo-bar"
+
+
+def test_decode_project_name_strips_prefix():
+    enc = "C--Users-elliot-Other-Claude-Code-Personal-Brand-Project"
+    decoded = P.decode_project_name(enc)
+    assert "Other" in decoded
+    assert "Personal" in decoded
+    assert "C--Users" not in decoded
+
+
+def test_decode_project_name_fallback_when_unparseable():
+    decoded = P.decode_project_name("totally-weird-thing")
+    assert decoded  # Non-empty, falls back gracefully
+
+
+def test_resolve_root_live():
+    assert P.resolve_root("live").name == "projects"
+
+
+def test_resolve_root_mirror():
+    r = P.resolve_root("mirror")
+    assert "mirror" in str(r)
+    assert r.name == "projects"
+
+
+def test_resolve_root_unknown_relative_raises():
+    with pytest.raises(ValueError):
+        P.resolve_root("not-a-known-root")
+
+
+def test_resolve_root_absolute_passes_through(tmp_path: Path):
+    r = P.resolve_root(str(tmp_path))
+    assert r == tmp_path
+
+
+def test_current_session_id_unset(monkeypatch):
+    monkeypatch.delenv("CLAUDE_SESSION_ID", raising=False)
+    assert P.current_session_id() is None
+
+
+def test_current_session_id_set(monkeypatch):
+    monkeypatch.setenv("CLAUDE_SESSION_ID", "abc-123")
+    assert P.current_session_id() == "abc-123"
+
+
+def test_parse_timespec_relative():
+    now = datetime.now()
+    delta = now - P.parse_timespec("1h")
+    assert timedelta(seconds=3590) <= delta <= timedelta(seconds=3610)
+
+
+def test_parse_timespec_iso_date():
+    assert P.parse_timespec("2026-05-01") == datetime(2026, 5, 1)
+
+
+def test_parse_timespec_yesterday():
+    y = P.parse_timespec("yesterday")
+    assert y.hour == 0
+    assert y.minute == 0
+
+
+def test_parse_timespec_invalid():
+    with pytest.raises(ValueError):
+        P.parse_timespec("not-a-time")
+
+
+def test_list_transcripts_empty(tmp_path: Path):
+    assert P.list_transcripts(tmp_path) == []
+
+
+def test_list_transcripts_excludes_agent_prefix(tmp_path: Path):
+    (tmp_path / "real.jsonl").write_text("{}\n")
+    (tmp_path / "agent-foo.jsonl").write_text("{}\n")
+    files = P.list_transcripts(tmp_path)
+    names = [f.name for f in files]
+    assert "real.jsonl" in names
+    assert "agent-foo.jsonl" not in names
+
+
+def test_list_transcripts_time_filter(tmp_path: Path):
+    old = tmp_path / "old.jsonl"
+    new = tmp_path / "new.jsonl"
+    old.write_text("{}\n")
+    new.write_text("{}\n")
+    # Backdate old
+    past = datetime.now() - timedelta(days=10)
+    os.utime(old, (past.timestamp(), past.timestamp()))
+
+    since = datetime.now() - timedelta(days=5)
+    files = P.list_transcripts(tmp_path, since=since)
+    assert [f.name for f in files] == ["new.jsonl"]
+
+
+def test_list_projects_empty(tmp_path: Path):
+    assert P.list_projects(tmp_path) == []
+
+
+def test_list_subagents_returns_empty_when_no_dir(tmp_path: Path):
+    f = tmp_path / "session.jsonl"
+    f.write_text("{}\n")
+    assert P.list_subagents(f) == []
+
+
+def test_list_subagents_finds_agent_files(tmp_path: Path):
+    f = tmp_path / "session.jsonl"
+    f.write_text("{}\n")
+    sub_dir = tmp_path / "session" / "subagents"
+    sub_dir.mkdir(parents=True)
+    (sub_dir / "agent-x.jsonl").write_text("{}\n")
+    (sub_dir / "agent-y.jsonl").write_text("{}\n")
+    subs = P.list_subagents(f)
+    assert len(subs) == 2

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

@@ -0,0 +1,78 @@
+"""Tests for lib.search."""
+
+from datetime import datetime
+from pathlib import Path
+
+from lib import search as S
+
+
+def test_search_session_text(fixtures_dir):
+    matches = S.search_session(
+        fixtures_dir / "basic-session.jsonl", "Hello", role="both", in_channel="text"
+    )
+    assert len(matches) >= 1
+
+
+def test_search_session_assistant_only(fixtures_dir):
+    matches = S.search_session(
+        fixtures_dir / "basic-session.jsonl", "Hello",
+        role="assistant", in_channel="text",
+    )
+    # "Hello" is in the user message only
+    assert len(matches) == 0
+
+
+def test_search_session_user_only(fixtures_dir):
+    matches = S.search_session(
+        fixtures_dir / "basic-session.jsonl", "Hello",
+        role="user", in_channel="text",
+    )
+    assert len(matches) >= 1
+
+
+def test_search_in_tool_use(fixtures_dir):
+    matches = S.search_session(
+        fixtures_dir / "tool-zoo.jsonl", "ls -la",
+        role="both", in_channel="tool_use",
+    )
+    assert len(matches) >= 1
+    assert matches[0].where == "tool_use"
+
+
+def test_search_in_thinking(fixtures_dir):
+    matches = S.search_session(
+        fixtures_dir / "with-thinking.jsonl", "step by step",
+        role="both", in_channel="thinking",
+    )
+    assert len(matches) >= 1
+    assert matches[0].where == "thinking"
+
+
+def test_search_no_match(fixtures_dir):
+    matches = S.search_session(
+        fixtures_dir / "basic-session.jsonl", "this-string-not-present",
+        role="both", in_channel="text",
+    )
+    assert matches == []
+
+
+def test_search_with_time_filter(fixtures_dir):
+    # "Hello" appears in basic-session.jsonl at 2026-05-01T10:00:00Z
+    # Excluding that date should yield no matches
+    matches = S.search_session(
+        fixtures_dir / "basic-session.jsonl", "Hello",
+        role="both", in_channel="text",
+        since=datetime(2026, 6, 1),
+    )
+    assert matches == []
+
+
+def test_search_project(fixtures_dir, tmp_path):
+    # Copy 2 fixtures into a fake project dir and search
+    import shutil
+    pd = tmp_path / "fake-proj"
+    pd.mkdir()
+    shutil.copy(fixtures_dir / "basic-session.jsonl", pd / "session-a.jsonl")
+    shutil.copy(fixtures_dir / "tool-zoo.jsonl", pd / "session-b.jsonl")
+    matches = list(S.search_project(pd, "Hello", progress=False))
+    assert len(matches) >= 1

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

@@ -0,0 +1,43 @@
+"""Tests for lib.subagents."""
+
+from pathlib import Path
+
+from lib import subagents as SA
+from lib import paths as P
+
+
+def test_load_meta_hit(fixtures_dir):
+    agent_file = fixtures_dir / "subagent-parent" / "subagents" / "agent-xyz123.jsonl"
+    meta = SA.load_meta(agent_file)
+    assert meta["agentType"] == "Explore"
+    assert "bug" in meta["description"].lower()
+
+
+def test_load_meta_miss(fixtures_dir):
+    agent_file = fixtures_dir / "subagent-no-meta" / "subagents" / "agent-aaa.jsonl"
+    meta = SA.load_meta(agent_file)
+    assert meta["agentType"] == "unknown"
+    assert meta["description"] == ""
+
+
+def test_agent_finals(fixtures_dir):
+    parent = fixtures_dir / "subagent-parent.jsonl"
+    finals = SA.agent_finals(parent)
+    assert len(finals) == 1
+    agent_id, meta, text = finals[0]
+    assert agent_id == "agent-xyz123"
+    assert meta["agentType"] == "Explore"
+    assert "Found it" in text
+
+
+def test_agent_finals_no_subagents(fixtures_dir):
+    parent = fixtures_dir / "basic-session.jsonl"
+    finals = SA.agent_finals(parent)
+    assert finals == []
+
+
+def test_list_subagents(fixtures_dir):
+    parent = fixtures_dir / "subagent-parent.jsonl"
+    subs = P.list_subagents(parent)
+    assert len(subs) == 1
+    assert subs[0].stem == "agent-xyz123"

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

@@ -0,0 +1,175 @@
+"""Tests for the timeline mode (build/render/gap parsing + CLI)."""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+
+import pytest
+
+import read_transcript as RT
+
+
+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,
+    )
+
+
+@pytest.fixture
+def fake_root(fixtures_dir, tmp_path):
+    root = tmp_path / "projects"
+    proj = root / "C--fake-proj"
+    proj.mkdir(parents=True)
+    shutil.copy(fixtures_dir / "timeline-day-test.jsonl", proj / "abc12345.jsonl")
+    return root
+
+
+# ── unit: gap + duration helpers ─────────────────────────────────────────────
+
+def test_parse_gap_default():
+    assert RT._parse_gap(None) == 15
+
+
+def test_parse_gap_minutes():
+    assert RT._parse_gap("20m") == 20
+    assert RT._parse_gap("20") == 20
+
+
+def test_parse_gap_hours():
+    assert RT._parse_gap("1h") == 60
+
+
+def test_parse_gap_invalid():
+    with pytest.raises(ValueError):
+        RT._parse_gap("soon")
+
+
+def test_fmt_dur():
+    assert RT._fmt_dur(timedelta(minutes=8)) == "8m"
+    assert RT._fmt_dur(timedelta(minutes=72)) == "1h12m"
+    assert RT._fmt_dur(timedelta(seconds=30)) == "<1m"
+
+
+# ── unit: block grouping ─────────────────────────────────────────────────────
+
+def test_build_timeline_blocks(fake_root):
+    from lib import parser as PR
+    PR.set_timezone("UTC")
+    try:
+        data = RT.build_timeline(
+            [fake_root / "C--fake-proj"],
+            since=datetime(2026, 5, 1),
+            until=datetime(2026, 5, 2),
+            gap_minutes=15,
+            current_uuid=None,
+        )
+    finally:
+        PR.set_timezone(None)
+    blocks = data["blocks"]
+    assert len(blocks) == 2
+    assert blocks[0]["start"] == datetime(2026, 5, 1, 10, 0)
+    assert blocks[0]["end"] == datetime(2026, 5, 1, 10, 8)
+    assert blocks[1]["start"] == datetime(2026, 5, 1, 12, 0)
+    assert blocks[1]["end"] == datetime(2026, 5, 1, 12, 2)
+
+
+def test_build_timeline_wide_gap_merges(fake_root):
+    from lib import parser as PR
+    PR.set_timezone("UTC")
+    try:
+        data = RT.build_timeline(
+            [fake_root / "C--fake-proj"],
+            since=datetime(2026, 5, 1),
+            until=datetime(2026, 5, 2),
+            gap_minutes=180,  # 3h gap threshold swallows the 1h52m idle
+            current_uuid=None,
+        )
+    finally:
+        PR.set_timezone(None)
+    assert len(data["blocks"]) == 1
+
+
+# ── CLI ──────────────────────────────────────────────────────────────────────
+
+def test_timeline_cli_text(cli_path, fake_root):
+    r = _run_cli(
+        cli_path, "--root", str(fake_root), "--tz", "UTC",
+        "--mode", "timeline", "--date", "2026-05-01",
+    )
+    assert r.returncode == 0
+    assert "10:00" in r.stdout
+    assert "12:02" in r.stdout
+    assert "idle" in r.stdout
+    assert "2 active block(s)" in r.stdout
+
+
+def test_timeline_cli_json(cli_path, fake_root):
+    r = _run_cli(
+        cli_path, "--root", str(fake_root), "--tz", "UTC",
+        "--mode", "timeline", "--date", "2026-05-01", "--format", "json",
+    )
+    assert r.returncode == 0
+    data = json.loads(r.stdout)
+    assert data["totals"]["blocks"] == 2
+    assert data["totals"]["sessions"] == 1
+    assert data["blocks"][0]["start"].endswith("10:00:00")
+    assert data["blocks"][0]["sessions"][0]["uuid"] == "abc12345"
+
+
+def test_timeline_cli_empty_range(cli_path, fake_root):
+    r = _run_cli(
+        cli_path, "--root", str(fake_root), "--tz", "UTC",
+        "--mode", "timeline", "--date", "2020-01-01",
+    )
+    assert r.returncode == 0
+    assert "no activity" in r.stdout
+
+
+def test_timeline_cli_project_filter(cli_path, fake_root):
+    r = _run_cli(
+        cli_path, "--root", str(fake_root), "--tz", "UTC",
+        "--mode", "timeline", "--date", "2026-05-01", "--project", "fake",
+    )
+    assert r.returncode == 0
+    assert "10:00" in r.stdout
+
+
+def test_timeline_cli_exclude_current(cli_path, fake_root):
+    r = _run_cli(
+        cli_path, "--root", str(fake_root), "--tz", "UTC",
+        "--mode", "timeline", "--date", "2026-05-01", "--exclude-current",
+        env_overrides={"CLAUDE_SESSION_ID": "abc12345"},
+    )
+    assert r.returncode == 0
+    assert "no activity" in r.stdout
+
+
+def test_journal_cli_exclude_current(cli_path, fake_root):
+    r = _run_cli(
+        cli_path, "--root", str(fake_root),
+        "--mode", "journal", "--since", "2020-01-01", "--all-projects",
+        "--exclude-current",
+        env_overrides={"CLAUDE_SESSION_ID": "abc12345"},
+    )
+    assert r.returncode == 0
+    assert "abc12345" not in r.stdout
+
+
+def test_timeline_cli_project_no_match(cli_path, fake_root):
+    r = _run_cli(
+        cli_path, "--root", str(fake_root), "--tz", "UTC",
+        "--mode", "timeline", "--date", "2026-05-01", "--project", "zzz-nope",
+    )
+    assert r.returncode == 1