agent-chat-reader 0.1.0__tar.gz → 0.1.2__tar.gz

{agent_chat_reader-0.1.0 → agent_chat_reader-0.1.2}/.github/workflows/ci.yml

@@ -104,7 +104,7 @@ jobs:
         run: python -m pip install --force-reinstall dist/*.whl
 
       - name: Smoke test installed package
-        run: python -c "import mypackage; print(mypackage.do_useful_thing())"
+        run: python -c "import agent_chat_reader; print(agent_chat_reader.__version__)"
 
   package-uv:
     name: Package Build (uv)
@@ -134,4 +134,4 @@ jobs:
         run: uv pip install --force-reinstall dist/*.whl
 
       - name: Smoke test installed package
-        run: uv run python -c "import mypackage; print(mypackage.do_useful_thing())"
+        run: uv run python -c "import agent_chat_reader; print(agent_chat_reader.__version__)"

{agent_chat_reader-0.1.0 → agent_chat_reader-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-chat-reader
-Version: 0.1.0
+Version: 0.1.2
 Summary: Read and search Codex CLI and Claude Code chat history from the terminal.
 Project-URL: Homepage, https://github.com/alik-git/agent-chat-reader
 Project-URL: Repository, https://github.com/alik-git/agent-chat-reader

{agent_chat_reader-0.1.0 → agent_chat_reader-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agent-chat-reader"
-version = "0.1.0"
+version = "0.1.2"
 description = "Read and search Codex CLI and Claude Code chat history from the terminal."
 readme = "README.md"
 requires-python = ">=3.11"

{agent_chat_reader-0.1.0 → agent_chat_reader-0.1.2}/src/agent_chat_reader/__init__.py

@@ -2,6 +2,6 @@
 
 from __future__ import annotations
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"
 
 __all__ = ["__version__"]

{agent_chat_reader-0.1.0 → agent_chat_reader-0.1.2}/src/agent_chat_reader/claude.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import json
 from pathlib import Path
+from typing import Any
 
 from agent_chat_reader.models import SessionMeta, Turn
 
@@ -31,23 +32,21 @@ def _session_title(path: Path) -> str:
     return last_title
 
 
-def _extract_user_text(content: str | list) -> str | None:  # type: ignore[type-arg]
+def _extract_user_text(content: str | list[Any]) -> str | None:
     """Extract real user text; return None for tool-result carriers."""
     if isinstance(content, str):
         return content.strip() or None
-    if isinstance(content, list):
-        has_tool_result = any(
-            b.get("type") == "tool_result" for b in content if isinstance(b, dict)
-        )
-        if has_tool_result:
-            return None
-        text = " ".join(
-            b.get("text", "")
-            for b in content
-            if isinstance(b, dict) and b.get("type") == "text"
-        ).strip()
-        return text or None
-    return None
+    has_tool_result = any(
+        b.get("type") == "tool_result" for b in content if isinstance(b, dict)
+    )
+    if has_tool_result:
+        return None
+    text = " ".join(
+        b.get("text", "")
+        for b in content
+        if isinstance(b, dict) and b.get("type") == "text"
+    ).strip()
+    return text or None
 
 
 def list_sessions() -> list[SessionMeta]:
@@ -142,7 +141,7 @@ def read_turns(
     return _apply_tail(turns, tail)
 
 
-def _format_tool_call(block: dict) -> str:  # type: ignore[type-arg]
+def _format_tool_call(block: dict[str, Any]) -> str:
     """Format a tool_use block as a short bracketed summary."""
     name = block.get("name", "?")
     inp = block.get("input", {})
@@ -164,4 +163,4 @@ def _apply_tail(turns: list[Turn], tail: int | None) -> list[Turn]:
     user_indices = [i for i, t in enumerate(turns) if t.role == "USER"]
     if tail >= len(user_indices):
         return turns
-    return turns[user_indices[-tail]:]
+    return turns[user_indices[-tail] :]

{agent_chat_reader-0.1.0 → agent_chat_reader-0.1.2}/src/agent_chat_reader/cli.py

@@ -8,7 +8,12 @@ from pathlib import Path
 
 from agent_chat_reader import __version__, claude, codex
 from agent_chat_reader.models import SessionMeta
-from agent_chat_reader.output import print_find_result, print_session_list, print_turn
+from agent_chat_reader.output import (
+    FindHit,
+    print_find_result,
+    print_session_list,
+    print_turn,
+)
 
 
 def _find_session(session_id: str) -> tuple[Path, str] | None:
@@ -47,13 +52,18 @@ def cmd_list(
     return 0
 
 
+def _title_key(title: str) -> str:
+    """Normalise a session title for dedup grouping."""
+    return title.strip()[:80].lower()
+
+
 def cmd_find(
     keyword: str,
     *,
     source_filter: str | None,
     include_subagents: bool,
 ) -> int:
-    """Search sessions for a keyword."""
+    """Search sessions for a keyword, deduplicating continuation sessions."""
     sessions: list[SessionMeta] = []
     if source_filter != "claude":
         sessions += codex.list_sessions(include_subagents=include_subagents)
@@ -62,7 +72,10 @@ def cmd_find(
 
     sessions = sorted(sessions, key=lambda s: s.mtime, reverse=True)
     keyword_lower = keyword.lower()
-    found_any = False
+
+    # Collect hits per session, then group by title to deduplicate continuations.
+    # Each group keeps the most-recent session's metadata as the representative.
+    groups: dict[str, tuple[SessionMeta, list[FindHit], int]] = {}
 
     for s in sessions:
         try:
@@ -73,17 +86,30 @@ def cmd_find(
         except Exception:
             continue
 
-        hits = [
-            (t.role, t.text[:120].replace("\n", " "))
+        hits: list[FindHit] = [
+            (t.role, t.text[:120].replace("\n", " "), t.timestamp)
             for t in turns
             if keyword_lower in t.text.lower()
         ]
-        if hits:
-            found_any = True
-            print_find_result(s, hits)
+        if not hits:
+            continue
 
-    if not found_any:
+        key = _title_key(s.title)
+        if key not in groups:
+            groups[key] = (s, hits, 1)
+        else:
+            rep, existing_hits, count = groups[key]
+            # Merge hits, keeping the most-recent session as representative.
+            rep = s if s.mtime > rep.mtime else rep
+            groups[key] = (rep, existing_hits + hits, count + 1)
+
+    if not groups:
         print(f"No sessions found containing {keyword!r}")
+        return 0
+
+    for rep, hits, count in groups.values():
+        print_find_result(rep, hits, merged_count=count)
+
     return 0
 
 
@@ -118,7 +144,7 @@ def cmd_read(
     for turn in turns:
         print_turn(turn)
 
-    print(f"\n{'─'*60}")
+    print(f"\n{'─' * 60}")
     print(f"Total turns: {len(turns)}")
     return 0
 
@@ -130,27 +156,42 @@ def main(argv: list[str] | None = None) -> int:
         description="Read and search Codex CLI and Claude Code chat history.",
     )
     p.add_argument(
-        "--version", action="version", version=f"agent-chat-reader {__version__}",
+        "--version",
+        action="version",
+        version=f"agent-chat-reader {__version__}",
     )
     p.add_argument("session", nargs="?", help="Session ID or file path to read")
     p.add_argument("--list", "-l", action="store_true", help="List recent sessions")
     p.add_argument(
-        "--find", "-f", metavar="KEYWORD", help="Search sessions for keyword",
+        "--find",
+        "-f",
+        metavar="KEYWORD",
+        help="Search sessions for keyword",
     )
     p.add_argument("--source", choices=["codex", "claude"], help="Filter to one source")
     p.add_argument(
-        "--verbose", "-v", action="store_true",
+        "--verbose",
+        "-v",
+        action="store_true",
         help="Include tool call summaries (Claude sessions)",
     )
     p.add_argument(
-        "--tail", "-n", type=int, metavar="N", help="Show only the last N user turns",
+        "--tail",
+        "-n",
+        type=int,
+        metavar="N",
+        help="Show only the last N user turns",
     )
     p.add_argument(
-        "--include-subagents", action="store_true",
+        "--include-subagents",
+        action="store_true",
         help="Include guardian/subagent sessions",
     )
     p.add_argument(
-        "--limit", type=int, default=40, help="Max sessions for --list (default: 40)",
+        "--limit",
+        type=int,
+        default=40,
+        help="Max sessions for --list (default: 40)",
     )
 
     args = p.parse_args(argv)

{agent_chat_reader-0.1.0 → agent_chat_reader-0.1.2}/src/agent_chat_reader/codex.py

@@ -21,7 +21,7 @@ def is_subagent(path: Path) -> bool:
                     if payload.get("thread_source") == "subagent":
                         return True
                     source = payload.get("source", {})
-                    return isinstance(source, dict) and "subagent" in source
+                    return bool(isinstance(source, dict) and "subagent" in source)
             except Exception:
                 pass
     return False
@@ -37,7 +37,8 @@ def _first_user_message(path: Path) -> str:
                     rec.get("type") == "event_msg"
                     and rec.get("payload", {}).get("type") == "user_message"
                 ):
-                    return rec["payload"].get("message", "").replace("\n", " ")[:80]
+                    msg: str = rec["payload"].get("message", "")
+                    return msg.replace("\n", " ")[:80]
             except Exception:
                 pass
     return ""
@@ -148,4 +149,4 @@ def _apply_tail(turns: list[Turn], tail: int | None) -> list[Turn]:
     user_indices = [i for i, t in enumerate(turns) if t.role == "USER"]
     if tail >= len(user_indices):
         return turns
-    return turns[user_indices[-tail]:]
+    return turns[user_indices[-tail] :]

{agent_chat_reader-0.1.0 → agent_chat_reader-0.1.2}/src/agent_chat_reader/output.py

@@ -10,6 +10,9 @@ from agent_chat_reader.models import SessionMeta, Turn
 _MAX_TURN_LEN = 3000
 _WRAP_THRESHOLD = 400
 
+# Type alias: (role, snippet, timestamp)
+FindHit = tuple[str, str, str]
+
 
 def fmt_ts(ts_str: str) -> str:
     """Format an ISO timestamp to a short local time string."""
@@ -30,7 +33,7 @@ def fmt_mtime(mtime: float) -> str:
 def print_turn(turn: Turn) -> None:
     """Print a single conversation turn with a header rule."""
     ts_str = f"  {fmt_ts(turn.timestamp)}" if turn.timestamp else ""
-    print(f"\n{'─'*60}")
+    print(f"\n{'─' * 60}")
     print(f"[{turn.role}]{ts_str}")
     print("─" * 60)
     text = turn.text
@@ -54,16 +57,21 @@ def print_session_list(sessions: list[SessionMeta]) -> None:
 
 def print_find_result(
     session: SessionMeta,
-    hits: list[tuple[str, str]],
+    hits: list[FindHit],
     *,
     max_hits: int = 4,
+    merged_count: int = 1,
 ) -> None:
     """Print a single session's find results."""
-    print(f"\n{'='*70}")
-    print(f"[{session.source.upper()}] {session.id}  {fmt_mtime(session.mtime)}")
+    print(f"\n{'=' * 70}")
+    merged = f"  [{merged_count} sessions]" if merged_count > 1 else ""
+    print(
+        f"[{session.source.upper()}] {session.id}  {fmt_mtime(session.mtime)}{merged}"
+    )
     if session.title:
         print(f'  "{session.title[:60]}"')
-    for role, snippet in hits[:max_hits]:
-        print(f"  [{role}] {snippet!r}")
+    for role, snippet, ts in hits[:max_hits]:
+        ts_str = f" {fmt_ts(ts)}" if ts else ""
+        print(f"  [{role}{ts_str}] {snippet!r}")
     if len(hits) > max_hits:
         print(f"  ... and {len(hits) - max_hits} more matches")

{agent_chat_reader-0.1.0 → agent_chat_reader-0.1.2}/tests/test_package.py

@@ -15,6 +15,7 @@ from agent_chat_reader.models import Turn
 
 # ── Version ───────────────────────────────────────────────────────────────────
 
+
 def test_version() -> None:
     """Package version is a non-empty string."""
     assert isinstance(agent_chat_reader.__version__, str)
@@ -31,6 +32,7 @@ def test_cli_version(capsys: pytest.CaptureFixture[str]) -> None:
 
 # ── Codex parsing ─────────────────────────────────────────────────────────────
 
+
 def _write_jsonl(path: Path, records: list[dict]) -> None:
     """Write a list of dicts as JSONL."""
     with path.open("w") as fh:
@@ -44,15 +46,30 @@ _SESSION_FILE = "rollout-2026-01-01T00-00-00-019eae7d-da44-7413-8eb7-52d87219b1d
 def test_codex_read_turns_basic(tmp_path: Path) -> None:
     """Extracts user and agent turns from a minimal Codex session."""
     session = tmp_path / _SESSION_FILE
-    _write_jsonl(session, [
-        {"type": "session_meta", "payload": {"thread_source": "user"}},
-        {"type": "event_msg", "timestamp": "2026-01-01T00:00:00Z",
-         "payload": {"type": "user_message", "message": "hello"}},
-        {"type": "event_msg", "timestamp": "2026-01-01T00:00:01Z",
-         "payload": {"type": "agent_message", "message": "hi there"}},
-        {"type": "response_item", "timestamp": "2026-01-01T00:00:02Z",
-         "payload": {"role": "assistant", "content": [{"type": "text", "text": "ok"}]}},
-    ])
+    _write_jsonl(
+        session,
+        [
+            {"type": "session_meta", "payload": {"thread_source": "user"}},
+            {
+                "type": "event_msg",
+                "timestamp": "2026-01-01T00:00:00Z",
+                "payload": {"type": "user_message", "message": "hello"},
+            },
+            {
+                "type": "event_msg",
+                "timestamp": "2026-01-01T00:00:01Z",
+                "payload": {"type": "agent_message", "message": "hi there"},
+            },
+            {
+                "type": "response_item",
+                "timestamp": "2026-01-01T00:00:02Z",
+                "payload": {
+                    "role": "assistant",
+                    "content": [{"type": "text", "text": "ok"}],
+                },
+            },
+        ],
+    )
     turns = read_turns(session)
     assert turns[0] == Turn("USER", "hello", "2026-01-01T00:00:00Z")
     assert turns[1] == Turn("AGENT", "hi there", "2026-01-01T00:00:01Z")
@@ -62,14 +79,29 @@ def test_codex_read_turns_basic(tmp_path: Path) -> None:
 def test_codex_deduplicates_agent_and_response_item(tmp_path: Path) -> None:
     """agent_message and response_item with same text are deduplicated."""
     session = tmp_path / _SESSION_FILE
-    _write_jsonl(session, [
-        {"type": "event_msg", "timestamp": "t1",
-         "payload": {"type": "user_message", "message": "hi"}},
-        {"type": "event_msg", "timestamp": "t2",
-         "payload": {"type": "agent_message", "message": "same text"}},
-        {"type": "response_item", "timestamp": "t3",
-         "payload": {"role": "assistant", "content": [{"type": "text", "text": "same text"}]}},
-    ])
+    _write_jsonl(
+        session,
+        [
+            {
+                "type": "event_msg",
+                "timestamp": "t1",
+                "payload": {"type": "user_message", "message": "hi"},
+            },
+            {
+                "type": "event_msg",
+                "timestamp": "t2",
+                "payload": {"type": "agent_message", "message": "same text"},
+            },
+            {
+                "type": "response_item",
+                "timestamp": "t3",
+                "payload": {
+                    "role": "assistant",
+                    "content": [{"type": "text", "text": "same text"}],
+                },
+            },
+        ],
+    )
     turns = read_turns(session)
     agent_turns = [t for t in turns if t.role == "AGENT"]
     assert len(agent_turns) == 1
@@ -79,11 +111,17 @@ def test_codex_deduplicates_agent_and_response_item(tmp_path: Path) -> None:
 def test_codex_skips_empty_messages(tmp_path: Path) -> None:
     """Empty user/agent messages are not emitted as turns."""
     session = tmp_path / _SESSION_FILE
-    _write_jsonl(session, [
-        {"type": "event_msg", "payload": {"type": "user_message", "message": "  "}},
-        {"type": "event_msg", "payload": {"type": "agent_message", "message": ""}},
-        {"type": "event_msg", "payload": {"type": "user_message", "message": "real"}},
-    ])
+    _write_jsonl(
+        session,
+        [
+            {"type": "event_msg", "payload": {"type": "user_message", "message": "  "}},
+            {"type": "event_msg", "payload": {"type": "agent_message", "message": ""}},
+            {
+                "type": "event_msg",
+                "payload": {"type": "user_message", "message": "real"},
+            },
+        ],
+    )
     turns = read_turns(session)
     assert len(turns) == 1
     assert turns[0].text == "real"
@@ -118,6 +156,7 @@ def test_apply_tail_none_returns_all() -> None:
 
 # ── Claude parsing ────────────────────────────────────────────────────────────
 
+
 def test_claude_extract_user_text_string() -> None:
     """Plain string content is returned as-is."""
     assert _extract_user_text("hello") == "hello"
@@ -142,6 +181,7 @@ def test_claude_extract_user_text_text_block() -> None:
 
 # ── CLI smoke ─────────────────────────────────────────────────────────────────
 
+
 def test_cli_no_args_exits_zero(capsys: pytest.CaptureFixture[str]) -> None:
     """Calling main() with no args prints help and exits 0."""
     assert main([]) == 0

{agent_chat_reader-0.1.0 → agent_chat_reader-0.1.2}/uv.lock

@@ -8,7 +8,7 @@ resolution-markers = [
 
 [[package]]
 name = "agent-chat-reader"
-version = "0.1.0"
+version = "0.1.2"
 source = { editable = "." }
 
 [package.optional-dependencies]