kibi-cli 2.0.0 → 2.2.0

package/dist/engine.js

@@ -15,6 +15,7 @@ import { fileURLToPath } from "node:url";
 import { PrologProcess, resolveKbPlPath } from "./prolog.js";
 import { parseEntityFromList, parseListOfLists } from "./prolog/codec.js";
 import { retryAttachAfterBreakingStaleLock } from "./prolog/store-lock.js";
+import { queryEntityChunks } from "./public/operations/discovery-entities.js";
 import { isValidBranchName } from "./utils/branch-resolver.js";
 import { branchStorePath, ensureBranchStoreManifest, } from "./utils/branch-store-locator.js";
 export const ENGINE_PROTOCOL_VERSION = 1;
@@ -219,11 +220,19 @@ function frame(value) {
     header.writeUInt32BE(payload.byteLength, 0);
     return Buffer.concat([header, payload]);
 }
+/**
+ * Swallow a write failure for a peer that is already gone.
+ *
+ * A socket write reports EPIPE/ECONNRESET asynchronously, so a surrounding
+ * try/catch cannot see it and Node raises it as an unhandled error. Passing a
+ * callback keeps the failure local to this write.
+ */
+function ignoreWriteFailure() { }
 function writeSocketFrame(socket, value) {
     if (socket.destroyed || !socket.writable)
         return;
     try {
-        socket.write(frame(value));
+        socket.write(frame(value), ignoreWriteFailure);
     }
     catch {
         // A client may disconnect while a queued request is finishing. The
@@ -783,16 +792,26 @@ export class EngineClient {
         socket.on("close", () => {
             this.socket = null;
             const error = new Error("Kibi engine connection closed");
-            for (const pending of this.pending.values())
-                pending.reject(error);
+            for (const pending of this.pending.values()) {
+                this.settlePending(pending, () => pending.reject(error));
+            }
             this.pending.clear();
         });
         socket.on("error", (error) => {
-            for (const pending of this.pending.values())
-                pending.reject(error);
+            for (const pending of this.pending.values()) {
+                this.settlePending(pending, () => pending.reject(error));
+            }
             this.pending.clear();
         });
     }
+    /** Settle a pending RPC at most once (abort vs response race-safe). */
+    settlePending(pending, settle) {
+        if (pending.settled)
+            return false;
+        pending.settled = true;
+        settle();
+        return true;
+    }
     handleResponse(value) {
         if (value === null || typeof value !== "object")
             return;
@@ -803,55 +822,20 @@ export class EngineClient {
         if (!pending)
             return;
         this.pending.delete(response.id);
-        if (response.ok)
-            pending.resolve(response.result);
-        else
-            pending.reject(new Error(response.error ?? "Kibi engine request failed"));
+        if (response.ok) {
+            this.settlePending(pending, () => pending.resolve(response.result));
+        }
+        else {
+            this.settlePending(pending, () => pending.reject(new Error(response.error ?? "Kibi engine request failed")));
+        }
     }
     async request(request, signal) {
+        // Connect/reconcile before taking the client queue. Holding requestTail
+        // across start()→reconcileAttachment()→queryStatusJson() deadlocks because
+        // that nested status RPC needs the same queue (see command-first clients).
         await this.start();
-        const socket = this.socket;
-        if (socket === null || socket.destroyed)
-            throw new Error("Kibi engine is not connected");
-        const id = ++this.requestId;
-        const result = new Promise((resolve, reject) => {
-            this.pending.set(id, {
-                resolve: resolve,
-                reject,
-            });
-            try {
-                socket.write(frame({
-                    ...request,
-                    id,
-                    protocolVersion: ENGINE_PROTOCOL_VERSION,
-                    packageVersions: ENGINE_PACKAGE_VERSIONS,
-                    workspaceRoot: this.workspaceRoot,
-                    branch: this.branch,
-                }));
-            }
-            catch (error) {
-                this.pending.delete(id);
-                reject(error instanceof Error ? error : new Error(String(error)));
-                return;
-            }
-            if (signal !== undefined) {
-                const abort = () => {
-                    if (!this.pending.has(id))
-                        return;
-                    this.pending.delete(id);
-                    this.cancel(id);
-                    reject(new Error("Kibi engine request cancelled"));
-                };
-                if (signal.aborted)
-                    abort();
-                else
-                    signal.addEventListener("abort", abort, { once: true });
-            }
-        });
-        return result;
-    }
-    async query(goal, signal) {
-        let result;
+        // Serialize query and command frames on one socket so concurrent MCP
+        // traffic cannot interleave length-prefixed writes/responses.
         const previous = this.requestTail;
         let release;
         this.requestTail = new Promise((resolve) => {
@@ -859,14 +843,59 @@ export class EngineClient {
         });
         await previous;
         try {
-            result = await this.request({ method: "query", goal }, signal);
-            this.lastResult = result;
-            return result;
+            const socket = this.socket;
+            if (socket === null || socket.destroyed)
+                throw new Error("Kibi engine is not connected");
+            const id = ++this.requestId;
+            return await new Promise((resolve, reject) => {
+                this.pending.set(id, {
+                    resolve: resolve,
+                    reject,
+                    settled: false,
+                });
+                try {
+                    socket.write(frame({
+                        ...request,
+                        id,
+                        protocolVersion: ENGINE_PROTOCOL_VERSION,
+                        packageVersions: ENGINE_PACKAGE_VERSIONS,
+                        workspaceRoot: this.workspaceRoot,
+                        branch: this.branch,
+                    }), ignoreWriteFailure);
+                }
+                catch (error) {
+                    const pending = this.pending.get(id);
+                    this.pending.delete(id);
+                    if (pending) {
+                        this.settlePending(pending, () => reject(error instanceof Error ? error : new Error(String(error))));
+                    }
+                    return;
+                }
+                if (signal !== undefined) {
+                    const abort = () => {
+                        const pending = this.pending.get(id);
+                        if (!pending || pending.settled)
+                            return;
+                        this.pending.delete(id);
+                        this.cancel(id);
+                        this.settlePending(pending, () => reject(new Error("Kibi engine request cancelled")));
+                    };
+                    if (signal.aborted)
+                        abort();
+                    else
+                        signal.addEventListener("abort", abort, { once: true });
+                }
+            });
         }
         finally {
             release();
         }
     }
+    async query(goal, signal) {
+        const result = await this.request({ method: "query", goal }, signal);
+        this.lastResult = result;
+        return result;
+    }
     /** Execute a versioned, goal-free engine command. Raw query remains private
      * compatibility traffic for the in-process Prolog adapter only. */
     async command(command, signal) {
@@ -877,6 +906,11 @@ export class EngineClient {
         return this.query(`rdf_transaction((${normalized.join(", ")}))`);
     }
     async queryEntities(input, signal) {
+        // Full entities carry receipt histories; a caller-sized page (up to 100k
+        // rows) is split into bounded engine requests.
+        return queryEntityChunks((chunk) => this.queryEntityChunk(chunk, signal), input);
+    }
+    async queryEntityChunk(input, signal) {
         const result = await this.command({
             version: 1,
             kind: "entities",
@@ -936,7 +970,7 @@ export class EngineClient {
             packageVersions: ENGINE_PACKAGE_VERSIONS,
             workspaceRoot: this.workspaceRoot,
             branch: this.branch,
-        }));
+        }), ignoreWriteFailure);
     }
     async nextSolution() {
         const result = this.lastResult;
@@ -952,8 +986,8 @@ export class EngineClient {
     async checkpoint() {
         return this.command({ version: 1, kind: "checkpoint" });
     }
-    async queryStatusJson() {
-        return this.command({ version: 1, kind: "status" });
+    async queryStatusJson(signal) {
+        return this.command({ version: 1, kind: "status" }, signal);
     }
     async compact() {
         return this.command({ version: 1, kind: "compact" });
@@ -1266,6 +1300,92 @@ function recoverInterruptedGeneration(branchPath) {
         }
     }
 }
+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"));
+}
+const ENGINE_PRELOADED_MODULES = [
+    ["status.pl", "status"],
+    ["discovery.pl", "discovery"],
+];
+const USE_MODULE_GOAL = /^use_module\('(?:[^']|'')*'\)$/u;
+/**
+ * Owns the daemon's interactive SWI session: the attached branch store plus
+ * every module loaded into it. An overflow or timeout terminates the SWI
+ * child; the next request recycles the session (restart, reattach, reload
+ * modules) instead of letting the port degrade into isolated one-shot
+ * processes that have lost the attachment and module state.
+ */
+// implements REQ-core-journaled-engine-persistence
+export class EngineSession {
+    prolog;
+    branchPath;
+    modules = [];
+    constructor(prolog, branchPath) {
+        this.prolog = prolog;
+        this.branchPath = branchPath;
+        const coreModuleDir = path.dirname(resolveKbPlPath());
+        for (const [fileName, label] of ENGINE_PRELOADED_MODULES) {
+            const modulePath = path.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) {
+            // The daemon hosts the branch store for every later request, so a
+            // store-locked startup with a provably dead holder is auto-healed here
+            // exactly like the CLI runtime path; live holders abort the startup
+            // with the holder identity surfaced.
+            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`);
+            }
+        }
+    }
+    /** Remember a successful client module load so a recycle restores it. */
+    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();
+    }
+    /**
+     * Restart a lost interactive session. Returns true when a recycle ran. A
+     * failed recycle leaves the process stopped so the next request retries.
+     */
+    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(() => undefined);
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Kibi engine failed to recycle its Prolog session: ${message}`);
+        }
+        return true;
+    }
+}
 // implements REQ-core-journaled-engine-lifecycle
 export async function runEngineDaemon(options) {
     if (!isValidBranchName(options.branch)) {
@@ -1273,42 +1393,67 @@ export async function runEngineDaemon(options) {
     }
     const branchPath = ensureBranchStoreManifest(options.workspaceRoot, options.branch);
     await ensureJournaledBranchStoreAsync(branchPath);
-    const prolog = new PrologProcess({ timeout: 120_000, oneShot: false });
-    await prolog.start();
-    const attached = await prolog.query(`kb_attach('${quoteProlog(branchPath)}')`);
-    if (!attached.success) {
-        // The daemon hosts the branch store for every later request, so a
-        // store-locked startup with a provably dead holder is auto-healed here
-        // exactly like the CLI runtime path; live holders abort the startup
-        // with the holder identity surfaced.
-        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 = path.dirname(resolveKbPlPath());
-    for (const [fileName, label] of [
-        ["status.pl", "status"],
-        ["discovery.pl", "discovery"],
-    ]) {
-        const modulePath = path.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: 120_000,
+        oneShot: false,
+        ...(options.maxOutputBytes === undefined
+            ? {}
+            : { maxOutputBytes: options.maxOutputBytes }),
+    });
+    const session = new EngineSession(prolog, branchPath);
+    await session.boot();
+    let attachedIdentity = readEngineAttachmentIdentity(branchPath);
     mkdirSync(path.dirname(options.socketPath), { recursive: true, mode: 0o700 });
     if (existsSync(options.socketPath)) {
+        const isLivePeerSignal = (error) => {
+            if (error && typeof error === "object") {
+                const code = "code" in error ? String(error.code) : "";
+                if (code === "EPIPE" || code === "ECONNRESET")
+                    return true;
+                const errno = "errno" in error
+                    ? Number(error.errno)
+                    : Number.NaN;
+                // POSIX EPIPE
+                if (errno === -32)
+                    return true;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            return /\bEPIPE\b|\bECONNRESET\b|broken pipe/i.test(message);
+        };
         let live = false;
         try {
             const existing = await connectSocket(options.socketPath, 100);
-            existing.destroy();
+            // Keep a permanent error sink. Bun 1.4 can surface write EPIPE from
+            // teardown into the caller promise on some CI runners, replacing the
+            // intended live-listener error.
+            existing.on("error", () => undefined);
             live = true;
+            try {
+                existing.destroy();
+            }
+            catch {
+                // Ignore destroy races; live detection already succeeded.
+            }
+            existing.unref?.();
         }
-        catch {
-            // A refused connection means this is a stale filesystem socket.
+        catch (error) {
+            // Bun 1.4 can reject the probe with EPIPE/ECONNRESET against a live
+            // unix listener instead of resolving connect.
+            if (isLivePeerSignal(error)) {
+                live = true;
+            }
+            // Otherwise a refused connection means a stale filesystem socket.
         }
         if (live) {
+            try {
+                await prolog.terminate();
+            }
+            catch (error) {
+                // Best-effort cleanup; Bun may surface late EPIPE here too.
+                if (!isLivePeerSignal(error)) {
+                    // Ignore non-EPIPE terminate failures.
+                }
+            }
             throw new Error(`A Kibi engine is already listening at ${options.socketPath}`);
         }
         try {
@@ -1326,7 +1471,6 @@ export async function runEngineDaemon(options) {
     let idleCompactionQueued = false;
     const queryCache = new Map();
     let freshnessCache = null;
-    const cancelledRequests = new Set();
     const clients = new Set();
     let shuttingDown = false;
     const exactBranchStatus = (result) => {
@@ -1382,7 +1526,8 @@ export async function runEngineDaemon(options) {
             idleCompactionQueued = true;
             queue = queue
                 .then(async () => {
-                if (activeClients === 0) {
+                // A lost session is recycled by the next request, not by idle work.
+                if (activeClients === 0 && !session.needsRecycle()) {
                     await prolog.query("kb_storage_compact_if_needed");
                 }
             })
@@ -1398,7 +1543,7 @@ export async function runEngineDaemon(options) {
                 void shutdown();
         }, engineIdleTimeoutMs());
     };
-    const handle = async (request) => {
+    const handle = async (request, cancelledRequests) => {
         if (request.protocolVersion !== ENGINE_PROTOCOL_VERSION) {
             throw new Error(`Kibi engine protocol mismatch: client=${request.protocolVersion ?? "missing"}, server=${ENGINE_PROTOCOL_VERSION}`);
         }
@@ -1412,6 +1557,13 @@ export async function runEngineDaemon(options) {
             request.branch !== options.branch) {
             throw new Error("Kibi engine workspace identity mismatch");
         }
+        if (!isEngineLifecycleRequest(request) && (await session.ensureLive())) {
+            // A recycled session re-read the store; nothing cached from the lost
+            // session may be served, and the attachment identity may have moved.
+            queryCache.clear();
+            freshnessCache = null;
+            attachedIdentity = readEngineAttachmentIdentity(branchPath);
+        }
         switch (request.method) {
             case "entities": {
                 const limit = request.limit ?? 100;
@@ -1621,6 +1773,7 @@ export 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);
                 }
@@ -1661,6 +1814,13 @@ export async function runEngineDaemon(options) {
                 setImmediate(() => void shutdown());
                 return { stopped: true };
             case "cancel":
+                // Best-effort: marks the id so a *queued* request on this connection
+                // is skipped before handle(). A request already inside
+                // `await prolog.query(...)` cannot be interrupted without redesigning
+                // SWI interactive cancellation; the client still rejects locally on
+                // AbortSignal, but the daemon queue remains occupied until that Prolog
+                // call returns. Cancel marks are per-connection. See
+                // docs/mcp-reference.md ("Engine cancellation limits").
                 if (typeof request.cancelOf === "number") {
                     cancelledRequests.add(request.cancelOf);
                 }
@@ -1676,7 +1836,9 @@ export 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);
@@ -1720,6 +1882,9 @@ export async function runEngineDaemon(options) {
     server.on("connection", (socket) => {
         clients.add(socket);
         activeClients += 1;
+        // Request ids are per-connection. Cancel marks must not be daemon-global
+        // or Client B's id=1 is poisoned by Client A's cancelOf=1.
+        const cancelledRequests = new Set();
         let buffer = Buffer.alloc(0);
         socket.on("data", (chunk) => {
             try {
@@ -1742,7 +1907,7 @@ export async function runEngineDaemon(options) {
                             return;
                         }
                         try {
-                            const result = await handle(request);
+                            const result = await handle(request, cancelledRequests);
                             writeSocketFrame(socket, {
                                 id: request.id,
                                 ok: true,
@@ -1758,6 +1923,11 @@ export async function runEngineDaemon(options) {
                                 serverPackageVersions: ENGINE_PACKAGE_VERSIONS,
                             });
                         }
+                        finally {
+                            // Drop stale cancel marks for in-flight goals that still ran
+                            // to completion after cancelOf (SWI cannot interrupt them).
+                            cancelledRequests.delete(request.id);
+                        }
                     })
                         .catch(() => undefined);
                 });

package/dist/env/bootstrap.d.ts

@@ -0,0 +1,84 @@
+/** Preferred project-local Kibi env file (harness-independent). */
+export declare const KIBI_PROJECT_ENV_FILE = ".env.kibi";
+/** Legacy generic dotenv still loaded for compatibility only. */
+export declare const KIBI_LEGACY_ENV_FILE = ".env";
+export type EnvValueSource = "process" | "project_env" | "user_env" | "legacy_env" | "missing";
+export type BootstrapKibiEnvironmentResult = Readonly<{
+    workspaceRoot: string;
+    userEnvPath: string;
+    projectEnvPath: string;
+    legacyEnvPath: string;
+    /** Attribution for keys present after bootstrap (never includes secret values). */
+    sources: Readonly<Record<string, EnvValueSource>>;
+    keysLoadedFromUser: readonly string[];
+    keysLoadedFromProject: readonly string[];
+    keysLoadedFromLegacy: readonly string[];
+}>;
+export type BootstrapKibiEnvironmentOptions = Readonly<{
+    env?: NodeJS.ProcessEnv;
+    startDir?: string;
+    homedir?: string;
+    /** Override XDG config home (defaults to env.XDG_CONFIG_HOME). */
+    xdgConfigHome?: string;
+    /**
+     * Keys that were non-empty on the real process before any Kibi file load.
+     * Callers normally omit this; the first default-env bootstrap remembers it.
+     */
+    initialNonEmptyProcessKeys?: ReadonlySet<string>;
+}>;
+type EnvEntry = Readonly<{
+    key: string;
+    value: string;
+}>;
+/**
+ * Test-only: clear remembered process-key snapshot and last bootstrap result.
+ */
+export declare function resetKibiEnvironmentBootstrapStateForTests(): void;
+/**
+ * Last bootstrap against the real `process.env`, if any.
+ */
+export declare function getLastBootstrapResult(): BootstrapKibiEnvironmentResult | null;
+/**
+ * Canonical workspace root for Kibi env files and KB attachment.
+ * Uses KIBI_WORKSPACE / KIBI_PROJECT_ROOT / KIBI_ROOT, then .kb / .git discovery.
+ */
+export declare function resolveKibiWorkspaceRoot(startDir?: string, env?: NodeJS.ProcessEnv): string;
+export declare function resolveEnvFilePath(envFileName: string, workspaceRoot: string): string;
+/** User-wide Kibi env file: $XDG_CONFIG_HOME/kibi/env or ~/.config/kibi/env. */
+export declare function resolveKibiUserEnvPath(options?: Readonly<{
+    homedir?: string;
+    xdgConfigHome?: string;
+    env?: NodeJS.ProcessEnv;
+}>): string;
+export declare function resolveKibiProjectEnvPath(workspaceRoot: string, env?: NodeJS.ProcessEnv): string;
+export declare function parseEnvContent(content: string): EnvEntry[];
+/**
+ * Load Kibi-owned env files into `process.env` (or an injectable env object).
+ * Blank values are treated as unset (never applied, never overwrite).
+ * Existing non-empty process keys are never overwritten. Project overrides user.
+ * Legacy `.env` only gap-fills and is attributed as `legacy_env`.
+ * Call only from CLI/MCP entrypoints — not on library import.
+ */
+export declare function bootstrapKibiEnvironment(options?: BootstrapKibiEnvironmentOptions): BootstrapKibiEnvironmentResult;
+/**
+ * Resolve a secret source label from an actual bootstrap result.
+ * Never reconstructs attribution by re-reading files alone.
+ */
+export declare function secretSourceFromBootstrap(key: string, bootstrap: BootstrapKibiEnvironmentResult, env?: NodeJS.ProcessEnv): EnvValueSource;
+export type InspectSecretSourceOptions = BootstrapKibiEnvironmentOptions & Readonly<{
+    /** @deprecated Prefer bootstrap result sources; kept for targeted tests. */
+    initialProcessKeys?: ReadonlySet<string>;
+}>;
+/**
+ * Read-only secret attribution via a dry bootstrap on an env snapshot.
+ * Prefer `secretSourceFromBootstrap` with the real entrypoint bootstrap result.
+ * Never returns secret values.
+ */
+export declare function inspectSecretSource(key: string, options?: InspectSecretSourceOptions): EnvValueSource;
+/**
+ * Whether a secret is available for provider use (non-empty after resolution).
+ * Blank values are unset.
+ */
+export declare function isSecretAvailable(key: string, options?: InspectSecretSourceOptions): boolean;
+export {};
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/env/bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../src/env/bootstrap.ts"],"names":[],"mappings":"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"}