elliot-stack 1.0.18 → 1.0.20

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,179 @@
+"""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 block(s)" in r.stdout
+    # Timeline makes no attention claim — that's engagement mode's job.
+    assert "active" not 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["totals"]["span_minutes"] == 122  # 10:00 → 12:02
+    assert "active_minutes" not in data["totals"]
+    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

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

@@ -0,0 +1,212 @@
+"""Tests for timezone handling (set_timezone / --tz) and the --project filter."""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+
+import pytest
+
+from lib import parser as PR
+from lib import paths as P
+
+
+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(autouse=True)
+def _reset_tz():
+    yield
+    PR.set_timezone(None)
+
+
+# ── set_timezone / _parse_timestamp ─────────────────────────────────────────
+
+def test_parse_timestamp_default_is_naive():
+    dt = PR._parse_timestamp("2026-05-01T10:00:00Z")
+    assert dt is not None
+    assert dt.tzinfo is None
+
+
+def test_parse_timestamp_utc():
+    PR.set_timezone("UTC")
+    assert PR._parse_timestamp("2026-05-01T10:00:00Z") == datetime(2026, 5, 1, 10, 0)
+
+
+def test_parse_timestamp_offset():
+    PR.set_timezone("+2")
+    assert PR._parse_timestamp("2026-05-01T10:00:00Z") == datetime(2026, 5, 1, 12, 0)
+
+
+def test_parse_timestamp_utc_minus():
+    PR.set_timezone("UTC-4")
+    assert PR._parse_timestamp("2026-05-01T10:00:00Z") == datetime(2026, 5, 1, 6, 0)
+
+
+def test_set_timezone_half_hour_offset():
+    PR.set_timezone("+05:30")
+    assert PR._parse_timestamp("2026-05-01T10:00:00Z") == datetime(2026, 5, 1, 15, 30)
+
+
+def test_set_timezone_local_resets():
+    PR.set_timezone("UTC")
+    PR.set_timezone("local")
+    assert PR._TARGET_TZ is None
+
+
+def test_set_timezone_iana():
+    try:
+        PR.set_timezone("America/New_York")
+    except ValueError:
+        pytest.skip("IANA tz database not available on this machine")
+    dt = PR._parse_timestamp("2026-01-15T10:00:00Z")  # EST = UTC-5
+    assert dt == datetime(2026, 1, 15, 5, 0)
+
+
+def test_set_timezone_invalid_raises():
+    with pytest.raises(ValueError):
+        PR.set_timezone("Mars/Olympus_Mons")
+
+
+def test_epoch_to_display_utc():
+    PR.set_timezone("UTC")
+    # 2026-05-01T10:00:00Z as epoch
+    epoch = datetime(2026, 5, 1, 10, 0).replace(
+        tzinfo=__import__("datetime").timezone.utc
+    ).timestamp()
+    assert PR.epoch_to_display(epoch) == datetime(2026, 5, 1, 10, 0)
+
+
+def test_cli_tz_invalid(cli_path, fixtures_dir):
+    r = _run_cli(
+        cli_path, "--file", str(fixtures_dir / "basic-session.jsonl"),
+        "--mode", "changelog", "--tz", "Nope/Nowhere",
+    )
+    assert r.returncode == 1
+    assert "timezone" in r.stderr.lower()
+
+
+def test_display_to_epoch_roundtrip_offset_tz():
+    PR.set_timezone("+2")
+    epoch = 1772546400.0
+    assert PR.display_to_epoch(PR.epoch_to_display(epoch)) == epoch
+
+
+def test_display_to_epoch_roundtrip_local():
+    epoch = 1772546400.0
+    assert PR.display_to_epoch(PR.epoch_to_display(epoch)) == epoch
+
+
+def test_now_display_matches_utc_clock():
+    from datetime import timezone as _tzmod
+    PR.set_timezone("UTC")
+    delta = abs((PR.now_display() - datetime.now(_tzmod.utc).replace(tzinfo=None)).total_seconds())
+    assert delta < 5
+
+
+def test_parse_timespec_now_respects_tz():
+    from datetime import timezone as _tzmod
+    PR.set_timezone("UTC")
+    now_spec = P.parse_timespec("now")
+    delta = abs((now_spec - datetime.now(_tzmod.utc).replace(tzinfo=None)).total_seconds())
+    assert delta < 5
+
+
+def test_json_timestamps_are_display_tz(cli_path, fixtures_dir):
+    # basic-session events are 10:00:0xZ — with +2 the JSON timestamps read 12:00
+    r = _run_cli(
+        cli_path, "--file", str(fixtures_dir / "basic-session.jsonl"),
+        "--mode", "last", "--format", "json", "--tz", "+2",
+    )
+    assert r.returncode == 0
+    data = json.loads(r.stdout)
+    assert data[-1]["timestamp"].startswith("2026-05-01T12:00:05")
+
+
+def test_cli_changelog_respects_tz(cli_path, fixtures_dir):
+    # tool-zoo events are 10:00:0xZ — with +3 they display as 13:00
+    r = _run_cli(
+        cli_path, "--file", str(fixtures_dir / "tool-zoo.jsonl"),
+        "--mode", "changelog", "--tz", "+3",
+    )
+    assert r.returncode == 0
+    assert "13:00:01" in r.stdout
+
+
+# ── --project filter ─────────────────────────────────────────────────────────
+
+@pytest.fixture
+def multi_root(fixtures_dir, tmp_path):
+    root = tmp_path / "projects"
+    keel = root / "C--Users-x-Keel-Project"
+    other = root / "C--Users-x-Other-Claude-Code"
+    keel.mkdir(parents=True)
+    other.mkdir(parents=True)
+    shutil.copy(fixtures_dir / "basic-session.jsonl", keel / "keelsession.jsonl")
+    shutil.copy(fixtures_dir / "tool-zoo.jsonl", other / "othersession.jsonl")
+    return root
+
+
+def test_filter_projects_substring(multi_root):
+    dirs = P.filter_projects(multi_root, "keel")
+    assert len(dirs) == 1
+    assert "Keel" in dirs[0].name
+
+
+def test_filter_projects_spaces_match_hyphens(multi_root):
+    dirs = P.filter_projects(multi_root, "Keel Project")
+    assert len(dirs) == 1
+
+
+def test_filter_projects_no_match(multi_root):
+    assert P.filter_projects(multi_root, "zzz") == []
+
+
+def test_cli_list_project_filter(cli_path, multi_root):
+    r = _run_cli(
+        cli_path, "--root", str(multi_root), "--mode", "list", "--project", "keel",
+    )
+    assert r.returncode == 0
+    assert "keelsess" in r.stdout
+    assert "othersess" not in r.stdout
+
+
+def test_cli_search_project_filter(cli_path, multi_root):
+    r = _run_cli(
+        cli_path, "--root", str(multi_root), "--mode", "search",
+        "--query", "help", "--project", "keel",
+    )
+    assert r.returncode == 0
+    assert "keelsession" in r.stdout
+
+
+def test_cli_journal_project_filter_json(cli_path, multi_root):
+    r = _run_cli(
+        cli_path, "--root", str(multi_root), "--mode", "journal",
+        "--since", "2020-01-01", "--project", "other claude", "--format", "json",
+    )
+    assert r.returncode == 0
+    data = json.loads(r.stdout)
+    assert len(data) == 1
+    assert data[0]["uuid"] == "othersession"
+
+
+def test_cli_project_no_match_exits_1(cli_path, multi_root):
+    r = _run_cli(
+        cli_path, "--root", str(multi_root), "--mode", "list", "--project", "zzz",
+    )
+    assert r.returncode == 1