@inerrata-corporation/errata 2.0.21-dev.3707 → 2.0.21-dev.3716

package/errata.mjs

@@ -34899,7 +34899,7 @@ function isQuotaError(err2) {
   return status === 403 && /quota/i.test(msg);
 }
 async function dualAugment(opts) {
-  const { store, cloud, localHits, seedNode, queryText, limit } = opts;
+  const { store, cloud, localHits, seedNode, queryText, limit, generalizeSoft } = opts;
   const cloudHits = [];
   let seedUsageCount;
   let seedProvenance = "local";
@@ -34910,7 +34910,7 @@ async function dualAugment(opts) {
       return !!n && isHardBridge(n);
     });
     const softText = queryText ?? (seedNode && BRIDGE_LABELS.has(seedNode.label) ? seedNode.description : void 0);
-    const softQ = softText ? generalizeSymbols(softText, lexiconsFor(store).symbols, 1) : void 0;
+    const softQ = softText ? await generalizeSoft?.(softText) ?? generalizeSymbols(softText, lexiconsFor(store).symbols, 1) : void 0;
     if (seedNode?.label === "Package") {
       calls.push(
         cloud.packages(seedNode.id).then((pn) => {
@@ -35022,6 +35022,50 @@ var init_dual_augment = __esm({
   }
 });
 
+// src/daemon-generalize-client.ts
+function daemonLoopbackUrl(lockPath = globalDaemonLock()) {
+  const url2 = readDaemonLock(lockPath)?.webUiUrl;
+  if (!url2) return null;
+  try {
+    const u = new URL(url2);
+    const isLoopback = u.hostname === "127.0.0.1" || u.hostname === "localhost" || u.hostname === "[::1]";
+    return u.protocol === "http:" && isLoopback ? u.origin : null;
+  } catch {
+    return null;
+  }
+}
+function daemonGeneralizer(workspaceRoot, opts = {}) {
+  const baseUrl = opts.baseUrl ?? (() => daemonLoopbackUrl());
+  const fetchFn = opts.fetchFn ?? fetch;
+  const timeoutMs = opts.timeoutMs ?? DAEMON_GENERALIZE_TIMEOUT_MS;
+  return async (text) => {
+    try {
+      const base = baseUrl();
+      if (!base) return void 0;
+      const res = await fetchFn(`${base}/api/generalize`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ workspaceRoot, text }),
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      if (!res.ok) return void 0;
+      const body2 = await res.json();
+      return typeof body2.generalized === "string" ? body2.generalized : void 0;
+    } catch {
+      return void 0;
+    }
+  };
+}
+var DAEMON_GENERALIZE_TIMEOUT_MS;
+var init_daemon_generalize_client = __esm({
+  "src/daemon-generalize-client.ts"() {
+    "use strict";
+    init_lock();
+    init_paths();
+    DAEMON_GENERALIZE_TIMEOUT_MS = 3e3;
+  }
+});
+
 // ../../packages/indexer/src/parse-cache.ts
 import { createHash as createHash6 } from "node:crypto";
 import { existsSync as existsSync15, mkdirSync as mkdirSync6, readFileSync as readFileSync14, readdirSync as readdirSync2, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync11 } from "node:fs";
@@ -44382,6 +44426,7 @@ async function runMcpServer(workspaceRoot, options = {}) {
   const store = openGraphStore({ path: paths.castalia });
   const handle2 = createMcpHandler(store, {
     ...buildToolContext(workspaceRoot),
+    generalizeSoft: daemonGeneralizer(workspaceRoot),
     sharedDbPath: sharedStorePath()
   }, options);
   process.stdin.setEncoding("utf8");
@@ -44427,6 +44472,7 @@ var init_mcp = __esm({
     init_src8();
     init_dual_burst();
     init_paths();
+    init_daemon_generalize_client();
     init_webui();
     init_reconcile();
     init_agent_signals();
@@ -44502,6 +44548,7 @@ var init_mcp = __esm({
             const dual = await dualAugment({
               store,
               cloud: ctx.cloud,
+              ...ctx.generalizeSoft ? { generalizeSoft: ctx.generalizeSoft } : {},
               localHits,
               queryText: query,
               limit
@@ -44681,6 +44728,7 @@ var init_mcp = __esm({
             const dual = await dualAugment({
               store,
               cloud: ctx.cloud,
+              ...ctx.generalizeSoft ? { generalizeSoft: ctx.generalizeSoft } : {},
               localHits,
               seedNode,
               limit: args2["limit"] != null ? Number(args2["limit"]) : 20
@@ -45252,6 +45300,7 @@ var init_mcp = __esm({
             const dual = await dualAugment({
               store,
               cloud: ctx.cloud,
+              ...ctx.generalizeSoft ? { generalizeSoft: ctx.generalizeSoft } : {},
               localHits,
               seedNode: node2,
               limit
@@ -82804,7 +82853,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.21-dev.3707" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.21-dev.3716" : "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;
@@ -86970,6 +87019,98 @@ var ConsolidateWorker = class {
   }
 };
 
+// src/generalize-worker-client.ts
+import { Worker as Worker3 } from "node:worker_threads";
+var GENERALIZE_WORKER_IDLE_MS = 30 * 6e4;
+var GeneralizeWorker = class {
+  worker = null;
+  ready = null;
+  pending = /* @__PURE__ */ new Map();
+  nextId = 1;
+  stopped = false;
+  idleTimer = null;
+  async generalize(castaliaPath, text) {
+    if (this.stopped) throw new Error("generalize worker stopped");
+    this.ensureWorker();
+    this.touch();
+    await this.ready;
+    const id = this.nextId++;
+    return new Promise((resolve10, reject) => {
+      this.pending.set(id, { resolve: resolve10, reject });
+      const req = { id, castaliaPath, text };
+      this.worker.postMessage(req);
+    });
+  }
+  touch() {
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    this.idleTimer = setTimeout(() => {
+      if (this.pending.size > 0) return this.touch();
+      const w = this.worker;
+      this.worker = null;
+      this.ready = null;
+      void w?.terminate().catch(() => {
+      });
+    }, GENERALIZE_WORKER_IDLE_MS);
+    this.idleTimer.unref?.();
+  }
+  ensureWorker() {
+    if (this.worker) return;
+    const worker = new Worker3(new URL("./generalize-worker.mjs", import.meta.url), {
+      workerData: {},
+      execArgv: process.execArgv,
+      resourceLimits: workerResourceLimits()
+    });
+    noteIsolateSpawned();
+    this.worker = worker;
+    this.ready = new Promise((resolve10, reject) => {
+      const onReady = (m) => {
+        if (m?.ready) {
+          worker.off("message", onReady);
+          worker.off("error", onErr);
+          resolve10();
+        }
+      };
+      const onErr = (err2) => {
+        worker.off("message", onReady);
+        reject(err2);
+      };
+      worker.once("error", onErr);
+      worker.on("message", onReady);
+    });
+    worker.on("message", (m) => {
+      if (typeof m?.id !== "number") return;
+      const p = this.pending.get(m.id);
+      if (!p) return;
+      this.pending.delete(m.id);
+      if (m.ok && typeof m.result === "string") p.resolve(m.result);
+      else p.reject(new Error(m.error ?? "generalization failed"));
+    });
+    const onGone = (err2) => {
+      const e = err2 instanceof Error ? err2 : new Error("generalize worker exited");
+      for (const [, p] of this.pending) p.reject(e);
+      this.pending.clear();
+      if (this.worker === worker) {
+        this.worker = null;
+        this.ready = null;
+      }
+    };
+    worker.on("error", onGone);
+    worker.on("exit", () => {
+      noteIsolateExited();
+      onGone();
+    });
+  }
+  async stop() {
+    this.stopped = true;
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    if (this.worker) {
+      await this.worker.terminate().catch(() => {
+      });
+      this.worker = null;
+    }
+  }
+};
+
 // src/prepare-store.ts
 init_src5();
 async function prepareStore(path2, root, workspaceId2) {
@@ -89925,6 +90066,7 @@ async function startMultiDaemon(opts = {}) {
   const sharedStore = openGraphStore({ path: sharedDbPath });
   const bundledRun = import.meta.url.endsWith(".mjs");
   const consolidateWorker = bundledRun && sharedDbPath !== ":memory:" ? new ConsolidateWorker() : null;
+  const generalizeWorker = bundledRun ? new GeneralizeWorker() : null;
   startLoopLagMonitor();
   let baseUrl = "";
   const records = [];
@@ -91612,6 +91754,7 @@ async function startMultiDaemon(opts = {}) {
         await Promise.allSettled(attaching.values());
         for (const r of records) await r.engine.stop();
         if (consolidateWorker) await consolidateWorker.stop();
+        if (generalizeWorker) await generalizeWorker.stop();
         try {
           sharedStore.close();
         } catch {
@@ -91640,6 +91783,33 @@ async function startMultiDaemon(opts = {}) {
     }
   });
   app.get("/api/sync", (c) => c.json(flushSnapshot()));
+  const GENERALIZE_MAX_CHARS = 8e3;
+  app.post("/api/generalize", async (c) => {
+    const host = (c.req.header("host") ?? "").toLowerCase();
+    if (!/^(127\.0\.0\.1|localhost|\[::1\])(:\d+)?$/.test(host)) return c.json({ error: "forbidden" }, 403);
+    if (!(c.req.header("content-type") ?? "").toLowerCase().startsWith("application/json")) {
+      return c.json({ error: "json required" }, 415);
+    }
+    let body2;
+    try {
+      body2 = await c.req.json();
+    } catch {
+      return c.json({ error: "bad json" }, 400);
+    }
+    if (typeof body2.workspaceRoot !== "string" || typeof body2.text !== "string") {
+      return c.json({ error: "workspaceRoot and text required" }, 400);
+    }
+    if (body2.text.length > GENERALIZE_MAX_CHARS) return c.json({ error: "text too long" }, 413);
+    const entry = workspaceEntryForPath(pathResolve(body2.workspaceRoot));
+    if (!entry) return c.json({ error: "unregistered workspace" }, 404);
+    if (!generalizeWorker) return c.json({ error: "no worker" }, 503);
+    try {
+      const generalized = await generalizeWorker.generalize(workspacePaths(entry.path).castalia, body2.text);
+      return c.json({ generalized });
+    } catch (err2) {
+      return c.json({ error: err2 instanceof Error ? err2.message : String(err2) }, 503);
+    }
+  });
   app.post("/api/tick", async (c) => {
     try {
       return c.json({ reports: Object.fromEntries(await daemon.tickAll()) });