@ericrisco/rsc 0.1.32 → 0.1.33

package/skills/roast-me/tools/adapters/base.py

@@ -0,0 +1,53 @@
+"""Base adapter contract for roast-me transcript discovery.
+
+Every runtime adapter implements two methods:
+  discover() -> list[Path]  — find local session files; return [] if none found
+  parse(path)  -> list[dict] — yield raw prompt-like records from one file
+
+The adapter contract is intentionally minimal. Higher-level normalisation
+(truncation, field enrichment, error/correction detection) happens in
+extract_prompts.py, not here.
+
+An adapter MUST:
+  - Never raise on missing files or unexpected formats — return [] instead.
+  - Tag every record with {"runtime": self.RUNTIME_ID}.
+  - Return only records that look like user-initiated prompts (not tool results,
+    not system messages).
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any
+
+
+class BaseAdapter(ABC):
+    """Contract every runtime adapter must satisfy."""
+
+    #: Short identifier used to tag records and in CLI --runtime flag.
+    RUNTIME_ID: str = "unknown"
+
+    @abstractmethod
+    def discover(self) -> list[Path]:
+        """Return a list of session file paths found for this runtime.
+
+        Must return [] (not raise) when the runtime is not installed or no
+        data directory exists.
+        """
+
+    @abstractmethod
+    def parse(self, path: Path) -> list[dict[str, Any]]:
+        """Parse one session file and return a list of raw prompt records.
+
+        Each record must include at minimum:
+          - "runtime": str          — the RUNTIME_ID of this adapter
+          - "prompt_text": str      — the user's message text
+          - "timestamp": float | None  — unix timestamp of the message (or None)
+          - "session_file": str     — stringified path of the source file
+
+        Additional fields are welcomed and used by extract_prompts.py if present
+        (e.g. "model", "cost_usd").
+
+        Must return [] (not raise) on parse failures.
+        """

package/skills/roast-me/tools/adapters/claude.py

@@ -0,0 +1,140 @@
+"""Claude Code adapter — first-class reference implementation.
+
+Session files: ~/.claude/projects/*/*.jsonl
+Format: JSON Lines, one object per line.
+
+Each line is a conversation event with a "type" field:
+  "user"      — user message (prompt or tool result)
+  "assistant" — model response
+
+User prompt records are lines where:
+  - type == "user"
+  - message.isMeta is falsy
+  - message.content contains at least one text block (not only tool_result blocks)
+
+This is the canonical adapter; its parsing logic is the reference for all others.
+
+Confirmed: path and format verified against live ~/.claude/projects structure on
+macOS (2026-06). The JSONL schema is stable across Claude Code versions.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+from .base import BaseAdapter
+
+
+class ClaudeAdapter(BaseAdapter):
+    RUNTIME_ID = "claude"
+
+    # Location of Claude Code project session files.
+    PROJECTS_DIR = Path.home() / ".claude" / "projects"
+
+    def discover(self) -> list[Path]:
+        """Find all *.jsonl session files under ~/.claude/projects/."""
+        if not self.PROJECTS_DIR.exists():
+            return []
+        files: list[Path] = []
+        try:
+            for jsonl in self.PROJECTS_DIR.rglob("*.jsonl"):
+                try:
+                    if jsonl.is_file():
+                        files.append(jsonl)
+                except OSError:
+                    continue
+        except OSError:
+            return []
+        return sorted(files, key=lambda f: f.stat().st_mtime, reverse=True)
+
+    def parse(self, path: Path) -> list[dict[str, Any]]:
+        """Parse one Claude Code .jsonl session file."""
+        records: list[dict[str, Any]] = []
+        try:
+            lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
+        except OSError:
+            return []
+
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+            if obj.get("type") != "user":
+                continue
+
+            msg = obj.get("message", {})
+            if msg.get("isMeta"):
+                continue
+
+            content = msg.get("content", [])
+            text = _extract_text(content)
+            if not text.strip():
+                continue
+            # Skip messages that are only tool_result blocks
+            if _is_only_tool_results(content):
+                continue
+
+            ts = _parse_timestamp(obj)
+            records.append({
+                "runtime": self.RUNTIME_ID,
+                "session_file": str(path),
+                "prompt_text": text,
+                "timestamp": ts,
+                # Forward the raw object so the main extractor can inspect
+                # adjacent lines for error/correction context.
+                "_raw": obj,
+            })
+
+        return records
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _extract_text(content: Any) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for block in content:
+            if isinstance(block, dict) and block.get("type") == "text":
+                parts.append(block.get("text", ""))
+        return "\n".join(parts)
+    return ""
+
+
+def _is_only_tool_results(content: Any) -> bool:
+    if not isinstance(content, list):
+        return False
+    has_text = any(
+        isinstance(b, dict) and b.get("type") == "text" for b in content
+    )
+    has_tool_result = any(
+        isinstance(b, dict) and b.get("type") == "tool_result" for b in content
+    )
+    return has_tool_result and not has_text
+
+
+def _parse_timestamp(obj: dict) -> float | None:
+    ts = obj.get("timestamp")
+    if ts is None:
+        return None
+    if isinstance(ts, (int, float)):
+        return float(ts)
+    if isinstance(ts, str):
+        try:
+            import datetime
+            dt = datetime.datetime.fromisoformat(ts.replace("Z", "+00:00"))
+            return dt.timestamp()
+        except (ValueError, AttributeError):
+            pass
+    return None

package/skills/roast-me/tools/adapters/codex.py

@@ -0,0 +1,113 @@
+"""Codex CLI adapter (@openai/codex).
+
+Session files: ~/.codex/sessions/YYYY/MM/DD/rollout-<timestamp>.jsonl
+Format: JSON Lines. Each line is an event object.
+
+CONFIRMED (2026-06, via official CLI reference and community tooling):
+  - Base path: ~/.codex/sessions/
+  - Subdirectory layout: year/month/day
+  - File naming: rollout-<ISO-timestamp>.jsonl
+  - Format: JSONL, one event per line
+
+STUBBED (format details):
+  The internal schema of each JSONL line has not been verified against a live
+  Codex installation. Based on community-authored session viewers, events appear
+  to carry {"role": "user"|"assistant", "content": "...", ...}. If the role
+  field is absent or the schema differs, parse() returns [] gracefully.
+
+Degradation: if ~/.codex/ does not exist, discover() returns [].
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from .base import BaseAdapter
+
+
+class CodexAdapter(BaseAdapter):
+    RUNTIME_ID = "codex"
+
+    # CONFIRMED: path layout from official CLI docs and community tools.
+    SESSIONS_DIR = Path.home() / ".codex" / "sessions"
+
+    def discover(self) -> list[Path]:
+        """Find all rollout-*.jsonl files under ~/.codex/sessions/."""
+        if not self.SESSIONS_DIR.exists():
+            return []
+        files: list[Path] = []
+        try:
+            for jsonl in self.SESSIONS_DIR.rglob("rollout-*.jsonl"):
+                try:
+                    if jsonl.is_file():
+                        files.append(jsonl)
+                except OSError:
+                    continue
+        except OSError:
+            return []
+        return sorted(files, key=lambda f: f.stat().st_mtime, reverse=True)
+
+    def parse(self, path: Path) -> list[dict[str, Any]]:
+        """Parse one Codex session JSONL file.
+
+        STUBBED schema: assumes {"role": "user", "content": "..."} event lines.
+        Falls back silently if the schema differs.
+        """
+        records: list[dict[str, Any]] = []
+        try:
+            lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
+        except OSError:
+            return []
+
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+            # STUBBED: expected schema based on community session viewers.
+            role = obj.get("role") or obj.get("type", "")
+            if role != "user":
+                continue
+
+            content = obj.get("content", "")
+            if isinstance(content, list):
+                # Some formats use a content array like OpenAI chat API.
+                parts = [
+                    c.get("text", "") if isinstance(c, dict) else str(c)
+                    for c in content
+                    if isinstance(c, dict) and c.get("type") == "text"
+                ]
+                text = "\n".join(parts)
+            elif isinstance(content, str):
+                text = content
+            else:
+                text = ""
+
+            if not text.strip():
+                continue
+
+            ts = obj.get("timestamp") or obj.get("created_at")
+            if isinstance(ts, str):
+                try:
+                    import datetime
+                    dt = datetime.datetime.fromisoformat(ts.replace("Z", "+00:00"))
+                    ts = dt.timestamp()
+                except (ValueError, AttributeError):
+                    ts = None
+            elif not isinstance(ts, (int, float)):
+                ts = None
+
+            records.append({
+                "runtime": self.RUNTIME_ID,
+                "session_file": str(path),
+                "prompt_text": text,
+                "timestamp": ts,
+            })
+
+        return records

package/skills/roast-me/tools/adapters/gemini.py

@@ -0,0 +1,121 @@
+"""Gemini CLI adapter (@google/gemini-cli).
+
+Session files: ~/.gemini/tmp/<project_hash>/chats/*.jsonl
+Format: JSON Lines. Each line is a MessageRecord.
+
+CONFIRMED (2026-06, via official Gemini CLI docs at google-gemini.github.io
+and github.com/google-gemini/gemini-cli session-management.md):
+  - Base path: ~/.gemini/tmp/
+  - Subdirectory: <project_hash>/chats/
+  - File format: JSONL
+  - MessageRecord fields include: sessionId, projectHash, model, role,
+    content (array of {text: "..."}), and token usage fields.
+
+STUBBED (exact MessageRecord schema):
+  The exact JSONL schema per line has not been verified against a live Gemini
+  CLI installation. The role/content structure is inferred from the official
+  session-management docs. If the schema differs, parse() returns [] gracefully.
+
+Degradation: if ~/.gemini/ does not exist, discover() returns [].
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from .base import BaseAdapter
+
+
+class GeminiAdapter(BaseAdapter):
+    RUNTIME_ID = "gemini"
+
+    # CONFIRMED: path from official gemini-cli session-management docs.
+    GEMINI_TMP_DIR = Path.home() / ".gemini" / "tmp"
+
+    def discover(self) -> list[Path]:
+        """Find all *.jsonl chat files under ~/.gemini/tmp/<hash>/chats/."""
+        if not self.GEMINI_TMP_DIR.exists():
+            return []
+        files: list[Path] = []
+        try:
+            # Pattern: ~/.gemini/tmp/<project_hash>/chats/*.jsonl
+            for jsonl in self.GEMINI_TMP_DIR.rglob("chats/*.jsonl"):
+                try:
+                    if jsonl.is_file():
+                        files.append(jsonl)
+                except OSError:
+                    continue
+        except OSError:
+            return []
+        return sorted(files, key=lambda f: f.stat().st_mtime, reverse=True)
+
+    def parse(self, path: Path) -> list[dict[str, Any]]:
+        """Parse one Gemini CLI chat JSONL file.
+
+        STUBBED schema: expected MessageRecord with {role, content: [{text}], ...}.
+        Falls back silently if the schema differs.
+        """
+        records: list[dict[str, Any]] = []
+        try:
+            lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
+        except OSError:
+            return []
+
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+            # STUBBED: inferred from gemini-cli session-management docs.
+            role = obj.get("role", "")
+            if role not in ("user", "USER"):
+                continue
+
+            content = obj.get("content", [])
+            if isinstance(content, list):
+                parts = []
+                for block in content:
+                    if isinstance(block, dict):
+                        text = block.get("text", "")
+                        if text:
+                            parts.append(text)
+                text = "\n".join(parts)
+            elif isinstance(content, str):
+                text = content
+            else:
+                text = ""
+
+            if not text.strip():
+                continue
+
+            # Gemini MessageRecord may carry token counts and model name.
+            model = obj.get("model") or obj.get("modelVersion")
+            ts = obj.get("timestamp") or obj.get("createTime")
+            if isinstance(ts, str):
+                try:
+                    import datetime
+                    dt = datetime.datetime.fromisoformat(ts.replace("Z", "+00:00"))
+                    ts = dt.timestamp()
+                except (ValueError, AttributeError):
+                    ts = None
+            elif not isinstance(ts, (int, float)):
+                ts = None
+
+            record: dict[str, Any] = {
+                "runtime": self.RUNTIME_ID,
+                "session_file": str(path),
+                "prompt_text": text,
+                "timestamp": ts,
+            }
+            if model:
+                record["model"] = str(model)
+
+            records.append(record)
+
+        return records

package/skills/roast-me/tools/adapters/registry.py

@@ -0,0 +1,68 @@
+"""Registry mapping runtime IDs to adapter classes.
+
+Usage:
+
+    from adapters.registry import get_adapters
+
+    # Get adapters to run for a given --runtime flag value.
+    for adapter in get_adapters("auto"):
+        files = adapter.discover()
+        ...
+
+auto mode: runs EVERY registered adapter and merges results. If an adapter
+finds no files (discover() returns []), it is silently skipped. Records from
+each adapter are tagged with their RUNTIME_ID.
+
+Unknown runtime: raises ValueError with a clear message so the caller can
+print it and exit 0 with an empty result (never crash).
+"""
+
+from __future__ import annotations
+
+from .base import BaseAdapter
+from .claude import ClaudeAdapter
+from .codex import CodexAdapter
+from .gemini import GeminiAdapter
+
+# All registered adapters. Add new runtimes here.
+_ALL_ADAPTERS: list[type[BaseAdapter]] = [
+    ClaudeAdapter,
+    CodexAdapter,
+    GeminiAdapter,
+]
+
+# Map runtime ID -> adapter class
+_REGISTRY: dict[str, type[BaseAdapter]] = {
+    cls.RUNTIME_ID: cls for cls in _ALL_ADAPTERS
+}
+
+
+def get_adapters(runtime: str) -> list[BaseAdapter]:
+    """Return instantiated adapters for the given runtime identifier.
+
+    Args:
+        runtime: One of "auto", or a specific runtime ID such as "claude",
+                 "codex", "gemini".
+
+    Returns:
+        A list of adapter instances. In "auto" mode, all registered adapters
+        are returned so the caller can try each one and keep those with data.
+
+    Raises:
+        ValueError: If the runtime ID is not recognised.
+    """
+    runtime = runtime.strip().lower()
+    if runtime == "auto":
+        return [cls() for cls in _ALL_ADAPTERS]
+    if runtime not in _REGISTRY:
+        known = ", ".join(sorted(_REGISTRY.keys()))
+        raise ValueError(
+            f"Unknown runtime '{runtime}'. Known runtimes: {known}. "
+            f"Use 'auto' to try all of them."
+        )
+    return [_REGISTRY[runtime]()]
+
+
+def list_runtime_ids() -> list[str]:
+    """Return all registered runtime IDs (excluding 'auto')."""
+    return sorted(_REGISTRY.keys())