kibi-cli 0.1.0

package/dist/extractors/symbols-ts.js

@@ -0,0 +1,197 @@
+/*
+ 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/>.
+*/
+/*
+ How to apply this header to source files (examples)
+
+ 1) Prepend header to a single file (POSIX shells):
+
+    cat LICENSE_HEADER.txt "$FILE" > "$FILE".with-header && mv "$FILE".with-header "$FILE"
+
+ 2) Apply to multiple files (example: the project's main entry files):
+
+    for f in packages/cli/bin/kibi packages/mcp/bin/kibi-mcp packages/cli/src/*.ts packages/mcp/src/*.ts; do
+      if [ -f "$f" ]; then
+        cp "$f" "$f".bak
+        (cat LICENSE_HEADER.txt; echo; cat "$f" ) > "$f".new && mv "$f".new "$f"
+      fi
+    done
+
+ 3) Avoid duplicating the header: run a quick guard to only add if missing
+
+    for f in packages/cli/bin/kibi packages/mcp/bin/kibi-mcp; do
+      if [ -f "$f" ]; then
+        if ! head -n 5 "$f" | grep -q "Copyright (C) 2026 Piotr Franczyk"; then
+          cp "$f" "$f".bak
+          (cat LICENSE_HEADER.txt; echo; cat "$f" ) > "$f".new && mv "$f".new "$f"
+        fi
+      fi
+    done
+*/
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Project, } from "ts-morph";
+const SUPPORTED_SOURCE_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mts",
+    ".cts",
+    ".mjs",
+    ".cjs",
+]);
+export async function enrichSymbolCoordinatesWithTsMorph(entries, workspaceRoot) {
+    const project = new Project({
+        skipAddingFilesFromTsConfig: true,
+    });
+    const sourceFileCache = new Map();
+    const enriched = [];
+    for (const entry of entries) {
+        try {
+            const resolved = resolveSourcePath(entry.sourceFile, workspaceRoot);
+            if (!resolved) {
+                enriched.push(entry);
+                continue;
+            }
+            const sourceFile = getOrAddSourceFile(project, sourceFileCache, resolved);
+            if (!sourceFile) {
+                enriched.push(entry);
+                continue;
+            }
+            const match = findNamedDeclaration(sourceFile, entry.title);
+            if (!match) {
+                enriched.push(entry);
+                continue;
+            }
+            const nameStart = match.getNameNode().getStart();
+            const end = match.node.getEnd();
+            const startLc = sourceFile.getLineAndColumnAtPos(nameStart);
+            const endLc = sourceFile.getLineAndColumnAtPos(end);
+            const coordinates = {
+                sourceLine: startLc.line,
+                sourceColumn: Math.max(0, startLc.column - 1),
+                sourceEndLine: endLc.line,
+                sourceEndColumn: Math.max(0, endLc.column - 1),
+                coordinatesGeneratedAt: new Date().toISOString(),
+            };
+            enriched.push({
+                ...entry,
+                ...coordinates,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[kibi] Failed to enrich symbol coordinates for ${entry.id}: ${message}`);
+            enriched.push(entry);
+        }
+    }
+    return enriched;
+}
+function resolveSourcePath(sourceFile, workspaceRoot) {
+    if (!sourceFile)
+        return null;
+    const absolute = path.isAbsolute(sourceFile)
+        ? sourceFile
+        : path.resolve(workspaceRoot, sourceFile);
+    const ext = path.extname(absolute).toLowerCase();
+    if (!SUPPORTED_SOURCE_EXTENSIONS.has(ext))
+        return null;
+    if (!fs.existsSync(absolute))
+        return null;
+    return absolute;
+}
+function getOrAddSourceFile(project, cache, absolutePath) {
+    const cached = cache.get(absolutePath);
+    if (cached)
+        return cached;
+    try {
+        const sourceFile = project.addSourceFileAtPath(absolutePath);
+        cache.set(absolutePath, sourceFile);
+        return sourceFile;
+    }
+    catch {
+        return null;
+    }
+}
+function findNamedDeclaration(sourceFile, title) {
+    const candidates = [];
+    for (const decl of sourceFile.getFunctions()) {
+        if (!decl.isExported())
+            continue;
+        if (decl.getName() !== title)
+            continue;
+        const nameNode = decl.getNameNode();
+        if (!nameNode)
+            continue;
+        candidates.push({ node: decl, getNameNode: () => nameNode });
+    }
+    for (const decl of sourceFile.getClasses()) {
+        if (!decl.isExported())
+            continue;
+        if (decl.getName() !== title)
+            continue;
+        const nameNode = decl.getNameNode();
+        if (!nameNode)
+            continue;
+        candidates.push({ node: decl, getNameNode: () => nameNode });
+    }
+    for (const decl of sourceFile.getInterfaces()) {
+        if (!decl.isExported())
+            continue;
+        if (decl.getName() !== title)
+            continue;
+        const nameNode = decl.getNameNode();
+        if (!nameNode)
+            continue;
+        candidates.push({ node: decl, getNameNode: () => nameNode });
+    }
+    for (const decl of sourceFile.getTypeAliases()) {
+        if (!decl.isExported())
+            continue;
+        if (decl.getName() !== title)
+            continue;
+        const nameNode = decl.getNameNode();
+        if (!nameNode)
+            continue;
+        candidates.push({ node: decl, getNameNode: () => nameNode });
+    }
+    for (const decl of sourceFile.getEnums()) {
+        if (!decl.isExported())
+            continue;
+        if (decl.getName() !== title)
+            continue;
+        const nameNode = decl.getNameNode();
+        if (!nameNode)
+            continue;
+        candidates.push({ node: decl, getNameNode: () => nameNode });
+    }
+    for (const statement of sourceFile.getVariableStatements()) {
+        if (!statement.isExported())
+            continue;
+        for (const declaration of statement.getDeclarations()) {
+            if (declaration.getName() !== title)
+                continue;
+            const nameNode = declaration.getNameNode();
+            candidates.push({ node: declaration, getNameNode: () => nameNode });
+        }
+    }
+    if (candidates.length === 0)
+        return null;
+    candidates.sort((a, b) => a.getNameNode().getStart() - b.getNameNode().getStart());
+    return candidates[0] ?? null;
+}

package/dist/prolog.d.ts

@@ -0,0 +1,35 @@
+export interface PrologOptions {
+    swiplPath?: string;
+    timeout?: number;
+}
+export interface QueryResult {
+    success: boolean;
+    bindings: Record<string, string>;
+    error?: string;
+}
+export declare class PrologProcess {
+    private process;
+    private swiplPath;
+    private timeout;
+    private outputBuffer;
+    private errorBuffer;
+    private cache;
+    private useOneShotMode;
+    private attachedKbPath;
+    private onProcessExit;
+    constructor(options?: PrologOptions);
+    start(): Promise<void>;
+    private waitForReady;
+    query(goal: string | string[]): Promise<QueryResult>;
+    invalidateCache(): void;
+    private isCacheableGoal;
+    private queryOneShot;
+    private execOneShot;
+    private normalizeGoal;
+    private extractBindings;
+    private translateError;
+    isRunning(): boolean;
+    getPid(): number;
+    terminate(): Promise<void>;
+}
+//# sourceMappingURL=prolog.d.ts.map

package/dist/prolog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prolog.d.ts","sourceRoot":"","sources":["../src/prolog.ts"],"names":[],"mappings":"AAoDA,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,KAAK,CAAuC;IACpD,OAAO,CAAC,cAAc,CACyC;IAC/D,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,aAAa,CAA6B;gBAEtC,OAAO,GAAE,aAAkB;IAKjC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAqCd,YAAY;IAapB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC;IAmF1D,eAAe,IAAI,IAAI;IAIvB,OAAO,CAAC,eAAe;YAYT,YAAY;IA0B1B,OAAO,CAAC,WAAW;IA8EnB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,cAAc;IA8BtB,SAAS,IAAI,OAAO;IAIpB,MAAM,IAAI,MAAM;IAIV,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CAyBjC"}

package/dist/prolog.js

@@ -0,0 +1,328 @@
+/*
+ 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/>.
+*/
+/*
+ How to apply this header to source files (examples)
+
+ 1) Prepend header to a single file (POSIX shells):
+
+    cat LICENSE_HEADER.txt "$FILE" > "$FILE".with-header && mv "$FILE".with-header "$FILE"
+
+ 2) Apply to multiple files (example: the project's main entry files):
+
+    for f in packages/cli/bin/kibi packages/mcp/bin/kibi-mcp packages/cli/src/*.ts packages/mcp/src/*.ts; do
+      if [ -f "$f" ]; then
+        cp "$f" "$f".bak
+        (cat LICENSE_HEADER.txt; echo; cat "$f" ) > "$f".new && mv "$f".new "$f"
+      fi
+    done
+
+ 3) Avoid duplicating the header: run a quick guard to only add if missing
+
+    for f in packages/cli/bin/kibi packages/mcp/bin/kibi-mcp; do
+      if [ -f "$f" ]; then
+        if ! head -n 5 "$f" | grep -q "Copyright (C) 2026 Piotr Franczyk"; then
+          cp "$f" "$f".bak
+          (cat LICENSE_HEADER.txt; echo; cat "$f" ) > "$f".new && mv "$f".new "$f"
+        fi
+      fi
+    done
+*/
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const importMetaDir = path.dirname(fileURLToPath(import.meta.url));
+export class PrologProcess {
+    process = null;
+    swiplPath;
+    timeout;
+    outputBuffer = "";
+    errorBuffer = "";
+    cache = new Map();
+    useOneShotMode = typeof globalThis.Bun !== "undefined";
+    attachedKbPath = null;
+    onProcessExit = null;
+    constructor(options = {}) {
+        this.swiplPath = options.swiplPath || "swipl";
+        this.timeout = options.timeout || 30000;
+    }
+    async start() {
+        if (!existsSync(this.swiplPath) && this.swiplPath !== "swipl") {
+            throw new Error(`SWI-Prolog not found at ${this.swiplPath}. Please install SWI-Prolog or check your PATH.`);
+        }
+        const kbPath = path.resolve(importMetaDir, "../../core/src/kb.pl");
+        this.process = spawn(this.swiplPath, [
+            "-g",
+            `use_module('${kbPath}'), set_prolog_flag(answer_write_options, [max_depth(0), quoted(true)])`,
+            "--quiet",
+        ]);
+        if (!this.process.stdout || !this.process.stderr || !this.process.stdin) {
+            throw new Error("Failed to spawn Prolog process");
+        }
+        this.process.stdout.on("data", (chunk) => {
+            this.outputBuffer += chunk.toString();
+        });
+        this.process.stderr.on("data", (chunk) => {
+            this.errorBuffer += chunk.toString();
+        });
+        if (!this.onProcessExit) {
+            this.onProcessExit = () => {
+                void this.terminate();
+            };
+            process.on("exit", this.onProcessExit);
+        }
+        await this.waitForReady();
+    }
+    async waitForReady() {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        if (this.errorBuffer.includes("ERROR")) {
+            throw new Error(`Failed to load kb module: ${this.translateError(this.errorBuffer)}`);
+        }
+        this.outputBuffer = "";
+        this.errorBuffer = "";
+    }
+    async query(goal) {
+        const isSingleGoal = typeof goal === "string";
+        const goalKey = isSingleGoal ? goal : null;
+        const cacheable = goalKey !== null && this.isCacheableGoal(goalKey);
+        if (cacheable) {
+            const cachedResult = this.cache.get(goalKey);
+            if (cachedResult) {
+                return cachedResult;
+            }
+        }
+        if (this.useOneShotMode) {
+            const oneShotResult = await this.queryOneShot(goal);
+            if (!cacheable && oneShotResult.success) {
+                this.invalidateCache();
+            }
+            if (cacheable && oneShotResult.success) {
+                this.cache.set(goalKey, oneShotResult);
+            }
+            return oneShotResult;
+        }
+        if (!isSingleGoal) {
+            const batchGoal = `(${goal.map((item) => this.normalizeGoal(item)).join(", ")})`;
+            return this.query(batchGoal);
+        }
+        if (!this.process || !this.process.stdin) {
+            throw new Error("Prolog process not started");
+        }
+        this.outputBuffer = "";
+        this.errorBuffer = "";
+        this.process.stdin.write(`${goal}.
+`);
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                reject(new Error("Query timeout after 30s"));
+            }, this.timeout);
+            const checkResult = () => {
+                if (this.errorBuffer.length > 0 && this.errorBuffer.includes("ERROR")) {
+                    clearTimeout(timeoutId);
+                    resolve({
+                        success: false,
+                        bindings: {},
+                        error: this.translateError(this.errorBuffer),
+                    });
+                }
+                else if (this.outputBuffer.includes("true.") ||
+                    this.outputBuffer.match(/^[A-Z_][A-Za-z0-9_]*\s*=\s*.+\./m)) {
+                    clearTimeout(timeoutId);
+                    const result = {
+                        success: true,
+                        bindings: this.extractBindings(this.outputBuffer),
+                    };
+                    if (cacheable) {
+                        this.cache.set(goalKey, result);
+                    }
+                    resolve(result);
+                }
+                else if (this.outputBuffer.includes("false.") ||
+                    this.outputBuffer.includes("fail.")) {
+                    clearTimeout(timeoutId);
+                    resolve({
+                        success: false,
+                        bindings: {},
+                        error: "Query failed",
+                    });
+                }
+                else {
+                    setTimeout(checkResult, 50);
+                }
+            };
+            checkResult();
+        });
+    }
+    invalidateCache() {
+        this.cache.clear();
+    }
+    isCacheableGoal(goal) {
+        const trimmed = goal.trim();
+        return !(trimmed.startsWith("kb_attach(") ||
+            trimmed.startsWith("kb_detach") ||
+            trimmed.startsWith("kb_save") ||
+            trimmed.startsWith("kb_assert_") ||
+            trimmed.startsWith("kb_delete_") ||
+            trimmed.startsWith("kb_retract_"));
+    }
+    async queryOneShot(goal) {
+        if (Array.isArray(goal)) {
+            return this.execOneShot(goal, this.attachedKbPath);
+        }
+        const trimmedGoal = this.normalizeGoal(goal);
+        // Keep a lightweight compatibility layer for callers that rely on
+        // stateful attach/detach across multiple query() calls.
+        if (trimmedGoal.startsWith("kb_detach")) {
+            this.attachedKbPath = null;
+            return { success: true, bindings: {} };
+        }
+        const attachMatch = trimmedGoal.match(/^kb_attach\('(.+)'\)$/);
+        if (attachMatch) {
+            const attachResult = this.execOneShot(trimmedGoal, null);
+            if (attachResult.success) {
+                this.attachedKbPath = attachMatch[1];
+            }
+            return attachResult;
+        }
+        return this.execOneShot(trimmedGoal, this.attachedKbPath);
+    }
+    execOneShot(goal, kbPath) {
+        const goalList = Array.isArray(goal)
+            ? goal.map((item) => this.normalizeGoal(item))
+            : [this.normalizeGoal(goal)];
+        const isBatch = goalList.length > 1;
+        const combinedGoal = goalList.length === 1 ? goalList[0] : `(${goalList.join(", ")})`;
+        const kbModulePath = path.resolve(importMetaDir, "../../core/src/kb.pl");
+        const prologGoal = [
+            `use_module('${kbModulePath}')`,
+            "use_module(library(semweb/rdf_db))",
+            "set_prolog_flag(answer_write_options, [max_depth(0), quoted(true)])",
+            "getenv('KIBI_GOAL', GoalAtom)",
+            "read_term_from_atom(GoalAtom, Goal, [variable_names(Vars)])",
+            kbPath ? "getenv('KIBI_KB_PATH', KBPath), kb_attach(KBPath)" : "true",
+            isBatch ? "WrappedGoal = rdf_transaction(Goal)" : "WrappedGoal = Goal",
+            "(catch(call(WrappedGoal), E, (print_message(error, E), fail)) -> (forall(member(Name=Value, Vars), (write(Name), write('='), write_term(Value, [quoted(true), max_depth(0)]), writeln('.'))), writeln('__KIBI_TRUE__.')) ; writeln('__KIBI_FALSE__.'))",
+            kbPath ? "kb_save, kb_detach" : "true",
+        ].join(", ");
+        const result = spawnSync(this.swiplPath, ["-q", "-g", prologGoal, "-t", "halt"], {
+            encoding: "utf8",
+            timeout: this.timeout,
+            env: {
+                ...process.env,
+                KIBI_GOAL: combinedGoal,
+                ...(kbPath ? { KIBI_KB_PATH: kbPath } : {}),
+            },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        if (result.error &&
+            (result.error.message.includes("timed out") ||
+                // Bun/Node differ here; keep a conservative timeout detection.
+                result.error.message.includes("ETIMEDOUT"))) {
+            throw new Error("Query timeout after 30s");
+        }
+        const stdout = result.stdout ?? "";
+        const stderr = result.stderr ?? "";
+        if (stdout.includes("__KIBI_TRUE__")) {
+            const clean = stdout
+                .split("\n")
+                .filter((line) => !line.includes("__KIBI_TRUE__"))
+                .join("\n");
+            return {
+                success: true,
+                bindings: this.extractBindings(clean),
+            };
+        }
+        if (stderr.includes("ERROR")) {
+            return {
+                success: false,
+                bindings: {},
+                error: this.translateError(stderr),
+            };
+        }
+        return {
+            success: false,
+            bindings: {},
+            error: "Query failed",
+        };
+    }
+    normalizeGoal(goal) {
+        return goal.trim().replace(/\.+\s*$/, "");
+    }
+    extractBindings(output) {
+        const bindings = {};
+        const lines = output.split("\n");
+        for (const line of lines) {
+            const match = line.match(/^([A-Z_][A-Za-z0-9_]*)\s*=\s*(.+)\.?\s*$/);
+            if (match) {
+                const [, varName, value] = match;
+                bindings[varName] = value.trim().replace(/\.$/, "").replace(/,$/, "");
+            }
+        }
+        return bindings;
+    }
+    translateError(errorText) {
+        if (errorText.includes("existence_error") ||
+            errorText.includes("Unknown procedure")) {
+            return "Predicate or file not found";
+        }
+        if (errorText.includes("permission_error")) {
+            return "Access denied or KB locked";
+        }
+        if (errorText.includes("syntax_error") ||
+            errorText.includes("Operator expected")) {
+            return "Invalid query syntax";
+        }
+        if (errorText.includes("timeout_error")) {
+            return "Operation exceeded 30s timeout";
+        }
+        const simpleError = errorText
+            .replace(/ERROR:\s*/g, "")
+            .replace(/^\*\*.*\*\*$/gm, "")
+            .replace(/^\s+/gm, "")
+            .split("\n")[0]
+            .trim();
+        return simpleError || "Unknown error";
+    }
+    isRunning() {
+        return this.process !== null && !this.process.killed;
+    }
+    getPid() {
+        return this.process?.pid || 0;
+    }
+    async terminate() {
+        if (this.onProcessExit) {
+            process.off("exit", this.onProcessExit);
+            this.onProcessExit = null;
+        }
+        if (this.process) {
+            this.process.stdin?.end();
+            this.process.kill("SIGTERM");
+            await new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    this.process?.kill("SIGKILL");
+                    resolve(undefined);
+                }, 1000);
+                this.process?.on("exit", () => {
+                    clearTimeout(timeout);
+                    resolve(undefined);
+                });
+            });
+            this.process = null;
+        }
+    }
+}

package/dist/public/extractors/symbols-coordinator.d.ts

@@ -0,0 +1,2 @@
+export { enrichSymbolCoordinates, type ManifestSymbolEntry, } from "../../extractors/symbols-coordinator.js";
+//# sourceMappingURL=symbols-coordinator.d.ts.map

package/dist/public/extractors/symbols-coordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbols-coordinator.d.ts","sourceRoot":"","sources":["../../../src/public/extractors/symbols-coordinator.ts"],"names":[],"mappings":"AA8CA,OAAO,EACL,uBAAuB,EACvB,KAAK,mBAAmB,GACzB,MAAM,yCAAyC,CAAC"}

package/dist/public/extractors/symbols-coordinator.js

@@ -0,0 +1,46 @@
+/*
+ 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/>.
+*/
+/*
+ How to apply this header to source files (examples)
+
+ 1) Prepend header to a single file (POSIX shells):
+
+    cat LICENSE_HEADER.txt "$FILE" > "$FILE".with-header && mv "$FILE".with-header "$FILE"
+
+ 2) Apply to multiple files (example: the project's main entry files):
+
+    for f in packages/cli/bin/kibi packages/mcp/bin/kibi-mcp packages/cli/src/*.ts packages/mcp/src/*.ts; do
+      if [ -f "$f" ]; then
+        cp "$f" "$f".bak
+        (cat LICENSE_HEADER.txt; echo; cat "$f" ) > "$f".new && mv "$f".new "$f"
+      fi
+    done
+
+ 3) Avoid duplicating the header: run a quick guard to only add if missing
+
+    for f in packages/cli/bin/kibi packages/mcp/bin/kibi-mcp; do
+      if [ -f "$f" ]; then
+        if ! head -n 5 "$f" | grep -q "Copyright (C) 2026 Piotr Franczyk"; then
+          cp "$f" "$f".bak
+          (cat LICENSE_HEADER.txt; echo; cat "$f" ) > "$f".new && mv "$f".new "$f"
+        fi
+      fi
+    done
+*/
+// Public re-export of symbols coordinator
+export { enrichSymbolCoordinates, } from "../../extractors/symbols-coordinator.js";

package/dist/public/prolog/index.d.ts

@@ -0,0 +1,2 @@
+export { PrologProcess } from "../../prolog.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/public/prolog/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/public/prolog/index.ts"],"names":[],"mappings":"AA8CA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/public/prolog/index.js

@@ -0,0 +1,46 @@
+/*
+ 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/>.
+*/
+/*
+ How to apply this header to source files (examples)
+
+ 1) Prepend header to a single file (POSIX shells):
+
+    cat LICENSE_HEADER.txt "$FILE" > "$FILE".with-header && mv "$FILE".with-header "$FILE"
+
+ 2) Apply to multiple files (example: the project's main entry files):
+
+    for f in packages/cli/bin/kibi packages/mcp/bin/kibi-mcp packages/cli/src/*.ts packages/mcp/src/*.ts; do
+      if [ -f "$f" ]; then
+        cp "$f" "$f".bak
+        (cat LICENSE_HEADER.txt; echo; cat "$f" ) > "$f".new && mv "$f".new "$f"
+      fi
+    done
+
+ 3) Avoid duplicating the header: run a quick guard to only add if missing
+
+    for f in packages/cli/bin/kibi packages/mcp/bin/kibi-mcp; do
+      if [ -f "$f" ]; then
+        if ! head -n 5 "$f" | grep -q "Copyright (C) 2026 Piotr Franczyk"; then
+          cp "$f" "$f".bak
+          (cat LICENSE_HEADER.txt; echo; cat "$f" ) > "$f".new && mv "$f".new "$f"
+        fi
+      fi
+    done
+*/
+// Public re-export of PrologProcess
+export { PrologProcess } from "../../prolog.js";