@ericrisco/rsc 0.1.32 → 0.1.34

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

@@ -0,0 +1,65 @@
+"""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
+
+import re
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any
+
+#: Shared correction detector — a user message matching this right after a prompt
+#: signals the previous turn went wrong. Single source of truth for every adapter
+#: (and re-used by extract_prompts.py) so the heuristic never drifts between runtimes.
+CORRECTION_RE = re.compile(
+    r"\b(no[,.]?\s|wrong|instead|actually|don'?t|shouldn'?t|stop|not that|"
+    r"I said|I meant|I asked|that'?s not|please don'?t|why did you|"
+    r"you should have|that was wrong|incorrect|try again|redo|"
+    r"that broke|you broke|revert|undo)\b",
+    re.IGNORECASE,
+)
+
+
+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,206 @@
+"""Codex CLI adapter (@openai/codex).
+
+Session files: ~/.codex/sessions/YYYY/MM/DD/rollout-<timestamp>.jsonl
+Format: JSON Lines. Each line is {"timestamp", "type", "payload"}.
+
+CONFIRMED (2026-06, against live ~/.codex/sessions on macOS):
+  - Base path / layout / naming: ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl
+  - Line envelope: {"timestamp": ISO8601, "type": str, "payload": {...}}
+  - The genuine user prompt is an `event_msg` line whose payload.type is
+    "user_message", carrying the typed text in payload.message. (Injected
+    AGENTS.md / developer preambles appear only as response_item/message lines,
+    so keying on user_message excludes them.)
+  - Assistant turns: event_msg/agent_message (payload.message) and
+    response_item/message role=assistant.
+  - Tool calls: response_item/function_call (payload.name).
+  - Tool results: response_item/function_call_output (payload.output) — shell
+    execs include a "Process exited with code N" line; N != 0 (or common error
+    markers) means the command failed.
+  - Model: turn_context.model / session_meta payload.
+
+Degradation: if ~/.codex/ does not exist, discover() returns []; any unexpected
+line shape is skipped, so parse() never raises.
+"""
+
+from __future__ import annotations
+
+import datetime
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+from .base import CORRECTION_RE, BaseAdapter
+
+# A shell tool result failed when it reports a non-zero exit code, or carries a
+# common error marker with no explicit success code. Conservative on purpose —
+# better to miss a soft error than to invent one.
+_EXIT_CODE_RE = re.compile(r"exited with code\s+(\d+)", re.IGNORECASE)
+_ERROR_MARKER_RE = re.compile(
+    r"\b(command not found|no such file|permission denied|traceback \(most recent|"
+    r"fatal:|panic:|segmentation fault|unhandled exception)\b",
+    re.IGNORECASE,
+)
+
+
+def _looks_like_error(output: str) -> bool:
+    if not output:
+        return False
+    m = _EXIT_CODE_RE.search(output)
+    if m:
+        return m.group(1) != "0"
+    return bool(_ERROR_MARKER_RE.search(output))
+
+
+def _ts(value: Any) -> float | None:
+    if isinstance(value, (int, float)):
+        return float(value)
+    if isinstance(value, str):
+        try:
+            return datetime.datetime.fromisoformat(value.replace("Z", "+00:00")).timestamp()
+        except (ValueError, AttributeError):
+            return None
+    return None
+
+
+class CodexAdapter(BaseAdapter):
+    RUNTIME_ID = "codex"
+
+    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 into user-prompt records with
+        session-aware error/correction context."""
+        try:
+            lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
+        except OSError:
+            return []
+
+        # 1) Flatten the file into an ordered timeline of turns.
+        timeline: list[dict[str, Any]] = []
+        model = ""
+        pending_tool = ""
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if not isinstance(obj, dict):
+                continue
+
+            top_type = obj.get("type")
+            payload = obj.get("payload")
+            if not isinstance(payload, dict):
+                payload = {}
+            ts = _ts(obj.get("timestamp"))
+
+            # Track the active model from session metadata / turn context.
+            if top_type in ("session_meta", "turn_context"):
+                m = payload.get("model")
+                if isinstance(m, str) and m:
+                    model = m
+                continue
+
+            if top_type == "event_msg":
+                p_type = payload.get("type")
+                if p_type == "user_message":
+                    text = payload.get("message", "")
+                    if isinstance(text, str) and text.strip():
+                        timeline.append({"kind": "user", "text": text, "ts": ts})
+                elif p_type == "agent_message":
+                    text = payload.get("message", "")
+                    if isinstance(text, str) and text.strip():
+                        timeline.append({"kind": "assistant", "text": text, "ts": ts})
+                continue
+
+            if top_type == "response_item":
+                p_type = payload.get("type")
+                if p_type == "function_call":
+                    name = payload.get("name", "")
+                    pending_tool = name if isinstance(name, str) else ""
+                elif p_type == "function_call_output":
+                    output = payload.get("output", "")
+                    output = output if isinstance(output, str) else json.dumps(output)
+                    timeline.append({
+                        "kind": "tool_output",
+                        "tool": pending_tool,
+                        "is_error": _looks_like_error(output),
+                        "text": output,
+                        "ts": ts,
+                    })
+                    pending_tool = ""
+                # response_item/message (assistant/user/developer) is intentionally
+                # ignored: genuine prompts come from event_msg/user_message, and the
+                # assistant context comes from event_msg/agent_message.
+                continue
+
+        # 2) Walk the timeline; enrich each user prompt with what follows it.
+        user_indices = [i for i, t in enumerate(timeline) if t["kind"] == "user"]
+        records: list[dict[str, Any]] = []
+        for n, idx in enumerate(user_indices):
+            turn = timeline[idx]
+            next_user = user_indices[n + 1] if n + 1 < len(user_indices) else len(timeline)
+
+            followed_by_error = False
+            error_tool = ""
+            error_text = ""
+            for j in range(idx + 1, next_user):
+                t = timeline[j]
+                if t["kind"] == "tool_output" and t.get("is_error"):
+                    followed_by_error = True
+                    error_tool = t.get("tool", "")
+                    error_text = t.get("text", "")
+                    break
+
+            followed_by_correction = False
+            correction_text = ""
+            if next_user < len(timeline):
+                nxt = timeline[next_user]["text"]
+                if CORRECTION_RE.search(nxt):
+                    followed_by_correction = True
+                    correction_text = nxt
+
+            # context_before: last assistant text strictly before this prompt.
+            context_before = ""
+            for j in range(idx - 1, -1, -1):
+                if timeline[j]["kind"] == "assistant":
+                    context_before = timeline[j]["text"]
+                    break
+
+            error_was_recovered = followed_by_error and not followed_by_correction
+
+            records.append({
+                "runtime": self.RUNTIME_ID,
+                "session_file": str(path),
+                "prompt_text": turn["text"],
+                "timestamp": turn.get("ts"),
+                "model": model,
+                "context_before": context_before,
+                "followed_by_error": followed_by_error,
+                "error_was_recovered": error_was_recovered,
+                "followed_by_correction": followed_by_correction,
+                "correction_text": correction_text,
+                "error_tool": error_tool,
+                "error_text": error_text,
+            })
+
+        return records

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

@@ -0,0 +1,142 @@
+"""Gemini CLI adapter (@google/gemini-cli).
+
+Session files: ~/.gemini/tmp/<project_hash>/chats/session-*.json
+Format: a SINGLE JSON object per file (not JSONL).
+
+CONFIRMED (2026-06, against live ~/.gemini/tmp on macOS):
+  - Base path / layout: ~/.gemini/tmp/<project_hash>/chats/*.json
+  - File shape: {"sessionId", "projectHash", "startTime", "lastUpdated",
+    "messages": [ {"id", "timestamp", "type", "content", ...} ]}
+  - messages[].type is "user" or "gemini"; content is a plain string.
+  - gemini (assistant) messages also carry "model", "thoughts", "tokens".
+  - The format does NOT persist tool calls/errors as messages, so tool-error
+    detection is not possible here — followed_by_error stays False (honest);
+    correction detection (next user message) still works.
+
+Degradation: if ~/.gemini/ does not exist, discover() returns []; a file that
+is not the expected object shape yields no records (parse never raises).
+"""
+
+from __future__ import annotations
+
+import datetime
+import json
+from pathlib import Path
+from typing import Any
+
+from .base import CORRECTION_RE, BaseAdapter
+
+
+def _ts(value: Any) -> float | None:
+    if isinstance(value, (int, float)):
+        return float(value)
+    if isinstance(value, str):
+        try:
+            return datetime.datetime.fromisoformat(value.replace("Z", "+00:00")).timestamp()
+        except (ValueError, AttributeError):
+            return None
+    return None
+
+
+class GeminiAdapter(BaseAdapter):
+    RUNTIME_ID = "gemini"
+
+    GEMINI_TMP_DIR = Path.home() / ".gemini" / "tmp"
+
+    def discover(self) -> list[Path]:
+        """Find all session *.json chat files under ~/.gemini/tmp/<hash>/chats/."""
+        if not self.GEMINI_TMP_DIR.exists():
+            return []
+        files: list[Path] = []
+        try:
+            for jf in self.GEMINI_TMP_DIR.rglob("chats/*.json"):
+                try:
+                    if jf.is_file():
+                        files.append(jf)
+                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 chat JSON file into user-prompt records with
+        correction context. Tool errors are not represented in this format."""
+        try:
+            obj = json.loads(path.read_text(encoding="utf-8", errors="replace"))
+        except (OSError, json.JSONDecodeError):
+            return []
+        if not isinstance(obj, dict):
+            return []
+
+        messages = obj.get("messages")
+        if not isinstance(messages, list):
+            return []
+
+        # Normalise into an ordered timeline of {kind, text, model, ts}.
+        timeline: list[dict[str, Any]] = []
+        for m in messages:
+            if not isinstance(m, dict):
+                continue
+            mtype = m.get("type")
+            content = m.get("content", "")
+            if not isinstance(content, str) or not content.strip():
+                continue
+            ts = _ts(m.get("timestamp"))
+            if mtype == "user":
+                timeline.append({"kind": "user", "text": content, "ts": ts})
+            elif mtype == "gemini":
+                model = m.get("model")
+                timeline.append({
+                    "kind": "assistant",
+                    "text": content,
+                    "ts": ts,
+                    "model": str(model) if model else "",
+                })
+
+        user_indices = [i for i, t in enumerate(timeline) if t["kind"] == "user"]
+        records: list[dict[str, Any]] = []
+        for n, idx in enumerate(user_indices):
+            turn = timeline[idx]
+            next_user = user_indices[n + 1] if n + 1 < len(user_indices) else len(timeline)
+
+            # Model that answered this prompt: the first assistant reply after it.
+            model = ""
+            context_after_assistant = ""
+            for j in range(idx + 1, next_user):
+                if timeline[j]["kind"] == "assistant":
+                    model = timeline[j].get("model", "") or model
+                    if not context_after_assistant:
+                        context_after_assistant = timeline[j]["text"]
+            # context_before: last assistant text strictly before this prompt.
+            context_before = ""
+            for j in range(idx - 1, -1, -1):
+                if timeline[j]["kind"] == "assistant":
+                    context_before = timeline[j]["text"]
+                    break
+
+            followed_by_correction = False
+            correction_text = ""
+            if next_user < len(timeline):
+                nxt = timeline[next_user]["text"]
+                if CORRECTION_RE.search(nxt):
+                    followed_by_correction = True
+                    correction_text = nxt
+
+            records.append({
+                "runtime": self.RUNTIME_ID,
+                "session_file": str(path),
+                "prompt_text": turn["text"],
+                "timestamp": turn.get("ts"),
+                "model": model,
+                "context_before": context_before,
+                # This format does not record tool errors — be honest, not invent.
+                "followed_by_error": False,
+                "error_was_recovered": False,
+                "followed_by_correction": followed_by_correction,
+                "correction_text": correction_text,
+                "error_tool": "",
+                "error_text": "",
+            })
+
+        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())