trajectoriz 0.2.0__py3-none-any.whl

trajectoriz/__init__.py

@@ -0,0 +1,685 @@
+"""trajectoriz: locate and parse agent trajectory files on the local machine."""
+
+__version__ = "0.1.0"
+
+import json
+from dataclasses import dataclass, field
+import os
+import re
+import sqlite3
+from pathlib import Path
+
+
+def iter_claude_trajectories(claude_dir=None):
+    """Yield all Claude Code trajectory JSONL paths."""
+    d = Path(claude_dir) if claude_dir else Path.home() / ".claude"
+    if d.is_dir():
+        yield from sorted(d.glob("projects/**/*.jsonl"))
+
+
+def claude_project_dir(repo_root: str, claude_dir=None) -> Path:
+    """Return the Claude Code project directory for a given repo root."""
+    d = Path(claude_dir) if claude_dir else Path.home() / ".claude"
+    slug = re.sub(r"[^a-zA-Z0-9]", "-", repo_root)
+    return d / "projects" / slug
+
+
+def iter_claude_project_trajectories(repo_root: str, claude_dir=None):
+    """Yield Claude Code trajectory JSONL paths for a specific project."""
+    d = claude_project_dir(repo_root, claude_dir)
+    if d.is_dir():
+        yield from sorted(d.glob("*.jsonl"))
+
+
+def iter_codex_trajectories(codex_dir=None):
+    """Yield all Codex CLI session JSONL paths."""
+    d = Path(codex_dir) if codex_dir else Path.home() / ".codex"
+    base = d / "sessions"
+    if base.is_dir():
+        yield from sorted(base.rglob("*.jsonl"))
+
+
+def iter_codex_rollout_files(codex_dir=None):
+    """Yield Codex CLI rollout JSONL paths (rollout-*.jsonl files only)."""
+    d = Path(codex_dir) if codex_dir else Path.home() / ".codex"
+    base = d / "sessions"
+    if base.is_dir():
+        yield from sorted(base.rglob("rollout-*.jsonl"))
+
+
+def iter_pi_trajectories(pi_dir=None):
+    """Yield all pi coding agent session JSONL paths."""
+    if pi_dir:
+        d = Path(pi_dir) / "sessions"
+    else:
+        env = os.environ.get("PI_CODING_AGENT_DIR")
+        d = Path(env) / "sessions" if env else Path.home() / ".pi" / "agent" / "sessions"
+    if d.is_dir():
+        yield from sorted(d.rglob("*.jsonl"))
+
+
+def iter_cursor_trajectories(cursor_dir=None):
+    """Yield all Cursor trajectory JSONL paths."""
+    d = Path(cursor_dir) if cursor_dir else Path.home() / ".cursor"
+    if not d.is_dir():
+        return
+    seen = set()
+    for pattern in ("sessions/**/*.jsonl", "projects/**/*.jsonl"):
+        for p in sorted(d.glob(pattern)):
+            if p not in seen:
+                seen.add(p)
+                yield p
+
+
+def iter_copilot_event_trajectories(copilot_dir=None):
+    """Yield Copilot CLI session event JSONL paths (~/.copilot/session-state/*/events.jsonl)."""
+    d = Path(copilot_dir) if copilot_dir else Path.home() / ".copilot"
+    base = d / "session-state"
+    if base.is_dir():
+        yield from sorted(base.glob("*/events.jsonl"))
+
+
+def iter_agent_probe_trajectories(agent_probe_dir=None):
+    """Yield all agent_probe session JSONL paths (~/.local/share/agent_probe/*/*/*. jsonl)."""
+    d = (
+        Path(agent_probe_dir)
+        if agent_probe_dir
+        else Path.home() / ".local" / "share" / "agent_probe"
+    )
+    if d.is_dir():
+        yield from sorted(d.glob("*/*/*.jsonl"))
+
+
+def iter_opencode_sessions(opencode_dir=None):
+    """Yield (id, updated_at_ms, model_json, directory, first_prompt) from the opencode SQLite store."""
+    d = (
+        Path(opencode_dir)
+        if opencode_dir
+        else Path.home() / ".local" / "share" / "opencode"
+    )
+    db = d / "opencode.db"
+    if not db.exists():
+        return
+    try:
+        conn = sqlite3.connect(str(db))
+        try:
+            rows = conn.execute(
+                "SELECT id, time_updated, model, directory FROM session ORDER BY time_updated DESC"
+            ).fetchall()
+            for session_id, ts_ms, model_json, directory in rows:
+                first_prompt = ""
+                try:
+                    row = conn.execute(
+                        """
+                        SELECT p.data
+                        FROM message m
+                        JOIN part p ON m.id = p.message_id
+                        WHERE m.session_id = ? AND json_extract(m.data, '$.role') = 'user'
+                        ORDER BY m.time_created, p.time_created
+                        LIMIT 1
+                        """,
+                        (session_id,),
+                    ).fetchone()
+                    if row:
+                        first_prompt = json.loads(row[0]).get("text", "").strip()
+                except Exception:
+                    pass
+                yield (session_id, ts_ms, model_json, directory, first_prompt)
+        finally:
+            conn.close()
+    except Exception:
+        return
+
+
+def iter_codex_db_sessions(codex_dir=None):
+    """Yield (id, updated_at_ms, first_user_message, model_provider, model, cwd) from ~/.codex/state_5.sqlite."""
+    d = Path(codex_dir) if codex_dir else Path.home() / ".codex"
+    db = d / "state_5.sqlite"
+    if not db.exists():
+        return
+    try:
+        conn = sqlite3.connect(str(db))
+        try:
+            rows = conn.execute(
+                "SELECT id, updated_at_ms, first_user_message, model_provider, model, cwd"
+                " FROM threads ORDER BY updated_at_ms DESC"
+            ).fetchall()
+            yield from rows
+        finally:
+            conn.close()
+    except Exception:
+        return
+
+
+def _extract_content_text(content) -> str:
+    if isinstance(content, str):
+        return content.strip()
+    if isinstance(content, list):
+        return " ".join(
+            b.get("text", "")
+            for b in content
+            if isinstance(b, dict) and b.get("type") == "text"
+        ).strip()
+    return ""
+
+
+def get_first_user_message_claude(jsonl_path) -> tuple[str, str]:
+    """Return (timestamp, first_user_text) from a Claude Code trajectory JSONL."""
+    timestamp = ""
+    try:
+        with open(Path(jsonl_path), encoding="utf-8") as f:
+            meta_prompt_ids: set = set()
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    d = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if not timestamp:
+                    timestamp = d.get("timestamp", "")
+                if d.get("isMeta"):
+                    meta_prompt_ids.add(d.get("promptId", ""))
+                    continue
+                if d.get("type") == "user":
+                    if d.get("promptId") in meta_prompt_ids:
+                        continue
+                    text = _extract_content_text(d.get("message", {}).get("content", ""))
+                    if text:
+                        return timestamp, text
+    except OSError:
+        pass
+    return timestamp, ""
+
+
+def get_first_user_message_copilot(jsonl_path) -> tuple[str, str]:
+    """Return (timestamp, first_user_text) from a Copilot events JSONL."""
+    timestamp = ""
+    try:
+        with open(Path(jsonl_path), encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    d = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if not timestamp:
+                    timestamp = d.get("timestamp", "")
+                if d.get("type") == "user.message":
+                    text = _extract_content_text(d.get("data", {}).get("content", ""))
+                    if text:
+                        return timestamp, text
+    except OSError:
+        pass
+    return timestamp, ""
+
+
+def get_first_user_message_agent_probe(jsonl_path) -> tuple[str, str]:
+    """Return (timestamp, first_user_text) from an agent_probe trajectory JSONL."""
+    timestamp = ""
+    try:
+        with open(Path(jsonl_path), encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    d = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if not timestamp:
+                    timestamp = d.get("timestamp", "")
+                event_type = d.get("type")
+                if event_type == "user":
+                    content = d.get("message", {}).get("content", "")
+                elif event_type == "user.message":
+                    content = d.get("data", {}).get("content", "")
+                else:
+                    continue
+                text = _extract_content_text(content)
+                if text:
+                    return timestamp, text
+    except OSError:
+        pass
+    return timestamp, ""
+
+
+def get_first_user_message(jsonl_path) -> tuple[str, str]:
+    """Return (timestamp, first_user_text), dispatching by trajectory source."""
+    path = Path(jsonl_path)
+    if path.is_relative_to(Path.home() / ".claude"):
+        return get_first_user_message_claude(path)
+    if path.is_relative_to(Path.home() / ".copilot"):
+        return get_first_user_message_copilot(path)
+    if path.is_relative_to(Path.home() / ".local" / "share" / "agent_probe"):
+        return get_first_user_message_agent_probe(path)
+    return "", ""
+
+
+def get_cwd_from_trajectory(jsonl_path) -> str:
+    """Extract the working directory from a JSONL trajectory file."""
+    try:
+        with open(Path(jsonl_path), encoding="utf-8") as f:
+            for i, line in enumerate(f):
+                if i > 30:
+                    break
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    d = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                for key in ("cwd", "workingDirectory", "working_directory"):
+                    val = d.get(key)
+                    if val and isinstance(val, str):
+                        return val
+    except OSError:
+        pass
+    return ""
+
+
+def iter_copilot_sessions(copilot_dir=None):
+    """Yield (session_id, created_at) pairs from the Copilot CLI SQLite store."""
+    d = Path(copilot_dir) if copilot_dir else Path.home() / ".copilot"
+    db = d / "session-store.db"
+    if not db.exists():
+        return
+    try:
+        conn = sqlite3.connect(str(db))
+        try:
+            rows = conn.execute("SELECT id, created_at FROM sessions").fetchall()
+            yield from rows
+        finally:
+            conn.close()
+    except Exception:
+        return
+
+
+# ── Trajectory parsing ────────────────────────────────────────────────────────
+
+@dataclass
+class ParsedTrajectory:
+    steps: list[dict] = field(default_factory=list)
+    session_id: str | None = None
+    model_name: str | None = None
+    agent_version: str | None = None
+    total_prompt_tokens: int = 0
+    total_completion_tokens: int = 0
+    total_cached_tokens: int = 0
+    total_tool_calls: int = 0
+    extra_agent: dict = field(default_factory=dict)
+
+
+def _truncate(text: str, limit: int = 4000) -> str:
+    if len(text) <= limit:
+        return text
+    return text[:limit] + f"\n… [{len(text) - limit} chars truncated]"
+
+
+def _cc_extract_text(content: object) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts: list[str] = []
+        for part in content:
+            if isinstance(part, str):
+                parts.append(part)
+            elif isinstance(part, dict):
+                if part.get("type") == "text":
+                    parts.append(part.get("text", ""))
+                elif part.get("type") == "image":
+                    parts.append("[image]")
+        return "\n".join(p for p in parts if p)
+    return ""
+
+
+def _cc_tool_result_text(content: object) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        return "\n".join(
+            p.get("text", "") for p in content
+            if isinstance(p, dict) and p.get("type") == "text"
+        )
+    return str(content) if content is not None else ""
+
+
+def _cc_is_pure_tool_result(content: object) -> bool:
+    return (
+        isinstance(content, list)
+        and bool(content)
+        and all(isinstance(p, dict) and p.get("type") == "tool_result" for p in content)
+    )
+
+
+def parse_claude_trajectory(jsonl_path: Path, fallback_timestamp: str = "") -> ParsedTrajectory:
+    """Parse a Claude Code project JSONL trajectory file."""
+    entries: list[dict] = []
+    with Path(jsonl_path).open(encoding="utf-8") as fh:
+        for raw in fh:
+            raw = raw.strip()
+            if raw:
+                try:
+                    entries.append(json.loads(raw))
+                except json.JSONDecodeError:
+                    continue
+
+    session_id: str | None = None
+    model_name: str | None = None
+    agent_version: str | None = None
+
+    for entry in entries:
+        if not session_id and "sessionId" in entry:
+            session_id = entry["sessionId"]
+        if entry.get("type") == "assistant":
+            msg = entry.get("message") or {}
+            if not model_name and msg.get("model"):
+                model_name = msg["model"]
+            if not agent_version and entry.get("version"):
+                agent_version = entry["version"]
+
+    tool_results: dict[str, str] = {}
+    for entry in entries:
+        if entry.get("type") != "user":
+            continue
+        msg = entry.get("message") or {}
+        content = msg.get("content", [])
+        if not isinstance(content, list):
+            continue
+        for part in content:
+            if isinstance(part, dict) and part.get("type") == "tool_result":
+                tid = part.get("tool_use_id", "")
+                if tid:
+                    tool_results[tid] = _cc_tool_result_text(part.get("content", ""))
+
+    steps: list[dict] = []
+    step_id = 0
+    total_tool_calls = 0
+    total_prompt = total_completion = total_cached = 0
+
+    for entry in entries:
+        entry_type = entry.get("type")
+        timestamp: str = entry.get("timestamp") or fallback_timestamp
+
+        if entry_type == "user":
+            msg = entry.get("message") or {}
+            content = msg.get("content", [])
+            if _cc_is_pure_tool_result(content):
+                continue
+            text = _cc_extract_text(content)
+            if not text.strip():
+                continue
+            step_id += 1
+            steps.append({"step_id": step_id, "timestamp": timestamp,
+                           "source": "user", "message": text.strip()})
+
+        elif entry_type == "assistant":
+            msg = entry.get("message") or {}
+            content = msg.get("content") or []
+            if not isinstance(content, list):
+                content = []
+
+            text_parts: list[str] = []
+            reasoning: str | None = None
+            tool_calls: list[dict] = []
+
+            for part in content:
+                if not isinstance(part, dict):
+                    continue
+                ptype = part.get("type")
+                if ptype == "text":
+                    text_parts.append(part.get("text", ""))
+                elif ptype == "thinking":
+                    reasoning = part.get("thinking", "")
+                elif ptype == "tool_use":
+                    tool_calls.append({
+                        "tool_call_id": part.get("id", ""),
+                        "function_name": part.get("name", ""),
+                        "arguments": part.get("input") or {},
+                    })
+                    total_tool_calls += 1
+
+            usage = msg.get("usage") or {}
+            prompt_tokens = (
+                (usage.get("input_tokens") or 0)
+                + (usage.get("cache_creation_input_tokens") or 0)
+                + (usage.get("cache_read_input_tokens") or 0)
+            )
+            completion_tokens = usage.get("output_tokens") or 0
+            cached_tokens = usage.get("cache_read_input_tokens") or 0
+            total_prompt += prompt_tokens
+            total_completion += completion_tokens
+            total_cached += cached_tokens
+
+            observation: dict | None = None
+            if tool_calls:
+                results = [
+                    {"source_call_id": tc["tool_call_id"],
+                     "content": _truncate(tool_results[tc["tool_call_id"]])}
+                    for tc in tool_calls
+                    if tc["tool_call_id"] in tool_results
+                ]
+                if results:
+                    observation = {"results": results}
+
+            step: dict = {
+                "step_id": step_id + 1,
+                "timestamp": timestamp,
+                "source": "agent",
+                "message": "\n".join(text_parts).strip(),
+            }
+            step_id += 1
+            if reasoning:
+                step["reasoning_content"] = reasoning
+            if tool_calls:
+                step["tool_calls"] = tool_calls
+            if observation:
+                step["observation"] = observation
+            if prompt_tokens or completion_tokens:
+                step["metrics"] = {
+                    "prompt_tokens": prompt_tokens,
+                    "completion_tokens": completion_tokens,
+                    "cached_tokens": cached_tokens,
+                }
+            steps.append(step)
+
+    return ParsedTrajectory(
+        session_id=session_id,
+        model_name=model_name,
+        agent_version=agent_version,
+        steps=steps,
+        total_prompt_tokens=total_prompt,
+        total_completion_tokens=total_completion,
+        total_cached_tokens=total_cached,
+        total_tool_calls=total_tool_calls,
+    )
+
+
+def parse_codex_trajectory(jsonl_path: Path, fallback_timestamp: str = "") -> ParsedTrajectory:
+    """Parse a Codex rollout-*.jsonl trajectory file."""
+    entries: list[dict] = []
+    with Path(jsonl_path).open(encoding="utf-8") as fh:
+        for raw in fh:
+            raw = raw.strip()
+            if raw:
+                try:
+                    entries.append(json.loads(raw))
+                except json.JSONDecodeError:
+                    continue
+
+    session_id: str | None = None
+    model_name: str | None = None
+    cli_version: str | None = None
+
+    for entry in entries:
+        t = entry.get("type", "")
+        p = entry.get("payload") or {}
+        if t == "session_meta":
+            session_id = p.get("id")
+            cli_version = p.get("cli_version")
+        if t == "turn_context" and p.get("model") and not model_name:
+            model_name = p["model"]
+
+    tool_results: dict[str, str] = {}
+    for entry in entries:
+        if entry.get("type") != "response_item":
+            continue
+        p = entry.get("payload") or {}
+        pt = p.get("type", "")
+        if pt in ("function_call_output", "custom_tool_call_output"):
+            call_id = p.get("call_id", "")
+            if call_id:
+                tool_results[call_id] = str(p.get("output", ""))
+
+    steps: list[dict] = []
+    step_id = 0
+    total_tool_calls = 0
+    total_prompt = total_completion = total_cached = 0
+
+    pending: dict | None = None
+
+    def _flush_pending() -> None:
+        nonlocal pending
+        if pending is None:
+            return
+        tool_calls: list[dict] = pending.get("tool_calls", [])
+        if tool_calls:
+            results = [
+                {"source_call_id": tc["tool_call_id"],
+                 "content": _truncate(tool_results[tc["tool_call_id"]])}
+                for tc in tool_calls
+                if tc["tool_call_id"] in tool_results
+            ]
+            if results:
+                pending["observation"] = {"results": results}
+        if not tool_calls:
+            pending.pop("tool_calls", None)
+        steps.append(pending)
+        pending = None
+
+    for entry in entries:
+        t = entry.get("type", "")
+        p = entry.get("payload") or {}
+        pt = p.get("type", "")
+        ts = entry.get("timestamp") or fallback_timestamp
+
+        if t == "event_msg" and pt == "user_message":
+            _flush_pending()
+            text = (p.get("message") or "").strip()
+            if text:
+                step_id += 1
+                steps.append({"step_id": step_id, "timestamp": ts,
+                               "source": "user", "message": text})
+
+        elif t == "response_item" and pt == "message" and p.get("role") == "assistant":
+            text = "".join(
+                part.get("text", "")
+                for part in (p.get("content") or [])
+                if isinstance(part, dict) and part.get("type") == "output_text"
+            ).strip()
+            if pending is None:
+                step_id += 1
+                pending = {"step_id": step_id, "timestamp": ts,
+                           "source": "agent", "message": text, "tool_calls": []}
+            elif text:
+                existing = pending.get("message", "")
+                pending["message"] = (existing + "\n" + text).strip()
+
+        elif t == "response_item" and pt in ("function_call", "custom_tool_call"):
+            call_id = p.get("call_id", "")
+            name = p.get("name", "")
+            if pt == "function_call":
+                try:
+                    arguments: object = json.loads(p.get("arguments") or "{}")
+                except (json.JSONDecodeError, TypeError):
+                    arguments = {"raw": p.get("arguments", "")}
+            else:
+                arguments = {"input": p.get("input", "")}
+
+            if pending is None:
+                step_id += 1
+                pending = {"step_id": step_id, "timestamp": ts,
+                           "source": "agent", "message": "", "tool_calls": []}
+            pending["tool_calls"].append({
+                "tool_call_id": call_id,
+                "function_name": name,
+                "arguments": arguments,
+            })
+            total_tool_calls += 1
+
+        elif t == "event_msg" and pt == "token_count":
+            tu = (p.get("info") or {}).get("total_token_usage") or {}
+            total_prompt = max(total_prompt, tu.get("input_tokens") or 0)
+            total_completion = max(total_completion, tu.get("output_tokens") or 0)
+            total_cached = max(total_cached, tu.get("cached_input_tokens") or 0)
+            if pending is not None:
+                lu = (p.get("info") or {}).get("last_token_usage") or {}
+                if lu:
+                    pending["metrics"] = {
+                        "prompt_tokens": lu.get("input_tokens") or 0,
+                        "completion_tokens": lu.get("output_tokens") or 0,
+                        "cached_tokens": lu.get("cached_input_tokens") or 0,
+                    }
+
+        elif t == "event_msg" and pt in ("task_complete", "turn_aborted"):
+            _flush_pending()
+
+    _flush_pending()
+
+    return ParsedTrajectory(
+        session_id=session_id,
+        model_name=model_name,
+        agent_version=cli_version,
+        steps=steps,
+        total_prompt_tokens=total_prompt,
+        total_completion_tokens=total_completion,
+        total_cached_tokens=total_cached,
+        total_tool_calls=total_tool_calls,
+    )
+
+
+def parse_copilot_trajectory(db_path: Path, session_id: str, fallback_timestamp: str = "") -> ParsedTrajectory:
+    """Parse a GitHub Copilot CLI session from the SQLite session store."""
+    conn = sqlite3.connect(str(db_path))
+    try:
+        session_row = conn.execute(
+            "SELECT cwd, repository, branch, summary, created_at FROM sessions WHERE id=?",
+            (session_id,),
+        ).fetchone()
+        if not session_row:
+            return ParsedTrajectory()
+        _cwd, repository, _branch, summary, _created_at = session_row
+
+        turns = conn.execute(
+            "SELECT turn_index, user_message, assistant_response, timestamp "
+            "FROM turns WHERE session_id=? ORDER BY turn_index",
+            (session_id,),
+        ).fetchall()
+    finally:
+        conn.close()
+
+    steps: list[dict] = []
+    step_id = 0
+
+    for _turn_idx, user_msg, asst_resp, ts in turns:
+        ts = ts or fallback_timestamp
+        if user_msg and user_msg.strip():
+            step_id += 1
+            steps.append({"step_id": step_id, "timestamp": ts,
+                           "source": "user", "message": user_msg.strip()})
+        if asst_resp and asst_resp.strip():
+            step_id += 1
+            steps.append({"step_id": step_id, "timestamp": ts,
+                           "source": "agent", "message": asst_resp.strip()})
+
+    return ParsedTrajectory(
+        steps=steps,
+        extra_agent={
+            "copilot_repository": repository or "",
+            "copilot_summary": summary or "",
+        },
+    )

trajectoriz/cli.py

@@ -0,0 +1,377 @@
+#!/usr/bin/env python3
+"""trajectoriz-cli: search and browse past agent trajectories."""
+
+import argparse
+import hashlib
+import json
+import math
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterator, Optional
+
+import trajectoriz as tz
+
+
+DEFAULT_SHOW_PAGE_SIZE = 20   # steps per page
+DEFAULT_LIST_PAGE_SIZE = 50   # trajectories per page
+
+
+@dataclass
+class TrajRecord:
+    id: str
+    agent: str
+    timestamp: str
+    first_msg: str
+    source: object  # Path for JSONL files; dict for DB sessions
+
+
+def _short_id(prefix: str, key: str) -> str:
+    return f"{prefix}-{hashlib.sha256(key.encode()).hexdigest()[:8]}"
+
+
+def _codex_first_user_message(path: Path) -> tuple[str, str]:
+    ts = ""
+    try:
+        with path.open(encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    d = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if not ts:
+                    ts = d.get("timestamp", "")
+                if d.get("type") == "event_msg":
+                    p = d.get("payload") or {}
+                    if p.get("type") == "user_message":
+                        msg = (p.get("message") or "").strip()
+                        if msg:
+                            return ts, msg
+    except OSError:
+        pass
+    return ts, ""
+
+
+def _cwd_matches(cwd_field: str, target: str) -> bool:
+    """True if cwd_field is target or a subdirectory of target."""
+    if not cwd_field:
+        return False
+    try:
+        return Path(cwd_field) == Path(target) or Path(cwd_field).is_relative_to(Path(target))
+    except (ValueError, TypeError):
+        return False
+
+
+def _local_records(cwd: str) -> Iterator[TrajRecord]:
+    """Yield only trajectories whose working directory is cwd or a subdirectory."""
+    for p in tz.iter_claude_project_trajectories(cwd):
+        ts, msg = tz.get_first_user_message_claude(p)
+        yield TrajRecord(_short_id("cl", str(p)), "claude", ts, msg, p)
+
+    for p in tz.iter_codex_rollout_files():
+        if _cwd_matches(tz.get_cwd_from_trajectory(p), cwd):
+            ts, msg = _codex_first_user_message(p)
+            yield TrajRecord(_short_id("cx", str(p)), "codex", ts, msg, p)
+
+    for p in tz.iter_copilot_event_trajectories():
+        if _cwd_matches(tz.get_cwd_from_trajectory(p), cwd):
+            ts, msg = tz.get_first_user_message_copilot(p)
+            yield TrajRecord(_short_id("cp", str(p)), "copilot", ts, msg, p)
+
+    for p in tz.iter_agent_probe_trajectories():
+        if _cwd_matches(tz.get_cwd_from_trajectory(p), cwd):
+            ts, msg = tz.get_first_user_message_agent_probe(p)
+            yield TrajRecord(_short_id("ap", str(p)), "agent_probe", ts, msg, p)
+
+    for session_id, ts_ms, model_json, directory, first_prompt in tz.iter_opencode_sessions():
+        if _cwd_matches(directory, cwd):
+            yield TrajRecord(
+                _short_id("oc", session_id),
+                "opencode",
+                str(ts_ms),
+                first_prompt,
+                {"type": "opencode", "session_id": session_id, "model": model_json, "dir": directory},
+            )
+
+    for row in tz.iter_codex_db_sessions():
+        sid, updated_ms, first_msg, _, model, rec_cwd = row
+        if _cwd_matches(rec_cwd, cwd):
+            yield TrajRecord(
+                _short_id("cd", str(sid)),
+                "codex_db",
+                str(updated_ms),
+                first_msg or "",
+                {"type": "codex_db", "session_id": sid, "model": model, "cwd": rec_cwd},
+            )
+
+
+def _all_records() -> Iterator[TrajRecord]:
+    for p in tz.iter_claude_trajectories():
+        ts, msg = tz.get_first_user_message_claude(p)
+        yield TrajRecord(_short_id("cl", str(p)), "claude", ts, msg, p)
+
+    for p in tz.iter_codex_rollout_files():
+        ts, msg = _codex_first_user_message(p)
+        yield TrajRecord(_short_id("cx", str(p)), "codex", ts, msg, p)
+
+    for p in tz.iter_copilot_event_trajectories():
+        ts, msg = tz.get_first_user_message_copilot(p)
+        yield TrajRecord(_short_id("cp", str(p)), "copilot", ts, msg, p)
+
+    for p in tz.iter_agent_probe_trajectories():
+        ts, msg = tz.get_first_user_message_agent_probe(p)
+        yield TrajRecord(_short_id("ap", str(p)), "agent_probe", ts, msg, p)
+
+    for session_id, ts_ms, model_json, directory, first_prompt in tz.iter_opencode_sessions():
+        yield TrajRecord(
+            _short_id("oc", session_id),
+            "opencode",
+            str(ts_ms),
+            first_prompt,
+            {"type": "opencode", "session_id": session_id, "model": model_json, "dir": directory},
+        )
+
+    for row in tz.iter_codex_db_sessions():
+        sid, updated_ms, first_msg, _, model, cwd = row
+        yield TrajRecord(
+            _short_id("cd", str(sid)),
+            "codex_db",
+            str(updated_ms),
+            first_msg or "",
+            {"type": "codex_db", "session_id": sid, "model": model, "cwd": cwd},
+        )
+
+    copilot_db = Path.home() / ".copilot" / "session-store.db"
+    if copilot_db.exists():
+        for session_id, created_at in tz.iter_copilot_sessions():
+            yield TrajRecord(
+                _short_id("gh", str(session_id)),
+                "copilot_db",
+                str(created_at or ""),
+                "",
+                {"type": "copilot_db", "session_id": session_id, "db_path": str(copilot_db)},
+            )
+
+
+def _render_step(step: dict) -> str:
+    lines: list[str] = []
+    role = "USER" if step["source"] == "user" else "AGENT"
+    ts_suffix = f" *{step['timestamp'][:19]}*" if step.get("timestamp") else ""
+    lines.append(f"---\n## Step {step['step_id']} — {role}{ts_suffix}\n")
+    if step.get("message"):
+        lines.append(step["message"])
+        lines.append("")
+    for tc in step.get("tool_calls", []):
+        args_str = json.dumps(tc.get("arguments", {}), indent=2)
+        if len(args_str) > 600:
+            args_str = args_str[:600] + "\n…"
+        lines.append(f"**Tool call:** `{tc['function_name']}`")
+        lines.append(f"```json\n{args_str}\n```\n")
+    for res in (step.get("observation") or {}).get("results", []):
+        content = res.get("content", "")
+        if len(content) > 1000:
+            content = content[:1000] + "\n…"
+        lines.append(f"**Tool result:**\n```\n{content}\n```\n")
+    return "\n".join(lines)
+
+
+def _trajectory_header_and_steps(record: TrajRecord) -> tuple[str, list[str]]:
+    """Return (header_markdown, list_of_rendered_steps)."""
+    hlines: list[str] = []
+    hlines.append(f"# Trajectory `{record.id}`")
+    hlines.append(f"**Agent:** {record.agent}")
+    if record.timestamp:
+        hlines.append(f"**Date:** {record.timestamp[:19]}")
+
+    if isinstance(record.source, Path):
+        if record.agent == "claude":
+            traj = tz.parse_claude_trajectory(record.source)
+        elif record.agent == "codex":
+            traj = tz.parse_codex_trajectory(record.source)
+        else:
+            hlines.append("\n*Full trajectory parsing not supported for this agent type.*")
+            return "\n".join(hlines), []
+    elif isinstance(record.source, dict):
+        src_type = record.source["type"]
+        if src_type == "copilot_db":
+            db_path = Path(record.source["db_path"])
+            traj = tz.parse_copilot_trajectory(db_path, record.source["session_id"])
+        else:
+            hlines.append(f"**Session ID:** {record.source.get('session_id', '')}")
+            if record.source.get("model"):
+                hlines.append(f"**Model:** {record.source['model']}")
+            d = record.source.get("dir") or record.source.get("cwd") or ""
+            if d:
+                hlines.append(f"**Directory:** {d}")
+            hlines.append("\n*Full trajectory parsing not available for this agent type.*")
+            return "\n".join(hlines), []
+    else:
+        return "\n".join(hlines), []
+
+    hlines.append(f"**Steps:** {len(traj.steps)}")
+    if traj.model_name:
+        hlines.append(f"**Model:** {traj.model_name}")
+    if traj.total_tool_calls:
+        hlines.append(f"**Tool calls:** {traj.total_tool_calls}")
+    if traj.total_prompt_tokens:
+        hlines.append(
+            f"**Tokens:** {traj.total_prompt_tokens} prompt / "
+            f"{traj.total_completion_tokens} completion"
+        )
+
+    return "\n".join(hlines), [_render_step(s) for s in traj.steps]
+
+
+def _paginate_items(
+    items: list[str], page: int, page_size: int, header: str, unit: str, footer: str = ""
+) -> None:
+    total = len(items)
+    total_pages = max(1, math.ceil(total / page_size))
+    if page < 1 or page > total_pages:
+        print(f"Error: page {page} out of range (1–{total_pages}).", file=sys.stderr)
+        sys.exit(1)
+    start = (page - 1) * page_size
+    chunk = items[start : start + page_size]
+    showing_end = min(start + page_size, total)
+    print(
+        f"<!-- trajectoriz | page {page}/{total_pages} | "
+        f"{unit} {start + 1}–{showing_end} of {total} -->"
+    )
+    if header:
+        print(header)
+    print("\n".join(chunk))
+    if footer and page == total_pages:
+        print(footer)
+    if page < total_pages:
+        remaining = total_pages - page
+        print(f"\n<!-- {remaining} more page(s) — run with --page {page + 1} to continue -->")
+
+
+# ── Commands ──────────────────────────────────────────────────────────────────
+
+
+def _record_row(rec: TrajRecord) -> str:
+    date = rec.timestamp[:10] if rec.timestamp else "—"
+    snippet = (rec.first_msg or "")[:80].replace("|", "\\|").replace("\n", " ")
+    return f"| `{rec.id}` | {rec.agent} | {date} | {snippet} |"
+
+
+def cmd_list(args) -> None:
+    source = _all_records() if args.all else _local_records(os.getcwd())
+    records = sorted(source, key=lambda r: r.timestamp, reverse=True)
+    if not records:
+        print("No trajectories found.")
+        return
+    header = (
+        f"## All trajectories ({len(records)} total)\n\n"
+        "| ID | Agent | Date | First message |\n"
+        "|---|---|---|---|"
+    )
+    rows = [_record_row(r) for r in records]
+    _paginate_items(rows, args.page, args.page_size, header, "trajectories",
+                    footer="\nUse `trajectoriz-cli show <id>` to view a trajectory.")
+
+
+def cmd_search(args) -> None:
+    query = args.query.lower()
+    source = _all_records() if args.all else _local_records(os.getcwd())
+    records = [
+        rec
+        for rec in source
+        if query in (rec.first_msg or "").lower()
+        or query in rec.id.lower()
+        or query in rec.agent.lower()
+    ]
+    records.sort(key=lambda r: r.timestamp, reverse=True)
+
+    if not records:
+        print(f"No trajectories found matching `{args.query}`.")
+        return
+    header = (
+        f"## Search: `{args.query}` — {len(records)} result(s)\n\n"
+        "| ID | Agent | Date | First message |\n"
+        "|---|---|---|---|"
+    )
+    rows = [_record_row(r) for r in records]
+    _paginate_items(rows, args.page, args.page_size, header, "trajectories",
+                    footer="\nUse `trajectoriz-cli show <id>` to view a trajectory.")
+
+
+def cmd_show(args) -> None:
+    target = args.id
+    record: Optional[TrajRecord] = None
+    for rec in _all_records():
+        if rec.id == target:
+            record = rec
+            break
+
+    if record is None:
+        print(f"Error: trajectory `{target}` not found.", file=sys.stderr)
+        sys.exit(1)
+
+    header, steps = _trajectory_header_and_steps(record)
+    _paginate_items(steps, args.page, args.page_size, header, "steps")
+
+
+# ── Entry point ───────────────────────────────────────────────────────────────
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="trajectoriz-cli",
+        description="Search and browse past agent trajectories.",
+    )
+
+    sub = parser.add_subparsers(dest="command", metavar="<command>")
+    sub.required = True
+
+    # list
+    p_list = sub.add_parser("list", help="List trajectories (current directory by default).")
+    p_list.add_argument("--page", type=int, default=1, metavar="N")
+    p_list.add_argument(
+        "--page-size", type=int, default=DEFAULT_LIST_PAGE_SIZE, metavar="N",
+        help=f"Trajectories per page (default: {DEFAULT_LIST_PAGE_SIZE})",
+    )
+    p_list.add_argument("--all", action="store_true", help="Include all agents/directories.")
+    p_list.set_defaults(func=cmd_list)
+
+    # search
+    p_search = sub.add_parser(
+        "search",
+        help="Search trajectories by keyword (current directory by default).",
+    )
+    p_search.add_argument("query", help="Search term (case-insensitive substring).")
+    p_search.add_argument("--page", type=int, default=1, metavar="N")
+    p_search.add_argument(
+        "--page-size", type=int, default=DEFAULT_LIST_PAGE_SIZE, metavar="N",
+        help=f"Trajectories per page (default: {DEFAULT_LIST_PAGE_SIZE})",
+    )
+    p_search.add_argument("--all", action="store_true", help="Search across all agents/directories.")
+    p_search.set_defaults(func=cmd_search)
+
+    # show
+    p_show = sub.add_parser(
+        "show",
+        help="Show a trajectory in agent-readable markdown.",
+    )
+    p_show.add_argument("id", help="Trajectory ID (from list or search).")
+    p_show.add_argument(
+        "--page", type=int, default=1, metavar="N",
+        help="Page number (default: 1). Increment to scroll.",
+    )
+    p_show.add_argument(
+        "--page-size", type=int, default=DEFAULT_SHOW_PAGE_SIZE, metavar="N",
+        help=f"Messages (steps) per page (default: {DEFAULT_SHOW_PAGE_SIZE})",
+    )
+    p_show.set_defaults(func=cmd_show)
+
+    args = parser.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

trajectoriz-0.2.0.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: trajectoriz
+Version: 0.2.0
+Summary: Locate agent trajectory files on the local machine
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# trajectoriz
+
+Locate agent trajectory files on the local machine.
+
+## Installation
+
+```bash
+pip install trajectoriz
+```
+
+## Usage
+
+```python
+from trajectoriz import (
+    iter_claude_trajectories,
+    iter_claude_project_trajectories,
+    iter_codex_trajectories,
+    iter_codex_rollout_files,
+    iter_codex_db_sessions,
+    iter_pi_trajectories,
+    iter_cursor_trajectories,
+    iter_copilot_event_trajectories,
+    iter_copilot_sessions,
+    iter_agent_probe_trajectories,
+    iter_opencode_sessions,
+)
+
+# List all Claude Code trajectory files
+for path in iter_claude_trajectories():
+    print(path)
+
+# List Claude trajectories for a specific project
+for path in iter_claude_project_trajectories("/path/to/repo"):
+    print(path)
+
+# List Codex CLI session files
+for path in iter_codex_trajectories():
+    print(path)
+
+# List Codex CLI rollout files
+for path in iter_codex_rollout_files():
+    print(path)
+
+# List Codex sessions from SQLite store (~/.codex/state_5.sqlite)
+for session_id, updated_at_ms, first_msg, provider, model, cwd in iter_codex_db_sessions():
+    print(session_id, first_msg)
+
+# List pi coding agent session files
+for path in iter_pi_trajectories():
+    print(path)
+
+# List Cursor trajectory files
+for path in iter_cursor_trajectories():
+    print(path)
+
+# List Copilot CLI session event JSONL files (~/.copilot/session-state/*/events.jsonl)
+for path in iter_copilot_event_trajectories():
+    print(path)
+
+# List Copilot CLI sessions from SQLite store
+for session_id, created_at in iter_copilot_sessions():
+    print(session_id, created_at)
+
+# List agent_probe session JSONL files (~/.local/share/agent_probe/*/*/*)
+for path in iter_agent_probe_trajectories():
+    print(path)
+
+# List opencode sessions from SQLite store (~/.local/share/opencode/opencode.db)
+for session_id, updated_at_ms, model_json, directory, first_prompt in iter_opencode_sessions():
+    print(session_id, first_prompt)
+```
+
+## License
+
+MIT

trajectoriz-0.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+trajectoriz/__init__.py,sha256=XGa8C_50P3qUJBjrb90TQok0rr5VOoNjyIwRmMCbQCk,24629
+trajectoriz/cli.py,sha256=JkRdARLKxEdU-kKarvxBUgykk3p1-NMxInpqP3DNuSE,14058
+trajectoriz-0.2.0.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
+trajectoriz-0.2.0.dist-info/METADATA,sha256=IHfKq-YtLsItgDHRwx44kCWgOiH5vTIDqAMq5bl1fu8,2185
+trajectoriz-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+trajectoriz-0.2.0.dist-info/entry_points.txt,sha256=YV_i-3pgUXiar4sj5R5Sn3PdBT115KMf2ztMRGZz_VY,57
+trajectoriz-0.2.0.dist-info/top_level.txt,sha256=8p6CY8WukAX6dc_kuSkMHlsHjw9b5gh0k8nq0f5OFgs,12
+trajectoriz-0.2.0.dist-info/RECORD,,

trajectoriz-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

trajectoriz-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+trajectoriz-cli = trajectoriz.cli:main

trajectoriz-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+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 COPYRIGHT HOLDERS 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.

trajectoriz-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+trajectoriz