@inerrata-corporation/errata 2.0.2-dev.1218 → 2.0.2-dev.1255

package/errata.mjs

@@ -53370,6 +53370,7 @@ function parseDesignResolutions(text) {
   }
   return out2;
 }
+var OPENCODE_TRANSCRIPT_HEADER_TYPE = "errata-opencode-session";
 var FILE_TOOLS = /* @__PURE__ */ new Set(["Read", "Edit", "Write", "MultiEdit", "NotebookEdit"]);
 var WRITE_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
 function isUserTurnBoundary(obj) {
@@ -53421,6 +53422,9 @@ function detectHostHarness(raw2) {
     if (obj.type === "gemini" || "$set" in obj || "projectHash" in obj && "sessionId" in obj || obj.type === "user" && !("message" in obj) && "content" in obj) {
       return "gemini";
     }
+    if (obj.type === OPENCODE_TRANSCRIPT_HEADER_TYPE || obj.type === void 0 && "info" in obj && Array.isArray(obj["parts"]) && typeof obj["info"]?.["role"] === "string") {
+      return "opencode";
+    }
     if (obj.type === "user" || obj.type === "assistant" || obj.type === "summary") {
       return "claude_code";
     }
@@ -53432,8 +53436,44 @@ function parseAssistantTurns(raw2, includeThinking, skipFirstLineParseFailure =
   const harness = detectHostHarness(raw2);
   if (harness === "codex") return parseCodexAssistantTurns(raw2, skipFirstLineParseFailure);
   if (harness === "gemini") return parseGeminiAssistantTurns(raw2, skipFirstLineParseFailure);
+  if (harness === "opencode") return parseOpencodeAssistantTurns(raw2, skipFirstLineParseFailure);
   return parseClaudeAssistantTurns(raw2, includeThinking, skipFirstLineParseFailure);
 }
+function parseOpencodeAssistantTurns(raw2, skipFirstLineParseFailure = false) {
+  const lines = raw2.split(/\r?\n/);
+  const byId = /* @__PURE__ */ new Map();
+  let order = 0;
+  let parseFailures = 0;
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const line = lines[i2];
+    if (!line) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      if (!(i2 === 0 && skipFirstLineParseFailure)) parseFailures++;
+      continue;
+    }
+    if (!obj || typeof obj !== "object") continue;
+    if (obj["type"] === OPENCODE_TRANSCRIPT_HEADER_TYPE) continue;
+    const info2 = obj["info"];
+    const parts2 = obj["parts"];
+    if (!info2 || typeof info2 !== "object" || !Array.isArray(parts2)) continue;
+    if (info2["role"] !== "assistant") continue;
+    const texts = [];
+    for (const p of parts2) {
+      if (!p || p["type"] !== "text") continue;
+      if (p["synthetic"] === true || p["ignored"] === true) continue;
+      if (typeof p["text"] === "string" && p["text"].length > 0) texts.push(p["text"]);
+    }
+    if (texts.length === 0) continue;
+    const id = typeof info2["id"] === "string" ? info2["id"] : `opencode-${i2}`;
+    const prev = byId.get(id);
+    byId.set(id, { text: texts.join("\n\n"), order: prev ? prev.order : order++ });
+  }
+  const turns = [...byId.entries()].sort((a, b) => a[1].order - b[1].order).map(([uuid3, v]) => ({ uuid: uuid3, text: v.text, hostHarness: "opencode" }));
+  return { turns, parseFailures };
+}
 function parseGeminiAssistantTurns(raw2, skipFirstLineParseFailure = false) {
   const lines = raw2.split(/\r?\n/);
   const byId = /* @__PURE__ */ new Map();
@@ -53805,6 +53845,71 @@ function geminiTranscriptsForCwd(cwd, opts = {}) {
   out2.sort((a, b) => b.mtimeMs - a.mtimeMs);
   return out2.slice(0, limit);
 }
+function opencodeSessionRoots(env2 = process.env, home = homedir4()) {
+  const roots = /* @__PURE__ */ new Set();
+  const explicit = env2["ERRATA_OPENCODE_SESSIONS_DIRS"];
+  if (explicit) {
+    for (const d of explicit.split(":")) if (d.trim()) roots.add(d.trim());
+  }
+  if (env2["XDG_DATA_HOME"]) roots.add(join16(env2["XDG_DATA_HOME"], "opencode", "errata"));
+  roots.add(join16(home, ".local", "share", "opencode", "errata"));
+  return [...roots];
+}
+function readOpencodeTranscriptDirectory(path2) {
+  let fd;
+  try {
+    fd = openSync(path2, "r");
+    const buf = Buffer.allocUnsafe(8192);
+    const n = readSync(fd, buf, 0, buf.length, 0);
+    const nl = buf.indexOf(10);
+    const first = buf.toString("utf8", 0, nl >= 0 && nl < n ? nl : n);
+    const o = JSON.parse(first);
+    if (o?.type !== OPENCODE_TRANSCRIPT_HEADER_TYPE) return null;
+    return typeof o.directory === "string" ? o.directory : null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== void 0) try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+}
+function opencodeTranscriptsForCwd(cwd, opts = {}) {
+  const sinceMs = opts.sinceMs ?? 0;
+  const limit = opts.limit ?? 25;
+  const want = /* @__PURE__ */ new Set([cwd, cwd.replace(/\/+$/, "")]);
+  try {
+    want.add(realpathSync(cwd));
+  } catch {
+  }
+  const out2 = [];
+  for (const root of opencodeSessionRoots(opts.env, opts.home)) {
+    if (!existsSync13(root)) continue;
+    let names;
+    try {
+      names = readdirSync6(root);
+    } catch {
+      continue;
+    }
+    for (const name2 of names) {
+      if (!name2.endsWith(".jsonl")) continue;
+      const full = join16(root, name2);
+      let st;
+      try {
+        st = statSync4(full);
+      } catch {
+        continue;
+      }
+      if (!st.isFile() || st.mtimeMs < sinceMs) continue;
+      const dir = readOpencodeTranscriptDirectory(full);
+      if (!dir || !(want.has(dir) || want.has(dir.replace(/\/+$/, "")))) continue;
+      out2.push({ path: full, sessionId: `opencode:${basename3(name2, ".jsonl")}`, mtimeMs: st.mtimeMs });
+    }
+  }
+  out2.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return out2.slice(0, limit);
+}
 
 // src/prior-tags.ts
 init_src();
@@ -57204,7 +57309,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.1218" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.1255" : "2.0.0-alpha.0";
 var IGNORED_PATH = /[\\/](?:\.git|node_modules|\.errata|\.claude|\.codex|\.cursor|\.turbo|\.next|dist|coverage|test-results|playwright-report|__pycache__)(?:[\\/]|$)/;
 var IGNORED_NOISE = /castalia\.db|eventlog\.sqlite|turn-cursors/;
 var GIT_OP_MUTE_MS = 4e3;
@@ -58855,6 +58960,14 @@ function createWorkspaceEngine(opts) {
           await yieldToLoop();
           await harvestSession(ref.sessionId, ref.path);
         }
+        const opencodeRefs = opencodeTranscriptsForCwd(opts.workspaceRoot, {
+          sinceMs: Date.now() - TURN_REPLAY_LOOKBACK_MS,
+          limit: 25
+        });
+        for (const ref of opencodeRefs) {
+          await yieldToLoop();
+          await harvestSession(ref.sessionId, ref.path);
+        }
       } catch {
       }
     })();
@@ -58866,7 +58979,8 @@ function createWorkspaceEngine(opts) {
           const since = Date.now() - CODEX_SWEEP_LOOKBACK_MS;
           const refs = [
             ...codexRolloutsForCwd(opts.workspaceRoot, { sinceMs: since, limit: 10 }),
-            ...geminiTranscriptsForCwd(opts.workspaceRoot, { sinceMs: since, limit: 10 })
+            ...geminiTranscriptsForCwd(opts.workspaceRoot, { sinceMs: since, limit: 10 }),
+            ...opencodeTranscriptsForCwd(opts.workspaceRoot, { sinceMs: since, limit: 10 })
           ];
           for (const ref of refs) {
             await yieldToLoop();
@@ -60803,7 +60917,7 @@ var CODEX_WAKE_LOOKBACK_MS = 10 * 6e4;
 var CODEX_WAKE_BOOT_LOOKBACK_MS = 24 * 60 * 6e4;
 function codexWakeCandidates(input) {
   if (input.disabled) return [];
-  const find = input.find ?? ((cwd, since) => codexRolloutsForCwd(cwd, { sinceMs: since, limit: 1 }).length + geminiTranscriptsForCwd(cwd, { sinceMs: since, limit: 1 }).length);
+  const find = input.find ?? ((cwd, since) => codexRolloutsForCwd(cwd, { sinceMs: since, limit: 1 }).length + geminiTranscriptsForCwd(cwd, { sinceMs: since, limit: 1 }).length + opencodeTranscriptsForCwd(cwd, { sinceMs: since, limit: 1 }).length);
   const out2 = [];
   for (const entry of input.entries) {
     if (input.liveRoots.has(input.normPath(entry.path))) continue;
@@ -61377,7 +61491,7 @@ async function startMultiDaemon(opts = {}) {
     });
     for (const c of candidates) {
       if (attachWorkspace(c.path).attached) {
-        console.log(`[errata] woke workspace ${c.name} \u2014 recent Codex/Gemini transcript (headless capture)`);
+        console.log(`[errata] woke workspace ${c.name} \u2014 recent Codex/Gemini/OpenCode transcript (headless capture)`);
       }
     }
   };
@@ -62924,6 +63038,145 @@ ${CODEX_HOOKS_END}
 `;
 }
 
+// src/opencode-plugin.ts
+var OPENCODE_PLUGIN_MARKER = "// @inerrata opencode plugin \u2014 errata-managed (errata install-hooks opencode)";
+var OPENCODE_D1_CONTRACT = "Behavioral contract: (1) On ANY error, call search() BEFORE debugging \u2014 costs ~400 tokens vs 5,000\u201350,000 cold. (2) After solving non-trivial problems, contribute back: if your harness emits typed nodes (canonicalId + label + attrs), use ingest \u2014 the typed door; otherwise call contribute(), the prose fallback. (3) Before web search, try search() first \u2014 graph is 2\u201315\xD7 cheaper. (4) At session end, review what you solved and contribute anything novel.";
+var OPENCODE_TOOL_FAILURE_NUDGE = "[inerrata] This tool call failed \u2014 call search() with the error message BEFORE debugging from scratch (~400 tokens vs 5,000\u201350,000 cold).";
+function buildOpencodePluginSource(port, opts = {}) {
+  const version2 = opts.version ?? "dev";
+  return `${OPENCODE_PLUGIN_MARKER}
+// Generated by errata ${version2}. Re-run \`errata install-hooks opencode\` to update; edits here are overwritten.
+// What it does: mirrors each OpenCode session's OWN message record to a JSONL
+// file the errata daemon can parse, and tells the daemon on every turn boundary.
+// It has no dependencies and never throws into OpenCode.
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const DAEMON = "http://127.0.0.1:${port}";
+const HEADER_TYPE = "errata-opencode-session";
+const D1_CONTRACT = ${JSON.stringify(OPENCODE_D1_CONTRACT)};
+const TOOL_FAILURE_NUDGE = ${JSON.stringify(OPENCODE_TOOL_FAILURE_NUDGE)};
+
+function mirrorRoot() {
+  const explicit = process.env.ERRATA_OPENCODE_SESSIONS_DIRS;
+  if (explicit) { const first = explicit.split(":").map((s) => s.trim()).find(Boolean); if (first) return first; }
+  if (process.env.XDG_DATA_HOME) return join(process.env.XDG_DATA_HOME, "opencode", "errata");
+  return join(homedir(), ".local", "share", "opencode", "errata");
+}
+
+async function post(path, body) {
+  try {
+    const res = await fetch(DAEMON + path, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body), signal: AbortSignal.timeout(15000) });
+    return res.status;
+  } catch { return 0; }
+}
+
+export const InerrataPlugin = async (input) => {
+  const directory = input.directory;
+  const projectID = input.project && input.project.id ? input.project.id : null;
+  const root = mirrorRoot();
+  // per-session state: which message ids are already in the mirror file
+  const written = new Map(); // sessionID -> Set<messageId>
+  const files = new Map();   // sessionID -> path
+
+  function fileFor(sessionID) {
+    let p = files.get(sessionID);
+    if (p) return p;
+    try { mkdirSync(root, { recursive: true }); } catch {}
+    p = join(root, sessionID + ".jsonl");
+    files.set(sessionID, p);
+    const seen = new Set();
+    if (existsSync(p)) {
+      // resumed session / plugin re-instantiated: learn what is already mirrored
+      try {
+        for (const line of readFileSync(p, "utf8").split("\\n")) {
+          if (!line) continue;
+          try { const o = JSON.parse(line); if (o && o.info && typeof o.info.id === "string") seen.add(o.info.id); } catch {}
+        }
+      } catch {}
+    } else {
+      appendFileSync(p, JSON.stringify({ type: HEADER_TYPE, version: 1, sessionID, directory, projectID, worktree: input.worktree || null, writtenAt: Date.now() }) + "\\n");
+    }
+    written.set(sessionID, seen);
+    return p;
+  }
+
+  async function mirror(sessionID) {
+    // OpenCode's own record: session.messages() items are {info: Message, parts: Part[]}
+    // (the same objects \`opencode export\` prints). Append only completed assistant
+    // messages + every user message not yet mirrored; ids never repeat.
+    const p = fileFor(sessionID);
+    const seen = written.get(sessionID);
+    let items = [];
+    try {
+      const r = await input.client.session.messages({ path: { id: sessionID } });
+      items = (r && r.data) ? r.data : (Array.isArray(r) ? r : []);
+    } catch { return { path: p, appended: 0 }; }
+    let appended = 0;
+    for (const item of items) {
+      const info = item && item.info;
+      if (!info || typeof info.id !== "string" || seen.has(info.id)) continue;
+      if (info.role === "assistant" && !(info.time && info.time.completed)) continue; // still streaming
+      try {
+        appendFileSync(p, JSON.stringify({ info, parts: Array.isArray(item.parts) ? item.parts : [] }) + "\\n");
+        seen.add(info.id); appended++;
+      } catch {}
+    }
+    return { path: p, appended };
+  }
+
+  const touched = new Set();
+  return {
+    // D1's text reaches OpenCode (\xA711.5 item 1): appended to the SYSTEM prompt
+    // of every request \u2014 the same channel the Claude session-start hook uses
+    // (system-level fires reliably; per-turn nudges measurably do not).
+    // \`experimental.chat.system.transform\` is the hook the 1.18.18 plugin
+    // API exposes for this ({sessionID?, model} \u2192 {system: string[]}).
+    "experimental.chat.system.transform": async (_input, output) => {
+      try {
+        if (output && Array.isArray(output.system) && !output.system.includes(D1_CONTRACT)) output.system.push(D1_CONTRACT);
+      } catch {}
+    },
+    // Tool-failure nudge (\xA711.5 item 2): when a tool result looks failed, one
+    // advisory line is appended to the OUTPUT the model reads. Failure is a
+    // heuristic \u2014 \`metadata\` is untyped in the plugin API \u2014 pinned to the
+    // shapes observed: metadata.error truthy, or a non-zero exit/exitCode.
+    "tool.execute.after": async (_input, output) => {
+      try {
+        if (!output || typeof output.output !== "string") return;
+        const meta = output.metadata;
+        const failed = !!(meta && (meta.error || (typeof meta.exit === "number" && meta.exit !== 0) || (typeof meta.exitCode === "number" && meta.exitCode !== 0)));
+        if (failed && !output.output.includes(TOOL_FAILURE_NUDGE)) output.output = output.output + "\\n\\n" + TOOL_FAILURE_NUDGE;
+      } catch {}
+    },
+    event: async ({ event }) => {
+      try {
+        if (!event || typeof event.type !== "string") return;
+        const sid = event.properties && event.properties.sessionID;
+        if (event.type === "session.created" && sid) { fileFor(sid); touched.add(sid); return; }
+        if (event.type === "session.idle" && sid) {
+          const { path, appended } = await mirror(sid);
+          touched.add(sid);
+          // turn boundary \u2192 the daemon harvests the mirror (idempotent per turn)
+          await post("/api/turn", { session_id: "opencode:" + sid, transcript_path: path, cwd: directory, hostHarness: "opencode", appended });
+        }
+      } catch {}
+    },
+    dispose: async () => {
+      // OpenCode has no session-end event; process disposal is the closest.
+      for (const sid of touched) {
+        try {
+          const { path } = await mirror(sid);
+          await post("/api/session-end", { session_id: "opencode:" + sid, transcript_path: path, cwd: directory, reason: "opencode-dispose" });
+        } catch {}
+      }
+    },
+  };
+};
+`;
+}
+
 // src/cli.ts
 var exitCleanOnEpipe = (err2) => {
   if (err2.code === "EPIPE") process.exit(0);
@@ -63106,7 +63359,7 @@ Commands:
                       Written to .errata/report.html. Flag: --future-verbs
   install-hooks <harness>
                       Wire harness hooks \u2192 daemon /api/hook (or MCP).
-                      <harness>: claude (default) | cursor | codex | aider
+                      <harness>: claude (default) | cursor | codex | opencode | aider
                       Flags: --port N (default 7891)
   mcp                 Run the MCP stdio server \u2014 the agent's full errata tool
                       surface (navigation, problems, claims, burst, health)
@@ -65006,15 +65259,61 @@ async function cmdInstallHooks(args2) {
     case "codex":
       await installCodexHooks(port);
       return;
+    case "opencode":
+      await installOpencodePlugin(port);
+      return;
     case "aider":
       printAiderInstructions();
       return;
     default:
       console.error(`unknown harness: ${harness}`);
-      console.error(`  supported: claude, cursor, codex, aider`);
+      console.error(`  supported: claude, cursor, codex, opencode, aider`);
       process.exit(2);
   }
 }
+async function installOpencodePlugin(port) {
+  const { mkdirSync: mkdirSync9, existsSync: existsSync31, readFileSync: readFileSync29, writeFileSync: writeFileSync23 } = await import("node:fs");
+  const { join: join33 } = await import("node:path");
+  const dir = join33(ROOT, ".opencode", "plugin");
+  if (!existsSync31(dir)) mkdirSync9(dir, { recursive: true });
+  const file2 = join33(dir, "inerrata.js");
+  if (existsSync31(file2)) {
+    const head2 = readFileSync29(file2, "utf8").split("\n")[0] ?? "";
+    if (head2.trim() !== OPENCODE_PLUGIN_MARKER) {
+      console.error(`refusing to overwrite ${file2}: not an errata-managed plugin (line 1 lacks the marker)`);
+      process.exit(2);
+    }
+  }
+  writeFileSync23(file2, buildOpencodePluginSource(port, { version: DAEMON_VERSION }), "utf8");
+  const cfgFile = join33(ROOT, "opencode.json");
+  let cfg = { $schema: "https://opencode.ai/config.json" };
+  if (existsSync31(cfgFile)) {
+    try {
+      cfg = JSON.parse(readFileSync29(cfgFile, "utf8"));
+    } catch {
+      console.error(`refusing to touch invalid JSON at ${cfgFile} \u2014 fix it and re-run`);
+      process.exit(2);
+    }
+  }
+  cfg.mcp ??= {};
+  const hadErrata = "errata" in cfg.mcp;
+  if (!hadErrata) {
+    const inv = errataMcpInvocation();
+    cfg.mcp["errata"] = { type: "local", command: [inv.command, ...inv.args] };
+    writeFileSync23(cfgFile, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  }
+  console.log(`installed OpenCode plugin \u2192 ${file2}`);
+  if (hadErrata) console.log(`  mcp.errata already present in ${cfgFile} \u2014 left untouched`);
+  else console.log(`installed OpenCode MCP server config \u2192 ${cfgFile} (mcp.errata: local \`errata mcp\`)`);
+  console.log(`  endpoint: http://127.0.0.1:${port}/api/turn on every session.idle (+ /api/session-end on dispose)`);
+  console.log("");
+  console.log(`  OpenCode keeps sessions in SQLite, so the plugin mirrors each session's`);
+  console.log(`  own message record to $XDG_DATA_HOME/opencode/errata/<sessionID>.jsonl`);
+  console.log(`  (override: ERRATA_OPENCODE_SESSIONS_DIRS) and the daemon parses THAT \u2014`);
+  console.log(`  role-typed, attested. Works for headless \`opencode run\` too.`);
+  console.log(`  Cloud tools (search/contribute) are the MCP entry in opencode.json:`);
+  console.log(`    { "mcp": { "inerrata": { "type": "remote", "url": "https://mcp.inerrata.dev/mcp", "headers": { "Authorization": "Bearer <errk_\u2026>" } } } }`);
+}
 var ERRATA_TAG = "# errata-managed";
 function errataMcpInvocation() {
   const { cmd: cmd2, args: args2 } = selfArgv("mcp");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inerrata-corporation/errata",
-  "version": "2.0.2-dev.1218",
+  "version": "2.0.2-dev.1255",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {