kibi-cli 0.1.0

package/bin/kibi

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/*
+ 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 "../dist/cli.js";

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,117 @@
+/*
+ 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 { Command } from "commander";
+import { branchEnsureCommand } from "./commands/branch.js";
+import { checkCommand } from "./commands/check.js";
+import { doctorCommand } from "./commands/doctor.js";
+import { gcCommand } from "./commands/gc.js";
+import { initCommand } from "./commands/init.js";
+import { queryCommand } from "./commands/query.js";
+import { syncCommand } from "./commands/sync.js";
+const VERSION = "0.1.0";
+const program = new Command();
+program
+    .name("kibi")
+    .description("Prolog-based project knowledge base")
+    .version(VERSION);
+program
+    .command("init")
+    .description("Initialize .kb/ directory")
+    .option("--no-hooks", "Do not install git hooks (hooks installed by default)")
+    .action(async (options) => {
+    await initCommand(options);
+});
+program
+    .command("sync")
+    .description("Sync entities from documents")
+    .option("--validate-only", "Perform validation without mutations")
+    .action(async (options) => {
+    await syncCommand(options);
+});
+program
+    .command("query [type]")
+    .description("Query knowledge base")
+    .option("--id <id>", "Query specific entity by ID")
+    .option("--tag <tag>", "Filter by tag")
+    .option("--source <path>", "Filter by source file path (substring match)")
+    .option("--relationships <id>", "Get relationships from entity")
+    .option("--format <format>", "Output format: json|table", "json")
+    .option("--limit <n>", "Limit results", "100")
+    .option("--offset <n>", "Skip results", "0")
+    .action(async (type, options) => {
+    await queryCommand(type, options);
+});
+program
+    .command("check")
+    .description("Check KB consistency and integrity")
+    .option("--fix", "Suggest fixes for violations")
+    .action(async (options) => {
+    await checkCommand(options);
+});
+program
+    .command("gc")
+    .description("Garbage collect stale branch KBs")
+    .option("--dry-run", "Preview without deleting (default)", true)
+    .option("--force", "Actually delete stale branches")
+    .action(async (options) => {
+    const dryRun = !options.force;
+    await gcCommand({ dryRun, force: options.force });
+});
+program
+    .command("doctor")
+    .description("Diagnose KB setup and configuration")
+    .action(async () => {
+    await doctorCommand();
+});
+program
+    .command("branch")
+    .description("Manage branch KBs")
+    .argument("<action>", "Action: ensure")
+    .action(async (action) => {
+    if (action === "ensure") {
+        await branchEnsureCommand();
+    }
+});
+program.parse(process.argv);

package/dist/commands/branch.d.ts

@@ -0,0 +1,3 @@
+export declare function branchEnsureCommand(): Promise<void>;
+export default branchEnsureCommand;
+//# sourceMappingURL=branch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"branch.d.ts","sourceRoot":"","sources":["../../src/commands/branch.ts"],"names":[],"mappings":"AAiDA,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAoBzD;AAED,eAAe,mBAAmB,CAAC"}

package/dist/commands/branch.js

@@ -0,0 +1,66 @@
+/*
+ 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 { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+export async function branchEnsureCommand() {
+    const branch = execSync("git branch --show-current", {
+        encoding: "utf-8",
+    }).trim();
+    const kbPath = path.join(process.cwd(), ".kb/branches", branch);
+    const mainPath = path.join(process.cwd(), ".kb/branches/main");
+    if (!fs.existsSync(mainPath)) {
+        console.warn("Warning: main branch KB does not exist, skipping branch ensure");
+        return;
+    }
+    if (!fs.existsSync(kbPath)) {
+        fs.cpSync(mainPath, kbPath, { recursive: true });
+        console.log(`Created branch KB: ${branch}`);
+    }
+    else {
+        console.log(`Branch KB already exists: ${branch}`);
+    }
+}
+export default branchEnsureCommand;

package/dist/commands/check.d.ts

@@ -0,0 +1,12 @@
+export interface CheckOptions {
+    fix?: boolean;
+}
+export interface Violation {
+    rule: string;
+    entityId: string;
+    description: string;
+    suggestion?: string;
+    source?: string;
+}
+export declare function checkCommand(options: CheckOptions): Promise<void>;
+//# sourceMappingURL=check.d.ts.map

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

@@ -0,0 +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"}

package/dist/commands/check.js

@@ -0,0 +1,439 @@
+/*
+ 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 path from "node:path";
+import { PrologProcess } from "../prolog.js";
+export async function checkCommand(options) {
+    try {
+        const prolog = new PrologProcess();
+        await prolog.start();
+        const kbPath = path.join(process.cwd(), ".kb/branches/main");
+        const attachResult = await prolog.query(`kb_attach('${kbPath}')`);
+        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)));
+        const allEntityIds = await getAllEntityIds(prolog);
+        violations.push(...(await checkRequiredFields(prolog, allEntityIds)));
+        violations.push(...(await checkDeprecatedAdrs(prolog)));
+        violations.push(...(await checkDomainContradictions(prolog)));
+        await prolog.query("kb_detach");
+        await prolog.terminate();
+        if (violations.length === 0) {
+            console.log("✓ No violations found. KB is valid.");
+            process.exit(0);
+        }
+        console.log(`Found ${violations.length} violation(s):`);
+        console.log();
+        for (const v of violations) {
+            const filename = v.source ? path.basename(v.source, ".md") : v.entityId;
+            console.log(`[${v.rule}] ${filename}`);
+            console.log(`  ${v.description}`);
+            if (options.fix && v.suggestion) {
+                console.log(`  Suggestion: ${v.suggestion}`);
+            }
+            console.log();
+        }
+        process.exit(1);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${message}`);
+        process.exit(1);
+    }
+}
+async function checkMustPriorityCoverage(prolog) {
+    const violations = [];
+    // Find all must-priority requirements
+    const mustReqs = await findMustPriorityReqs(prolog);
+    for (const reqId of mustReqs) {
+        const entityResult = await prolog.query(`kb_entity('${reqId}', req, Props)`);
+        let source = "";
+        if (entityResult.success && entityResult.bindings.Props) {
+            const propsStr = entityResult.bindings.Props;
+            const sourceMatch = propsStr.match(/source\s*=\s*\^\^?\("([^"]+)"/);
+            if (sourceMatch) {
+                source = sourceMatch[1];
+            }
+        }
+        const scenarioResult = await prolog.query(`kb_relationship(specified_by, '${reqId}', ScenarioId)`);
+        const hasScenario = scenarioResult.success;
+        const testResult = await prolog.query(`kb_relationship(validates, TestId, '${reqId}')`);
+        const hasTest = testResult.success;
+        if (!hasScenario || !hasTest) {
+            let desc = "Must-priority requirement lacks ";
+            const missing = [];
+            if (!hasScenario)
+                missing.push("scenario");
+            if (!hasTest)
+                missing.push("test");
+            desc = `${desc}${missing.join(" and ")} coverage`;
+            violations.push({
+                rule: "must-priority-coverage",
+                entityId: reqId,
+                description: desc,
+                source,
+                suggestion: missing
+                    .map((m) => `Create ${m} that covers this requirement`)
+                    .join("; "),
+            });
+        }
+    }
+    return violations;
+}
+async function findMustPriorityReqs(prolog) {
+    const query = `findall(Id, (kb_entity(Id, req, Props), memberchk(priority=P, Props), (P = ^^("must", _) ; P = "must" ; P = 'must' ; (atom(P), atom_string(P, PS), sub_string(PS, _, 4, 0, "must")))), Ids)`;
+    const result = await prolog.query(query);
+    if (!result.success || !result.bindings.Ids) {
+        return [];
+    }
+    const idsStr = result.bindings.Ids;
+    const match = idsStr.match(/\[(.*)\]/);
+    if (!match) {
+        return [];
+    }
+    const content = match[1].trim();
+    if (!content) {
+        return [];
+    }
+    return content.split(",").map((id) => id.trim().replace(/^'|'$/g, ""));
+}
+async function getAllEntityIds(prolog, type) {
+    const typeFilter = type ? `, Type = ${type}` : "";
+    const query = `findall(Id, (kb_entity(Id, Type, _)${typeFilter}), Ids)`;
+    const result = await prolog.query(query);
+    if (!result.success || !result.bindings.Ids) {
+        return [];
+    }
+    const idsStr = result.bindings.Ids;
+    const match = idsStr.match(/\[(.*)\]/);
+    if (!match) {
+        return [];
+    }
+    const content = match[1].trim();
+    if (!content) {
+        return [];
+    }
+    return content.split(",").map((id) => id.trim().replace(/^'|'$/g, ""));
+}
+async function checkNoDanglingRefs(prolog) {
+    const violations = [];
+    // Get all entity IDs once
+    const allEntityIds = new Set(await getAllEntityIds(prolog));
+    // Get all relationships by querying all known relationship types
+    const relTypes = [
+        "depends_on",
+        "verified_by",
+        "validates",
+        "specified_by",
+        "constrains",
+        "requires_property",
+        "supersedes",
+        "relates_to",
+    ];
+    const allRels = [];
+    for (const relType of relTypes) {
+        const relsResult = await prolog.query(`findall([From,To], kb_relationship(${relType}, From, To), Rels)`);
+        if (relsResult.success && relsResult.bindings.Rels) {
+            const relsStr = relsResult.bindings.Rels;
+            const match = relsStr.match(/\[(.*)\]/);
+            if (match) {
+                const content = match[1].trim();
+                if (content) {
+                    const relMatches = content.matchAll(/\[([^,]+),([^\]]+)\]/g);
+                    for (const relMatch of relMatches) {
+                        const fromId = relMatch[1].trim().replace(/^'|'$/g, "");
+                        const toId = relMatch[2].trim().replace(/^'|'$/g, "");
+                        allRels.push({ from: fromId, to: toId });
+                    }
+                }
+            }
+        }
+    }
+    // Check all collected relationships for dangling refs
+    for (const rel of allRels) {
+        if (!allEntityIds.has(rel.from)) {
+            violations.push({
+                rule: "no-dangling-refs",
+                entityId: rel.from,
+                description: `Relationship references non-existent entity: ${rel.from}`,
+                suggestion: "Remove relationship or create missing entity",
+            });
+        }
+        if (!allEntityIds.has(rel.to)) {
+            violations.push({
+                rule: "no-dangling-refs",
+                entityId: rel.to,
+                description: `Relationship references non-existent entity: ${rel.to}`,
+                suggestion: "Remove relationship or create missing entity",
+            });
+        }
+    }
+    return violations;
+}
+async function checkNoCycles(prolog) {
+    const violations = [];
+    // Get all depends_on relationships
+    const depsResult = await prolog.query("findall([From,To], kb_relationship(depends_on, From, To), Deps)");
+    if (!depsResult.success || !depsResult.bindings.Deps) {
+        return violations;
+    }
+    const depsStr = depsResult.bindings.Deps;
+    const match = depsStr.match(/\[(.*)\]/);
+    if (!match) {
+        return violations;
+    }
+    const content = match[1].trim();
+    if (!content) {
+        return violations;
+    }
+    // Build adjacency map
+    const graph = new Map();
+    const depMatches = content.matchAll(/\[([^,]+),([^\]]+)\]/g);
+    for (const depMatch of depMatches) {
+        const from = depMatch[1].trim().replace(/^'|'$/g, "");
+        const to = depMatch[2].trim().replace(/^'|'$/g, "");
+        if (!graph.has(from)) {
+            graph.set(from, []);
+        }
+        const fromList = graph.get(from);
+        if (fromList) {
+            fromList.push(to);
+        }
+    }
+    // DFS to detect cycles
+    const visited = new Set();
+    const recStack = new Set();
+    function hasCycleDFS(node, path) {
+        visited.add(node);
+        recStack.add(node);
+        path.push(node);
+        const neighbors = graph.get(node) || [];
+        for (const neighbor of neighbors) {
+            if (!visited.has(neighbor)) {
+                const cyclePath = hasCycleDFS(neighbor, [...path]);
+                if (cyclePath)
+                    return cyclePath;
+            }
+            else if (recStack.has(neighbor)) {
+                // Cycle detected
+                return [...path, neighbor];
+            }
+        }
+        recStack.delete(node);
+        return null;
+    }
+    // Check each node for cycles
+    for (const node of graph.keys()) {
+        if (!visited.has(node)) {
+            const cyclePath = hasCycleDFS(node, []);
+            if (cyclePath) {
+                const cycleWithSources = [];
+                for (const entityId of cyclePath) {
+                    const entityResult = await prolog.query(`kb_entity('${entityId}', _, Props)`);
+                    let sourceName = entityId;
+                    if (entityResult.success && entityResult.bindings.Props) {
+                        const propsStr = entityResult.bindings.Props;
+                        const sourceMatch = propsStr.match(/source\s*=\s*\^\^?\("([^"]+)"/);
+                        if (sourceMatch) {
+                            sourceName = path.basename(sourceMatch[1], ".md");
+                        }
+                    }
+                    cycleWithSources.push(sourceName);
+                }
+                violations.push({
+                    rule: "no-cycles",
+                    entityId: cyclePath[0],
+                    description: `Circular dependency detected: ${cycleWithSources.join(" → ")}`,
+                    suggestion: "Break cycle by removing one of the depends_on relationships",
+                });
+                break; // Report only first cycle found
+            }
+        }
+    }
+    return violations;
+}
+async function checkRequiredFields(prolog, allEntityIds) {
+    const violations = [];
+    const required = [
+        "id",
+        "title",
+        "status",
+        "created_at",
+        "updated_at",
+        "source",
+    ];
+    for (const entityId of allEntityIds) {
+        const result = await prolog.query(`kb_entity('${entityId}', Type, Props)`);
+        if (result.success && result.bindings.Props) {
+            // Parse properties list: [key1=value1, key2=value2, ...]
+            const propsStr = result.bindings.Props;
+            const propKeys = new Set();
+            // Extract keys from Props
+            const keyMatches = propsStr.matchAll(/(\w+)\s*=/g);
+            for (const match of keyMatches) {
+                propKeys.add(match[1]);
+            }
+            // Check for missing required fields
+            for (const field of required) {
+                if (!propKeys.has(field)) {
+                    violations.push({
+                        rule: "required-fields",
+                        entityId: entityId,
+                        description: `Missing required field: ${field}`,
+                        suggestion: `Add ${field} to entity definition`,
+                    });
+                }
+            }
+        }
+    }
+    return violations;
+}
+async function checkDeprecatedAdrs(prolog) {
+    const violations = [];
+    // Use Prolog predicate to find deprecated ADRs without successors
+    const result = await prolog.query("setof(Id, deprecated_no_successor(Id), Ids)");
+    if (!result.success || !result.bindings.Ids) {
+        return violations;
+    }
+    const idsStr = result.bindings.Ids;
+    const match = idsStr.match(/\[(.*)\]/);
+    if (!match) {
+        return violations;
+    }
+    const content = match[1].trim();
+    if (!content) {
+        return violations;
+    }
+    const adrIds = content
+        .split(",")
+        .map((id) => id.trim().replace(/^'|'$/g, ""));
+    for (const adrId of adrIds) {
+        // Get source for better error message
+        const entityResult = await prolog.query(`kb_entity('${adrId}', adr, Props)`);
+        let source = "";
+        if (entityResult.success && entityResult.bindings.Props) {
+            const propsStr = entityResult.bindings.Props;
+            const sourceMatch = propsStr.match(/source\s*=\s*\^\^?\("([^"]+)"/);
+            if (sourceMatch) {
+                source = sourceMatch[1];
+            }
+        }
+        violations.push({
+            rule: "deprecated-adr-no-successor",
+            entityId: adrId,
+            description: "Archived/deprecated ADR has no successor — add a supersedes link from the replacement ADR",
+            suggestion: `Create a new ADR and add: links: [{type: supersedes, target: ${adrId}}]`,
+            source,
+        });
+    }
+    return violations;
+}
+async function checkDomainContradictions(prolog) {
+    const violations = [];
+    const result = await prolog.query("setof([A,B,Reason], contradicting_reqs(A, B, Reason), Rows)");
+    if (!result.success || !result.bindings.Rows) {
+        return violations;
+    }
+    const rows = parseTripleRows(result.bindings.Rows);
+    for (const [reqA, reqB, reason] of rows) {
+        violations.push({
+            rule: "domain-contradictions",
+            entityId: `${reqA}/${reqB}`,
+            description: reason,
+            suggestion: "Supersede one requirement or align both to the same required property",
+        });
+    }
+    return violations;
+}
+async function checkSymbolCoverage(prolog) {
+    const violations = [];
+    const uncoveredResult = await prolog.query("setof(Symbol, symbol_no_req_coverage(Symbol, _), Symbols)");
+    if (uncoveredResult.success && uncoveredResult.bindings.Symbols) {
+        const symbolsStr = uncoveredResult.bindings.Symbols;
+        const match = symbolsStr.match(/\[(.*)\]/);
+        if (match) {
+            const content = match[1].trim();
+            if (content) {
+                const symbolMatches = content.matchAll(/'([^']+)'/g);
+                for (const symbolMatch of symbolMatches) {
+                    const symbolId = symbolMatch[1];
+                    violations.push({
+                        rule: "symbol-coverage",
+                        entityId: symbolId,
+                        description: "Code symbol is not traceable to any functional requirement.",
+                        suggestion: "Update symbols.yaml to link this symbol to a related requirement.",
+                    });
+                }
+            }
+        }
+    }
+    return violations;
+}
+function parseTripleRows(raw) {
+    const cleaned = raw.trim();
+    if (cleaned === "[]" || cleaned.length === 0) {
+        return [];
+    }
+    const rows = [];
+    const rowRegex = /\[([^,]+),([^,]+),([^\]]+)\]/g;
+    let match;
+    do {
+        match = rowRegex.exec(cleaned);
+        if (match) {
+            rows.push([
+                match[1].trim().replace(/^'|'$/g, ""),
+                match[2].trim().replace(/^'|'$/g, ""),
+                match[3].trim().replace(/^'|'$/g, ""),
+            ]);
+        }
+    } while (match);
+    return rows;
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,2 @@
+export declare function doctorCommand(): Promise<void>;
+//# sourceMappingURL=doctor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAsDA,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAsDnD"}