@xaccefy/pi-casefile 0.9.0 → 0.9.2

package/src/ledger-worker-entry.ts

@@ -0,0 +1,35 @@
+/**
+ * Worker-thread entry for heavy ledger reads (suggestChains, writeCaseContext).
+ *
+ * Runs in a dedicated thread so an O(n²) chain scan or a multi-megabyte
+ * context-bundle build never blocks the agent's event loop. Each call spawns
+ * a fresh worker — rare operations, no lifecycle to manage, no stale state.
+ * The worker opens its OWN connection to the same WAL database (read-mostly
+ * work + one small reportPath write); WAL + busy_timeout make multi-connection
+ * access safe.
+ */
+
+import { parentPort, workerData } from "node:worker_threads";
+import { suggestChains, writeCaseContext } from "./ledger.ts";
+import { setScratchpadRoot } from "./scratchpad.ts";
+
+process.env.PI_CASEFILE_PATH = workerData.casefilePath as string;
+setScratchpadRoot(workerData.workspaceRoot as string | undefined);
+
+type WorkerRequest =
+  | { op: "suggestChains"; caseId?: string }
+  | { op: "writeCaseContext"; id: string };
+
+parentPort?.on("message", (req: WorkerRequest) => {
+  try {
+    if (req.op === "suggestChains") {
+      parentPort?.postMessage({ ok: true, result: suggestChains(req.caseId) });
+    } else if (req.op === "writeCaseContext") {
+      parentPort?.postMessage({ ok: true, result: writeCaseContext(req.id) });
+    } else {
+      parentPort?.postMessage({ ok: false, error: `unknown ledger worker op` });
+    }
+  } catch (e) {
+    parentPort?.postMessage({ ok: false, error: (e as Error).message });
+  }
+});

package/src/ledger-worker.ts

@@ -0,0 +1,77 @@
+/**
+ * Async offload for the two heavy ledger reads — main-thread side.
+ *
+ * suggestChains is O(rules × cases²) over the whole ledger; writeCaseContext
+ * reads every artifact of every matching scratchpad run and builds a
+ * multi-hundred-KB bundle. Both ran synchronously inside async tool handlers,
+ * stalling the event loop. Each call here spawns a short-lived worker thread
+ * (ledger-worker-entry.ts) and falls back to the inline sync function when
+ * the worker cannot run (Node < 22.18 has no default type stripping for the
+ * TS entry) or times out. Writes stay sync on the main thread: they are
+ * single-row upserts, bounded by the 5s busy_timeout.
+ */
+
+import { Worker } from "node:worker_threads";
+import {
+  type CaseContextResult,
+  type ChainSuggestion,
+  getCasefilePath,
+  suggestChains,
+  writeCaseContext,
+} from "./ledger.ts";
+import { detectWorkspaceRoot } from "./scratchpad.ts";
+
+type WorkerResponse = { ok: true; result: unknown } | { ok: false; error: string };
+
+const WORKER_TIMEOUT_MS = 30_000;
+
+function runInLedgerWorker(
+  request:
+    | {
+        op: "suggestChains";
+        caseId?: string;
+      }
+    | {
+        op: "writeCaseContext";
+        id: string;
+      },
+): Promise<unknown> {
+  const { promise, resolve, reject } = Promise.withResolvers<unknown>();
+  const worker = new Worker(new URL("./ledger-worker-entry.ts", import.meta.url), {
+    workerData: { casefilePath: getCasefilePath(), workspaceRoot: detectWorkspaceRoot() },
+  });
+  const timer = setTimeout(() => {
+    void worker.terminate();
+    reject(new Error("ledger worker timed out"));
+  }, WORKER_TIMEOUT_MS);
+  worker.once("message", (msg: WorkerResponse) => {
+    clearTimeout(timer);
+    void worker.terminate();
+    if (msg.ok) resolve(msg.result);
+    else reject(new Error(msg.error));
+  });
+  worker.once("error", (e) => {
+    clearTimeout(timer);
+    reject(e);
+  });
+  worker.postMessage(request);
+  return promise;
+}
+
+/** suggestChains on a worker thread; inline fallback keeps behavior identical. */
+export async function suggestChainsAsync(caseId?: string): Promise<ChainSuggestion[]> {
+  try {
+    return (await runInLedgerWorker({ op: "suggestChains", caseId })) as ChainSuggestion[];
+  } catch {
+    return suggestChains(caseId);
+  }
+}
+
+/** writeCaseContext on a worker thread; inline fallback keeps behavior identical. */
+export async function writeCaseContextAsync(id: string): Promise<CaseContextResult> {
+  try {
+    return (await runInLedgerWorker({ op: "writeCaseContext", id })) as CaseContextResult;
+  } catch {
+    return writeCaseContext(id);
+  }
+}