agent-chat-reader 0.1.0__py3-none-any.whl

agent_chat_reader/__init__.py

@@ -0,0 +1,7 @@
+"""Read and search Codex CLI and Claude Code chat history."""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+__all__ = ["__version__"]

agent_chat_reader/claude.py

@@ -0,0 +1,167 @@
+"""Claude Code session reader."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from agent_chat_reader.models import SessionMeta, Turn
+
+CLAUDE_PROJECTS = Path.home() / ".claude" / "projects"
+
+
+def _decode_project_path(dirname: str) -> str:
+    """Decode '-home-ali' -> '/home/ali'."""
+    return dirname.replace("-", "/")
+
+
+def _session_title(path: Path) -> str:
+    """Return the last ai-title from a Claude session file."""
+    last_title = ""
+    with path.open() as fh:
+        for raw in fh:
+            try:
+                rec = json.loads(raw.strip())
+                if rec.get("type") == "ai-title":
+                    t = rec.get("aiTitle", "").strip()
+                    if t:
+                        last_title = t
+            except Exception:
+                pass
+    return last_title
+
+
+def _extract_user_text(content: str | list) -> str | None:  # type: ignore[type-arg]
+    """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
+
+
+def list_sessions() -> list[SessionMeta]:
+    """List all Claude Code sessions, sorted by most recent first."""
+    if not CLAUDE_PROJECTS.exists():
+        return []
+    results = []
+    for proj_dir in CLAUDE_PROJECTS.iterdir():
+        if not proj_dir.is_dir():
+            continue
+        for f in proj_dir.glob("*.jsonl"):
+            stat = f.stat()
+            results.append(
+                SessionMeta(
+                    source="claude",
+                    id=f.stem,
+                    path=f,
+                    mtime=stat.st_mtime,
+                    size_kb=stat.st_size // 1024,
+                    title=_session_title(f) or "(untitled)",
+                )
+            )
+    return sorted(results, key=lambda s: s.mtime, reverse=True)
+
+
+def read_turns(
+    path: Path,
+    *,
+    verbose: bool = False,
+    include_subagents: bool = False,
+    tail: int | None = None,
+) -> list[Turn]:
+    """Read conversation turns from a Claude Code session file.
+
+    Args:
+        path: Path to the session JSONL file.
+        verbose: If True, append brief tool call summaries to assistant turns.
+        include_subagents: If True, include sidechain (sub-agent) turns.
+        tail: If set, return only turns from the last N user messages onward.
+
+    Returns:
+        List of Turn namedtuples in conversation order.
+    """
+    turns: list[Turn] = []
+
+    with path.open() as fh:
+        for raw in fh:
+            stripped = raw.strip()
+            if not stripped:
+                continue
+            try:
+                rec = json.loads(stripped)
+                t = rec.get("type", "")
+                is_sidechain = rec.get("isSidechain", False)
+                ts: str = rec.get("timestamp", "")
+
+                if not include_subagents and is_sidechain:
+                    continue
+
+                if t == "user":
+                    content = rec.get("message", {}).get("content", "")
+                    text = _extract_user_text(content)
+                    if text:
+                        turns.append(Turn("USER", text, ts))
+
+                elif t == "assistant":
+                    blocks = rec.get("message", {}).get("content", [])
+                    if not isinstance(blocks, list):
+                        continue
+                    text_parts = []
+                    tool_parts = []
+                    for block in blocks:
+                        if not isinstance(block, dict):
+                            continue
+                        btype = block.get("type", "")
+                        if btype == "text":
+                            t_text = block.get("text", "").strip()
+                            if t_text:
+                                text_parts.append(t_text)
+                        elif btype == "tool_use" and verbose:
+                            tool_parts.append(_format_tool_call(block))
+
+                    full_text = "\n".join(text_parts).strip()
+                    if tool_parts and verbose:
+                        full_text = (full_text + "\n" + " ".join(tool_parts)).strip()
+                    if full_text:
+                        turns.append(Turn("CLAUDE", full_text, ts))
+
+            except Exception:
+                pass
+
+    return _apply_tail(turns, tail)
+
+
+def _format_tool_call(block: dict) -> str:  # type: ignore[type-arg]
+    """Format a tool_use block as a short bracketed summary."""
+    name = block.get("name", "?")
+    inp = block.get("input", {})
+    if name == "Bash":
+        desc = inp.get("description", inp.get("command", ""))[:60]
+    elif name in ("Read", "Edit", "Write"):
+        desc = str(inp.get("file_path", ""))
+    elif name == "Agent":
+        desc = str(inp.get("description", ""))[:60]
+    else:
+        desc = str(next(iter(inp.values()), ""))[:60]
+    return f"[{name}: {desc}]"
+
+
+def _apply_tail(turns: list[Turn], tail: int | None) -> list[Turn]:
+    """Trim to the last N user-message turns and everything after."""
+    if tail is None:
+        return turns
+    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]:]

agent_chat_reader/cli.py

@@ -0,0 +1,183 @@
+"""Command-line entry point for agent-chat-reader."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+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
+
+
+def _find_session(session_id: str) -> tuple[Path, str] | None:
+    """Locate a session file by ID fragment, returning (path, source)."""
+    p = Path(session_id)
+    if p.exists():
+        source = "codex" if ".codex" in str(p) else "claude"
+        return p, source
+
+    codex_matches = list(codex.CODEX_SESSIONS.rglob(f"*{session_id}*.jsonl"))
+    if codex_matches:
+        return sorted(codex_matches)[-1], "codex"
+
+    claude_matches = list(claude.CLAUDE_PROJECTS.rglob(f"*{session_id}*.jsonl"))
+    if claude_matches:
+        return sorted(claude_matches)[-1], "claude"
+
+    return None
+
+
+def cmd_list(
+    *,
+    source_filter: str | None,
+    include_subagents: bool,
+    limit: int,
+) -> int:
+    """List recent sessions from both sources."""
+    sessions: list[SessionMeta] = []
+    if source_filter != "claude":
+        sessions += codex.list_sessions(include_subagents=include_subagents)
+    if source_filter != "codex":
+        sessions += claude.list_sessions()
+
+    sessions = sorted(sessions, key=lambda s: s.mtime, reverse=True)[:limit]
+    print_session_list(sessions)
+    return 0
+
+
+def cmd_find(
+    keyword: str,
+    *,
+    source_filter: str | None,
+    include_subagents: bool,
+) -> int:
+    """Search sessions for a keyword."""
+    sessions: list[SessionMeta] = []
+    if source_filter != "claude":
+        sessions += codex.list_sessions(include_subagents=include_subagents)
+    if source_filter != "codex":
+        sessions += claude.list_sessions()
+
+    sessions = sorted(sessions, key=lambda s: s.mtime, reverse=True)
+    keyword_lower = keyword.lower()
+    found_any = False
+
+    for s in sessions:
+        try:
+            if s.source == "codex":
+                turns = codex.read_turns(s.path)
+            else:
+                turns = claude.read_turns(s.path)
+        except Exception:
+            continue
+
+        hits = [
+            (t.role, t.text[:120].replace("\n", " "))
+            for t in turns
+            if keyword_lower in t.text.lower()
+        ]
+        if hits:
+            found_any = True
+            print_find_result(s, hits)
+
+    if not found_any:
+        print(f"No sessions found containing {keyword!r}")
+    return 0
+
+
+def cmd_read(
+    session_id: str,
+    *,
+    verbose: bool,
+    include_subagents: bool,
+    tail: int | None,
+) -> int:
+    """Read a specific session as clean conversation."""
+    result = _find_session(session_id)
+    if result is None:
+        print(f"Session not found: {session_id}", file=sys.stderr)
+        return 1
+
+    path, source = result
+    size_kb = path.stat().st_size // 1024
+    print(f"Source: {source.upper()}  |  {path.name}  |  {size_kb}KB")
+
+    if source == "codex":
+        turns = codex.read_turns(path, tail=tail)
+    else:
+        turns = claude.read_turns(
+            path, verbose=verbose, include_subagents=include_subagents, tail=tail
+        )
+
+    if not turns:
+        print("(no conversation turns found)")
+        return 0
+
+    for turn in turns:
+        print_turn(turn)
+
+    print(f"\n{'─'*60}")
+    print(f"Total turns: {len(turns)}")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Run the agent-chat-reader command-line interface."""
+    p = argparse.ArgumentParser(
+        prog="agent-chat-reader",
+        description="Read and search Codex CLI and Claude Code chat history.",
+    )
+    p.add_argument(
+        "--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",
+    )
+    p.add_argument("--source", choices=["codex", "claude"], help="Filter to one source")
+    p.add_argument(
+        "--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",
+    )
+    p.add_argument(
+        "--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)",
+    )
+
+    args = p.parse_args(argv)
+
+    if args.list:
+        return cmd_list(
+            source_filter=args.source,
+            include_subagents=args.include_subagents,
+            limit=args.limit,
+        )
+    if args.find:
+        return cmd_find(
+            args.find,
+            source_filter=args.source,
+            include_subagents=args.include_subagents,
+        )
+    if args.session:
+        return cmd_read(
+            args.session,
+            verbose=args.verbose,
+            include_subagents=args.include_subagents,
+            tail=args.tail,
+        )
+
+    p.print_help()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

agent_chat_reader/codex.py

@@ -0,0 +1,151 @@
+"""Codex CLI session reader."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from agent_chat_reader.models import SessionMeta, Turn
+
+CODEX_SESSIONS = Path.home() / ".codex" / "sessions"
+
+
+def is_subagent(path: Path) -> bool:
+    """Return True if this Codex session is a guardian/subagent session."""
+    with path.open() as fh:
+        for raw in fh:
+            try:
+                rec = json.loads(raw.strip())
+                if rec.get("type") == "session_meta":
+                    payload = rec.get("payload", {})
+                    if payload.get("thread_source") == "subagent":
+                        return True
+                    source = payload.get("source", {})
+                    return isinstance(source, dict) and "subagent" in source
+            except Exception:
+                pass
+    return False
+
+
+def _first_user_message(path: Path) -> str:
+    """Return the first user message text, truncated to 80 chars."""
+    with path.open() as fh:
+        for raw in fh:
+            try:
+                rec = json.loads(raw.strip())
+                if (
+                    rec.get("type") == "event_msg"
+                    and rec.get("payload", {}).get("type") == "user_message"
+                ):
+                    return rec["payload"].get("message", "").replace("\n", " ")[:80]
+            except Exception:
+                pass
+    return ""
+
+
+def _session_id_from_path(path: Path) -> str:
+    """Extract the UUID from a rollout filename."""
+    name = path.stem.replace("rollout-", "")
+    parts = name.split("-")
+    # UUID is the last 5 hyphen-groups (8-4-4-4-12)
+    return "-".join(parts[-5:]) if len(parts) >= 5 else name
+
+
+def list_sessions(*, include_subagents: bool = False) -> list[SessionMeta]:
+    """List all Codex sessions, sorted by most recent first."""
+    if not CODEX_SESSIONS.exists():
+        return []
+    files = sorted(
+        CODEX_SESSIONS.rglob("*.jsonl"),
+        key=lambda f: f.stat().st_mtime,
+        reverse=True,
+    )
+    results = []
+    for f in files:
+        if not include_subagents and is_subagent(f):
+            continue
+        stat = f.stat()
+        results.append(
+            SessionMeta(
+                source="codex",
+                id=_session_id_from_path(f),
+                path=f,
+                mtime=stat.st_mtime,
+                size_kb=stat.st_size // 1024,
+                title=_first_user_message(f),
+            )
+        )
+    return results
+
+
+def read_turns(path: Path, *, tail: int | None = None) -> list[Turn]:
+    """Read conversation turns from a Codex session file.
+
+    Extracts user messages, agent commentary (event_msg/agent_message), and
+    full assistant responses (response_item). Adjacent duplicate text between
+    agent_message and response_item records is deduplicated.
+
+    Args:
+        path: Path to the session JSONL file.
+        tail: If set, return only turns from the last N user messages onward.
+
+    Returns:
+        List of Turn namedtuples in conversation order.
+    """
+    turns: list[Turn] = []
+    last_assistant_text: str | None = None
+
+    with path.open() as fh:
+        for raw in fh:
+            stripped = raw.strip()
+            if not stripped:
+                continue
+            try:
+                rec = json.loads(stripped)
+                t = rec.get("type", "")
+                pt = rec.get("payload", {}).get("type", "")
+                ts: str = rec.get("timestamp", "")
+
+                if t == "event_msg" and pt == "user_message":
+                    msg = rec["payload"].get("message", "").strip()
+                    if msg:
+                        turns.append(Turn("USER", msg, ts))
+                        last_assistant_text = None
+
+                elif t == "event_msg" and pt == "agent_message":
+                    msg = rec["payload"].get("message", "").strip()
+                    if msg and msg != last_assistant_text:
+                        turns.append(Turn("AGENT", msg, ts))
+                        last_assistant_text = msg
+
+                elif t == "response_item":
+                    role = rec.get("payload", {}).get("role", "")
+                    if role == "assistant":
+                        content = rec.get("payload", {}).get("content", [])
+                        text = ""
+                        if isinstance(content, str):
+                            text = content.strip()
+                        elif isinstance(content, list):
+                            text = "\n".join(
+                                b.get("text", "")
+                                for b in content
+                                if isinstance(b, dict) and b.get("type") == "text"
+                            ).strip()
+                        if text and text != last_assistant_text:
+                            turns.append(Turn("AGENT", text, ts))
+                            last_assistant_text = text
+
+            except Exception:
+                pass
+
+    return _apply_tail(turns, tail)
+
+
+def _apply_tail(turns: list[Turn], tail: int | None) -> list[Turn]:
+    """Trim to the last N user-message turns and everything after."""
+    if tail is None:
+        return turns
+    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]:]

agent_chat_reader/models.py

@@ -0,0 +1,25 @@
+"""Shared data models."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import NamedTuple
+
+
+class Turn(NamedTuple):
+    """A single conversation turn."""
+
+    role: str  # "USER" | "AGENT" | "CLAUDE"
+    text: str
+    timestamp: str
+
+
+class SessionMeta(NamedTuple):
+    """Metadata for a single chat session."""
+
+    source: str  # "codex" | "claude"
+    id: str
+    path: Path
+    mtime: float
+    size_kb: int
+    title: str

agent_chat_reader/output.py

@@ -0,0 +1,69 @@
+"""Output formatting helpers."""
+
+from __future__ import annotations
+
+import textwrap
+from datetime import datetime
+
+from agent_chat_reader.models import SessionMeta, Turn
+
+_MAX_TURN_LEN = 3000
+_WRAP_THRESHOLD = 400
+
+
+def fmt_ts(ts_str: str) -> str:
+    """Format an ISO timestamp to a short local time string."""
+    if not ts_str:
+        return ""
+    try:
+        dt = datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
+        return dt.astimezone().strftime("%Y-%m-%d %H:%M")
+    except ValueError:
+        return ts_str[:16]
+
+
+def fmt_mtime(mtime: float) -> str:
+    """Format a Unix mtime float to a short local time string."""
+    return datetime.fromtimestamp(mtime).strftime("%Y-%m-%d %H:%M")  # noqa: DTZ006
+
+
+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"[{turn.role}]{ts_str}")
+    print("─" * 60)
+    text = turn.text
+    if len(text) <= _WRAP_THRESHOLD:
+        print(textwrap.fill(text, width=100))
+    else:
+        print(text[:_MAX_TURN_LEN] + ("…" if len(text) > _MAX_TURN_LEN else ""))
+
+
+def print_session_list(sessions: list[SessionMeta]) -> None:
+    """Print a formatted table of sessions."""
+    print(f"{'SRC':<6} {'DATE':<16} {'SIZE':>7}  {'ID':<36}  TITLE")
+    print("─" * 100)
+    for s in sessions:
+        src = s.source
+        date = fmt_mtime(s.mtime)
+        size = f"{s.size_kb}KB"
+        title = (s.title or "(no title)")[:55]
+        print(f"{src:<6} {date:<16} {size:>7}  {s.id:<36}  {title}")
+
+
+def print_find_result(
+    session: SessionMeta,
+    hits: list[tuple[str, str]],
+    *,
+    max_hits: int = 4,
+) -> None:
+    """Print a single session's find results."""
+    print(f"\n{'='*70}")
+    print(f"[{session.source.upper()}] {session.id}  {fmt_mtime(session.mtime)}")
+    if session.title:
+        print(f'  "{session.title[:60]}"')
+    for role, snippet in hits[:max_hits]:
+        print(f"  [{role}] {snippet!r}")
+    if len(hits) > max_hits:
+        print(f"  ... and {len(hits) - max_hits} more matches")

agent_chat_reader-0.1.0.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: agent-chat-reader
+Version: 0.1.0
+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
+Project-URL: Issues, https://github.com/alik-git/agent-chat-reader/issues
+Author-email: Ali K <alikgithb@gmail.com>
+Maintainer-email: Ali K <alikgithb@gmail.com>
+License-File: LICENSE
+Keywords: ai-agents,chat-history,claude,cli,codex,developer-tools
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.15; extra == 'dev'
+Requires-Dist: pre-commit>=4.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.11; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# agent-chat-reader
+
+Read and search [Codex CLI](https://github.com/openai/codex) and [Claude Code](https://claude.ai/code) chat history from the terminal.
+
+Useful for AI agents that need to recall what was discussed or decided in past sessions, without manually parsing noisy JSONL files.
+
+## Install
+
+```bash
+uv tool install agent-chat-reader
+```
+
+Or for development:
+
+```bash
+git clone https://github.com/alik-git/agent-chat-reader
+cd agent-chat-reader
+uv sync --extra dev
+uv run agent-chat-reader --help
+```
+
+## Usage
+
+**List recent sessions** (both Codex and Claude Code, sorted by recency):
+
+```bash
+agent-chat-reader --list
+```
+
+**Search across all sessions** for a keyword:
+
+```bash
+agent-chat-reader --find "sim2sim"
+agent-chat-reader --find "policy_interface" --source codex
+```
+
+**Read a specific session** by UUID prefix:
+
+```bash
+agent-chat-reader 019eaecb
+agent-chat-reader 1bfc739b --verbose     # include tool call summaries
+agent-chat-reader 019eaecb --tail 5      # last 5 user turns only
+```
+
+## What it filters out
+
+The raw JSONL files are very noisy. This tool extracts only:
+
+- **Codex**: `user_message` events, `agent_message` events, and full `response_item` assistant text. Guardian/subagent sessions (auto-approval bots) are hidden by default.
+- **Claude Code**: real user turns (not tool-result carriers), and assistant text blocks (not thinking blocks or tool calls). Sidechain sub-agent turns are hidden by default.
+
+Use `--include-subagents` to see everything.
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `--list` / `-l` | List recent sessions from both sources |
+| `--find KEYWORD` / `-f` | Search all sessions for a keyword |
+| `--source codex\|claude` | Filter to one source |
+| `--verbose` / `-v` | Include brief tool call summaries (Claude sessions) |
+| `--tail N` / `-n N` | Show only the last N user turns of a session |
+| `--include-subagents` | Include guardian/subagent sessions |
+| `--limit N` | Max sessions shown by `--list` (default: 40) |
+
+## Session storage locations
+
+| Agent | Path |
+|-------|------|
+| Codex CLI | `~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl` |
+| Claude Code | `~/.claude/projects/*/*.jsonl` |
+
+## Development
+
+```bash
+uv run ruff format --check .
+uv run ruff check .
+uv run mypy
+uv run pytest
+uv build
+```

agent_chat_reader-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+agent_chat_reader/__init__.py,sha256=wZ7hNNuZynG9J-57C6yx4DdBHB0c4d2JULdhbcgv1Ck,148
+agent_chat_reader/claude.py,sha256=R1FFJAHqpCCpXwF66OVE2Z_OOlmuRJVJB4MX_95e8GA,5629
+agent_chat_reader/cli.py,sha256=w_Glfqj8UbgKnlQregqrhrssB84x-5qINAWCNoKy5uA,5289
+agent_chat_reader/codex.py,sha256=Jt5PPgvqrA4QNLrmpd-6CuKIBXcK-wdS_CLs6YgN_U4,5339
+agent_chat_reader/models.py,sha256=GR6hBuecMDpBnDZhtu5FKSDU7ZPC-EcKwt4-TUt7oBQ,455
+agent_chat_reader/output.py,sha256=Xe4Kq46t0kMQad6h3MeAvd3GUfPseEFuCTKBp7nbdQE,2127
+agent_chat_reader/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent_chat_reader-0.1.0.dist-info/METADATA,sha256=WNYSKl3p_K6j-hdq20_zEF0hKRojJmgs_pC-YjttxZ0,3478
+agent_chat_reader-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+agent_chat_reader-0.1.0.dist-info/entry_points.txt,sha256=tZ7fDCX48KbBC4Myq_iHpUGLsNL2b3mb4VgcNt8hl-0,65
+agent_chat_reader-0.1.0.dist-info/licenses/LICENSE,sha256=tR8qNVMEuTuQ451Je9XMooqw5lrRSrgUj-Oc9HIwcWc,1051
+agent_chat_reader-0.1.0.dist-info/RECORD,,

agent_chat_reader-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

agent_chat_reader-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agent-chat-reader = agent_chat_reader.cli:main

agent_chat_reader-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ali K
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR Ali KS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.