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

package/errata.mjs

@@ -53249,9 +53249,10 @@ init_src10();
 init_review2();
 
 // src/turn.ts
-import { closeSync, existsSync as existsSync13, fstatSync, openSync, readdirSync as readdirSync6, readSync, statSync as statSync4 } from "node:fs";
+import { closeSync, existsSync as existsSync13, fstatSync, openSync, readdirSync as readdirSync6, readSync, realpathSync, statSync as statSync4 } from "node:fs";
 import { basename as basename3, dirname as dirname8, join as join16 } from "node:path";
 import { homedir as homedir4 } from "node:os";
+import { createHash as createHash13 } from "node:crypto";
 function readFrom(path2, fromByte, maxBytes) {
   let fd;
   try {
@@ -53417,6 +53418,9 @@ function detectHostHarness(raw2) {
     if (obj.type === "response_item" || obj.type === "event_msg" || obj.type === "session_meta" || obj.type === "turn_context" || obj.type === "world_state") {
       return "codex";
     }
+    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 === "user" || obj.type === "assistant" || obj.type === "summary") {
       return "claude_code";
     }
@@ -53425,7 +53429,61 @@ function detectHostHarness(raw2) {
 }
 function parseAssistantTurns(raw2, includeThinking, skipFirstLineParseFailure = false) {
   if (!raw2) return { turns: [], parseFailures: 0 };
-  return detectHostHarness(raw2) === "codex" ? parseCodexAssistantTurns(raw2, skipFirstLineParseFailure) : parseClaudeAssistantTurns(raw2, includeThinking, skipFirstLineParseFailure);
+  const harness = detectHostHarness(raw2);
+  if (harness === "codex") return parseCodexAssistantTurns(raw2, skipFirstLineParseFailure);
+  if (harness === "gemini") return parseGeminiAssistantTurns(raw2, skipFirstLineParseFailure);
+  return parseClaudeAssistantTurns(raw2, includeThinking, skipFirstLineParseFailure);
+}
+function parseGeminiAssistantTurns(raw2, skipFirstLineParseFailure = false) {
+  const lines = raw2.split(/\r?\n/);
+  const byId = /* @__PURE__ */ new Map();
+  let order = 0;
+  let parseFailures = 0;
+  const textOf = (content) => {
+    if (typeof content === "string") return content;
+    if (Array.isArray(content)) {
+      const parts2 = [];
+      for (const b of content) {
+        if (b && typeof b["text"] === "string") parts2.push(b["text"]);
+      }
+      return parts2.length > 0 ? parts2.join("\n\n") : null;
+    }
+    return null;
+  };
+  const fold = (m, fallbackId) => {
+    if (m["type"] !== "gemini") return;
+    const text = textOf(m["content"]);
+    if (text === null || text.length === 0) return;
+    const id = typeof m["id"] === "string" ? m["id"] : fallbackId;
+    const prev = byId.get(id);
+    byId.set(id, { text, order: prev ? prev.order : order++ });
+  };
+  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;
+    const set2 = obj["$set"];
+    if (set2 && typeof set2 === "object") {
+      const msgs = set2["messages"];
+      if (Array.isArray(msgs)) {
+        for (let j = 0; j < msgs.length; j++) {
+          const m = msgs[j];
+          if (m && typeof m === "object") fold(m, `gemini-${i2}-${j}`);
+        }
+      }
+      continue;
+    }
+    if (typeof obj["type"] === "string") fold(obj, `gemini-${i2}`);
+  }
+  const turns = [...byId.entries()].sort((a, b) => a[1].order - b[1].order).map(([uuid3, v]) => ({ uuid: uuid3, text: v.text, hostHarness: "gemini" }));
+  return { turns, parseFailures };
 }
 function parseCodexAssistantTurns(raw2, skipFirstLineParseFailure = false) {
   const turns = [];
@@ -53666,6 +53724,87 @@ function codexRolloutsForCwd(cwd, opts = {}) {
   out2.sort((a, b) => b.mtimeMs - a.mtimeMs);
   return out2.slice(0, limit);
 }
+function geminiSessionRoots(env2 = process.env, home = homedir4()) {
+  const roots = /* @__PURE__ */ new Set();
+  const explicit = env2["ERRATA_GEMINI_SESSIONS_DIRS"];
+  if (explicit) {
+    for (const d of explicit.split(":")) if (d.trim()) roots.add(d.trim());
+  }
+  if (env2["GEMINI_CLI_HOME"]) roots.add(join16(env2["GEMINI_CLI_HOME"], ".gemini", "tmp"));
+  roots.add(join16(home, ".gemini", "tmp"));
+  return [...roots];
+}
+function geminiProjectHash(cwd) {
+  return createHash13("sha256").update(cwd).digest("hex");
+}
+function geminiHashesFor(cwd) {
+  const variants = /* @__PURE__ */ new Set([cwd, cwd.replace(/\/+$/, "")]);
+  try {
+    variants.add(realpathSync(cwd));
+  } catch {
+  }
+  return new Set([...variants].map(geminiProjectHash));
+}
+function readGeminiTranscriptProjectHash(path2) {
+  let fd;
+  try {
+    fd = openSync(path2, "r");
+    const CAP = 65536;
+    const buf = Buffer.allocUnsafe(CAP);
+    const n = readSync(fd, buf, 0, CAP, 0);
+    const nl = buf.indexOf(10);
+    const firstLine = buf.toString("utf8", 0, nl >= 0 && nl < n ? nl : n);
+    const o = JSON.parse(firstLine);
+    return typeof o?.projectHash === "string" ? o.projectHash : null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== void 0) try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+}
+function geminiTranscriptsForCwd(cwd, opts = {}) {
+  const sinceMs = opts.sinceMs ?? 0;
+  const limit = opts.limit ?? 25;
+  const hashes = geminiHashesFor(cwd);
+  const out2 = [];
+  for (const root of geminiSessionRoots(opts.env, opts.home)) {
+    if (!existsSync13(root)) continue;
+    let slugs;
+    try {
+      slugs = readdirSync6(root);
+    } catch {
+      continue;
+    }
+    for (const slug2 of slugs) {
+      const chats = join16(root, slug2, "chats");
+      let names;
+      try {
+        names = readdirSync6(chats);
+      } catch {
+        continue;
+      }
+      for (const name2 of names) {
+        if (!name2.startsWith("session-") || !name2.endsWith(".jsonl")) continue;
+        const full = join16(chats, name2);
+        let st;
+        try {
+          st = statSync4(full);
+        } catch {
+          continue;
+        }
+        if (!st.isFile() || st.mtimeMs < sinceMs) continue;
+        const h = readGeminiTranscriptProjectHash(full);
+        if (!h || !hashes.has(h)) continue;
+        out2.push({ path: full, sessionId: `gemini:${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();
@@ -56339,7 +56478,7 @@ init_paths();
 init_src2();
 init_paths();
 import { existsSync as existsSync21, readFileSync as readFileSync20, writeFileSync as writeFileSync17 } from "node:fs";
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 import { join as join25 } from "node:path";
 
 // src/git-remote.ts
@@ -56396,11 +56535,11 @@ function detectRepoLocator(root, remote) {
 
 // src/profile.ts
 function workspaceId(root) {
-  return "wp_" + createHash13("sha256").update(root).digest("hex").slice(0, 12);
+  return "wp_" + createHash14("sha256").update(root).digest("hex").slice(0, 12);
 }
 function sessionOriginKey(sessionId) {
   if (!sessionId) return void 0;
-  return "ws_" + createHash13("sha256").update(sessionId).digest("hex").slice(0, 12);
+  return "ws_" + createHash14("sha256").update(sessionId).digest("hex").slice(0, 12);
 }
 function refreshRepoLocator(root, profile) {
   const detected = detectRepoLocator(root, profile.repoRemote);
@@ -57065,7 +57204,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.1203" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.1218" : "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;
@@ -58708,6 +58847,14 @@ function createWorkspaceEngine(opts) {
           await yieldToLoop();
           await harvestSession(ref.sessionId, ref.path);
         }
+        const geminiRefs = geminiTranscriptsForCwd(opts.workspaceRoot, {
+          sinceMs: Date.now() - TURN_REPLAY_LOOKBACK_MS,
+          limit: 25
+        });
+        for (const ref of geminiRefs) {
+          await yieldToLoop();
+          await harvestSession(ref.sessionId, ref.path);
+        }
       } catch {
       }
     })();
@@ -58716,10 +58863,11 @@ function createWorkspaceEngine(opts) {
     setImmediate(() => {
       void (async () => {
         try {
-          const refs = codexRolloutsForCwd(opts.workspaceRoot, {
-            sinceMs: Date.now() - CODEX_SWEEP_LOOKBACK_MS,
-            limit: 10
-          });
+          const since = Date.now() - CODEX_SWEEP_LOOKBACK_MS;
+          const refs = [
+            ...codexRolloutsForCwd(opts.workspaceRoot, { sinceMs: since, limit: 10 }),
+            ...geminiTranscriptsForCwd(opts.workspaceRoot, { sinceMs: since, limit: 10 })
+          ];
           for (const ref of refs) {
             await yieldToLoop();
             await harvestSession(ref.sessionId, ref.path);
@@ -60650,6 +60798,26 @@ function createHealthSentinel(deps = {}) {
   };
 }
 
+// src/codex-wake.ts
+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 out2 = [];
+  for (const entry of input.entries) {
+    if (input.liveRoots.has(input.normPath(entry.path))) continue;
+    let n = 0;
+    try {
+      n = find(entry.path, input.sinceMs);
+    } catch {
+      continue;
+    }
+    if (n > 0) out2.push({ name: entry.name, path: entry.path });
+  }
+  return out2;
+}
+
 // src/multi.ts
 var projectSymbolSalts = /* @__PURE__ */ new Map();
 async function resolveProjectSymbolSalt(client, projectId) {
@@ -61190,6 +61358,33 @@ async function startMultiDaemon(opts = {}) {
   };
   const idleSweep = setInterval(sweepIdleWorkspaces, WORKSPACE_SWEEP_INTERVAL_MS);
   idleSweep.unref?.();
+  let codexWakeFirstPass = true;
+  const sweepCodexWake = () => {
+    const lookback = codexWakeFirstPass ? CODEX_WAKE_BOOT_LOOKBACK_MS : CODEX_WAKE_LOOKBACK_MS;
+    codexWakeFirstPass = false;
+    let entries2;
+    try {
+      entries2 = listWorkspaceEntries();
+    } catch {
+      return;
+    }
+    const candidates = codexWakeCandidates({
+      entries: entries2,
+      liveRoots: new Set(records.map((r) => normPath(r.root))),
+      normPath,
+      sinceMs: Date.now() - lookback,
+      disabled: process.env["ERRATA_CODEX_WAKE_DISABLE"] === "1"
+    });
+    for (const c of candidates) {
+      if (attachWorkspace(c.path).attached) {
+        console.log(`[errata] woke workspace ${c.name} \u2014 recent Codex/Gemini transcript (headless capture)`);
+      }
+    }
+  };
+  const codexWake = setInterval(sweepCodexWake, WORKSPACE_SWEEP_INTERVAL_MS);
+  codexWake.unref?.();
+  const codexWakeBoot = setTimeout(sweepCodexWake, 5e3);
+  codexWakeBoot.unref?.();
   const reindexAll = async (rOpts) => {
     const out2 = /* @__PURE__ */ new Map();
     const toIndex = records.filter((r) => rOpts?.force || r.engine.store.nodeCount() === 0);
@@ -61903,6 +62098,8 @@ async function startMultiDaemon(opts = {}) {
     },
     async stop() {
       clearInterval(idleSweep);
+      clearInterval(codexWake);
+      clearTimeout(codexWakeBoot);
       try {
         const cur = readFileSync27(lockPath, "utf8");
         if (JSON.parse(cur).pid === process.pid) unlinkSync3(lockPath);

package/package.json

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