kibi-runtime 2.0.1 → 2.0.2

package/dist/engine-daemon.js

@@ -385,7 +385,7 @@ function unquoteAtom(value) {
 
 // ../cli/src/prolog.ts
 var importMetaDir = path.dirname(fileURLToPath(import.meta.url));
-var PROLOG_OUTPUT_MAX_BUFFER_BYTES = 8 * 1024 * 1024;
+var DEFAULT_PROLOG_OUTPUT_MAX_BUFFER_BYTES = 8 * 1024 * 1024;
 var PROLOG_OUTPUT_OVERFLOW_ERROR = "Query exceeded bounded Prolog output capacity (ENOBUFS); narrow the operation or reduce stored entity size";
 var INTERACTIVE_QUERY_FRAME_END = "__KIBI_QUERY_FRAME_END__";
 var require2 = createRequire2(import.meta.url);
@@ -426,6 +426,16 @@ function resolveKbPlPath() {
   }
   throw new Error("Unable to resolve kb.pl. Expected kibi-core to be installed (node_modules) " + "or to be running inside the monorepo checkout.");
 }
+
+class PrologProcessTerminatedError extends Error {
+  code = "prolog_process_terminated";
+  reason;
+  constructor(reason) {
+    super(`Kibi Prolog process is no longer running (${reason}); the interactive session and its attached KB were lost. The owning engine must restart it before serving more queries — run 'kibi engine stop' and retry if this persists.`);
+    this.name = "PrologProcessTerminatedError";
+    this.reason = reason;
+  }
+}
 function registerProcessExitOnce(current, handler, on = (event, listener) => process.on(event, listener)) {
   if (current)
     return current;
@@ -454,19 +464,32 @@ class PrologProcess {
   useOneShotMode;
   attachedKbPath = null;
   onProcessExit = null;
+  maxOutputBytes;
+  interactiveStarted = false;
+  terminationReason = null;
   constructor(options = {}) {
     this.swiplPath = options.swiplPath || "swipl";
     this.timeout = options.timeout || 30000;
+    this.maxOutputBytes = options.maxOutputBytes !== undefined && Number.isInteger(options.maxOutputBytes) && options.maxOutputBytes > 0 ? options.maxOutputBytes : DEFAULT_PROLOG_OUTPUT_MAX_BUFFER_BYTES;
     this.useOneShotMode = options.oneShot ?? false;
   }
   attachProcessExitHandler(on = (event, listener) => process.on(event, listener)) {
     this.onProcessExit = bindProcessExitHandler(this.onProcessExit, () => this.terminate(), on);
   }
+  get oneShotMode() {
+    return this.useOneShotMode || !this.interactiveStarted;
+  }
+  needsRestart() {
+    return this.interactiveStarted && !this.isProcessUsable();
+  }
   async start() {
     if (!existsSync(this.swiplPath) && this.swiplPath !== "swipl") {
       throw new Error(`SWI-Prolog not found at ${this.swiplPath}. Please install SWI-Prolog or check your PATH.`);
     }
     const kbPath = resolveKbPlPath();
+    this.interactiveStarted = true;
+    this.terminationReason = null;
+    this.invalidateCache();
     this.process = spawn(this.swiplPath, [
       "-g",
       `use_module('${kbPath}'), use_module(library(semweb/rdf_db)), set_prolog_flag(answer_write_options, [max_depth(0), quoted(true)])`,
@@ -490,6 +513,12 @@ class PrologProcess {
     this.process.stderr.on("data", (chunk) => {
       this.appendErrorChunk(chunk);
     });
+    const child = this.process;
+    child.stdin?.on("error", (error) => {
+      if (this.process === child) {
+        this.terminationReason ??= `stdin ${error.code ?? "error"}`;
+      }
+    });
     this.process.stdin.write(`true.
 `);
     this.attachProcessExitHandler();
@@ -543,10 +572,10 @@ class PrologProcess {
       return this.query(batchGoal);
     }
     if (!this.isProcessUsable()) {
-      if (this.process === null) {
+      if (this.process === null && !this.interactiveStarted) {
         return this.execOneShot(goal, this.attachedKbPath);
       }
-      throw new Error("Prolog process not started");
+      throw this.lostProcessError();
     }
     const runInteractiveQuery = async () => {
       this.clearQueryBuffers();
@@ -576,6 +605,7 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
             console.error(`[prolog debug] runtime=${runtime ?? "unknown"} packages=${process.env.KIBI_PACKAGE_VERSIONS ?? KIBI_PACKAGE_VERSIONS}`);
           }
           settled = true;
+          this.terminationReason = `query timeout: ${goalLabel}`;
           this.terminate().finally(() => {
             reject(new Error(msg));
           });
@@ -587,6 +617,7 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
           if (this.outputOverflowed) {
             clearTimeout(timeoutId);
             settled = true;
+            this.terminationReason = `output overflow (ENOBUFS): ${goalLabel}`;
             this.terminate().finally(() => {
               resolve({
                 success: false,
@@ -599,6 +630,7 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
           if (!this.isProcessUsable()) {
             clearTimeout(timeoutId);
             settled = true;
+            this.terminationReason ??= `process exited during query: ${goalLabel}`;
             resolve({
               success: false,
               bindings: {},
@@ -666,7 +698,7 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
     await previousQuery;
     try {
       if (!this.isProcessUsable()) {
-        throw new Error("Prolog process not started");
+        throw this.lostProcessError();
       }
       return await runInteractiveQuery();
     } finally {
@@ -784,7 +816,7 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
       if (outputOverflowed)
         return;
       const bytes = target === "stdout" ? outputBytes : errorBytes;
-      const remaining = PROLOG_OUTPUT_MAX_BUFFER_BYTES - bytes;
+      const remaining = this.maxOutputBytes - bytes;
       if (chunk.byteLength > remaining) {
         const clipped = chunk.subarray(0, Math.max(0, remaining)).toString();
         if (target === "stdout")
@@ -897,10 +929,10 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
   appendOutputChunk(chunk) {
     if (this.outputOverflowed)
       return;
-    const remaining = PROLOG_OUTPUT_MAX_BUFFER_BYTES - this.outputBufferBytes;
+    const remaining = this.maxOutputBytes - this.outputBufferBytes;
     if (chunk.byteLength > remaining) {
       this.outputBuffer += chunk.subarray(0, remaining).toString();
-      this.outputBufferBytes = PROLOG_OUTPUT_MAX_BUFFER_BYTES;
+      this.outputBufferBytes = this.maxOutputBytes;
       this.outputOverflowed = true;
       return;
     }
@@ -910,10 +942,10 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
   appendErrorChunk(chunk) {
     if (this.outputOverflowed)
       return;
-    const remaining = PROLOG_OUTPUT_MAX_BUFFER_BYTES - this.errorBufferBytes;
+    const remaining = this.maxOutputBytes - this.errorBufferBytes;
     if (chunk.byteLength > remaining) {
       this.errorBuffer += chunk.subarray(0, remaining).toString();
-      this.errorBufferBytes = PROLOG_OUTPUT_MAX_BUFFER_BYTES;
+      this.errorBufferBytes = this.maxOutputBytes;
       this.outputOverflowed = true;
       return;
     }
@@ -1059,7 +1091,16 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
   getPid() {
     return this.process?.pid || 0;
   }
+  lostProcessError() {
+    if (!this.interactiveStarted) {
+      return new Error("Prolog process not started");
+    }
+    return new PrologProcessTerminatedError(this.terminationReason ?? "process exited");
+  }
   async terminate() {
+    if (this.interactiveStarted) {
+      this.terminationReason ??= "terminated";
+    }
     if (this.terminationPromise) {
       await this.terminationPromise;
       return;
@@ -1448,11 +1489,12 @@ function frame(value) {
   header.writeUInt32BE(payload.byteLength, 0);
   return Buffer.concat([header, payload]);
 }
+function ignoreWriteFailure() {}
 function writeSocketFrame(socket, value) {
   if (socket.destroyed || !socket.writable)
     return;
   try {
-    socket.write(frame(value));
+    socket.write(frame(value), ignoreWriteFailure);
   } catch {}
 }
 function parseFrames(buffer, onFrame) {
@@ -1756,32 +1798,88 @@ function recoverInterruptedGeneration(branchPath) {
     } catch {}
   }
 }
+function isEngineLifecycleRequest(request) {
+  if (request.method === "stop" || request.method === "cancel")
+    return true;
+  const kind = request.command?.kind;
+  return request.method === "command" && (kind === "stop" || kind === "cancel" || kind === "lifecycle");
+}
+var ENGINE_PRELOADED_MODULES = [
+  ["status.pl", "status"],
+  ["discovery.pl", "discovery"]
+];
+var USE_MODULE_GOAL = /^use_module\('(?:[^']|'')*'\)$/u;
+
+class EngineSession {
+  prolog;
+  branchPath;
+  modules = [];
+  constructor(prolog, branchPath) {
+    this.prolog = prolog;
+    this.branchPath = branchPath;
+    const coreModuleDir = path4.dirname(resolveKbPlPath());
+    for (const [fileName, label] of ENGINE_PRELOADED_MODULES) {
+      const modulePath = path4.join(coreModuleDir, fileName);
+      this.modules.push({
+        goal: `use_module('${quoteProlog(modulePath.replaceAll("\\", "/"))}')`,
+        label
+      });
+    }
+  }
+  async boot() {
+    await this.prolog.start();
+    const attached = await this.prolog.query(`kb_attach('${quoteProlog(this.branchPath)}')`);
+    if (!attached.success) {
+      const recovered = await retryAttachAfterBreakingStaleLock(this.prolog, this.branchPath, attached);
+      if (!recovered.success)
+        throw new Error(recovered.error ?? "Failed to attach branch KB");
+    }
+    for (const { goal, label } of this.modules) {
+      const loaded = await this.prolog.query(goal);
+      if (!loaded.success) {
+        throw new Error(loaded.error ?? `Failed to load Kibi ${label} module`);
+      }
+    }
+  }
+  recordModuleLoad(goal, result) {
+    const normalized = goal.trim().replace(/\.+\s*$/u, "");
+    if (result.success && USE_MODULE_GOAL.test(normalized) && !this.modules.some((module) => module.goal === normalized)) {
+      this.modules.push({ goal: normalized, label: "client-loaded" });
+    }
+  }
+  needsRecycle() {
+    return this.prolog.needsRestart();
+  }
+  async ensureLive() {
+    if (!this.prolog.needsRestart())
+      return false;
+    console.error("[KIBI] engine Prolog session was lost (output overflow, timeout, or crash); restarting and reattaching the branch store");
+    try {
+      await this.boot();
+    } catch (error) {
+      await this.prolog.terminate().catch(() => {
+        return;
+      });
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Kibi engine failed to recycle its Prolog session: ${message}`);
+    }
+    return true;
+  }
+}
 async function runEngineDaemon(options) {
   if (!isValidBranchName(options.branch)) {
     throw new Error(`Invalid Kibi engine branch name: ${options.branch}`);
   }
   const branchPath = ensureBranchStoreManifest(options.workspaceRoot, options.branch);
   await ensureJournaledBranchStoreAsync(branchPath);
-  const prolog = new PrologProcess({ timeout: 120000, oneShot: false });
-  await prolog.start();
-  const attached = await prolog.query(`kb_attach('${quoteProlog(branchPath)}')`);
-  if (!attached.success) {
-    const recovered = await retryAttachAfterBreakingStaleLock(prolog, branchPath, attached);
-    if (!recovered.success)
-      throw new Error(recovered.error ?? "Failed to attach branch KB");
-  }
-  const attachedIdentity = readEngineAttachmentIdentity(branchPath);
-  const coreModuleDir = path4.dirname(resolveKbPlPath());
-  for (const [fileName, label] of [
-    ["status.pl", "status"],
-    ["discovery.pl", "discovery"]
-  ]) {
-    const modulePath = path4.join(coreModuleDir, fileName);
-    const loaded = await prolog.query(`use_module('${quoteProlog(modulePath.replaceAll("\\", "/"))}')`);
-    if (!loaded.success) {
-      throw new Error(loaded.error ?? `Failed to load Kibi ${label} module`);
-    }
-  }
+  const prolog = new PrologProcess({
+    timeout: 120000,
+    oneShot: false,
+    ...options.maxOutputBytes === undefined ? {} : { maxOutputBytes: options.maxOutputBytes }
+  });
+  const session = new EngineSession(prolog, branchPath);
+  await session.boot();
+  let attachedIdentity = readEngineAttachmentIdentity(branchPath);
   mkdirSync2(path4.dirname(options.socketPath), { recursive: true, mode: 448 });
   if (existsSync4(options.socketPath)) {
     const isLivePeerSignal = (error) => {
@@ -1880,7 +1978,7 @@ async function runEngineDaemon(options) {
     if (!idleCompactionQueued) {
       idleCompactionQueued = true;
       queue = queue.then(async () => {
-        if (activeClients === 0) {
+        if (activeClients === 0 && !session.needsRecycle()) {
           await prolog.query("kb_storage_compact_if_needed");
         }
       }).catch(() => {
@@ -1907,6 +2005,11 @@ async function runEngineDaemon(options) {
     if (path4.resolve(request.workspaceRoot ?? "") !== path4.resolve(options.workspaceRoot) || request.branch !== options.branch) {
       throw new Error("Kibi engine workspace identity mismatch");
     }
+    if (!isEngineLifecycleRequest(request) && await session.ensureLive()) {
+      queryCache.clear();
+      freshnessCache = null;
+      attachedIdentity = readEngineAttachmentIdentity(branchPath);
+    }
     switch (request.method) {
       case "entities": {
         const limit = request.limit ?? 100;
@@ -2067,6 +2170,7 @@ async function runEngineDaemon(options) {
             return cached;
         }
         const result = await prolog.query(request.goal);
+        session.recordModuleLoad(request.goal, result);
         if (result.success && mutatingEngineGoal(request.goal)) {
           fsyncJournaledBranchStore(branchPath);
         }
@@ -2119,7 +2223,7 @@ async function runEngineDaemon(options) {
     if (idleTimer)
       clearTimeout(idleTimer);
     clearInterval(workspaceWatchdog);
-    const saved = await prolog.query("kb_save").catch(() => null);
+    const saved = session.needsRecycle() ? null : await prolog.query("kb_save").catch(() => null);
     if (saved?.success) {
       try {
         fsyncJournaledBranchStore(branchPath);

package/dist/index.d.ts

@@ -30,7 +30,8 @@ export { RULE_NAMES, RULES, getCanonicalRules, getDefaultRules, getEffectiveRule
 export type { RuleDefinition, RuleEnforcementClass, StrictWriteSet, Violation, } from "kibi-cli/public/check-types";
 export type { ChangedFileImpactResult, QualityDiagnostic, } from "kibi-cli/public/impact-diagnostics";
 export { branchStorePath, branchStoreManifestPath, branchStoresRoot, branchStoreKey, resolveActiveBranch, resolveBranchAttachment, isValidBranchName, copyCleanSnapshot, ensureBranchStoreManifest, getBranchDiagnostic, } from "kibi-cli/public/branch-resolver";
-export { KIBI_PROTOCOL_VERSION, operationData, resultVersion, toKibiResult, } from "kibi-cli/operations/result-envelope";
+export { KIBI_PROTOCOL_VERSION, appendPayloadCountField, normalizeResultPayload, operationData, resultVersion, toKibiResult, } from "kibi-cli/operations/result-envelope";
+export type { NormalizedResultPayload } from "kibi-cli/operations/result-envelope";
 export * from "kibi-cli/public/branch-resolver";
 export { EngineClient, engineSocketPath } from "kibi-cli/engine";
 export { PrologProcess, resolveKbPlPath } from "kibi-cli/prolog";