kibi-cli 2.38.0 → 2.40.0

package/dist/operations/proof/claim-bindings.js

@@ -18,7 +18,11 @@
 import { randomBytes } from "node:crypto";
 import { rmSync, writeFileSync } from "node:fs";
 import path from "node:path";
+import fg from "fast-glob";
+import { normalizeEntityId, parseTriples } from "../../prolog/codec.js";
 import { runOperationJsonQuery, toPrologAtom, } from "../../public/operations/prolog-json.js";
+import { loadEntities } from "../../public/operations/discovery-entities.js";
+import { matchWorkspaceFiles } from "../../public/proof-sources.js";
 import { compileWitness, loadSymbol, smtAssertion, } from "./code-certificates.js";
 import { stringConstraintProblem } from "./code-models.js";
 function record(value) {
@@ -264,6 +268,143 @@ async function derivedProblem(context, contract, certificate, row, coveredBy) {
         return `the query does not assert the negation of ${factId}'s constraint ${negation}`;
     return null;
 }
+/**
+ * Callees that read one environment variable. A string_args read of one of
+ * them sees only that getter's first arguments, never the other ways the
+ * code reads the environment, so it cannot decide an eq, subset_of or
+ * excludes claim about what the code reads; the env extract reads them all.
+ */
+const ENVIRONMENT_GETTER = /(?:^|[.:/])(?:getenv|Getenv|LookupEnv|getenvb|GetEnvironmentVariable)$|(?:^|[.:/])env::var(?:_os)?$|^(?:os\.environ\.get|ENV\.fetch|process\.env)$/;
+export function environmentGetterCallee(callee) {
+    return ENVIRONMENT_GETTER.test(callee.replace(/\s+/g, "").replace(/\/\d+$/, ""));
+}
+const CLOSED_OPERATORS = new Set(["eq", "subset_of", "excludes"]);
+const FILE_NAME_TOKEN = /[A-Za-z0-9_][A-Za-z0-9_./-]*\.[A-Za-z0-9]{1,10}\b/g;
+/** A quoted or backticked path, which may hold spaces (`automated install/x.sh`). */
+const QUOTED_PATH = /[`'"]([^`'"\n]*[/.][^`'"\n]*)[`'"]/g;
+/** A slashed path without an extension (`src/match` for src/match.c). */
+const BARE_PATH = /[A-Za-z0-9_][A-Za-z0-9_.-]*(?:\/[A-Za-z0-9_.-]+)+/g;
+function claimFileCandidates(token) {
+    const escaped = fg.escapePath(token.replace(/^\.?\/+/, ""));
+    const segments = escaped.split("/");
+    // The token as a path, as a name anywhere, then with leading segments
+    // dropped (a repository prefix such as fzy/src/match.c), then, for a
+    // slashed name without an extension, any extension.
+    const tries = [[escaped], [`**/${escaped}`]];
+    for (let drop = 1; drop < segments.length; drop += 1)
+        tries.push([`**/${segments.slice(drop).join("/")}`]);
+    if (segments.length > 1 && !/\.[^/.]+$/.test(escaped))
+        tries.push([`${escaped}.*`, `**/${escaped}.*`]);
+    return tries;
+}
+/**
+ * The project files a claim names in its subject key or claim text (for
+ * example `src/match.c`, `utils.sh`, `fzy/src/match.c`, `src/Match.c` or
+ * `src/match`): a token resolves, ignoring case, to the file at that path,
+ * else to every project file with that name or path suffix, else (for a
+ * slashed name without an extension) to the files with that stem. Tokens
+ * that name no file (dotted subject keys such as `kibi.cli`) resolve to
+ * nothing.
+ */
+// implements REQ-kibi-source-proof-kinds
+export function namedClaimFiles(workspaceRoot, texts) {
+    const named = new Map();
+    for (const value of texts) {
+        const tokens = [
+            ...[...value.matchAll(QUOTED_PATH)].map((match) => match[1] ?? ""),
+            ...[...value.matchAll(FILE_NAME_TOKEN)].map((match) => match[0]),
+            ...[...value.matchAll(BARE_PATH)].map((match) => match[0]),
+        ];
+        for (const raw of tokens) {
+            const token = raw.trim();
+            if (token === "" || named.has(token))
+                continue;
+            for (const patterns of claimFileCandidates(token)) {
+                const files = matchWorkspaceFiles(workspaceRoot, patterns, [], false);
+                if (files.length > 0) {
+                    named.set(token, files);
+                    break;
+                }
+            }
+        }
+    }
+    return named;
+}
+/**
+ * What a references read must cover for the claims it proves. The read
+ * decides a claim only for the files it reads, so every symbol the test
+ * covers (covered_by) and every symbol that implements the claim's
+ * requirement must lie in one of those files: otherwise the claim, which is
+ * about that symbol's code, would be decided on other files. A string_args
+ * read of an environment getter cannot decide a closed claim (eq, subset_of,
+ * excludes) about what the code reads, since the other getters are unread.
+ */
+// implements REQ-kibi-source-proof-kinds
+async function sourceScopeCheck(context, contract, coveredBy) {
+    const spec = contract.source;
+    if (contract.kind !== "source" || spec?.reader !== "references")
+        return null;
+    const list = (value) => typeof value === "string"
+        ? [value]
+        : Array.isArray(value)
+            ? value.filter((item) => typeof item === "string")
+            : [];
+    const read = new Set(matchWorkspaceFiles(context.workspaceRoot, list(spec.files), list(spec.ignore)));
+    const implementers = new Map();
+    if (context.prolog !== undefined) {
+        const result = await context.prolog.query("findall([From,To,'implements'], kb_relationship(implements, From, To), Rels)");
+        if (!result.success)
+            throw new Error(`implements relationship query failed: ${result.error ?? "Unknown error"}`);
+        for (const [from, to] of parseTriples(result.bindings.Rels ?? "[]")) {
+            const requirement = normalizeEntityId(to);
+            implementers.set(requirement, [
+                ...(implementers.get(requirement) ?? []),
+                normalizeEntityId(from),
+            ]);
+        }
+    }
+    const files = new Map();
+    const fileOf = async (symbolId) => {
+        if (!files.has(symbolId))
+            files.set(symbolId, (await loadSymbol(context, symbolId))?.sourceFile ?? "");
+        return files.get(symbolId) ?? "";
+    };
+    const callee = typeof spec.callee === "string" ? spec.callee : "";
+    const getter = spec.extract === "string_args" && environmentGetterCallee(callee);
+    return async (row) => {
+        const operator = text(record(row.obligation)?.operator);
+        if (getter && CLOSED_OPERATORS.has(operator))
+            return `a string_args read of ${callee} sees only that getter's arguments, not the other ways the code reads the environment, so it cannot decide a ${operator} claim; read the files with extract env`;
+        const linked = [
+            ...[...coveredBy].map((id) => ({ id, how: "is covered by the test" })),
+            ...(implementers.get(row.requirement_id ?? "") ?? []).map((id) => ({
+                id,
+                how: `implements ${row.requirement_id}`,
+            })),
+        ];
+        if (row.fact_id && context.prolog !== undefined) {
+            const [fact] = await loadEntities(context.prolog, { id: row.fact_id, type: "fact" });
+            const named = namedClaimFiles(context.workspaceRoot, [
+                text(fact?.subject_key),
+                text(fact?.claim_text),
+            ]);
+            const unread = [...named].filter(([, paths]) => !paths.some((file) => read.has(file)));
+            if (unread.length > 0) {
+                const [token, paths] = unread[0];
+                return `the claim is about ${token}${paths[0] !== token ? ` (${paths.slice(0, 3).join(", ")})` : ""}, which the read does not include. Kibi decides the claim only on the files it reads, so add that file to files; if Kibi cannot read it, the claim cannot be decided`;
+            }
+        }
+        const outside = [];
+        for (const { id, how } of linked) {
+            const file = await fileOf(id);
+            if (file !== "" && !read.has(file) && !outside.some((text) => text.startsWith(`${id} `)))
+                outside.push(`${id} (${file}) ${how}`);
+        }
+        if (outside.length === 0)
+            return null;
+        return `the read does not cover the code the claim is about: ${outside.slice(0, 3).join("; ")}${outside.length > 3 ? ` and ${outside.length - 3} more` : ""}. Kibi decides the claim only on the files it reads, so add those files to files; if Kibi cannot read them, the claim cannot be decided for them`;
+    };
+}
 /**
  * The evidence level a receipt records. A certificate that re-checks but
  * derives none of the claims it names from the code proves nothing about
@@ -306,6 +447,7 @@ export async function judgeClaimBindings(context, input) {
     const harnessed = input.contract.kind === "rule" &&
         Object.values(input.contract.predicate_source ?? {}).some((row) => (row.harness_for ?? []).length > 0);
     const certificate = record(input.verdict.certificate) ?? {};
+    const scopeCheck = await sourceScopeCheck(context, input.contract, coveredBy);
     const bindings = [];
     for (const row of rows) {
         const base = {
@@ -344,7 +486,8 @@ export async function judgeClaimBindings(context, input) {
             });
             continue;
         }
-        const problem = await derivedProblem(context, input.contract, certificate, row, coveredBy);
+        const problem = (await scopeCheck?.(row)) ??
+            (await derivedProblem(context, input.contract, certificate, row, coveredBy));
         const numeric = text(obligation.kind) === "numeric_constraint";
         bindings.push(problem === null
             ? {

package/dist/operations/proof/code-certificates.d.ts

@@ -23,7 +23,9 @@ export declare function readWorkspaceFile(workspaceRoot: string, relative: strin
  * `identifier`: the domain is read from the code, not hand-listed. A suite
  * that tests compiled output imports the domain from the TypeScript
  * project's `outDir`; given the workspace root, such an import counts when it
- * maps back to the domain's source file under `rootDir`.
+ * maps back to the domain's source file under `rootDir`. A SWI-Prolog proof
+ * names the predicate and loads its file (use_module, ensure_loaded, consult
+ * or a load list), or is the plunit file beside it (`x.plt` for `x.pl`).
  */
 export declare function importsDomain(source: string, sourcePath: string, targetPath: string, identifier: string, workspaceRoot?: string): boolean;
 /**
@@ -47,6 +49,8 @@ export declare function evaluateDomain(workspaceRoot: string, sourceFile: string
     runners?: readonly ("bun" | "tsx" | "node")[];
     /** Read this field of each member instead of the member itself. */
     field?: string;
+    /** A Prolog predicate's argument that names each member. */
+    arg?: number;
 }>): {
     ok: true;
     count: number;
@@ -56,9 +60,12 @@ export declare function evaluateDomain(workspaceRoot: string, sourceFile: string
     reason: string;
 };
 /**
- * The number a value_source export holds, read the same way as a domain.
+ * The number a value_source export holds, read the same way as a domain. A
+ * Prolog constant is a predicate with a single solution holding a number.
  */
-export declare function evaluateScalar(workspaceRoot: string, sourceFile: string, exportName: string): {
+export declare function evaluateScalar(workspaceRoot: string, sourceFile: string, exportName: string, options?: Readonly<{
+    arg?: number;
+}>): {
     ok: true;
     value: number;
 } | {

package/dist/operations/proof/code-certificates.d.ts.map

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

package/dist/operations/proof/code-certificates.js

@@ -25,6 +25,8 @@ import { canonicalCertificateJson, certificateDigest, } from "../../public/proof
 import { CODE_CERTIFICATE_VERSION, isCertificateProofKind, } from "../../public/proof-protocol.js";
 import { describeSource, normalizeSourceSpec, readSource, } from "../../public/proof-sources.js";
 import { runCodeEvaluator, spawnSyncThroughFiles, TS_RESOLVE_HOOKS, } from "./code-runner.js";
+import { CODE_LANGUAGE_NAMES, codeLanguage, prologLoadSpecs, stripPrologExtension, unsupportedLanguageReason, } from "./code-languages.js";
+import { PROLOG_EVALUATOR } from "./prolog-evaluator.js";
 import { evaluateSourceCode } from "./source-code-readers.js";
 import { machineCertificateProblem, patternCertificateProblem, ruleCertificateProblem, } from "./code-models.js";
 function record(value) {
@@ -59,10 +61,14 @@ const IMPORT_SPECIFIER = /(?:\bfrom\s*|\bimport\s*\(\s*|\bimport\s+|\brequire\s*
  * `identifier`: the domain is read from the code, not hand-listed. A suite
  * that tests compiled output imports the domain from the TypeScript
  * project's `outDir`; given the workspace root, such an import counts when it
- * maps back to the domain's source file under `rootDir`.
+ * maps back to the domain's source file under `rootDir`. A SWI-Prolog proof
+ * names the predicate and loads its file (use_module, ensure_loaded, consult
+ * or a load list), or is the plunit file beside it (`x.plt` for `x.pl`).
  */
 // implements REQ-kibi-code-proof-kinds
 export function importsDomain(source, sourcePath, targetPath, identifier, workspaceRoot) {
+    if (codeLanguage(targetPath) === "prolog")
+        return prologLoadsModule(source, sourcePath, targetPath, identifier);
     // A dotted export (BRAND.name) is imported under its head.
     const imported = identifier.split(".")[0] ?? "";
     if (imported === "" || !new RegExp(`\\b${escapeRegExp(imported)}\\b`).test(source))
@@ -85,6 +91,23 @@ export function importsDomain(source, sourcePath, targetPath, identifier, worksp
     }
     return false;
 }
+/**
+ * Whether a SWI-Prolog proof names the predicate `identifier` (Name/Arity,
+ * optionally module-qualified) and loads the file at `targetPath`: a relative
+ * path resolved from the proof's directory, `library(X)` for a pack's
+ * `prolog/X.pl`, or the plunit convention of a `.plt` file beside its `.pl`.
+ */
+function prologLoadsModule(source, sourcePath, targetPath, identifier) {
+    const name = identifier.replace(/^[^:]*:/, "").replace(/\/\/?\d+$/, "");
+    if (name === "" || !new RegExp(`(?<![\\w])${escapeRegExp(name)}(?![\\w])`).test(source))
+        return false;
+    const target = stripPrologExtension(targetPath);
+    if (stripPrologExtension(sourcePath) === target && /\.plt$/i.test(sourcePath))
+        return true;
+    return prologLoadSpecs(source).some((spec) => "library" in spec
+        ? `${path.sep}${target}`.endsWith(`${path.sep}prolog${path.sep}${path.normalize(spec.library)}`)
+        : stripPrologExtension(path.join(path.dirname(sourcePath), spec.path)) === target);
+}
 const PYTHON_FROM_IMPORT = /^\s*from\s+(\.*)([\w.]*)\s+import\b/gm;
 const PYTHON_IMPORT = /^\s*import\s+([\w.]+(?:\s*,\s*[\w.]+)*)/gm;
 /**
@@ -288,7 +311,7 @@ else:
  */
 // implements REQ-kibi-code-proof-kinds
 export function evaluateDomain(workspaceRoot, sourceFile, exportName, options = {}) {
-    const evaluated = evaluateExport(workspaceRoot, sourceFile, exportName, options);
+    const evaluated = evaluateExport(workspaceRoot, sourceFile, exportName, "domain", options);
     if (!evaluated.ok)
         return evaluated;
     if (evaluated.scalar !== undefined)
@@ -299,20 +322,44 @@ export function evaluateDomain(workspaceRoot, sourceFile, exportName, options =
     return { ok: true, count: evaluated.count, members: evaluated.members };
 }
 /**
- * The number a value_source export holds, read the same way as a domain.
+ * The number a value_source export holds, read the same way as a domain. A
+ * Prolog constant is a predicate with a single solution holding a number.
  */
 // implements REQ-kibi-claim-bound-proofs
-export function evaluateScalar(workspaceRoot, sourceFile, exportName) {
-    const evaluated = evaluateExport(workspaceRoot, sourceFile, exportName);
+export function evaluateScalar(workspaceRoot, sourceFile, exportName, options = {}) {
+    const evaluated = evaluateExport(workspaceRoot, sourceFile, exportName, "scalar", options);
     if (!evaluated.ok)
         return evaluated;
     if (evaluated.scalar === undefined || !Number.isFinite(evaluated.scalar))
         return { ok: false, reason: `${exportName} in ${sourceFile} is not a finite number` };
     return { ok: true, value: evaluated.scalar };
 }
-function evaluateExport(workspaceRoot, sourceFile, exportName, options = {}) {
+function evaluateExport(workspaceRoot, sourceFile, exportName, want, options = {}) {
     const absolute = path.resolve(workspaceRoot, sourceFile);
-    const run = runCodeEvaluator(workspaceRoot, sourceFile, { js: DOMAIN_EVALUATOR, python: PYTHON_DOMAIN_EVALUATOR }, [absolute, exportName, options.field ?? ""], (parsed) => {
+    const language = codeLanguage(sourceFile);
+    if (language === null)
+        return {
+            ok: false,
+            reason: unsupportedLanguageReason("Kibi's domain loader", ["js", "python", "prolog"], [sourceFile]),
+        };
+    if (language === "prolog" && options.field !== undefined)
+        return {
+            ok: false,
+            reason: `a SWI-Prolog predicate has arguments, not fields: name the argument of ${exportName} with arg instead of field`,
+        };
+    if (language !== "prolog" && options.arg !== undefined)
+        return {
+            ok: false,
+            reason: `arg applies only to a SWI-Prolog predicate, not to ${CODE_LANGUAGE_NAMES[language]} in ${sourceFile}`,
+        };
+    const ref = {
+        file: absolute,
+        export: exportName,
+        ...(options.arg === undefined ? {} : { arg: options.arg }),
+    };
+    const run = runCodeEvaluator(workspaceRoot, sourceFile, { js: DOMAIN_EVALUATOR, python: PYTHON_DOMAIN_EVALUATOR, prolog: PROLOG_EVALUATOR }, language === "prolog"
+        ? [JSON.stringify({ mode: "export", want, ref })]
+        : [absolute, exportName, options.field ?? ""], (parsed) => {
         const row = parsed;
         return (row.error !== undefined ||
             typeof row.scalar === "number" ||
@@ -321,7 +368,7 @@ function evaluateExport(workspaceRoot, sourceFile, exportName, options = {}) {
     if (!run.ok)
         return {
             ok: false,
-            reason: `Kibi could not load ${exportName} from ${sourceFile}${run.failure ? `: ${run.failure}` : ""}${run.python ? " (a Python domain loads with KIBI_PYTHON, the active or project virtualenv (.venv or venv), then python3 on PATH)" : " (without bun or the workspace's tsx, node's type stripping loads the domain; a type imported without import type stops it)"}`,
+            reason: `Kibi could not load ${exportName} from ${sourceFile}${run.failure ? `: ${run.failure}` : ""}${run.language === "python" ? " (a Python domain loads with KIBI_PYTHON, the active or project virtualenv (.venv or venv), then python3 on PATH)" : run.language === "prolog" ? " (a SWI-Prolog domain loads with KIBI_SWIPL, the bundled SWI-Prolog, then swipl on PATH)" : " (without bun or the workspace's tsx, node's type stripping loads the domain; a type imported without import type stops it)"}`,
         };
     const parsed = run.value;
     if (parsed.error !== undefined)
@@ -606,13 +653,13 @@ export async function valueSourceValues(context, contract) {
         if (source.measure === "count") {
             // A count claim reads the collection itself, not a number kept
             // beside it for the proof.
-            const domain = evaluateDomain(context.workspaceRoot, symbol.sourceFile, exportName);
+            const domain = evaluateDomain(context.workspaceRoot, symbol.sourceFile, exportName, source.arg === undefined ? {} : { arg: source.arg });
             if (!domain.ok)
                 return domain;
             values.push({ symbol_id: source.symbol_id, value: domain.count });
             continue;
         }
-        const evaluated = evaluateScalar(context.workspaceRoot, symbol.sourceFile, exportName);
+        const evaluated = evaluateScalar(context.workspaceRoot, symbol.sourceFile, exportName, source.arg === undefined ? {} : { arg: source.arg });
         if (!evaluated.ok)
             return evaluated;
         values.push({ symbol_id: source.symbol_id, value: evaluated.value });
@@ -729,9 +776,14 @@ async function workspaceProblem(context, contract, certificate) {
         if (!importing)
             return `the proof does not import ${exportName || domainId} from ${domain.sourceFile}, so its domain may be hand-listed${contract.domain_source?.export === undefined ? ` (Kibi reads the export named by the symbol's title; set domain_source.export when the export has another name)` : ""}`;
         if (kind === "exhaustive") {
-            const evaluated = evaluateDomain(context.workspaceRoot, domain.sourceFile, exportName, contract.domain_source?.field === undefined
-                ? {}
-                : { field: contract.domain_source.field });
+            const evaluated = evaluateDomain(context.workspaceRoot, domain.sourceFile, exportName, {
+                ...(contract.domain_source?.field === undefined
+                    ? {}
+                    : { field: contract.domain_source.field }),
+                ...(contract.domain_source?.arg === undefined
+                    ? {}
+                    : { arg: contract.domain_source.arg }),
+            });
             if (!evaluated.ok)
                 return evaluated.reason;
             const members = record(certificate.domain)?.members;

package/dist/operations/proof/code-languages.d.ts

@@ -0,0 +1,104 @@
+/**
+ * The languages Kibi reads code models in, decided by a file's extension in
+ * one place. Every proof kind that loads code (exhaustive domains, value
+ * constants, rule tables, state machines, patterns) asks this module which
+ * evaluator a file needs, so adding a language adds one entry here and its
+ * evaluator scripts, not another extension test at each call site.
+ */
+export type CodeLanguage = "js" | "python" | "prolog";
+/** The language whose evaluator reads `file`, or null for any other file. */
+export declare function codeLanguage(file: string): CodeLanguage | null;
+export type PrologLoadSpec = {
+    library: string;
+} | {
+    path: string;
+};
+/**
+ * The files a SWI-Prolog source loads, read from its text: use_module,
+ * ensure_loaded, consult, load_files, reexport and include with a quoted or
+ * plain path or `library(X)`, and `:- [a, b]` load lists. Nothing runs.
+ */
+export declare function prologLoadSpecs(source: string): PrologLoadSpec[];
+export declare function stripPrologExtension(file: string): string;
+/** How a reason names a language. */
+/**
+ * Languages whose references a qualified plugin reads (kibi-plugin-treesitter
+ * through kibi.reference-extractor.v1). Kibi itself runs nothing for them.
+ */
+export declare const PLUGIN_REFERENCE_LANGUAGES: readonly [{
+    readonly name: "Go";
+    readonly pattern: RegExp;
+}, {
+    readonly name: "Java";
+    readonly pattern: RegExp;
+}, {
+    readonly name: "C#";
+    readonly pattern: RegExp;
+}, {
+    readonly name: "Rust";
+    readonly pattern: RegExp;
+}];
+/**
+ * The data-only kibi-lang-* packs kibi-plugin-treesitter reads these
+ * languages with, by the file extensions its catalog maps to them. Every
+ * grammar ships in a pack; `.pl` counts as SWI-Prolog here.
+ */
+export declare const PLUGIN_LANGUAGE_PACKS: readonly [{
+    readonly pack: "kibi-lang-go";
+    readonly name: "Go";
+    readonly pattern: RegExp;
+}, {
+    readonly pack: "kibi-lang-rust";
+    readonly name: "Rust";
+    readonly pattern: RegExp;
+}, {
+    readonly pack: "kibi-lang-java";
+    readonly name: "Java";
+    readonly pattern: RegExp;
+}, {
+    readonly pack: "kibi-lang-csharp";
+    readonly name: "C#";
+    readonly pattern: RegExp;
+}, {
+    readonly pack: "kibi-lang-php";
+    readonly name: "PHP";
+    readonly pattern: RegExp;
+}, {
+    readonly pack: "kibi-lang-c";
+    readonly name: "C";
+    readonly pattern: RegExp;
+}, {
+    readonly pack: "kibi-lang-cpp";
+    readonly name: "C++";
+    readonly pattern: RegExp;
+}, {
+    readonly pack: "kibi-lang-bash";
+    readonly name: "Bash";
+    readonly pattern: RegExp;
+}, {
+    readonly pack: "kibi-lang-ruby";
+    readonly name: "Ruby";
+    readonly pattern: RegExp;
+}, {
+    readonly pack: "kibi-lang-hcl";
+    readonly name: "Terraform/HCL";
+    readonly pattern: RegExp;
+}, {
+    readonly pack: "kibi-lang-python";
+    readonly name: "Python";
+    readonly pattern: RegExp;
+}, {
+    readonly pack: "kibi-lang-prolog";
+    readonly name: "SWI-Prolog";
+    readonly pattern: RegExp;
+}];
+export declare function pluginReferenceLanguage(file: string): string | null;
+export declare const CODE_LANGUAGE_NAMES: Readonly<Record<CodeLanguage, string>>;
+/** How a reason names the language of `file`. */
+export declare function languageName(file: string): string;
+/**
+ * The one refusal for a file whose language a reader cannot read: what reads
+ * which languages, and the files it was handed outside them.
+ */
+export declare function unsupportedLanguageReason(reader: string, supported: readonly CodeLanguage[], files: readonly string[]): string;
+//# sourceMappingURL=code-languages.d.ts.map

package/dist/operations/proof/code-languages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-languages.d.ts","sourceRoot":"","sources":["../../../src/operations/proof/code-languages.ts"],"names":[],"mappings":"AAoBA;;;;;;GAMG;AAEH,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAQtD,6EAA6E;AAE7E,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAK9D;AAMD,MAAM,MAAM,cAAc,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpE;;;;GAIG;AAEH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,EAAE,CAehE;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,qCAAqC;AACrC;;;GAGG;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;EAK7B,CAAC;AAEX;;;;GAIG;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAaxB,CAAC;AAEX,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAEnE;AAED,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAItE,CAAC;AAEF,iDAAiD;AACjD,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGjD;AAED;;;GAGG;AAEH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,YAAY,EAAE,EAClC,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,MAAM,CAOR"}

package/dist/operations/proof/code-languages.js

@@ -0,0 +1,119 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+import path from "node:path";
+const JS_FILE = /\.(?:[cm]?[jt]sx?)$/i;
+const PYTHON_FILE = /\.py$/i;
+// Symbol discovery resolves an ambiguous `.pl` file by its content; one that
+// is Perl fails to load in SWI-Prolog, so the read refuses rather than guess.
+const PROLOG_FILE = /\.(?:pl|plt)$/i;
+/** The language whose evaluator reads `file`, or null for any other file. */
+// implements REQ-kibi-multilingual-code-proofs
+export function codeLanguage(file) {
+    if (JS_FILE.test(file))
+        return "js";
+    if (PYTHON_FILE.test(file))
+        return "python";
+    if (PROLOG_FILE.test(file))
+        return "prolog";
+    return null;
+}
+const PROLOG_LOAD = /\b(?:use_module|ensure_loaded|consult|load_files|reexport|include)\s*\(\s*(?:library\(\s*([^)\s]+)\s*\)|'([^']+)'|"([^"]+)"|([a-z][\w/]*))/g;
+const PROLOG_LOAD_LIST = /:-\s*\[([^\]]+)\]/g;
+/**
+ * The files a SWI-Prolog source loads, read from its text: use_module,
+ * ensure_loaded, consult, load_files, reexport and include with a quoted or
+ * plain path or `library(X)`, and `:- [a, b]` load lists. Nothing runs.
+ */
+// implements REQ-kibi-multilingual-code-proofs
+export function prologLoadSpecs(source) {
+    const specs = [];
+    for (const match of source.matchAll(PROLOG_LOAD)) {
+        if (match[1] !== undefined)
+            specs.push({ library: match[1] });
+        else {
+            const spec = match[2] ?? match[3] ?? match[4] ?? "";
+            if (spec !== "")
+                specs.push({ path: spec });
+        }
+    }
+    for (const match of source.matchAll(PROLOG_LOAD_LIST))
+        for (const item of (match[1] ?? "").split(",")) {
+            const spec = item.trim().replace(/^['"]|['"]$/g, "");
+            if (spec !== "")
+                specs.push({ path: spec });
+        }
+    return specs;
+}
+export function stripPrologExtension(file) {
+    return path.normalize(file).replace(/\.(?:pl|plt|pro)$/i, "");
+}
+/** How a reason names a language. */
+/**
+ * Languages whose references a qualified plugin reads (kibi-plugin-treesitter
+ * through kibi.reference-extractor.v1). Kibi itself runs nothing for them.
+ */
+// implements REQ-kibi-tree-sitter-references
+export const PLUGIN_REFERENCE_LANGUAGES = [
+    { name: "Go", pattern: /\.go$/i },
+    { name: "Java", pattern: /\.java$/i },
+    { name: "C#", pattern: /\.cs$/i },
+    { name: "Rust", pattern: /\.rs$/i },
+];
+/**
+ * The data-only kibi-lang-* packs kibi-plugin-treesitter reads these
+ * languages with, by the file extensions its catalog maps to them. Every
+ * grammar ships in a pack; `.pl` counts as SWI-Prolog here.
+ */
+// implements REQ-kibi-tree-sitter-language-packs
+export const PLUGIN_LANGUAGE_PACKS = [
+    { pack: "kibi-lang-go", name: "Go", pattern: /\.go$/i },
+    { pack: "kibi-lang-rust", name: "Rust", pattern: /\.rs$/i },
+    { pack: "kibi-lang-java", name: "Java", pattern: /\.java$/i },
+    { pack: "kibi-lang-csharp", name: "C#", pattern: /\.cs$/i },
+    { pack: "kibi-lang-php", name: "PHP", pattern: /\.php$/i },
+    { pack: "kibi-lang-c", name: "C", pattern: /\.c$/i },
+    { pack: "kibi-lang-cpp", name: "C++", pattern: /\.(?:cc|cpp|cxx|hh|hpp|hxx)$/i },
+    { pack: "kibi-lang-bash", name: "Bash", pattern: /\.(?:bash|sh)$/i },
+    { pack: "kibi-lang-ruby", name: "Ruby", pattern: /\.rb$/i },
+    { pack: "kibi-lang-hcl", name: "Terraform/HCL", pattern: /\.(?:tf|hcl)$/i },
+    { pack: "kibi-lang-python", name: "Python", pattern: /\.pyi?$/i },
+    { pack: "kibi-lang-prolog", name: "SWI-Prolog", pattern: /\.(?:pl|plt)$/i },
+];
+export function pluginReferenceLanguage(file) {
+    return PLUGIN_REFERENCE_LANGUAGES.find((language) => language.pattern.test(file))?.name ?? null;
+}
+export const CODE_LANGUAGE_NAMES = {
+    js: "TypeScript or JavaScript",
+    python: "Python",
+    prolog: "SWI-Prolog",
+};
+/** How a reason names the language of `file`. */
+export function languageName(file) {
+    const language = codeLanguage(file);
+    return language === null ? "an unsupported language" : CODE_LANGUAGE_NAMES[language];
+}
+/**
+ * The one refusal for a file whose language a reader cannot read: what reads
+ * which languages, and the files it was handed outside them.
+ */
+// implements REQ-kibi-multilingual-code-proofs
+export function unsupportedLanguageReason(reader, supported, files) {
+    const names = supported.map((language) => language === "js" ? "TypeScript, JavaScript" : CODE_LANGUAGE_NAMES[language]);
+    const listed = names.length > 1 ? `${names.slice(0, -1).join(", ")} and ${names.at(-1)}` : (names[0] ?? "no");
+    return `${reader} reads ${listed} files, not ${files.slice(0, 3).join(", ")}${files.length > 3 ? ` and ${files.length - 3} more` : ""}`;
+}

package/dist/operations/proof/code-models.d.ts

@@ -3,9 +3,11 @@ import type { ProofContract } from "../../public/proof-protocol.js";
 import { type LanguageSpec } from "./regular-language.js";
 /** The most predicate calls one rule certificate may need. */
 export declare const MAX_TABLE_ROWS = 100000;
+/** A code export Kibi reads; `arg` projects a Prolog predicate's solutions. */
 export type Resolved = {
     file: string;
     export: string;
+    arg?: number;
 };
 export type TableRow = Readonly<{
     args: readonly string[];

package/dist/operations/proof/code-models.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"code-models.d.ts","sourceRoot":"","sources":["../../../src/operations/proof/code-models.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EACL,KAAK,YAAY,EAKlB,MAAM,uBAAuB,CAAC;AAM/B,8DAA8D;AAC9D,eAAO,MAAM,cAAc,SAAU,CAAC;AAGtC,MAAM,MAAM,QAAQ,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAExD,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC;IAC9B,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC,CAAC;AAEH,2EAA2E;AAC3E,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC;IAC/B,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;IACrD,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,QAAQ,EAAE,CAAC,CAAC,CAAC;CAC3D,CAAC,CAAC;AAEH,sDAAsD;AACtD,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC;IAClC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,WAAW,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC;IACpD,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B,CAAC,CAAC;AAEH,8CAA8C;AAC9C,MAAM,MAAM,YAAY,GACpB,QAAQ,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,IAAI,GAAG,QAAQ,CAAA;CAAE,CAAC,GACpF,QAAQ,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AA6ShD;;;GAGG;AAEH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CA0BxD;AAED;;;GAGG;AAEH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,aAAa,EACvB,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,GACpD,OAAO,CAAC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CA+BzE;AAED,qEAAqE;AAErE,wBAAsB,eAAe,CACnC,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,aAAa,GACtB,OAAO,CAAC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,YAAY,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CA0B5E;AAED,4EAA4E;AAE5E,wBAAsB,eAAe,CACnC,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,aAAa,GACtB,OAAO,CAAC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,YAAY,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAS5E;AA2CD;;;;GAIG;AAEH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,aAAa,EACvB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAqCxB;AAED,gFAAgF;AAEhF,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,aAAa,EACvB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiBxB;AAED,+EAA+E;AAE/E,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,aAAa,EACvB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAoBxB;AAED,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAExD;AAED;;;;;;;;GAQG;AAEH,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAC7C,MAAM,EAAE,MAAM,GACb,MAAM,GAAG,IAAI,CAgDf"}
+{"version":3,"file":"code-models.d.ts","sourceRoot":"","sources":["../../../src/operations/proof/code-models.ts"],"names":[],"mappings":"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"}