rulereceipt 0.1.81 → 0.1.83

package/NOTICE.md

@@ -30,3 +30,5 @@ we did not copy the code):
   documented by **yigitkonur/cli-continues** (MIT), pinned commit
   `e486cd22a592d89d890cff056624647fbe9cbe80`, which itself reverse-engineered it
   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.)

package/dist/adapters/cursor.d.ts

@@ -0,0 +1,7 @@
+import type { TranscriptEvent } from "../types.js";
+/** Cursor agent-transcript files for this cwd, newest first. */
+export declare function listCursorSessions(cwd: string): string[];
+/** True when a file looks like a Cursor agent-transcript (≥1 {role,content[]} line). */
+export declare function cursorFormatIsKnown(file: string): boolean;
+/** Parse a Cursor agent-transcript JSONL into neutral events. Tolerant. */
+export declare function parseCursorTranscript(file: string): TranscriptEvent[];

package/dist/adapters/cursor.js

@@ -0,0 +1,190 @@
+import { existsSync, readFileSync, readdirSync, statSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * Cursor adapter — EXPERIMENTAL (no real-session fixtures yet).
+ *
+ * Reads the CURRENT Cursor agent-transcripts (JSONL, Anthropic-API shaped), not
+ * the old `state.vscdb` SQLite. Format documented by yigitkonur/cli-continues
+ * (MIT, src/parsers/cursor.ts, pinned e486cd22a592d89d890cff056624647fbe9cbe80).
+ * Credit: NOTICE.md / REUSE.md. Read-only; never opens/locks state.vscdb.
+ *
+ * Storage: `~/.cursor/projects/<slug>/agent-transcripts/**​/*.jsonl` (nested
+ * `<uuid>/transcript.jsonl` or flat `<uuid>.jsonl`). The project's cwd is in
+ * `~/.cursor/projects/<slug>/repo.json` (`workspace` | `rootPath` | `path`).
+ * Each JSONL line is `{ role:'user'|'assistant', content: [Anthropic blocks] }`:
+ *   {type:'text',text}                         -> text
+ *   {type:'tool_use',id,name,input}            -> tool_use (shell -> canonical Bash)
+ *   {type:'tool_result',tool_use_id,content,is_error} -> tool_result
+ *
+ * DEFERRED: the legacy `state.vscdb` SQLite path (partial, reverse-engineered,
+ * multi-migration) — it needs a WASM sqlite reader and is low-confidence without
+ * real samples. Logged in REUSE.md.
+ *
+ * RESILIENCE: only the fields above; unknown blocks/lines skipped, never guessed;
+ * `cursorFormatIsKnown` gates use so another tool's log is not mis-parsed.
+ */
+function cursorProjectsDir() {
+    const env = process.env.CURSOR_HOME?.trim();
+    return env && env.length > 0 ? join(env, "projects") : join(homedir(), ".cursor", "projects");
+}
+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 : {}; }
+/** The cwd a Cursor project dir maps to, from its repo.json. */
+function projectCwd(projectDir) {
+    try {
+        const o = JSON.parse(readFileSync(join(projectDir, "repo.json"), "utf-8"));
+        return str(o.workspace) ?? str(o.rootPath) ?? str(o.path) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function jsonlFilesUnder(dir, out, depth = 0) {
+    if (depth > 4 || !existsSync(dir))
+        return;
+    let entries = [];
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        const p = join(dir, name);
+        let isDir = false;
+        try {
+            isDir = statSync(p).isDirectory();
+        }
+        catch {
+            continue;
+        }
+        if (isDir)
+            jsonlFilesUnder(p, out, depth + 1);
+        else if (name.endsWith(".jsonl"))
+            out.push(p);
+    }
+}
+/** Cursor agent-transcript files for this cwd, newest first. */
+export function listCursorSessions(cwd) {
+    const base = cursorProjectsDir();
+    if (!existsSync(base))
+        return [];
+    const target = realpathOr(cwd);
+    let projects = [];
+    try {
+        projects = readdirSync(base);
+    }
+    catch {
+        return [];
+    }
+    const hits = [];
+    for (const slug of projects) {
+        const projectDir = join(base, slug);
+        const mapped = projectCwd(projectDir);
+        if (mapped && realpathOr(mapped) !== target)
+            continue; // another project
+        const files = [];
+        jsonlFilesUnder(join(projectDir, "agent-transcripts"), files);
+        for (const f of files) {
+            try {
+                hits.push({ file: f, mtimeMs: statSync(f).mtimeMs });
+            }
+            catch { /* skip */ }
+        }
+    }
+    return hits.sort((a, b) => b.mtimeMs - a.mtimeMs).map((h) => h.file);
+}
+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.target_file);
+    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 };
+}
+function toolResultContent(block) {
+    const c = block.content;
+    if (typeof c === "string")
+        return c;
+    if (Array.isArray(c))
+        return c.map((p) => str(rec(p).text) ?? "").filter(Boolean).join("\n");
+    return c ? JSON.stringify(c).slice(0, 2000) : "";
+}
+/** True when a file looks like a Cursor agent-transcript (≥1 {role,content[]} line). */
+export function cursorFormatIsKnown(file) {
+    let raw;
+    try {
+        raw = readFileSync(file, "utf-8");
+    }
+    catch {
+        return false;
+    }
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const o = JSON.parse(line);
+            // A Cursor line has a top-level role + content array and NO Claude-style
+            // `message` wrapper and NO Codex/Copilot `type`.
+            if ((o.role === "user" || o.role === "assistant") && Array.isArray(o.content) && o.message === undefined && o.type === undefined)
+                return true;
+        }
+        catch { /* skip */ }
+        break; // only the first non-blank line decides
+    }
+    return false;
+}
+/** Parse a Cursor agent-transcript JSONL into neutral events. Tolerant. */
+export function parseCursorTranscript(file) {
+    let raw;
+    try {
+        raw = readFileSync(file, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        let o;
+        try {
+            o = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const role = o.role === "assistant" ? "assistant" : o.role === "user" ? "user" : undefined;
+        if (!role || !Array.isArray(o.content))
+            continue;
+        for (const raw2 of o.content) {
+            const b = rec(raw2);
+            if (b.type === "text" && str(b.text)) {
+                out.push({ role, kind: "text", text: b.text, timestamp: "" });
+            }
+            else if (b.type === "tool_use" && role === "assistant") {
+                const name = str(b.name);
+                if (name)
+                    out.push(toToolUse(name, rec(b.input), str(b.id), ""));
+            }
+            else if (b.type === "tool_result") {
+                out.push({ role: "user", kind: "tool_result", toolUseId: str(b.tool_use_id), content: toolResultContent(b), isError: b.is_error === true, timestamp: "" });
+            }
+        }
+    }
+    return out;
+}

package/dist/adapters/gemini.d.ts

@@ -0,0 +1,7 @@
+import type { TranscriptEvent } from "../types.js";
+/** Gemini CLI session files for this cwd, newest first. */
+export declare function listGeminiSessions(cwd: string): string[];
+/** True when the file looks like a Gemini CLI session (≥1 user/gemini message). */
+export declare function geminiFormatIsKnown(file: string): boolean;
+/** Parse a Gemini CLI session into neutral events. Tolerant: unknown → skipped. */
+export declare function parseGeminiTranscript(file: string): TranscriptEvent[];

package/dist/adapters/gemini.js

@@ -0,0 +1,219 @@
+import { existsSync, readFileSync, readdirSync, statSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * Gemini CLI adapter — EXPERIMENTAL (no real-session fixtures yet).
+ *
+ * Reader is OUR OWN code; the FORMAT is documented by yigitkonur/cli-continues
+ * (MIT, src/parsers/gemini.ts, pinned e486cd22a592d89d890cff056624647fbe9cbe80,
+ * reverse-engineered from Pilan-AI/mnemo MIT). Credit: NOTICE.md / REUSE.md.
+ *
+ * Storage: `~/.gemini/tmp/<project-hash>/chats/*.{jsonl,json}` (current) and
+ * `~/.gemini/sessions/*.json` (legacy). `GEMINI_HOME`/`HOME` set the root. The
+ * project-hash → cwd map is `~/.gemini/projects.json` ({ projects: { <cwd>:
+ * <id> } }); we also match by a session's own absolute tool paths as a fallback.
+ *
+ * A session is `{ messages: [...] }` (single JSON) or one record per JSONL line
+ * that accretes into that array. Each message: `{ type: 'user'|'gemini'|'info',
+ * content?, toolCalls?: [{ name, args:{command?,file_path?,path?}, status?,
+ * result?:[{functionResponse:{response:{output?,error?}}}], resultDisplay? }] }`.
+ *   user    -> text (user)
+ *   gemini  -> text (assistant); each toolCall -> tool_use (shell -> canonical
+ *              Bash) + a tool_result from its response/status.
+ *
+ * RESILIENCE: depend only on those fields; ignore unknown; a bad line/record is
+ * skipped, never guessed. `geminiFormatIsKnown` gates use so a non-Gemini file
+ * is never mis-parsed.
+ */
+function geminiRoot() {
+    const env = process.env.GEMINI_HOME?.trim();
+    return env && env.length > 0 ? join(env, ".gemini") : join(homedir(), ".gemini");
+}
+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 : {}; }
+/** project-hash → cwd, from ~/.gemini/projects.json ({projects:{<cwd>:<id>}}). */
+function projectHashToCwd() {
+    const out = new Map();
+    try {
+        const parsed = JSON.parse(readFileSync(join(geminiRoot(), "projects.json"), "utf-8"));
+        for (const [cwd, id] of Object.entries(parsed.projects ?? {}))
+            out.set(id, cwd);
+    }
+    catch { /* absent */ }
+    return out;
+}
+function sessionFilesIn(dir) {
+    const out = [];
+    let names = [];
+    try {
+        names = readdirSync(dir);
+    }
+    catch {
+        return out;
+    }
+    for (const n of names)
+        if (n.endsWith(".jsonl") || n.endsWith(".json"))
+            out.push(join(dir, n));
+    return out;
+}
+/** Gemini CLI session files for this cwd, newest first. */
+export function listGeminiSessions(cwd) {
+    const root = geminiRoot();
+    const target = realpathOr(cwd);
+    const hashCwd = projectHashToCwd();
+    const candidates = [];
+    const tmp = join(root, "tmp");
+    if (existsSync(tmp)) {
+        let hashes = [];
+        try {
+            hashes = readdirSync(tmp);
+        }
+        catch {
+            hashes = [];
+        }
+        for (const h of hashes) {
+            const mapped = hashCwd.get(h);
+            // Only this project's hash dir when we can resolve it; when projects.json
+            // doesn't map it, fall back to per-file cwd inference below.
+            if (mapped && realpathOr(mapped) !== target)
+                continue;
+            candidates.push(...sessionFilesIn(join(tmp, h, "chats")));
+        }
+    }
+    const legacy = join(root, "sessions");
+    if (existsSync(legacy))
+        candidates.push(...sessionFilesIn(legacy));
+    const hits = [];
+    for (const file of candidates) {
+        try {
+            // When the hash wasn't in projects.json, confirm by the session's own
+            // absolute tool paths before claiming it for this cwd.
+            if (!fileBelongsToCwd(file, target, hashCwd))
+                continue;
+            hits.push({ file, mtimeMs: statSync(file).mtimeMs });
+        }
+        catch { /* skip */ }
+    }
+    return hits.sort((a, b) => b.mtimeMs - a.mtimeMs).map((h) => h.file);
+}
+/** True if a session file is for `target` cwd (by inferred absolute tool paths). */
+function fileBelongsToCwd(file, target, hashCwd) {
+    // If its hash dir mapped to a cwd, listGeminiSessions already filtered it.
+    if (hashCwd.size > 0)
+        return true; // mapping-authoritative path handled above
+    for (const m of readGeminiMessages(file)) {
+        for (const tc of m.toolCalls ?? []) {
+            const p = str(rec(tc.args).file_path) ?? str(rec(tc.args).path);
+            if (p && p.startsWith("/"))
+                return realpathOr(p).startsWith(target);
+        }
+    }
+    return true; // no evidence either way: don't exclude (experimental, best-effort)
+}
+/** Messages from a Gemini session file, whether single-JSON or JSONL. Tolerant. */
+function readGeminiMessages(file) {
+    let raw;
+    try {
+        raw = readFileSync(file, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    // Single JSON object with a messages array?
+    try {
+        const obj = JSON.parse(raw);
+        if (obj && Array.isArray(obj.messages))
+            return obj.messages;
+    }
+    catch { /* not a single JSON: try JSONL */ }
+    const msgs = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const r = JSON.parse(line);
+            if (Array.isArray(r.messages)) {
+                msgs.push(...r.messages);
+                continue;
+            }
+            const m = (r.message ?? r);
+            if (typeof m.type === "string")
+                msgs.push(m);
+        }
+        catch { /* skip bad line */ }
+    }
+    return msgs;
+}
+function contentText(content) {
+    if (typeof content === "string")
+        return content || undefined;
+    if (Array.isArray(content)) {
+        const parts = content.map((p) => (typeof p === "string" ? p : str(rec(p).text))).filter((p) => Boolean(p));
+        return parts.length ? parts.join("\n") : undefined;
+    }
+    return content ? JSON.stringify(content).slice(0, 2000) : undefined;
+}
+function toToolUse(name, args, id, ts) {
+    const command = str(args.command) ?? str(args.cmd);
+    const filePath = str(args.file_path) ?? str(args.path);
+    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)/.test(lower)) {
+        return { role: "assistant", kind: "tool_use", toolName: /(edit|replace|patch)/.test(lower) ? "Edit" : "Write", toolUseId: id, input: { file_path: filePath, ...args }, 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: args, timestamp: ts };
+}
+function toolResultText(tc) {
+    const first = Array.isArray(tc.result) ? tc.result[0] : undefined;
+    const resp = rec(rec(rec(first).functionResponse).response);
+    const out = str(resp.output);
+    const err = str(resp.error);
+    const display = typeof tc.resultDisplay === "string" ? tc.resultDisplay : str(rec(tc.resultDisplay).fileDiff) ?? str(rec(tc.resultDisplay).newContent);
+    return { content: (out ?? err ?? display ?? "").slice(0, 2000), isError: tc.status === "error" || Boolean(err) };
+}
+/** True when the file looks like a Gemini CLI session (≥1 user/gemini message). */
+export function geminiFormatIsKnown(file) {
+    for (const m of readGeminiMessages(file)) {
+        if (m.type === "gemini" || (m.type === "user" && m.content !== undefined))
+            return true;
+    }
+    return false;
+}
+/** Parse a Gemini CLI session into neutral events. Tolerant: unknown → skipped. */
+export function parseGeminiTranscript(file) {
+    const out = [];
+    let i = 0;
+    for (const m of readGeminiMessages(file)) {
+        if (m.type === "user") {
+            const text = contentText(m.content);
+            if (text)
+                out.push({ role: "user", kind: "text", text, timestamp: "" });
+        }
+        else if (m.type === "gemini") {
+            const text = contentText(m.content);
+            if (text)
+                out.push({ role: "assistant", kind: "text", text, timestamp: "" });
+            for (const tc of m.toolCalls ?? []) {
+                const name = str(tc.name);
+                if (!name)
+                    continue;
+                const id = `g:${i++}`;
+                out.push(toToolUse(name, rec(tc.args), id, ""));
+                const { content, isError } = toolResultText(tc);
+                out.push({ role: "user", kind: "tool_result", toolUseId: id, content, isError, timestamp: "" });
+            }
+        }
+    }
+    return out;
+}

package/dist/adapters/index.d.ts

@@ -42,6 +42,10 @@ export declare const codexAdapter: SessionAdapter;
 export declare const copilotCliAdapter: SessionAdapter;
 /** Adapters with a verified, tested parser — these auto-detect the newest session. */
 export declare const ADAPTERS: SessionAdapter[];
+/** Gemini CLI — EXPERIMENTAL. Our reader; format per cli-continues (MIT, pinned). */
+export declare const geminiCliAdapter: SessionAdapter;
+/** Cursor — EXPERIMENTAL. Current agent-transcripts (JSONL, Anthropic-shaped); old SQLite deferred. */
+export declare const cursorAdapter: SessionAdapter;
 /** Experimental adapters: reader exists, awaiting real+planted+clean fixtures. */
 export declare const EXPERIMENTAL_ADAPTERS: SessionAdapter[];
 /**

package/dist/adapters/index.js

@@ -3,6 +3,8 @@ import { basename } from "node:path";
 import { listAllSessionFiles, readTranscriptFromFile, findSubagentFiles } from "../parsers/transcriptParser.js";
 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";
 /**
  * Claude Code — the original and reference adapter. Delegates to the existing
  * transcriptParser so its behaviour (including subagent transcripts) is
@@ -38,19 +40,31 @@ export const copilotCliAdapter = {
 };
 /** Adapters with a verified, tested parser — these auto-detect the newest session. */
 export const ADAPTERS = [claudeCodeAdapter, codexAdapter];
+/** Gemini CLI — EXPERIMENTAL. Our reader; format per cli-continues (MIT, pinned). */
+export const geminiCliAdapter = {
+    tool: "gemini-cli",
+    listSessions: (cwd) => listGeminiSessions(cwd),
+    parse: (sessionFile) => parseGeminiTranscript(sessionFile),
+    experimental: true,
+};
+/** Cursor — EXPERIMENTAL. Current agent-transcripts (JSONL, Anthropic-shaped); old SQLite deferred. */
+export const cursorAdapter = {
+    tool: "cursor",
+    listSessions: (cwd) => listCursorSessions(cwd),
+    parse: (sessionFile) => parseCursorTranscript(sessionFile),
+    experimental: true,
+};
 /** Experimental adapters: reader exists, awaiting real+planted+clean fixtures. */
-export const EXPERIMENTAL_ADAPTERS = [copilotCliAdapter];
+export const EXPERIMENTAL_ADAPTERS = [copilotCliAdapter, geminiCliAdapter, cursorAdapter];
 /**
  * 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
  * and why, and so adding one later is a visible change here.
  */
 export const UNSUPPORTED_TOOLS = [
-    { tool: "gemini-cli", reason: "session-log path is known (~/.gemini/tmp/<hash>/chats/*.json) but the per-line JSON schema is unverified — not parsed, to avoid fabricating events" },
     { 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) since v1.2.0 (per-record JSON before) — needs a SQLite reader, version-dependent" },
-    { tool: "cursor", reason: "IDE-embedded; chat history lives in undocumented internal state that changes across Cursor versions — real ongoing maintenance, out of scope for this pass" },
-    { tool: "windsurf", reason: "IDE-embedded; history in undocumented internal state, same as Cursor" },
+    { 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" },
 ];
 /**
  * The single most recently modified session across ALL supported tools for
@@ -137,6 +151,15 @@ export function parseSessionFile(file) {
     catch {
         /* first line is not JSON: treat as a Claude transcript below */
     }
+    // Gemini CLI: a `{messages:[...]}` JSON or JSONL of `type:'gemini'|'user'`
+    // records (with their own `content`, unlike Claude's `message.content`).
+    // Confirmed by a known-format check so a Claude/other log is never mis-read.
+    if (geminiFormatIsKnown(file))
+        return parseGeminiTranscript(file);
+    // Cursor agent-transcript: a JSONL line `{role, content:[...]}` with no Claude
+    // `message` wrapper and no `type`. Gated the same way.
+    if (cursorFormatIsKnown(file))
+        return parseCursorTranscript(file);
     return readTranscriptFromFile(file);
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rulereceipt",
-  "version": "0.1.81",
+  "version": "0.1.83",
   "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",