kibi-cli 0.2.3 → 0.2.5

package/dist/commands/sync/manifest.js

@@ -0,0 +1,118 @@
+/*
+ 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 { existsSync, readFileSync, writeFileSync } from "node:fs";
+import * as path from "node:path";
+import { dump as dumpYAML, load as parseYAML } from "js-yaml";
+import { enrichSymbolCoordinates, } from "../../extractors/symbols-coordinator.js";
+const SYMBOLS_MANIFEST_COMMENT_BLOCK = `# symbols.yaml
+# AUTHORED fields (edit freely):
+#   id, title, sourceFile, links, status, tags, owner, priority
+# GENERATED fields (never edit manually — overwritten by kibi sync and kb.symbols.refresh):
+#   sourceLine, sourceColumn, sourceEndLine, sourceEndColumn, coordinatesGeneratedAt
+# Run \`kibi sync\` or call the \`kb.symbols.refresh\` MCP tool to refresh coordinates.
+`;
+const SYMBOL_COORD_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mts",
+    ".cts",
+    ".mjs",
+    ".cjs",
+]);
+const GENERATED_COORD_FIELDS = [
+    "sourceLine",
+    "sourceColumn",
+    "sourceEndLine",
+    "sourceEndColumn",
+    "coordinatesGeneratedAt",
+];
+export async function refreshManifestCoordinates(manifestPath, workspaceRoot) {
+    const rawContent = readFileSync(manifestPath, "utf8");
+    const parsed = parseYAML(rawContent);
+    if (!isRecord(parsed)) {
+        console.warn(`Warning: symbols manifest ${manifestPath} is not a YAML object; skipping coordinate refresh`);
+        return;
+    }
+    const rawSymbols = parsed.symbols;
+    if (!Array.isArray(rawSymbols)) {
+        console.warn(`Warning: symbols manifest ${manifestPath} has no symbols array; skipping coordinate refresh`);
+        return;
+    }
+    const before = rawSymbols.map((entry) => isRecord(entry)
+        ? { ...entry }
+        : {});
+    const enriched = await enrichSymbolCoordinates(before, workspaceRoot);
+    parsed.symbols = enriched;
+    let refreshed = 0;
+    let failed = 0;
+    let unchanged = 0;
+    for (let i = 0; i < before.length; i++) {
+        const previous = before[i] ?? {};
+        const current = enriched[i] ?? previous;
+        const changed = GENERATED_COORD_FIELDS.some((field) => previous[field] !== current[field]);
+        if (changed) {
+            refreshed++;
+            continue;
+        }
+        const eligible = isEligibleForCoordinateRefresh(typeof current.sourceFile === "string"
+            ? current.sourceFile
+            : typeof previous.sourceFile === "string"
+                ? previous.sourceFile
+                : undefined, workspaceRoot);
+        if (eligible && !hasAllGeneratedCoordinates(current)) {
+            failed++;
+        }
+        else {
+            unchanged++;
+        }
+    }
+    const dumped = dumpYAML(parsed, {
+        lineWidth: -1,
+        noRefs: true,
+        sortKeys: false,
+    });
+    const nextContent = `${SYMBOLS_MANIFEST_COMMENT_BLOCK}${dumped}`;
+    if (rawContent !== nextContent) {
+        writeFileSync(manifestPath, nextContent, "utf8");
+    }
+    console.log(`✓ Refreshed symbol coordinates in ${path.relative(workspaceRoot, manifestPath)} (refreshed=${refreshed}, unchanged=${unchanged}, failed=${failed})`);
+}
+export function hasAllGeneratedCoordinates(entry) {
+    return (typeof entry.sourceLine === "number" &&
+        typeof entry.sourceColumn === "number" &&
+        typeof entry.sourceEndLine === "number" &&
+        typeof entry.sourceEndColumn === "number" &&
+        typeof entry.coordinatesGeneratedAt === "string" &&
+        entry.coordinatesGeneratedAt.length > 0);
+}
+export function isEligibleForCoordinateRefresh(sourceFile, workspaceRoot) {
+    if (!sourceFile)
+        return false;
+    const absolute = path.isAbsolute(sourceFile)
+        ? sourceFile
+        : path.resolve(workspaceRoot, sourceFile);
+    if (!existsSync(absolute))
+        return false;
+    const ext = path.extname(absolute).toLowerCase();
+    return SYMBOL_COORD_EXTENSIONS.has(ext);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/commands/sync/persistence.d.ts

@@ -0,0 +1,16 @@
+import type { ExtractedRelationship, ExtractionResult } from "../../extractors/markdown.js";
+import type { PrologProcess } from "../../prolog.js";
+export interface PersistenceResult {
+    entityCount: number;
+    relationshipCount: number;
+    kbModified: boolean;
+}
+export declare function persistEntities(prolog: PrologProcess, results: ExtractionResult[], entityIds: Set<string>): Promise<{
+    entityCount: number;
+    kbModified: boolean;
+}>;
+export declare function persistRelationships(prolog: PrologProcess, results: ExtractionResult[], shardRelationships: ExtractedRelationship[]): Promise<{
+    relationshipCount: number;
+    kbModified: boolean;
+}>;
+//# sourceMappingURL=persistence.d.ts.map

package/dist/commands/sync/persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/persistence.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EACV,qBAAqB,EACrB,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGrD,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,wBAAsB,eAAe,CACnC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,gBAAgB,EAAE,EAC3B,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,GACrB,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,CAAC,CA0DvD;AAED,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,gBAAgB,EAAE,EAC3B,kBAAkB,EAAE,qBAAqB,EAAE,GAC1C,OAAO,CAAC;IAAE,iBAAiB,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,CAAC,CAiI7D"}

package/dist/commands/sync/persistence.js

@@ -0,0 +1,188 @@
+/*
+ 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 * as path from "node:path";
+import { toPrologAtom } from "../../prolog/codec.js";
+export async function persistEntities(prolog, results, entityIds) {
+    let entityCount = 0;
+    let kbModified = false;
+    // Query existing entity IDs to include unchanged entities
+    const existingIdsResult = await prolog.query("findall(Id, kb_entity(Id, _, _), ExistingIds)");
+    if (existingIdsResult.success && existingIdsResult.bindings?.ExistingIds) {
+        const raw = existingIdsResult.bindings.ExistingIds;
+        const cleaned = raw.trim().replace(/^\[/, "").replace(/\]$/, "");
+        if (cleaned) {
+            for (const atom of cleaned.split(",")) {
+                const id = atom.trim().replace(/^'|'$/g, "");
+                if (id)
+                    entityIds.add(id);
+            }
+        }
+    }
+    for (const { entity } of results) {
+        entityIds.add(entity.id);
+    }
+    for (const { entity } of results) {
+        try {
+            const props = [
+                `id='${entity.id}'`,
+                `title="${entity.title.replace(/"/g, '\\"')}"`,
+                `status=${toPrologAtom(entity.status)}`,
+                `created_at="${entity.created_at}"`,
+                `updated_at="${entity.updated_at}"`,
+                `source="${entity.source.replace(/"/g, '\\"')}"`,
+            ];
+            if (entity.tags && entity.tags.length > 0) {
+                const tagsList = entity.tags.map(toPrologAtom).join(",");
+                props.push(`tags=[${tagsList}]`);
+            }
+            if (entity.owner)
+                props.push(`owner=${toPrologAtom(entity.owner)}`);
+            if (entity.priority)
+                props.push(`priority=${toPrologAtom(entity.priority)}`);
+            if (entity.severity)
+                props.push(`severity=${toPrologAtom(entity.severity)}`);
+            if (entity.text_ref)
+                props.push(`text_ref="${entity.text_ref}"`);
+            const propsList = `[${props.join(", ")}]`;
+            const goal = `kb_assert_entity(${entity.type}, ${propsList})`;
+            const result = await prolog.query(goal);
+            if (result.success) {
+                entityCount++;
+                kbModified = true;
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`Warning: Failed to upsert entity ${entity.id}: ${message}`);
+        }
+    }
+    return { entityCount, kbModified };
+}
+export async function persistRelationships(prolog, results, shardRelationships) {
+    let relCount = 0;
+    let kbModified = false;
+    // Build ID lookup for relationship resolution
+    const idLookup = new Map();
+    for (const { entity } of results) {
+        const filename = path.basename(entity.source, ".md");
+        idLookup.set(filename, entity.id);
+        idLookup.set(entity.id, entity.id);
+    }
+    // Collect all relationships from results and shards
+    const failedRelationships = [];
+    for (const { relationships } of results) {
+        for (const rel of relationships) {
+            try {
+                const fromId = idLookup.get(rel.from) || rel.from;
+                const toId = idLookup.get(rel.to) || rel.to;
+                const goal = `kb_assert_relationship(${toPrologAtom(rel.type)}, ${toPrologAtom(fromId)}, ${toPrologAtom(toId)}, [])`;
+                const result = await prolog.query(goal);
+                if (result.success) {
+                    relCount++;
+                    kbModified = true;
+                }
+                else {
+                    failedRelationships.push({
+                        rel,
+                        fromId,
+                        toId,
+                        error: result.error || "Unknown error",
+                    });
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const fromId = idLookup.get(rel.from) || rel.from;
+                const toId = idLookup.get(rel.to) || rel.to;
+                failedRelationships.push({ rel, fromId, toId, error: message });
+            }
+        }
+    }
+    // Assert relationships from shards
+    for (const rel of shardRelationships) {
+        try {
+            const goal = `kb_assert_relationship(${toPrologAtom(rel.type)}, ${toPrologAtom(rel.from)}, ${toPrologAtom(rel.to)}, [])`;
+            const result = await prolog.query(goal);
+            if (result.success) {
+                relCount++;
+                kbModified = true;
+            }
+            else {
+                failedRelationships.push({
+                    rel,
+                    fromId: rel.from,
+                    toId: rel.to,
+                    error: result.error || "Unknown error",
+                });
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            failedRelationships.push({
+                rel,
+                fromId: rel.from,
+                toId: rel.to,
+                error: message,
+            });
+        }
+    }
+    // Retry failed relationships
+    const retryCount = 3;
+    for (let pass = 0; pass < retryCount && failedRelationships.length > 0; pass++) {
+        const remainingFailed = [];
+        for (const { rel, fromId, toId } of failedRelationships) {
+            try {
+                const goal = `kb_assert_relationship(${toPrologAtom(rel.type)}, ${toPrologAtom(fromId)}, ${toPrologAtom(toId)}, [])`;
+                const result = await prolog.query(goal);
+                if (result.success) {
+                    relCount++;
+                    kbModified = true;
+                }
+                else {
+                    remainingFailed.push({
+                        rel,
+                        fromId,
+                        toId,
+                        error: result.error || "Unknown error",
+                    });
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                remainingFailed.push({ rel, fromId, toId, error: message });
+            }
+        }
+        failedRelationships.length = 0;
+        failedRelationships.push(...remainingFailed);
+    }
+    // Log remaining failures
+    if (failedRelationships.length > 0) {
+        console.warn(`\nWarning: ${failedRelationships.length} relationship(s) failed to sync:`);
+        const seen = new Set();
+        for (const { rel, fromId, toId, error } of failedRelationships) {
+            const key = `${rel.type}:${fromId}->${toId}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                console.warn(`  - ${rel.type}: ${fromId} -> ${toId}`);
+                console.warn(`    Error: ${error}`);
+            }
+        }
+        console.warn("\nTip: Ensure target entities exist before creating relationships.");
+    }
+    return { relationshipCount: relCount, kbModified };
+}

package/dist/commands/sync/staging.d.ts

@@ -0,0 +1,4 @@
+export declare function prepareStagingEnvironment(stagingPath: string, livePath: string, rebuild: boolean): Promise<void>;
+export declare function atomicPublish(stagingPath: string, livePath: string): void;
+export declare function cleanupStaging(stagingPath: string): void;
+//# sourceMappingURL=staging.d.ts.map

package/dist/commands/sync/staging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staging.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/staging.ts"],"names":[],"mappings":"AAwBA,wBAAsB,yBAAyB,CAC7C,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,IAAI,CAAC,CAYf;AAuCD,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAczE;AAED,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAIxD"}

package/dist/commands/sync/staging.js

@@ -0,0 +1,86 @@
+/*
+ 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 { existsSync, mkdirSync, renameSync, rmSync } from "node:fs";
+import { copyFileSync } from "node:fs";
+import * as path from "node:path";
+import fg from "fast-glob";
+import { copyCleanSnapshot } from "../../utils/branch-resolver.js";
+export async function prepareStagingEnvironment(stagingPath, livePath, rebuild) {
+    // Cleanup any existing staging directory
+    cleanupStaging(stagingPath);
+    mkdirSync(stagingPath, { recursive: true });
+    if (!rebuild && existsSync(livePath)) {
+        // Use existing live path if available
+        copyCleanSnapshot(livePath, stagingPath);
+    }
+    else {
+        // Start fresh with schema only
+        await copySchemaToStaging(stagingPath);
+    }
+}
+async function copySchemaToStaging(stagingPath) {
+    const possibleSchemaPaths = [
+        path.resolve(process.cwd(), "node_modules", "kibi-cli", "schema"),
+        path.resolve(process.cwd(), "..", "..", "schema"),
+        path.resolve(import.meta.dirname || __dirname, "..", "..", "schema"),
+        path.resolve(process.cwd(), "packages", "cli", "schema"),
+    ];
+    let schemaSourceDir = null;
+    for (const p of possibleSchemaPaths) {
+        if (existsSync(p)) {
+            schemaSourceDir = p;
+            break;
+        }
+    }
+    if (!schemaSourceDir) {
+        return;
+    }
+    const schemaFiles = await fg("*.pl", {
+        cwd: schemaSourceDir,
+        absolute: false,
+    });
+    const schemaDestDir = path.join(stagingPath, "schema");
+    if (!existsSync(schemaDestDir)) {
+        mkdirSync(schemaDestDir, { recursive: true });
+    }
+    for (const file of schemaFiles) {
+        const sourcePath = path.join(schemaSourceDir, file);
+        const destPath = path.join(schemaDestDir, file);
+        copyFileSync(sourcePath, destPath);
+    }
+}
+export function atomicPublish(stagingPath, livePath) {
+    const liveParent = path.dirname(livePath);
+    if (!existsSync(liveParent)) {
+        mkdirSync(liveParent, { recursive: true });
+    }
+    if (existsSync(livePath)) {
+        const tempPath = `${livePath}.old.${Date.now()}`;
+        renameSync(livePath, tempPath);
+        renameSync(stagingPath, livePath);
+        rmSync(tempPath, { recursive: true, force: true });
+    }
+    else {
+        renameSync(stagingPath, livePath);
+    }
+}
+export function cleanupStaging(stagingPath) {
+    if (existsSync(stagingPath)) {
+        rmSync(stagingPath, { recursive: true, force: true });
+    }
+}

package/dist/commands/sync.d.ts

@@ -1,4 +1,4 @@
-import { type SyncSummary } from "../diagnostics.js";
+import type { SyncSummary } from "../diagnostics.js";
 export declare class SyncError extends Error {
     constructor(message: string);
 }
@@ -6,4 +6,5 @@ export declare function syncCommand(options?: {
     validateOnly?: boolean;
     rebuild?: boolean;
 }): Promise<SyncSummary>;
+export { normalizeMarkdownPath } from "./sync/discovery.js";
 //# sourceMappingURL=sync.d.ts.map

package/dist/commands/sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../src/commands/sync.ts"],"names":[],"mappings":"AAmEA,OAAO,EAEL,KAAK,WAAW,EAMjB,MAAM,mBAAmB,CAAC;AAc3B,qBAAa,SAAU,SAAQ,KAAK;gBACtB,OAAO,EAAE,MAAM;CAI5B;AAwLD,wBAAsB,WAAW,CAC/B,OAAO,GAAE;IACP,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;CACd,GACL,OAAO,CAAC,WAAW,CAAC,CAyhBtB"}
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../src/commands/sync.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAc,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAyCjE,qBAAa,SAAU,SAAQ,KAAK;gBACtB,OAAO,EAAE,MAAM;CAI5B;AAED,wBAAsB,WAAW,CAC/B,OAAO,GAAE;IACP,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;CACd,GACL,OAAO,CAAC,WAAW,CAAC,CA4VtB;AAGD,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC"}