kibi-cli 0.18.1 → 0.19.0

package/src/public/operations/discovery-executors.ts

@@ -80,6 +80,36 @@ export async function executeQuery(
   // implements REQ-kibi-operation-interface-parity
   const { type, id, tags, sourceFile, limit = 100, offset = 0 } = input;
   try {
+    const prolog = requireProlog(context);
+    const indexedPage = prolog.queryEntities
+      ? await prolog.queryEntities({
+          ...(type !== undefined ? { type } : {}),
+          ...(id !== undefined ? { id } : {}),
+          ...(tags !== undefined ? { tags } : {}),
+          ...(sourceFile !== undefined ? { sourceFile } : {}),
+          limit,
+          offset,
+        })
+      : null;
+    if (indexedPage !== null) {
+      const paginated = indexedPage.entities;
+      const text =
+        indexedPage.count === 0
+          ? `No entities found${type ? ` of type '${type}'` : ""}.`
+          : `Found ${indexedPage.count} entities${type ? ` of type '${type}'` : ""}. Showing ${paginated.length} (offset ${offset}, limit ${limit}): ${paginated
+              .map((entity) => {
+                const entityId = String(entity.id ?? "").replace(
+                  /^file:\/\/.*\//,
+                  "",
+                );
+                return `${entityId} (${String(entity.title ?? "")}, status=${String(entity.status ?? "")})`;
+              })
+              .join(", ")}`;
+      return {
+        content: [{ type: "text", text }],
+        structuredContent: { entities: paginated, count: indexedPage.count },
+      };
+    }
     const entities = await loadEntities(requireProlog(context), {
       ...(type !== undefined ? { type } : {}),
       ...(id !== undefined ? { id } : {}),
@@ -123,9 +153,20 @@ export async function executeSearch(
   }
   validateEntityType(type);
   try {
-    const entities = await loadEntities(requireProlog(context), {
-      ...(type !== undefined ? { type } : {}),
-    });
+    const prolog = requireProlog(context);
+    const indexedCandidates = prolog.searchEntities
+      ? await prolog.searchEntities({
+          query: trimmedQuery,
+          ...(type !== undefined ? { type } : {}),
+          limit: 100_000,
+          offset: 0,
+        })
+      : null;
+    const entities = indexedCandidates
+      ? [...indexedCandidates.entities]
+      : await loadEntities(prolog, {
+          ...(type !== undefined ? { type } : {}),
+        });
     const matches = await rankEntities(
       entities,
       trimmedQuery,

package/src/public/operations/prolog-json.ts

@@ -22,11 +22,23 @@ export async function runOperationJsonQuery<T>(
   const modulePath = escapeAtom(
     resolveCoreModulePath(fileName).replaceAll("\\", "/"),
   );
+  // Loading a module and invoking its predicate in one interactive goal makes
+  // SWI reject `use_module/1` under the engine's guarded `once/1` wrapper, so
+  // use two serialized requests for production and retain the combined goal
+  // only for the repository's Bun-based one-shot tests.
+  const longLivedEngine =
+    typeof (prolog as { storageStatus?: unknown }).storageStatus === "function";
   const oneShotMode =
+    !longLivedEngine &&
+    process.env.NODE_ENV === "test" &&
     typeof (globalThis as { Bun?: unknown }).Bun !== "undefined";
-  const result = oneShotMode
-    ? await prolog.query(`(use_module('${modulePath}'), ${goal})`)
-    : await runInteractiveModuleQuery(prolog, modulePath, goal, errorLabel);
+  const typedStatusQuery = prolog.queryStatusJson;
+  const result =
+    fileName === "status.pl" && typeof typedStatusQuery === "function"
+      ? await typedStatusQuery.call(prolog)
+      : oneShotMode
+        ? await prolog.query(`(use_module('${modulePath}'), ${goal})`)
+        : await runInteractiveModuleQuery(prolog, modulePath, goal, errorLabel);
   if (!result.success) {
     throw new Error(
       `${errorLabel} query failed: ${result.error ?? "Unknown error"}`,

package/src/public/operations/runtime-types.ts

@@ -8,12 +8,51 @@ export type PrologQueryResult = {
   readonly error?: string;
 };
 
+export type PrologEntityQueryInput = Readonly<{
+  type?: string;
+  id?: string;
+  tags?: readonly string[];
+  sourceFile?: string;
+  limit: number;
+  offset: number;
+}>;
+
+export type PrologEntityQueryResult = Readonly<{
+  entities: readonly Record<string, unknown>[];
+  count: number;
+}>;
+
+export type PrologSearchQueryInput = Readonly<{
+  query: string;
+  type?: string;
+  /** Candidate bound before deterministic TypeScript ranking. */
+  limit: number;
+  offset: number;
+}>;
+
+export type PrologSearchQueryResult = Readonly<{
+  entities: readonly Record<string, unknown>[];
+  count: number;
+}>;
+
 // implements REQ-kibi-operation-interface-parity
 export interface PrologPort {
   query(goal: string): Promise<PrologQueryResult>;
+  /** Optional index-backed page query supplied by the journaled engine. */
+  queryEntities?(
+    input: PrologEntityQueryInput,
+  ): Promise<PrologEntityQueryResult>;
+  /** Optional normalized-token candidate lookup supplied by the engine. */
+  searchEntities?(
+    input: PrologSearchQueryInput,
+  ): Promise<PrologSearchQueryResult>;
   nextSolution(): Promise<PrologQueryResult | null>;
   invalidateCache?(): void;
   save(): Promise<PrologQueryResult>;
+  /** Present on the journaled engine; used to distinguish a persistent port from one-shot SWI. */
+  storageStatus?(): Promise<PrologQueryResult>;
+  /** Typed public freshness query; avoids exposing module loading over RPC. */
+  queryStatusJson?(): Promise<PrologQueryResult>;
 }
 
 export type FilesystemStat = {

package/src/public/skills/init-kibi/SKILL.md

@@ -17,7 +17,7 @@ Set up or refresh Kibi knowledge for the current branch through approved Kibi in
 ## Interface Selection
 
 1. If approved Kibi MCP tools are visible, use the MCP route.
-2. Otherwise, in a trusted workspace, use the canonical project-local CLI fallback: `npx --no-install kibi ...` or `bunx --no-install kibi ...`.
+2. Otherwise, in a trusted workspace, use the canonical project-local CLI fallback: `npx --no-install kibi ...`.
 3. If neither approved MCP tools nor the project-local CLI are available, stop and tell the operator to enable or install Kibi for this workspace.
 4. Never use a global fallback, an installing runner, or any route outside the approved Kibi interface.
 
@@ -59,4 +59,4 @@ echo '{"maxCandidates":25,"minConfidence":0.8}' | npx --no-install kibi autopilo
 
 ```json
 [{"taskId":"init-kibi-bootstrap-analysis-train-1","family":"bootstrap-analysis","reflection":"Analyze the cold-start repository and produce a read-only bootstrap preview. This is train case 1; use only the public Kibi MCP surface."},{"taskId":"init-kibi-bootstrap-analysis-train-2","family":"bootstrap-analysis","reflection":"Analyze the cold-start repository and produce a read-only bootstrap preview. This is train case 2; use only the public Kibi MCP surface."},{"taskId":"init-kibi-bounded-context-questions-train-1","family":"bounded-context-questions","reflection":"Ask only the bounded context questions needed before bootstrap synthesis. This is train case 1; use only the public Kibi MCP surface."},{"taskId":"init-kibi-bounded-context-questions-train-2","family":"bounded-context-questions","reflection":"Ask only the bounded context questions needed before bootstrap synthesis. This is train case 2; use only the public Kibi MCP surface."},{"taskId":"init-kibi-approval-sequential-writes-train-1","family":"approval-sequential-writes","reflection":"Apply the approved bootstrap plan sequentially and finish with validation. This is train case 1; use only the public Kibi MCP surface."},{"taskId":"init-kibi-approval-sequential-writes-train-2","family":"approval-sequential-writes","reflection":"Apply the approved bootstrap plan sequentially and finish with validation. This is train case 2; use only the public Kibi MCP surface."},{"taskId":"init-kibi-repair-escalation-train-1","family":"repair-escalation","reflection":"Identify the partial setup and stop at the documented operator repair boundary. This is train case 1; use only the public Kibi MCP surface."},{"taskId":"init-kibi-repair-escalation-train-2","family":"repair-escalation","reflection":"Identify the partial setup and stop at the documented operator repair boundary. This is train case 2; use only the public Kibi MCP surface."}]
-```
+```

package/src/public/skills/kibi-freshness/SKILL.md

@@ -17,7 +17,7 @@ Help agents decide whether Kibi knowledge is current enough to support safe chan
 ## Interface Selection
 
 1. If Kibi MCP tools are visible and approved for the workspace, use the MCP surface only.
-2. Otherwise, in a trusted workspace, use the canonical project-local CLI fallback through `npx --no-install kibi ...` or `bunx --no-install kibi ...`.
+2. Otherwise, in a trusted workspace, use the canonical project-local CLI fallback through `npx --no-install kibi ...`.
 3. If the project-local CLI is unavailable or too old, stop and tell the operator to enable or install Kibi.
 4. Never use a global fallback or an installing runner.
 
@@ -41,4 +41,4 @@ echo '{}' | npx --no-install kibi status --input -
 - If entities look stale, refresh context through an approved Kibi capability and then re-query.
 - Preserve source-file traceability by carrying `sourceFile`, text references, and validation evidence through discovery, mutation, and completion.
 - Do not read or edit files inside `.kb` directly; use the selected Kibi interface instead.
-- Completion must state one freshness outcome: KB updated, no KB impact with rationale, or deferred/failed.
+- Completion must state one freshness outcome: KB updated, no KB impact with rationale, or deferred/failed.

package/src/public/skills/kibi-traceability/SKILL.md

@@ -17,7 +17,7 @@ Validate and strengthen requirement, scenario, test, behavioral-symbol, and sour
 ## Interface Selection
 
 1. If Kibi MCP tools are visible and approved, use the MCP surface as the primary authority.
-2. Otherwise, in a trusted workspace, use the canonical project-local CLI fallback through `npx --no-install kibi ...` or `bunx --no-install kibi ...`.
+2. Otherwise, in a trusted workspace, use the canonical project-local CLI fallback through `npx --no-install kibi ...`.
 3. If neither approved MCP tools nor the project-local CLI are available, or if the CLI is unavailable or too old, stop and tell the operator to enable or install Kibi.
 4. Never use a global fallback or an installing runner.
 

package/src/public/skills/kibi-usage/SKILL.md

@@ -27,7 +27,7 @@ Consult this skill before any Kibi knowledge base operation, on first interactio
 Kibi exposes two peer surfaces over the same 18 operations: visible MCP tools and the trusted project-local CLI. Both accept the same business input and effects (see `resources/operation-access.md`). Choose by what is visible and approved in the current environment — MCP and the CLI are equal choices, not a preference order:
 
 1. If Kibi MCP tools are visible and approved in the current environment, use MCP.
-2. Otherwise, in a trusted workspace, use the project-local CLI through a non-installing runner: `npx --no-install kibi ...` or `bunx --no-install kibi ...`. The CLI is a peer interface, not a fallback.
+2. Otherwise, in a trusted workspace, use the project-local CLI through a non-installing runner: `npx --no-install kibi ...`. The CLI is a peer interface, not a fallback.
 3. If the project-local CLI is unavailable or too old for the needed route, stop and tell the operator to enable or install Kibi.
 4. Never use a global fallback or an installing runner. Never probe or install packages as a side effect of interface selection.
 
@@ -40,7 +40,7 @@ echo '{"type":"req","id":"REQ-001","properties":{"title":"Test","status":"open"}
 ```
 
 ```bash
-echo '{"query":"authentication","limit":10}' | bunx --no-install kibi search --input -
+echo '{"query":"authentication","limit":10}' | npx --no-install kibi search --input -
 ```
 
 ## MCP Tool Names

package/src/public/skills/kibi-usage/resources/operation-access.md

@@ -36,7 +36,7 @@ echo '{"type":"req","id":"REQ-001","properties":{"title":"Test","status":"open"}
 ```
 
 ```bash
-echo '{"rules":["required-fields","no-dangling-refs"]}' | bunx --no-install kibi check --input -
+echo '{"rules":["required-fields","no-dangling-refs"]}' | npx --no-install kibi check --input -
 ```
 
 ## Telemetry handling