kibi-cli 2.38.0 → 2.40.0

package/dist/operations/proof/java-package-shadow.js

@@ -0,0 +1,389 @@
+/*
+ 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/>.
+*/
+/**
+ * Names another file of the project may bind instead of the standard one.
+ * The tree-sitter reference reader reads one file at a time, so it marks:
+ *
+ * - a bare Java `System` or `Runtime` ("System may be a class of package
+ *   p: ..."): a top-level type of that name in another file of the package
+ *   would be used instead of java.lang's;
+ * - a bare Rust standard macro ("println may be a macro_rules! macro of the
+ *   crate: ..."): a `macro_rules! println` elsewhere in the crate, in
+ *   textual scope through `#[macro_use]`, would be expanded instead;
+ * - a C# System type spelled bare ("Environment may be a type of the
+ *   project: ..."): a type of that name in the file's namespace, an
+ *   enclosing one or the global namespace, declared in any file of the
+ *   project, or a `global using` alias of that name, would bind instead of
+ *   System's;
+ * - a Go name the file uses but does not declare ("getenv may be declared in
+ *   another file of the package: ..."), for env: another file of the package
+ *   may hold a getter or a wrapper of one;
+ * - a Go name the file calls but does not declare ("command may be a
+ *   function of another file of the package: ..."), for calls: another file
+ *   of the package may bind it to a function value (`var command =
+ *   exec.Command`), so the call is that function's;
+ * - a Go import ("config may be a package of the project: ..."), for env: a
+ *   package of the project may wrap a getter (`config.Get("X")`, `var Get =
+ *   os.Getenv`) or read the environment at init.
+ *
+ * The host drops such a row only after it has looked at those files and
+ * found no such declaration. When it finds one, or cannot read the files,
+ * the row stays and the read is refused.
+ */
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+const JAVA_ROW = /^(System|Runtime) may be a class of (?:package ([\w.]+)|the default package): /;
+const RUST_ROW = /^(\w+) may be a macro_rules! macro of the crate: /;
+const CSHARP_ROW = /^(\w+) may be a type of the project: /;
+const GO_ROW = /^(\w+) may be declared in another file of the package: /;
+const GO_IMPORT_ROW = /^\S+ may be a package of the project: /;
+const GO_CALL_ROW = /^(\w+) may be a function of another file of the package: /;
+/**
+ * What in Go source may read the environment: a getter of os, syscall or
+ * x/sys (also as a value, or through an alias or a dot import), cgo, and a
+ * `//go:linkname`, which binds a local name to any function.
+ */
+const GO_ENV_SOURCE = /\b(?:Getenv|LookupEnv|Environ|ExpandEnv|Expand)\b|"C"|go:linkname/;
+/** Java source with comments, string, char and text-block contents removed. */
+export function javaCode(text) {
+    let out = "";
+    let index = 0;
+    while (index < text.length) {
+        const rest = text.slice(index, index + 3);
+        if (rest.startsWith("//")) {
+            const end = text.indexOf("\n", index);
+            index = end === -1 ? text.length : end;
+            out += " ";
+        }
+        else if (rest.startsWith("/*")) {
+            const end = text.indexOf("*/", index + 2);
+            index = end === -1 ? text.length : end + 2;
+            out += " ";
+        }
+        else if (rest === '"""') {
+            const end = text.indexOf('"""', index + 3);
+            index = end === -1 ? text.length : end + 3;
+            out += '""';
+        }
+        else if (rest[0] === '"' || rest[0] === "'") {
+            const quote = rest[0];
+            index += 1;
+            while (index < text.length && text[index] !== quote && text[index] !== "\n")
+                index += text[index] === "\\" ? 2 : 1;
+            index += 1;
+            out += `${quote}${quote}`;
+        }
+        else {
+            out += text[index];
+            index += 1;
+        }
+    }
+    return out;
+}
+/**
+ * Java source with its Unicode escapes decoded (`q` is `q`), as the
+ * compiler reads it before anything else; a backslash escaped by another
+ * starts no escape.
+ */
+function javaUnicode(text) {
+    return text.replace(/(\\+)u+([0-9a-fA-F]{4})/g, (escape, slashes, hex) => slashes.length % 2 === 1 ? `${slashes.slice(1)}${String.fromCharCode(Number.parseInt(hex, 16))}` : escape);
+}
+/** The package a Java file declares, "" for the default package. */
+function javaPackage(text) {
+    const declared = /\bpackage\s+([\w$.\s]+?)\s*;/.exec(javaCode(javaUnicode(text)));
+    return declared === null ? "" : declared[1].replace(/\s+/g, "");
+}
+/** Whether Java source declares a type of that name (any nesting). */
+function javaDeclares(text, name) {
+    // A Unicode escape may spell any identifier: the file is not ruled out.
+    if (text.includes("\\u"))
+        return true;
+    return new RegExp(`(?:^|[^\\w$.])(?:class|interface|enum|record)\\s+${name}(?![\\w$])`).test(javaCode(text));
+}
+/**
+ * Source files with an extension under a directory, skipping dot folders,
+ * node_modules and the named build folders.
+ */
+function sourceFiles(directory, extension, skipped = []) {
+    const files = [];
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules" || skipped.includes(entry.name))
+            continue;
+        const full = path.join(directory, entry.name);
+        if (entry.isDirectory())
+            files.push(...sourceFiles(full, extension, skipped));
+        else if (entry.name.endsWith(extension))
+            files.push(full);
+    }
+    return files;
+}
+/**
+ * Whether C# source may declare a type, namespace or `global using` alias of
+ * that name. Comments and strings are not stripped (a mention there keeps
+ * the row too), and an identifier spelled with a Unicode escape may be any
+ * name.
+ */
+function csharpDeclares(text, name) {
+    const id = `@?${name}(?![\\w\\\\])`;
+    return (new RegExp(`\\b(?:class|struct|interface|enum|record)\\s+(?:(?:class|struct)\\s+)?${id}`).test(text) ||
+        new RegExp(`\\bdelegate\\s+[^;{}()]*?[\\s>\\]?]${id}\\s*[<(]`).test(text) ||
+        new RegExp(`\\bnamespace\\s+(?:[\\w@]+\\s*\\.\\s*)*${id}`).test(text) ||
+        new RegExp(`\\bglobal\\s+using\\s+${id}\\s*=`).test(text) ||
+        /\b(?:class|struct|interface|enum|record|delegate)\b[^;{}]*?\\[uU]/.test(text));
+}
+/** Go string literals, interpreted and raw: every import path a file may spell. */
+function goStrings(text) {
+    return [...text.matchAll(/"((?:[^"\\\n]|\\.)*)"|`([^`]*)`/g)].map((match) => match[1] ?? match[2] ?? "");
+}
+/**
+ * The project's Go modules: each go.mod's module path at its folder (which
+ * covers the modules of a go.work), and each replace with a local folder.
+ */
+function goModules(workspaceRoot) {
+    const modules = [];
+    for (const file of sourceFiles(workspaceRoot, "go.mod", ["vendor"])) {
+        if (path.basename(file) !== "go.mod")
+            continue;
+        const dir = path.dirname(file);
+        const text = readFileSync(file, "utf8").replace(/\/\/[^\n]*/g, "");
+        const name = /^\s*module\s+"?([^\s"]+)"?/m.exec(text);
+        if (name !== null)
+            modules.push({ path: name[1], dir });
+        // `replace a v1 => ../a`, alone or in a `replace ( ... )` block.
+        for (const replace of text.matchAll(/^\s*(?:replace\s+)?"?([^\s"(]+)"?(?:\s+\S+)?\s*=>\s*"?((?:\.\.?|\/)[^\s"]*)"?/gm))
+            modules.push({ path: replace[1], dir: path.resolve(dir, replace[2]) });
+    }
+    return modules;
+}
+/** Whether a go.mod at or above `directory`, within the workspace, puts it in module mode. */
+function goModuleMode(workspaceRoot, directory) {
+    for (let current = directory;; current = path.dirname(current)) {
+        try {
+            if (statSync(path.join(current, "go.mod")).isFile())
+                return true;
+        }
+        catch {
+            // no go.mod here
+        }
+        if (path.relative(workspaceRoot, current) === "" || path.dirname(current) === current)
+            return false;
+    }
+}
+/**
+ * Which Go packages are the project's, and whether one can read the
+ * environment. Folder scans and go.mod files are read once per filter.
+ */
+function createGoReach(workspaceRoot) {
+    let modules;
+    const reached = new Map();
+    /**
+     * The folder an import path names when it is the project's: relative,
+     * under a module path or local replace of the project (the longest
+     * wins), or, without a go.mod (GOPATH mode), that path under one of the
+     * importer's enclosing folders. Null for another package (the standard
+     * library's, a third-party one); "" when the project's go.mod files
+     * cannot be read.
+     */
+    const resolve = (spelled, from) => {
+        if (/^\.\.?(?:\/|$)/.test(spelled))
+            return path.resolve(from, spelled);
+        if (goModuleMode(workspaceRoot, from)) {
+            if (modules === undefined) {
+                try {
+                    modules = goModules(workspaceRoot);
+                }
+                catch {
+                    modules = null;
+                }
+            }
+            if (modules === null)
+                return "";
+            let best = null;
+            for (const module of modules)
+                if ((spelled === module.path || spelled.startsWith(`${module.path}/`)) &&
+                    (best === null || module.path.length > best.path.length))
+                    best = module;
+            return best === null ? null : path.join(best.dir, spelled.slice(best.path.length));
+        }
+        for (let current = from;; current = path.dirname(current)) {
+            const candidate = path.join(current, spelled);
+            try {
+                if (statSync(candidate).isDirectory())
+                    return candidate;
+            }
+            catch {
+                // not here
+            }
+            if (path.relative(workspaceRoot, current) === "" || path.dirname(current) === current)
+                return null;
+        }
+    };
+    /**
+     * Whether a package of the project can read the environment: one of its
+     * files (not its tests, which an importer does not compile) spells a
+     * getter, cgo or a linkname, or imports a package of the project that
+     * can. A folder that cannot be read, or holds no Go file, can.
+     */
+    const reaches = (dir) => {
+        const known = reached.get(dir);
+        if (known !== undefined)
+            return known;
+        // An import cycle reads nothing by itself.
+        reached.set(dir, false);
+        let result;
+        try {
+            const texts = readdirSync(dir)
+                .filter((name) => name.endsWith(".go") && !name.endsWith("_test.go"))
+                .map((name) => readFileSync(path.join(dir, name), "utf8"));
+            result = texts.some((text) => GO_ENV_SOURCE.test(text) || importsReach(text, dir));
+        }
+        catch (error) {
+            // No such folder: no package of the project, so the path is not an
+            // import of it (an import of it would not build), only a string.
+            const code = error.code;
+            result = code !== "ENOENT" && code !== "ENOTDIR";
+        }
+        reached.set(dir, result);
+        return result;
+    };
+    /** Whether Go source imports a package of the project that can read the environment. */
+    const importsReach = (text, from) => goStrings(text).some((spelled) => {
+        const target = resolve(spelled, from);
+        return target === "" || (target !== null && target !== from && reaches(target));
+    });
+    return { importsReach };
+}
+/** The nearest folder holding Cargo.toml at or above `directory`, within the workspace. */
+function crateRoot(workspaceRoot, directory) {
+    for (let current = directory;; current = path.dirname(current)) {
+        try {
+            if (statSync(path.join(current, "Cargo.toml")).isFile())
+                return current;
+        }
+        catch {
+            // no manifest here
+        }
+        if (path.relative(workspaceRoot, current) === "" || path.dirname(current) === current)
+            return workspaceRoot;
+    }
+}
+/**
+ * Whether Rust source may define a macro of that name for the crate: a
+ * `macro_rules!` of it (comments allowed between the tokens), a
+ * `macro_rules!` whose name is a macro variable, or `#[macro_use] extern
+ * crate`, which brings another crate's macros in.
+ */
+function rustDefines(text, name) {
+    const gap = String.raw `(?:\s|\/\*[\s\S]*?\*\/|\/\/[^\n]*)*`;
+    return (new RegExp(`macro_rules${gap}!${gap}(?:r#)?${name}(?!\\w)`).test(text) ||
+        new RegExp(`macro_rules${gap}!${gap}\\$`).test(text) ||
+        new RegExp(`#${gap}\\[${gap}macro_use${gap}\\]${gap}(?:pub${gap})?extern${gap}crate\\b`).test(text));
+}
+/**
+ * A filter for one read: keeps every row, except a marked row whose
+ * declaration the project's files rule out. Directory scans are shared by
+ * the files of the read.
+ */
+export function createShadowRowFilter(workspaceRoot) {
+    const sources = new Map();
+    const read = (key, list) => {
+        if (!sources.has(key)) {
+            try {
+                sources.set(key, list().map((file) => readFileSync(file, "utf8")));
+            }
+            catch {
+                sources.set(key, null);
+            }
+        }
+        return sources.get(key) ?? null;
+    };
+    const go = createGoReach(workspaceRoot);
+    return (file, rows) => {
+        const directory = path.dirname(path.join(workspaceRoot, file));
+        return rows.filter((row) => {
+            const java = JAVA_ROW.exec(row.text);
+            if (java !== null) {
+                const texts = read(`java:${directory}`, () => readdirSync(directory)
+                    .filter((name) => name.endsWith(".java"))
+                    .map((name) => path.join(directory, name)));
+                const type = java[1];
+                if (texts === null || texts.some((text) => javaDeclares(text, type)))
+                    return true;
+                // A package spans source roots (src/main/java beside generated or
+                // test sources), and a file's package is what it declares, not its
+                // folder: every .java file of the project declaring the package is
+                // read too.
+                const all = read("java:*", () => sourceFiles(workspaceRoot, ".java"));
+                const pkg = java[2] ?? "";
+                return all === null || all.some((text) => javaPackage(text) === pkg && javaDeclares(text, type));
+            }
+            const rust = RUST_ROW.exec(row.text);
+            if (rust !== null) {
+                const root = crateRoot(workspaceRoot, directory);
+                const texts = read(`rust:${root}`, () => sourceFiles(root, ".rs", ["target"]));
+                return texts === null || texts.some((text) => rustDefines(text, rust[1]));
+            }
+            if (GO_IMPORT_ROW.test(row.text)) {
+                // The row's text may be cut short, so the import is read from the
+                // file's line; every path spelled there is checked.
+                const texts = read(`file:${file}`, () => [path.join(workspaceRoot, file)]);
+                const line = texts?.[0]?.split("\n")[row.line - 1];
+                return line === undefined || goStrings(line).length === 0 || go.importsReach(line, directory);
+            }
+            const goCall = GO_CALL_ROW.exec(row.text);
+            if (goCall !== null) {
+                const own = path.basename(file);
+                const test = own.endsWith("_test.go");
+                const texts = read(`go:${file}`, () => readdirSync(directory)
+                    .filter((name) => name.endsWith(".go") && name !== own && (test || !name.endsWith("_test.go")))
+                    .map((name) => path.join(directory, name)));
+                // A function declared in another file is the package's own function;
+                // a variable of that name may hold any function value.
+                const name = goCall[1];
+                const variable = new RegExp(`\\bvar\\s+${name}\\b|\\b${name}\\s*(?:,\\s*\\w+\\s*)*(?::=|=(?!=))|^\\s*${name}\\s+[^\\s(=]`, "m");
+                return texts === null || texts.some((text) => variable.test(javaCode(text)));
+            }
+            const goName = GO_ROW.exec(row.text);
+            if (goName !== null) {
+                // The package's other files: the directory's .go files, with its
+                // test files only for a test file.
+                const own = path.basename(file);
+                const test = own.endsWith("_test.go");
+                const texts = read(`go:${file}`, () => readdirSync(directory)
+                    .filter((name) => name.endsWith(".go") && name !== own && (test || !name.endsWith("_test.go")))
+                    .map((name) => path.join(directory, name)));
+                // A getter may be reached through the name by any chain of the
+                // package's functions and values, so the row stays when any of
+                // those files can read the environment and any names it.
+                // A file that imports a package of the project that can read the
+                // environment can read it too.
+                const name = new RegExp(`\\b${goName[1]}\\b`);
+                return (texts === null ||
+                    (texts.some((text) => GO_ENV_SOURCE.test(text) || go.importsReach(text, directory)) &&
+                        texts.some((text) => name.test(text))));
+            }
+            const csharp = CSHARP_ROW.exec(row.text);
+            if (csharp !== null) {
+                // Generated sources under obj/ are compiled too, so they are read.
+                const texts = read("csharp", () => sourceFiles(workspaceRoot, ".cs"));
+                return texts === null || texts.some((text) => csharpDeclares(text, csharp[1]));
+            }
+            return true;
+        });
+    };
+}

package/dist/operations/proof/prolog-evaluator.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The SWI-Prolog evaluator behind the code proof kinds. Kibi runs it with the
+ * SWI-Prolog it resolves for its own engine (KIBI_SWIPL, the bundled runtime,
+ * then swipl on PATH). It loads the file a symbol names (a module, or a plain
+ * file into user) and reads a predicate named by its indicator: a domain is
+ * the distinct solutions of one argument (`arg`, or the only one), a value is
+ * the single number such a solution holds, a rule predicate is called once
+ * per row and decides it by success or failure, and a transition table lists
+ * every solution as an edge. The plan is the last command-line argument; the
+ * answer is the last line of output, in the JSON the JavaScript and Python
+ * evaluators print.
+ */
+export declare const PROLOG_EVALUATOR: string;
+//# sourceMappingURL=prolog-evaluator.d.ts.map

package/dist/operations/proof/prolog-evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prolog-evaluator.d.ts","sourceRoot":"","sources":["../../../src/operations/proof/prolog-evaluator.ts"],"names":[],"mappings":"AAkBA;;;;;;;;;;;GAWG;AAEH,eAAO,MAAM,gBAAgB,QAwN5B,CAAC"}

package/dist/operations/proof/prolog-evaluator.js

@@ -0,0 +1,247 @@
+/*
+ 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/>.
+*/
+/**
+ * The SWI-Prolog evaluator behind the code proof kinds. Kibi runs it with the
+ * SWI-Prolog it resolves for its own engine (KIBI_SWIPL, the bundled runtime,
+ * then swipl on PATH). It loads the file a symbol names (a module, or a plain
+ * file into user) and reads a predicate named by its indicator: a domain is
+ * the distinct solutions of one argument (`arg`, or the only one), a value is
+ * the single number such a solution holds, a rule predicate is called once
+ * per row and decides it by success or failure, and a transition table lists
+ * every solution as an edge. The plan is the last command-line argument; the
+ * answer is the last line of output, in the JSON the JavaScript and Python
+ * evaluators print.
+ */
+// implements REQ-kibi-multilingual-code-proofs
+export const PROLOG_EVALUATOR = String.raw `
+:- module(kibi_proof_evaluator, []).
+:- use_module(library(http/json)).
+:- use_module(library(apply)).
+:- use_module(library(lists)).
+:- use_module(library(pairs)).
+
+:- initialization(main, main).
+
+:- dynamic loaded_module/2.
+
+main :-
+    current_prolog_flag(argv, Argv),
+    last(Argv, PlanText),
+    atom_json_dict(PlanText, Plan, [value_string_as(string)]),
+    (   catch(run(Plan, Out), Error, (failure_text(Error, Text), failed(Plan, Text, Out)))
+    ->  true
+    ;   failed(Plan, "the evaluation failed", Out)
+    ),
+    nl,
+    json_write_dict(current_output, Out, [width(0)]),
+    nl.
+
+failed(Plan, Text, _{error: Text}) :- Plan.mode == "export", !.
+failed(_, Text, _{ok: false, error: Text}).
+
+failure_text(kibi(Text), Text) :- !.
+failure_text(Error, Text) :-
+    catch('$messages':translate_message(Error, Lines, []), _, fail),
+    !,
+    with_output_to(string(Raw), print_message_lines(current_output, '', Lines)),
+    split_string(Raw, "", "\n ", [Text]).
+failure_text(Error, Text) :- format(string(Text), "~q", [Error]).
+
+refuse(Format, Args) :- format(string(Text), Format, Args), throw(kibi(Text)).
+
+% The module a file defines, loaded once; user for a plain file.
+module_of(File, Module) :- loaded_module(File, Module), !.
+module_of(File, Module) :-
+    atom_string(Path, File),
+    load_files(user:Path, [if(not_loaded), silent(true)]),
+    absolute_file_name(Path, Absolute, [file_type(prolog), access(read)]),
+    (   module_property(Defined, file(Absolute)) -> Module = Defined ; Module = user ),
+    assertz(loaded_module(File, Module)).
+
+% A predicate indicator: Name/Arity, Name//Arity (a DCG rule) or Module:Indicator.
+indicator(Text, Default, Module, Name, Arity) :-
+    catch(term_string(Term, Text), _, refuse("~s is not a predicate indicator Name/Arity", [Text])),
+    indicator_term(Term, Text, Default, Module, Name, Arity).
+
+indicator_term(Module:Term, Text, _, Found, Name, Arity) :- atom(Module), !,
+    indicator_term(Term, Text, Module, Found, Name, Arity).
+indicator_term(Name/Arity, _, Module, Module, Name, Arity) :- atom(Name), integer(Arity), Arity >= 0, !.
+indicator_term(Name//Rule, _, Module, Module, Name, Arity) :- atom(Name), integer(Rule), Rule >= 0, !,
+    Arity is Rule + 2.
+indicator_term(_, Text, _, _, _, _) :- refuse("~s is not a predicate indicator Name/Arity", [Text]).
+
+% The goal behind a reference, after checking the predicate is defined.
+predicate(Ref, Module, Head, Name, Arity) :-
+    module_of(Ref.file, Default),
+    indicator(Ref.export, Default, Module, Name, Arity),
+    functor(Head, Name, Arity),
+    (   predicate_property(Module:Head, defined) -> true
+    ;   refuse("~s is not defined in ~s", [Ref.export, Ref.file])
+    ).
+
+% The argument a reference projects its solutions on: arg, or the only one.
+projected(Ref, Arity, Index) :-
+    (   get_dict(arg, Ref, Index)
+    ->  (   integer(Index), Index >= 1, Index =< Arity -> true
+        ;   refuse("arg ~w is not an argument of ~s", [Index, Ref.export])
+        )
+    ;   Arity =:= 1
+    ->  Index = 1
+    ;   Arity =:= 0
+    ->  refuse("~s takes no argument to list", [Ref.export])
+    ;   refuse("~s has ~w arguments; set arg to the one that names each member", [Ref.export, Arity])
+    ).
+
+limit_solutions(100000).
+
+% The distinct solutions of a reference's projected argument, in order.
+values(Ref, Values) :-
+    predicate(Ref, Module, Head, _, Arity),
+    projected(Ref, Arity, Index),
+    arg(Index, Head, Value),
+    limit_solutions(Limit),
+    Over is Limit + 1,
+    findall(Value, limit(Over, Module:Head), All),
+    length(All, Count),
+    (   Count > Limit -> refuse("~s has more than ~w solutions", [Ref.export, Limit]) ; true ),
+    (   member(Open, All), \+ ground(Open)
+    ->  refuse("a solution of ~s leaves argument ~w unbound", [Ref.export, Index])
+    ;   true
+    ),
+    list_to_set(All, Values).
+
+text(Value, Text) :- string(Value), !, Text = Value.
+text(Value, Text) :- atom(Value), !, atom_string(Value, Text).
+text(Value, Text) :- number(Value), !, number_string(Value, Text).
+text(Value, Text) :- format(string(Text), "~q", [Value]).
+
+run(Plan, Out) :- Plan.mode == "export", !, export(Plan, Out).
+run(Plan, _{ok: true, model: Model}) :- Plan.mode == "table", !, table(Plan, Model).
+run(Plan, _{ok: true, model: Model}) :- Plan.mode == "machine", !, machine(Plan, Model).
+run(Plan, _{ok: true, model: Model}) :- Plan.mode == "pattern", !, pattern(Plan.pattern, Model).
+run(Plan, _) :- refuse("unknown plan mode ~w", [Plan.mode]).
+
+% A domain lists its members; a value is the single number a constant holds.
+export(Plan, Out) :-
+    values(Plan.ref, Values),
+    (   Plan.want == "scalar"
+    ->  (   Values = [Number], number(Number)
+        ->  Out = _{scalar: Number}
+        ;   Values = [Other]
+        ->  refuse("~s holds ~q, not a number", [Plan.ref.export, Other])
+        ;   length(Values, Count),
+            refuse("~s has ~w solutions, not the single value of a constant", [Plan.ref.export, Count])
+        )
+    ;   length(Values, Count),
+        maplist(text, Values, Members),
+        Out = _{count: Count, members: Members}
+    ).
+
+domain(Ref, Values) :- get_dict(values, Ref, Texts), !, maplist(atom_string, Values, Texts).
+domain(Ref, Values) :- values(Ref, Values).
+
+table(Plan, _{domains: Domains, predicates: Predicates}) :-
+    dict_pairs(Plan.domains, _, DomainRefs),
+    findall(Type-Values, (member(Type-Ref, DomainRefs), domain(Ref, Values)), Typed),
+    findall(Type-Texts, (member(Type-Values, Typed), maplist(text, Values, Texts)), DomainTexts),
+    dict_pairs(Domains, _, DomainTexts),
+    dict_pairs(Plan.predicates, _, PredicateRefs),
+    foldl(predicate_table(Typed, Plan.limit), PredicateRefs, []-0, Reversed-_),
+    reverse(Reversed, Rows),
+    dict_pairs(Predicates, _, Rows).
+
+predicate_table(Typed, Limit, Name-Ref, Done-Used, [Name-Rows|Done]-Total) :-
+    predicate(Ref, Module, Head, _, Arity),
+    length(Ref.arg_types, Types),
+    (   Types =:= Arity -> true
+    ;   refuse("~s takes ~w arguments, but the predicate ~w has ~w argument types", [Ref.export, Arity, Name, Types])
+    ),
+    findall(Values,
+            ( member(TypeText, Ref.arg_types),
+              atom_string(Type, TypeText),
+              (   memberchk(Type-Values, Typed) -> true
+              ;   refuse("no domain for argument type ~s of ~w", [TypeText, Name])
+              )
+            ),
+            Lists),
+    foldl([List, P0, P]>>(length(List, L), P is P0 * L), Lists, 1, Count),
+    Total is Used + Count,
+    (   Total > Limit -> refuse("the predicate tables need more than ~w calls", [Limit]) ; true ),
+    findall(Row, (maplist(member, Tuple, Lists), row(Module, Head, Tuple, Row)), Rows).
+
+row(Module, Head, Tuple, Row) :-
+    copy_term(Head, Goal),
+    Goal =.. [_|Tuple],
+    maplist(text, Tuple, Args),
+    catch(( once(Module:Goal) -> Row = _{args: Args, value: true} ; Row = _{args: Args, value: false} ),
+          Error,
+          ( failure_text(Error, Text), Row = _{args: Args, error: Text} )).
+
+% A transition table: Name/2 facts (from, to), Name/3 facts (from, event,
+% to), or with state and event domains a Name/3 next-state predicate Kibi
+% calls on every state and event.
+machine(Plan, Model) :-
+    Ref = Plan.transitions,
+    predicate(Ref, Module, Head, _, Arity),
+    (   get_dict(domains, Plan, Domains)
+    ->  (   Arity =:= 3 -> true ; refuse("~s must take a state, an event and the next state", [Ref.export]) ),
+        values(Domains.state, States0),
+        values(Domains.event, Events),
+        findall(From-To,
+                ( member(From, States0), member(Event, Events),
+                  Head =.. [_, From, Event, To],
+                  catch(Module:Head, _, fail)
+                ),
+                Edges)
+    ;   Arity =:= 2
+    ->  Head =.. [_, From, To],
+        findall(From-To, Module:Head, Edges),
+        States0 = []
+    ;   Arity =:= 3
+    ->  Head =.. [_, From, _, To],
+        findall(From-To, Module:Head, Edges),
+        States0 = []
+    ;   refuse("~s is not a transition table Name/2 or Name/3", [Ref.export])
+    ),
+    (   member(Edge, Edges), \+ ground(Edge) -> refuse("a transition of ~s leaves a state unbound", [Ref.export]) ; true ),
+    findall(Text, (member(State, States0), text(State, Text)), Listed),
+    findall([FromText, ToText], (member(F-T, Edges), text(F, FromText), text(T, ToText)), Pairs0),
+    sort(Pairs0, Pairs),
+    findall(S, (member([A, B], Pairs), member(S, [A, B])), Ends),
+    append(Listed, Ends, AllStates),
+    sort(AllStates, StateTexts),
+    Base = _{states: StateTexts, transitions: Pairs},
+    (   get_dict(initial, Plan, Initial), Initial \== null
+    ->  values(Initial, InitialValues),
+        maplist(text, InitialValues, InitialTexts0),
+        sort(InitialTexts0, InitialTexts),
+        Model = Base.put(initial, InitialTexts)
+    ;   Model = Base
+    ).
+
+% A pattern constant: the single atom or string a Name/1 fact holds.
+pattern(Ref, _{type: "string", value: Text}) :-
+    values(Ref, Values),
+    (   Values = [Value], (atom(Value) ; string(Value))
+    ->  text(Value, Text)
+    ;   Values = [Other]
+    ->  refuse("~s holds ~q, not an atom or a string", [Ref.export, Other])
+    ;   length(Values, Count),
+        refuse("~s has ~w solutions, not the single pattern of a constant", [Ref.export, Count])
+    ).
+`;

package/dist/operations/proof/prolog-source-reader.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The SWI-Prolog reader behind the `references` reader for `.pl` and `.plt`
+ * files and the `prolog` source reader. It reads terms with read_term/3 and
+ * runs none of the project's code: operators come from the file's own op/3
+ * directives and module export lists, those of project modules it loads
+ * (read from their module header) and those of the SWI-Prolog libraries it
+ * loads. `references` mode walks clause bodies and directives through
+ * control constructs and meta-predicate arguments (the file's own
+ * meta_predicate declarations and SWI-Prolog's), the goals ~@ calls in
+ * format strings and message lines, and the bodies of clauses
+ * asserted from literal terms, and reports every place it cannot read
+ * statically: a variable called as a goal or closure, a goal qualified by a
+ * variable module, a clause asserted from data, conditional compilation, a
+ * term_expansion or goal_expansion clause in the files or in a project file
+ * they load (expansion can produce any clause), and an include of a file
+ * outside the files read. `terms` mode lists one argument of every fact with
+ * a given functor, in file order.
+ */
+export declare const PROLOG_SOURCE_READER: string;
+//# sourceMappingURL=prolog-source-reader.d.ts.map

package/dist/operations/proof/prolog-source-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prolog-source-reader.d.ts","sourceRoot":"","sources":["../../../src/operations/proof/prolog-source-reader.ts"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;GAiBG;AAEH,eAAO,MAAM,oBAAoB,QA8jChC,CAAC"}