kibi-cli 0.1.4 → 0.1.6

package/dist/cli.js

@@ -87,6 +87,11 @@ program
     .command("check")
     .description("Check KB consistency and integrity")
     .option("--fix", "Suggest fixes for violations")
+    .option("--kb-path <dir>", "Path to KB directory (overrides branch resolution)")
+    .option("--rules <csv>", "Comma-separated allowlist of rule names to run")
+    .option("--staged", "Run check only against staged changes (experimental)")
+    .option("--min-links <n>", "Minimum number of links required for symbol coverage", "1")
+    .option("--dry-run", "Do not modify files; only print what would happen")
     .action(async (options) => {
     await checkCommand(options);
 });

package/dist/commands/aggregated-checks.d.ts

@@ -0,0 +1,9 @@
+import { type PrologProcess } from "../prolog.js";
+import type { Violation } from "./check.js";
+/**
+ * Run all checks using the aggregated Prolog predicates.
+ * This makes a single Prolog call and parses JSON output, significantly
+ * faster than running individual checks with multiple round-trips.
+ */
+export declare function runAggregatedChecks(prolog: PrologProcess, rulesAllowlist: Set<string> | null): Promise<Violation[]>;
+//# sourceMappingURL=aggregated-checks.d.ts.map

package/dist/commands/aggregated-checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregated-checks.d.ts","sourceRoot":"","sources":["../../src/commands/aggregated-checks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAAmB,MAAM,cAAc,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,aAAa,EACrB,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,GACjC,OAAO,CAAC,SAAS,EAAE,CAAC,CAoFtB"}

package/dist/commands/aggregated-checks.js

@@ -0,0 +1,80 @@
+import path from "node:path";
+import { resolveKbPlPath } from "../prolog.js";
+/**
+ * Run all checks using the aggregated Prolog predicates.
+ * This makes a single Prolog call and parses JSON output, significantly
+ * faster than running individual checks with multiple round-trips.
+ */
+export async function runAggregatedChecks(prolog, rulesAllowlist) {
+    const violations = [];
+    // Build the check goal based on allowlist
+    const checkGoals = [];
+    const supportedRules = [
+        "must-priority-coverage",
+        "symbol-coverage",
+        "no-dangling-refs",
+        "no-cycles",
+        "required-fields",
+        "deprecated-adr-no-successor",
+        "domain-contradictions",
+    ];
+    for (const rule of supportedRules) {
+        if (!rulesAllowlist || rulesAllowlist.has(rule)) {
+            // Convert kebab-case to snake_case for Prolog
+            const prologRule = rule.replace(/-/g, "_");
+            checkGoals.push(`findall(V, checks:check_${prologRule}(V), ${prologRule}_violations)`);
+        }
+    }
+    if (checkGoals.length === 0) {
+        return violations;
+    }
+    const checksPlPath = path.join(path.dirname(resolveKbPlPath()), "checks.pl");
+    const checksPlPathEscaped = checksPlPath.replace(/'/g, "''");
+    const query = `(use_module('${checksPlPathEscaped}'), call(checks:check_all_json(JsonString)))`;
+    try {
+        const result = await prolog.query(query);
+        if (!result.success) {
+            console.warn("Aggregated checks query failed, falling back to individual checks");
+            return [];
+        }
+        // Parse the JSON from the binding
+        let violationsDict;
+        try {
+            const jsonString = result.bindings.JsonString;
+            if (jsonString) {
+                violationsDict = JSON.parse(jsonString);
+            }
+            else {
+                throw new Error("No JSON string in binding");
+            }
+        }
+        catch (parseError) {
+            console.warn("Failed to parse violations JSON:", parseError);
+            return [];
+        }
+        // Convert Prolog violation terms to Violation objects
+        for (const [ruleKey, ruleViolations] of Object.entries(violationsDict)) {
+            const rule = ruleKey.replace(/_/g, "-");
+            for (const v of ruleViolations) {
+                if (typeof v === "string") {
+                    // Parse Prolog violation/5 term: violation(Rule, EntityId, Desc, Sugg, Source)
+                    const match = v.match(/violation\(([^,]+),\s*'([^']+)'\s*,\s*"([^"]*)"\s*,\s*"([^"]*)"\s*,\s*"([^"]*)"\)/);
+                    if (match) {
+                        violations.push({
+                            rule: rule,
+                            entityId: match[2],
+                            description: match[3],
+                            suggestion: match[4] || undefined,
+                            source: match[5] || undefined,
+                        });
+                    }
+                }
+            }
+        }
+        return violations;
+    }
+    catch (error) {
+        console.warn("Error running aggregated checks:", error);
+        return [];
+    }
+}

package/dist/commands/check.d.ts

@@ -1,5 +1,10 @@
 export interface CheckOptions {
     fix?: boolean;
+    kbPath?: string;
+    rules?: string;
+    staged?: boolean;
+    minLinks?: string | number;
+    dryRun?: boolean;
 }
 export interface Violation {
     rule: string;

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

@@ -1 +1 @@
-{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/commands/check.ts"],"names":[],"mappings":"AA+CA,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAkDvE"}
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/commands/check.ts"],"names":[],"mappings":"AAsDA,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAqMvE"}

package/dist/commands/check.js

@@ -44,26 +44,163 @@
 */
 import * as path from "node:path";
 import { PrologProcess } from "../prolog.js";
+import { getStagedFiles } from "../traceability/git-staged.js";
+import { extractSymbolsFromStagedFile } from "../traceability/symbol-extract.js";
+import { cleanupTempKb, consultOverlay, createOverlayFacts, createTempKb } from "../traceability/temp-kb.js";
+import { formatViolations as formatStagedViolations, validateStagedSymbols } from "../traceability/validate.js";
+import { getCurrentBranch } from "./init-helpers.js";
+import { runAggregatedChecks } from "./aggregated-checks.js";
 export async function checkCommand(options) {
     try {
-        const prolog = new PrologProcess();
+        // Resolve KB path with priority:
+        // --kb-path > git branch --show-current > KIBI_BRANCH env > develop > main
+        let resolvedKbPath = "";
+        if (options.kbPath) {
+            resolvedKbPath = options.kbPath;
+        }
+        else {
+            const envBranch = process.env.KIBI_BRANCH;
+            let branch = envBranch || undefined;
+            if (!branch) {
+                try {
+                    branch = await getCurrentBranch(process.cwd());
+                }
+                catch {
+                    branch = undefined;
+                }
+            }
+            if (!branch)
+                branch = envBranch || "develop";
+            // fallback to main if develop isn't present? keep path consistent
+            resolvedKbPath = path.join(process.cwd(), ".kb/branches", branch || "main");
+        }
+        // If --staged mode requested, run staged-symbol traceability gate.
+        // We skip creating the main prolog session entirely in this path.
+        if (options.staged) {
+            const minLinks = options.minLinks ? Number(options.minLinks) : 1;
+            let tempCtx = null;
+            try {
+                // Get staged files
+                const stagedFiles = getStagedFiles();
+                if (!stagedFiles || stagedFiles.length === 0) {
+                    console.log("No staged files found.");
+                    process.exit(0);
+                }
+                // Extract symbols from staged files
+                const allSymbols = [];
+                for (const f of stagedFiles) {
+                    try {
+                        const symbols = extractSymbolsFromStagedFile(f);
+                        if (symbols && symbols.length) {
+                            allSymbols.push(...symbols);
+                        }
+                    }
+                    catch (e) {
+                        console.error(`Error extracting symbols from staged file ${f.path}: ${e instanceof Error ? e.message : String(e)}`);
+                    }
+                }
+                if (allSymbols.length === 0) {
+                    console.log("No exported symbols found in staged files.");
+                    process.exit(0);
+                }
+                // Create temp KB
+                tempCtx = await createTempKb(resolvedKbPath);
+                // Write overlay facts THEN consult so Prolog sees the changed_symbol facts
+                const overlayFacts = createOverlayFacts(allSymbols);
+                const fs = await import("node:fs/promises");
+                await fs.writeFile(tempCtx.overlayPath, overlayFacts, "utf8");
+                await consultOverlay(tempCtx);
+                // Validate staged symbols using the temp KB prolog session
+                const violationsRaw = await validateStagedSymbols({ minLinks, prolog: tempCtx.prolog });
+                const violationsFormatted = formatStagedViolations(violationsRaw);
+                if (violationsRaw && violationsRaw.length > 0) {
+                    console.log(violationsFormatted);
+                    await cleanupTempKb(tempCtx.tempDir);
+                    if (options.dryRun) {
+                        process.exit(0);
+                    }
+                    process.exit(1);
+                }
+                console.log("✓ No violations found in staged symbols.");
+                await cleanupTempKb(tempCtx.tempDir);
+                process.exit(0);
+            }
+            catch (err) {
+                console.error(`Error running staged validation: ${err instanceof Error ? err.message : String(err)}`);
+                if (tempCtx) {
+                    try {
+                        await cleanupTempKb(tempCtx.tempDir);
+                    }
+                    catch { }
+                }
+                process.exit(1);
+            }
+        }
+        const prolog = new PrologProcess({ timeout: 120000 });
         await prolog.start();
-        const kbPath = path.join(process.cwd(), ".kb/branches/main");
-        const attachResult = await prolog.query(`kb_attach('${kbPath}')`);
+        const kbPathEscaped = resolvedKbPath.replace(/'/g, "''");
+        const attachResult = await prolog.query(`kb_attach('${kbPathEscaped}')`);
         if (!attachResult.success) {
             await prolog.terminate();
             console.error(`Error: Failed to attach KB: ${attachResult.error}`);
             process.exit(1);
         }
         const violations = [];
-        violations.push(...(await checkMustPriorityCoverage(prolog)));
-        violations.push(...(await checkSymbolCoverage(prolog)));
-        violations.push(...(await checkNoDanglingRefs(prolog)));
-        violations.push(...(await checkNoCycles(prolog)));
+        // Parse rules allowlist if provided
+        let rulesAllowlist = null;
+        if (options.rules) {
+            const parts = options.rules
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean);
+            rulesAllowlist = new Set(parts);
+        }
+        // Helper to conditionally run a check by name
+        async function runCheck(name, fn, ...args) {
+            if (rulesAllowlist?.has(name) === false)
+                return;
+            const res = await fn(prolog, ...args);
+            if (res && res.length)
+                violations.push(...res);
+        }
+        // Use aggregated checks (single Prolog call) when possible for better performance
+        // This is significantly faster in Bun/Docker environments where one-shot mode
+        // spawns a new Prolog process for each query
+        const supportedRules = [
+            'must-priority-coverage',
+            'symbol-coverage',
+            'no-dangling-refs',
+            'no-cycles',
+            'required-fields',
+            'deprecated-adr-no-successor',
+            'domain-contradictions',
+        ];
+        const canUseAggregated = !rulesAllowlist ||
+            Array.from(rulesAllowlist).every(r => supportedRules.includes(r));
+        if (canUseAggregated) {
+            // Fast path: single Prolog call returning all violations
+            const aggregatedViolations = await runAggregatedChecks(prolog, rulesAllowlist);
+            violations.push(...aggregatedViolations);
+        }
+        else {
+            // Legacy path: individual checks for backward compatibility
+            await runCheck("must-priority-coverage", checkMustPriorityCoverage);
+            await runCheck("symbol-coverage", checkSymbolCoverage);
+            await runCheck("no-dangling-refs", checkNoDanglingRefs);
+            await runCheck("no-cycles", checkNoCycles);
+            const allEntityIds = await getAllEntityIds(prolog);
+            await runCheck("required-fields", checkRequiredFields, allEntityIds);
+            await runCheck("deprecated-adr-no-successor", checkDeprecatedAdrs);
+            await runCheck("domain-contradictions", checkDomainContradictions);
+        }
+        await runCheck("must-priority-coverage", checkMustPriorityCoverage);
+        await runCheck("symbol-coverage", checkSymbolCoverage);
+        await runCheck("no-dangling-refs", checkNoDanglingRefs);
+        await runCheck("no-cycles", checkNoCycles);
         const allEntityIds = await getAllEntityIds(prolog);
-        violations.push(...(await checkRequiredFields(prolog, allEntityIds)));
-        violations.push(...(await checkDeprecatedAdrs(prolog)));
-        violations.push(...(await checkDomainContradictions(prolog)));
+        await runCheck("required-fields", checkRequiredFields, allEntityIds);
+        await runCheck("deprecated-adr-no-successor", checkDeprecatedAdrs);
+        await runCheck("domain-contradictions", checkDomainContradictions);
         await prolog.query("kb_detach");
         await prolog.terminate();
         if (violations.length === 0) {

package/dist/commands/doctor.js

@@ -247,10 +247,30 @@ function checkPreCommitHook() {
     try {
         const preCommitStats = statSync(preCommitPath);
         const preCommitExecutable = (preCommitStats.mode & 0o111) !== 0;
+        // Read hook content to determine whether it's using the new staged check
+        const content = readFileSync(preCommitPath, "utf-8");
+        const usesKibi = content.includes("kibi check");
+        const usesStaged = content.includes("kibi check --staged");
+        if (!usesKibi) {
+            // Fail if hook doesn't invoke kibi at all
+            return {
+                passed: false,
+                message: "pre-commit hook installed but does not invoke kibi",
+                remediation: "Run: kibi init --hooks to install recommended hooks",
+            };
+        }
         if (preCommitExecutable) {
+            if (usesStaged) {
+                return {
+                    passed: true,
+                    message: "Installed and executable (uses 'kibi check --staged')",
+                };
+            }
+            // Warn but pass if using legacy kibi check without --staged
             return {
                 passed: true,
-                message: "Installed and executable",
+                message: "Installed and executable (uses legacy 'kibi check' — consider running 'kibi init' to update hooks to use '--staged')",
+                remediation: "Run: kibi init --hooks to update git hooks to the latest template",
             };
         }
         return {
@@ -262,7 +282,8 @@ function checkPreCommitHook() {
     catch (error) {
         return {
             passed: false,
-            message: "Unable to check hook permissions",
+            message: "Unable to check hook permissions or read content",
+            remediation: "Run: kibi init --hooks",
         };
     }
 }

package/dist/commands/init-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init-helpers.d.ts","sourceRoot":"","sources":["../../src/commands/init-helpers.ts"],"names":[],"mappings":"AAiFA,wBAAsB,gBAAgB,CACpC,GAAG,GAAE,MAAsB,GAC1B,OAAO,CAAC,MAAM,CAAC,CAejB;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,GACpB,IAAI,CAQN;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAMpD;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAajD;AAED,wBAAsB,eAAe,CACnC,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,IAAI,CAAC,CAYf;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAqBnE;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAapD"}
+{"version":3,"file":"init-helpers.d.ts","sourceRoot":"","sources":["../../src/commands/init-helpers.ts"],"names":[],"mappings":"AAkFA,wBAAsB,gBAAgB,CACpC,GAAG,GAAE,MAAsB,GAC1B,OAAO,CAAC,MAAM,CAAC,CAejB;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,GACpB,IAAI,CAQN;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAMpD;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAajD;AAED,wBAAsB,eAAe,CACnC,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,IAAI,CAAC,CAYf;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAuBnE;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAapD"}

package/dist/commands/init-helpers.js

@@ -42,7 +42,7 @@
       fi
     done
 */
-import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
 import * as path from "node:path";
 import fg from "fast-glob";
 const POST_CHECKOUT_HOOK = `#!/bin/sh
@@ -53,7 +53,7 @@ kibi sync
 `;
 const PRE_COMMIT_HOOK = `#!/bin/sh
 set -e
-kibi check
+kibi check --staged
 `;
 const DEFAULT_CONFIG = {
     paths: {
@@ -136,6 +136,8 @@ ${content}`, {
         writeFileSync(hookPath, `#!/bin/sh
 ${content}`, { mode: 0o755 });
     }
+    // Explicitly ensure hook is executable (mode option can be inconsistent in Docker)
+    chmodSync(hookPath, 0o755);
 }
 export function installGitHooks(gitDir) {
     const hooksDir = path.join(gitDir, "hooks");

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

@@ -1 +1 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/commands/query.ts"],"names":[],"mappings":"AAiDA,UAAU,YAAY;IACpB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,IAAI,CAAC,CA2Jf"}
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/commands/query.ts"],"names":[],"mappings":"AAoDA,UAAU,YAAY;IACpB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,IAAI,CAAC,CAwKf"}

package/dist/commands/query.js

@@ -45,9 +45,11 @@
 import * as path from "node:path";
 import Table from "cli-table3";
 import { PrologProcess } from "../prolog.js";
+import relationshipSchema from "../public/schemas/relationship.js";
+const REL_TYPES = relationshipSchema.properties.type.enum;
 export async function queryCommand(type, options) {
     try {
-        const prolog = new PrologProcess();
+        const prolog = new PrologProcess({ timeout: 120000 });
         await prolog.start();
         await prolog.query("set_prolog_flag(answer_write_options, [max_depth(0), spacing(next_argument)])");
         let currentBranch = "main";
@@ -73,15 +75,26 @@ export async function queryCommand(type, options) {
         let results = [];
         // Query relationships mode
         if (options.relationships) {
-            const goal = `findall([Type,From,To], kb_relationship(Type, ${options.relationships}, To), Results)`;
+            const fromId = String(options.relationships);
+            const safeFromId = fromId.replace(/'/g, "''");
+            // Query all relationship types for the given source ID
+            const goal = `findall([Type,From,To], (From='${safeFromId}', kb_relationship(Type, From, To)), Results)`;
             const queryResult = await prolog.query(goal);
             if (queryResult.success && queryResult.bindings.Results) {
-                const relationshipsData = parseListOfLists(queryResult.bindings.Results);
-                results = relationshipsData.map((rel) => ({
-                    type: rel[0],
-                    from: options.relationships,
-                    to: rel[1],
+                const rows = parseListOfLists(queryResult.bindings.Results);
+                const parsed = rows
+                    .filter((r) => r.length >= 3)
+                    .map((r) => ({
+                    type: parsePrologValue(r[0]),
+                    from: parsePrologValue(r[1]),
+                    to: parsePrologValue(r[2]),
                 }));
+                results = parsed.filter((rel) => rel &&
+                    typeof rel.type === "string" &&
+                    typeof rel.from === "string" &&
+                    typeof rel.to === "string" &&
+                    rel.from === fromId &&
+                    REL_TYPES.includes(rel.type));
             }
         }
         // Query entities mode

package/dist/commands/sync.js

@@ -327,7 +327,7 @@ export async function syncCommand(options = {}) {
             process.exit(0);
         }
         // Connect to KB
-        const prolog = new PrologProcess();
+        const prolog = new PrologProcess({ timeout: 120000 });
         await prolog.start();
         const kbPath = path.join(process.cwd(), `.kb/branches/${currentBranch}`);
         const mainPath = path.join(process.cwd(), ".kb/branches/main");

package/dist/prolog.d.ts

@@ -1,3 +1,4 @@
+export declare function resolveKbPlPath(): string;
 export interface PrologOptions {
     swiplPath?: string;
     timeout?: number;

package/dist/prolog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prolog.d.ts","sourceRoot":"","sources":["../src/prolog.ts"],"names":[],"mappings":"AA4EA,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;YAoCd,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"}
+{"version":3,"file":"prolog.d.ts","sourceRoot":"","sources":["../src/prolog.ts"],"names":[],"mappings":"AAuDA,wBAAgB,eAAe,IAAI,MAAM,CAsCxC;AACD,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;YAoCd,YAAY;IAyCpB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC;IAsH1D,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

@@ -49,23 +49,32 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 const importMetaDir = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
-function resolveKbPlPath() {
-    // 1) Prefer installed dependency (works after publish)
+export function resolveKbPlPath() {
+    const overrideKbPath = process.env.KIBI_KB_PL_PATH;
+    if (overrideKbPath && existsSync(overrideKbPath)) {
+        return overrideKbPath;
+    }
     try {
-        const corePkgJson = require.resolve("kibi-core/package.json");
-        const coreDir = path.dirname(corePkgJson);
-        const installedKbPl = path.join(coreDir, "src", "kb.pl");
+        const installedKbPl = require.resolve("kibi-core/src/kb.pl");
         if (existsSync(installedKbPl))
             return installedKbPl;
     }
-    catch {
-        // ignore; fall back to dev layout
+    catch { }
+    const startDirs = [importMetaDir, process.cwd()];
+    for (const startDir of startDirs) {
+        let currentDir = path.resolve(startDir);
+        while (true) {
+            const candidate = path.join(currentDir, "packages", "core", "src", "kb.pl");
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+            const parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir) {
+                break;
+            }
+            currentDir = parentDir;
+        }
     }
-    // 2) Dev fallback for monorepo checkout
-    const devKbPl = path.resolve(importMetaDir, "../../core/src/kb.pl");
-    if (existsSync(devKbPl))
-        return devKbPl;
-    // 3) Hard fail with actionable message
     throw new Error("Unable to resolve kb.pl. Expected kibi-core to be installed (node_modules) " +
         "or to be running inside the monorepo checkout.");
 }
@@ -111,7 +120,27 @@ export class PrologProcess {
         await this.waitForReady();
     }
     async waitForReady() {
-        await new Promise((resolve) => setTimeout(resolve, 500));
+        // Wait for Prolog to initialize and detect startup failures explicitly.
+        const start = Date.now();
+        const maxStartWait = 2000; // ms
+        while (Date.now() - start < maxStartWait) {
+            // If process exited or was killed, surface the error buffer.
+            if (!this.process || this.process.killed) {
+                throw new Error(`Prolog process terminated unexpectedly during startup: ${this.translateError(this.errorBuffer)}`);
+            }
+            // If stderr contains an ERROR, fail fast with translated message.
+            if (this.errorBuffer.includes("ERROR")) {
+                throw new Error(`Failed to load kb module: ${this.translateError(this.errorBuffer)}`);
+            }
+            // If stdout or stderr shows any output, assume ready.
+            if (this.outputBuffer.length > 0 || this.errorBuffer.length > 0) {
+                break;
+            }
+            // brief pause
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+        // Final sanity check
         if (this.errorBuffer.includes("ERROR")) {
             throw new Error(`Failed to load kb module: ${this.translateError(this.errorBuffer)}`);
         }
@@ -149,13 +178,30 @@ export class PrologProcess {
         this.errorBuffer = "";
         this.process.stdin.write(`${goal}.
 `);
+        const debug = !!process.env.KIBI_PROLOG_DEBUG;
+        const normalizedGoal = isSingleGoal
+            ? this.normalizeGoal(goal)
+            : undefined;
+        const start = Date.now();
+        if (debug && normalizedGoal)
+            console.error(`[prolog debug] start query: ${normalizedGoal}`);
         return new Promise((resolve, reject) => {
             const timeoutId = setTimeout(() => {
-                reject(new Error("Query timeout after 30s"));
+                const msg = `Query timeout after ${this.timeout / 1000}s`;
+                if (debug) {
+                    const tailOut = this.outputBuffer.slice(-2048);
+                    const tailErr = this.errorBuffer.slice(-2048);
+                    console.error(`[prolog debug] timeout: ${msg}`);
+                    console.error(`[prolog debug] last stdout: ---\n${tailOut}\n---`);
+                    console.error(`[prolog debug] last stderr: ---\n${tailErr}\n---`);
+                }
+                reject(new Error(msg));
             }, this.timeout);
             const checkResult = () => {
                 if (this.errorBuffer.length > 0 && this.errorBuffer.includes("ERROR")) {
                     clearTimeout(timeoutId);
+                    if (debug && normalizedGoal)
+                        console.error(`[prolog debug] query error: ${normalizedGoal} error=${this.errorBuffer.split("\n")[0]}`);
                     resolve({
                         success: false,
                         bindings: {},
@@ -163,7 +209,9 @@ export class PrologProcess {
                     });
                 }
                 else if (this.outputBuffer.includes("true.") ||
-                    this.outputBuffer.match(/^[A-Z_][A-Za-z0-9_]*\s*=\s*.+\./m)) {
+                    this.outputBuffer.match(/^[A-Z_][A-Za-z0-9_]*\s*=\s*.+\./m) ||
+                    // Match multi-line output ending with ] (Prolog list/term output without trailing period)
+                    this.outputBuffer.match(/\]\s*$/m)) {
                     clearTimeout(timeoutId);
                     const result = {
                         success: true,
@@ -172,11 +220,20 @@ export class PrologProcess {
                     if (cacheable) {
                         this.cache.set(goalKey, result);
                     }
+                    if (debug && normalizedGoal) {
+                        console.error(`[prolog debug] query success: ${normalizedGoal} elapsed=${(Date.now() - start) / 1000}s`);
+                    }
                     resolve(result);
+                    // Send newline to exit Prolog's interactive prompt
+                    if (this.process?.stdin) {
+                        this.process.stdin.write("\n");
+                    }
                 }
                 else if (this.outputBuffer.includes("false.") ||
                     this.outputBuffer.includes("fail.")) {
                     clearTimeout(timeoutId);
+                    if (debug && normalizedGoal)
+                        console.error(`[prolog debug] query failed (false): ${normalizedGoal}`);
                     resolve({
                         success: false,
                         bindings: {},
@@ -255,7 +312,7 @@ export class PrologProcess {
             (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");
+            throw new Error(`Query timeout after ${this.timeout / 1000}s`);
         }
         const stdout = result.stdout ?? "";
         const stderr = result.stderr ?? "";
@@ -310,7 +367,7 @@ export class PrologProcess {
             return "Invalid query syntax";
         }
         if (errorText.includes("timeout_error")) {
-            return "Operation exceeded 30s timeout";
+            return `Operation exceeded ${this.timeout / 1000}s timeout`;
         }
         const simpleError = errorText
             .replace(/ERROR:\s*/g, "")
@@ -348,3 +405,4 @@ export class PrologProcess {
         }
     }
 }
+// FIX_VERSION_2024_03_06

package/dist/traceability/git-staged.d.ts

@@ -0,0 +1,29 @@
+export type Status = "A" | "M" | "R" | "D";
+export interface HunkRange {
+    start: number;
+    end: number;
+}
+export interface StagedFile {
+    path: string;
+    status: Status;
+    oldPath?: string;
+    hunkRanges: HunkRange[];
+    content?: string;
+}
+/**
+ * Parse null-separated name-status output from git
+ */
+export declare function parseNameStatusNull(input: string): Array<{
+    status: string;
+    parts: string[];
+}>;
+/**
+ * Parse unified diff hunks (new-file coordinates) from git diff output
+ */
+export declare function parseHunksFromDiff(diffText: string, isNewFile?: boolean): HunkRange[];
+/**
+ * Get staged files with statuses, hunks and content.
+ */
+export declare function getStagedFiles(): StagedFile[];
+export default getStagedFiles;
+//# sourceMappingURL=git-staged.d.ts.map

package/dist/traceability/git-staged.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-staged.d.ts","sourceRoot":"","sources":["../../src/traceability/git-staged.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,MAAM,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAE3C,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAaD;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,GACZ,KAAK,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAS5C;AAoBD;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,SAAS,UAAQ,GAChB,SAAS,EAAE,CAoBb;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,UAAU,EAAE,CAmF7C;AAED,eAAe,cAAc,CAAC"}