rulereceipt 0.1.83 → 0.1.84

package/NOTICE.md

@@ -32,3 +32,4 @@ we did not copy the code):
   from **Pilan-AI/mnemo** (MIT). Our reader is `src/adapters/copilot.ts`.
 - **Gemini CLI** session format (`~/.gemini/tmp/<hash>/chats/*.{jsonl,json}`, legacy `~/.gemini/sessions/*.json`): documented by **yigitkonur/cli-continues** (MIT, pinned `e486cd2`; from mnemo MIT). Our reader is `src/adapters/gemini.ts`.
 - **Cursor** agent-transcripts (`~/.cursor/projects/<slug>/agent-transcripts/**/*.jsonl`, Anthropic-API shaped): documented by **yigitkonur/cli-continues** (MIT, pinned `e486cd2`). Our reader `src/adapters/cursor.ts`. (Old `state.vscdb` SQLite path deferred.)
+- **OpenCode** JSON file store (`$XDG_DATA_HOME/opencode/storage/{session,message,part}/*.json`): documented by **yigitkonur/cli-continues** (MIT, pinned `e486cd2`). Our reader `src/adapters/opencode.ts`. (opencode.db SQLite path deferred.)

package/dist/adapters/index.d.ts

@@ -46,6 +46,8 @@ export declare const ADAPTERS: SessionAdapter[];
 export declare const geminiCliAdapter: SessionAdapter;
 /** Cursor — EXPERIMENTAL. Current agent-transcripts (JSONL, Anthropic-shaped); old SQLite deferred. */
 export declare const cursorAdapter: SessionAdapter;
+/** OpenCode — EXPERIMENTAL. JSON file store (3-dir join); opencode.db SQLite deferred. */
+export declare const openCodeAdapter: SessionAdapter;
 /** Experimental adapters: reader exists, awaiting real+planted+clean fixtures. */
 export declare const EXPERIMENTAL_ADAPTERS: SessionAdapter[];
 /**

package/dist/adapters/index.js

@@ -5,6 +5,7 @@ import { listCodexSessions, parseCodexTranscript } from "./codex.js";
 import { listCopilotSessions, parseCopilotTranscript, copilotFormatIsKnown } from "./copilot.js";
 import { listGeminiSessions, parseGeminiTranscript, geminiFormatIsKnown } from "./gemini.js";
 import { listCursorSessions, parseCursorTranscript, cursorFormatIsKnown } from "./cursor.js";
+import { listOpenCodeSessions, parseOpenCodeTranscript, openCodeFormatIsKnown } from "./opencode.js";
 /**
  * Claude Code — the original and reference adapter. Delegates to the existing
  * transcriptParser so its behaviour (including subagent transcripts) is
@@ -54,8 +55,15 @@ export const cursorAdapter = {
     parse: (sessionFile) => parseCursorTranscript(sessionFile),
     experimental: true,
 };
+/** OpenCode — EXPERIMENTAL. JSON file store (3-dir join); opencode.db SQLite deferred. */
+export const openCodeAdapter = {
+    tool: "opencode",
+    listSessions: (cwd) => listOpenCodeSessions(cwd),
+    parse: (sessionFile) => parseOpenCodeTranscript(sessionFile),
+    experimental: true,
+};
 /** Experimental adapters: reader exists, awaiting real+planted+clean fixtures. */
-export const EXPERIMENTAL_ADAPTERS = [copilotCliAdapter, geminiCliAdapter, cursorAdapter];
+export const EXPERIMENTAL_ADAPTERS = [copilotCliAdapter, geminiCliAdapter, cursorAdapter, openCodeAdapter];
 /**
  * Tools deliberately NOT read yet, with the honest reason. Kept as data (not
  * silence) so the tool — and its docs — can state exactly where the line is
@@ -63,7 +71,6 @@ export const EXPERIMENTAL_ADAPTERS = [copilotCliAdapter, geminiCliAdapter, curso
  */
 export const UNSUPPORTED_TOOLS = [
     { tool: "aider", reason: "history is a Markdown transcript (.aider.chat.history.md), not structured events — needs a prose parser, not a field mapping" },
-    { tool: "opencode", reason: "stores sessions in a SQLite DB (opencode.db) — needs a WASM sqlite reader; planned next" },
     { tool: "windsurf", reason: "IDE-embedded; history in undocumented internal state, same as old Cursor" },
 ];
 /**
@@ -160,6 +167,10 @@ export function parseSessionFile(file) {
     // `message` wrapper and no `type`. Gated the same way.
     if (cursorFormatIsKnown(file))
         return parseCursorTranscript(file);
+    // OpenCode: a single session JSON (`id` starting `ses_`); the message/part
+    // dirs are resolved relative to this file.
+    if (openCodeFormatIsKnown(file))
+        return parseOpenCodeTranscript(file);
     return readTranscriptFromFile(file);
 }
 /**

package/dist/adapters/opencode.d.ts

@@ -0,0 +1,7 @@
+import type { TranscriptEvent } from "../types.js";
+/** OpenCode session files for this cwd, newest first. */
+export declare function listOpenCodeSessions(cwd: string): string[];
+/** True when the file is an OpenCode session JSON (id starting `ses_`). */
+export declare function openCodeFormatIsKnown(sessionFile: string): boolean;
+/** Parse one OpenCode session (by its ses_*.json) into neutral events. Tolerant. */
+export declare function parseOpenCodeTranscript(sessionFile: string): TranscriptEvent[];

package/dist/adapters/opencode.js

@@ -0,0 +1,179 @@
+import { existsSync, readFileSync, readdirSync, statSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+/**
+ * OpenCode adapter — EXPERIMENTAL (no real-session fixtures yet).
+ *
+ * Reads the JSON file store (NOT the newer `opencode.db` SQLite, which is
+ * deferred — see REUSE.md). Format documented by yigitkonur/cli-continues (MIT,
+ * src/parsers/opencode.ts, pinned e486cd22a592d89d890cff056624647fbe9cbe80).
+ * Credit: NOTICE.md / REUSE.md.
+ *
+ * Store (under `$XDG_DATA_HOME/opencode/storage` or `~/.local/share/opencode/
+ * storage`): a 3-directory join
+ *   session/<proj>/ses_*.json   → { id, projectID, directory, time:{updated} }
+ *   message/<sessionId>/msg_*.json → { id, role }
+ *   part/<messageId>/prt_*.json    → { type:'text'|'tool'|…, text?, tool?, callID?,
+ *                                      state:{ input, status, output, error } }
+ * cwd = session.directory, else project/<projectID>.json `.worktree`.
+ *   text part  -> text (role of its message)
+ *   tool part  -> tool_use (shell -> canonical Bash) + a tool_result from its state.
+ *
+ * The message/part dirs are resolved RELATIVE to the session file, so
+ * `--transcript <…/session/<proj>/ses_X.json>` works wherever the store lives.
+ *
+ * RESILIENCE: only the fields above; unknown part types / bad files skipped,
+ * never guessed; `openCodeFormatIsKnown` gates use.
+ */
+function realpathOr(p) { try {
+    return realpathSync(p);
+}
+catch {
+    return p;
+} }
+function str(v) { return typeof v === "string" && v.length > 0 ? v : undefined; }
+function rec(v) { return v && typeof v === "object" && !Array.isArray(v) ? v : {}; }
+function storageDir() {
+    const xdg = process.env.XDG_DATA_HOME?.trim();
+    const base = xdg && xdg.length > 0 ? join(xdg, "opencode") : join(homedir(), ".local", "share", "opencode");
+    return join(base, "storage");
+}
+function readJson(file) {
+    try {
+        const o = JSON.parse(readFileSync(file, "utf-8"));
+        return rec(o);
+    }
+    catch {
+        return null;
+    }
+}
+/** storage root for a given session file (…/storage/session/<proj>/ses_X.json). */
+function storageRootOf(sessionFile) {
+    return join(dirname(sessionFile), "..", "..");
+}
+/** cwd of a session JSON: its `directory`, else project/<projectID>.json .worktree. */
+function sessionCwd(sessionFile, s) {
+    const dir = str(s.directory);
+    if (dir)
+        return dir;
+    const pid = str(s.projectID);
+    if (pid) {
+        const proj = readJson(join(storageRootOf(sessionFile), "project", `${pid}.json`));
+        if (proj)
+            return str(proj.worktree) ?? null;
+    }
+    return null;
+}
+function listSessionJsonFiles(storage) {
+    const sessionBase = join(storage, "session");
+    const out = [];
+    let projs = [];
+    try {
+        projs = readdirSync(sessionBase);
+    }
+    catch {
+        return out;
+    }
+    for (const p of projs) {
+        const d = join(sessionBase, p);
+        let names = [];
+        try {
+            names = readdirSync(d);
+        }
+        catch {
+            continue;
+        }
+        for (const n of names)
+            if (n.startsWith("ses_") && n.endsWith(".json"))
+                out.push(join(d, n));
+    }
+    return out;
+}
+/** OpenCode session files for this cwd, newest first. */
+export function listOpenCodeSessions(cwd) {
+    const storage = storageDir();
+    if (!existsSync(storage))
+        return [];
+    const target = realpathOr(cwd);
+    const hits = [];
+    for (const file of listSessionJsonFiles(storage)) {
+        const s = readJson(file);
+        if (!s)
+            continue;
+        const c = sessionCwd(file, s);
+        if (c && realpathOr(c) !== target)
+            continue;
+        try {
+            hits.push({ file, mtimeMs: statSync(file).mtimeMs });
+        }
+        catch { /* skip */ }
+    }
+    return hits.sort((a, b) => b.mtimeMs - a.mtimeMs).map((h) => h.file);
+}
+function sortedJson(dir) {
+    try {
+        return readdirSync(dir).filter((f) => f.endsWith(".json")).sort();
+    }
+    catch {
+        return [];
+    }
+}
+function toToolUse(name, input, id, ts) {
+    const command = str(input.command) ?? str(input.cmd);
+    const filePath = str(input.file_path) ?? str(input.path) ?? str(input.filePath);
+    const lower = name.toLowerCase();
+    if (command && (/(shell|bash|terminal|exec|run|command)/.test(lower) || !filePath)) {
+        return { role: "assistant", kind: "tool_use", toolName: "Bash", toolUseId: id, input: { command }, timestamp: ts };
+    }
+    if (filePath && /(write|create|edit|replace|patch|insert|modif|apply)/.test(lower)) {
+        return { role: "assistant", kind: "tool_use", toolName: /(edit|replace|patch|apply)/.test(lower) ? "Edit" : "Write", toolUseId: id, input: { file_path: filePath, ...input }, timestamp: ts };
+    }
+    if (filePath && /(read|view|open|cat|show)/.test(lower)) {
+        return { role: "assistant", kind: "tool_use", toolName: "Read", toolUseId: id, input: { file_path: filePath }, timestamp: ts };
+    }
+    return { role: "assistant", kind: "tool_use", toolName: name, toolUseId: id, input, timestamp: ts };
+}
+/** True when the file is an OpenCode session JSON (id starting `ses_`). */
+export function openCodeFormatIsKnown(sessionFile) {
+    const s = readJson(sessionFile);
+    return Boolean(s && str(s.id)?.startsWith("ses_"));
+}
+/** Parse one OpenCode session (by its ses_*.json) into neutral events. Tolerant. */
+export function parseOpenCodeTranscript(sessionFile) {
+    const s = readJson(sessionFile);
+    const sessionId = s ? str(s.id) : undefined;
+    if (!s || !sessionId)
+        return [];
+    const root = storageRootOf(sessionFile);
+    const messageDir = join(root, "message", sessionId);
+    const out = [];
+    for (const msgFile of sortedJson(messageDir)) {
+        const m = readJson(join(messageDir, msgFile));
+        if (!m)
+            continue;
+        const role = m.role === "assistant" ? "assistant" : m.role === "user" ? "user" : undefined;
+        const msgId = str(m.id);
+        if (!role || !msgId)
+            continue;
+        const partDir = join(root, "part", msgId);
+        for (const prtFile of sortedJson(partDir)) {
+            const part = readJson(join(partDir, prtFile));
+            if (!part)
+                continue;
+            if (part.type === "text" && str(part.text)) {
+                out.push({ role, kind: "text", text: part.text, timestamp: "" });
+            }
+            else if (part.type === "tool" && role === "assistant") {
+                const name = str(part.tool);
+                if (!name)
+                    continue;
+                const state = rec(part.state);
+                const id = str(part.callID);
+                out.push(toToolUse(name, rec(state.input), id, ""));
+                const content = str(state.output) ?? str(state.error) ?? "";
+                out.push({ role: "user", kind: "tool_result", toolUseId: id, content: content.slice(0, 2000), isError: state.status === "error", timestamp: "" });
+            }
+        }
+    }
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rulereceipt",
-  "version": "0.1.83",
+  "version": "0.1.84",
   "description": "Checks whether your AI coding agent followed your rules, with evidence. Works with Claude Code (Codex in testing); reads CLAUDE.md, AGENTS.md, Cursor, Copilot and Windsurf rules.",
   "repository": {
     "type": "git",