kibi-cli 0.17.0 → 0.19.0

package/src/public/operations/node-ports.ts

@@ -1,5 +1,7 @@
 import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
 import * as fs from "node:fs/promises";
+import path from "node:path";
 import { promisify } from "node:util";
 import fg from "fast-glob";
 
@@ -21,6 +23,7 @@ type NodeGitPort = GitPort & {
 };
 
 const execFileAsync = promisify(execFile);
+const SNAPSHOT_EXCLUDED_PREFIXES = [".changeset/", ".kb/", "docs/"] as const;
 const ALWAYS_IGNORED_GLOBS = [
   "**/.git/**",
   "**/.kb/**",
@@ -35,6 +38,111 @@ const ALWAYS_IGNORED_GLOBS = [
   "**/target/**",
 ] as const;
 
+function includedSnapshotPath(relativePath: string): boolean {
+  return !SNAPSHOT_EXCLUDED_PREFIXES.some(
+    (prefix) =>
+      relativePath === prefix.slice(0, -1) || relativePath.startsWith(prefix),
+  );
+}
+
+function withoutVerificationReceiptFrontmatter(content: string): string {
+  const lines = content.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+  if (lines[0]?.trim() !== "---") return content;
+  let inFrontmatter = true;
+  let skippingReceipts = false;
+  const retained: string[] = [];
+  for (const [index, line] of lines.entries()) {
+    const trimmed = line.trim();
+    if (index > 0 && inFrontmatter && trimmed === "---") {
+      inFrontmatter = false;
+      skippingReceipts = false;
+      retained.push(line);
+      continue;
+    }
+    if (inFrontmatter && /^verification_receipts\s*:/.test(line)) {
+      skippingReceipts = true;
+      continue;
+    }
+    if (
+      inFrontmatter &&
+      skippingReceipts &&
+      /^[A-Za-z_][A-Za-z0-9_-]*\s*:/.test(line)
+    ) {
+      skippingReceipts = false;
+    }
+    if (!skippingReceipts) retained.push(line);
+  }
+  return retained.join("");
+}
+
+function snapshotFileContent(relativePath: string, content: Buffer): Buffer {
+  if (
+    relativePath.startsWith("documentation/") &&
+    relativePath.endsWith(".md")
+  ) {
+    return Buffer.from(
+      withoutVerificationReceiptFrontmatter(content.toString("utf8")),
+    );
+  }
+  return content;
+}
+
+async function workspaceSnapshot(workspaceRoot: string) {
+  const { stdout: listed } = await execFileAsync(
+    "git",
+    [
+      "-C",
+      workspaceRoot,
+      "ls-files",
+      "--cached",
+      "--others",
+      "--exclude-standard",
+      "-z",
+    ],
+    { encoding: "buffer", maxBuffer: 64 * 1024 * 1024 },
+  );
+  const paths = listed
+    .toString("utf8")
+    .split("\0")
+    .filter(Boolean)
+    .filter(includedSnapshotPath)
+    .sort();
+  const digest = createHash("sha256");
+  digest.update("kibi.workspace-snapshot.v1\0");
+  for (const relativePath of paths) {
+    digest.update(relativePath);
+    digest.update("\0");
+    try {
+      const content = await fs.readFile(path.join(workspaceRoot, relativePath));
+      digest.update(snapshotFileContent(relativePath, content));
+    } catch (error) {
+      const code =
+        typeof error === "object" && error !== null && "code" in error
+          ? String(error.code)
+          : "unreadable";
+      digest.update(`<${code}>`);
+    }
+    digest.update("\0");
+  }
+  const { stdout: status } = await execFileAsync(
+    "git",
+    [
+      "-C",
+      workspaceRoot,
+      "status",
+      "--porcelain=v1",
+      "--untracked-files=normal",
+    ],
+    { maxBuffer: 16 * 1024 * 1024 },
+  );
+  return {
+    version: "kibi.workspace-snapshot.v1" as const,
+    hash: digest.digest("hex"),
+    dirty: status.trim().length > 0,
+    fileCount: paths.length,
+  };
+}
+
 export const nodeFilesystem: NodeFilesystemPort = {
   readFile: (filePath) => fs.readFile(filePath, "utf8"),
   writeFile: async (filePath, data) => {
@@ -67,6 +175,7 @@ export const nodeGit: NodeGitPort = {
     ]);
     return stdout.trim();
   },
+  workspaceSnapshot,
   ignoredPaths: async (workspaceRoot, paths) => {
     const policy = createRepoIgnorePolicy(workspaceRoot);
     return paths.filter((candidate) => policy.isIgnored(candidate));

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"}`,