kibi-mcp 0.3.0 → 0.3.1

package/dist/tools/prolog-list.js

@@ -15,6 +15,7 @@
  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/>.
 */
+// implements REQ-002
 export function parseAtomList(raw) {
     const trimmed = raw.trim();
     if (trimmed === "[]" || trimmed.length === 0) {
@@ -28,6 +29,7 @@ export function parseAtomList(raw) {
         .map((token) => stripQuotes(token.trim()))
         .filter((token) => token.length > 0);
 }
+// implements REQ-002
 export function parsePairList(raw) {
     const rows = parseListRows(raw);
     const pairs = [];
@@ -39,17 +41,6 @@ export function parsePairList(raw) {
     }
     return pairs;
 }
-export function parseTriples(raw) {
-    const rows = parseListRows(raw);
-    const triples = [];
-    for (const row of rows) {
-        const parts = splitTopLevel(row, ",").map((part) => stripQuotes(part.trim()));
-        if (parts.length >= 3) {
-            triples.push([parts[0], parts[1], parts[2]]);
-        }
-    }
-    return triples;
-}
 function parseListRows(raw) {
     const trimmed = raw.trim();
     if (trimmed === "[]" || trimmed.length === 0) {

package/dist/tools-config.js

@@ -16,6 +16,7 @@
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 export const TOOLS = [
+    // implements REQ-002
     {
         name: "kb_query",
         description: "Read entities from the KB with filters. Use for discovery and lookup before edits. Do not use for writes. No mutation side effects. Tags filter by metadata tags only, not entity IDs.",
@@ -97,18 +98,7 @@ export const TOOLS = [
                         },
                         status: {
                             type: "string",
-                            enum: [
-                                "active",
-                                "draft",
-                                "archived",
-                                "deleted",
-                                "approved",
-                                "rejected",
-                                "pending",
-                                "in_progress",
-                                "superseded",
-                            ],
-                            description: "Required lifecycle state. Allowed values are fixed enum options. Example: 'active'.",
+                            description: "Required lifecycle state. Allowed values depend on entity type; backward-compatible legacy statuses are also accepted. Examples: 'open', 'passing', 'accepted', 'active'.",
                         },
                         source: {
                             type: "string",

package/dist/workspace.js

@@ -23,6 +23,7 @@ const WORKSPACE_ENV_KEYS = [
     "KIBI_ROOT",
 ];
 const KB_PATH_ENV_KEYS = ["KIBI_KB_PATH", "KB_PATH"];
+// implements REQ-002, REQ-012
 export function resolveWorkspaceRoot(startDir = process.cwd()) {
     const envRoot = readFirstEnv(WORKSPACE_ENV_KEYS);
     if (envRoot) {
@@ -38,21 +39,7 @@ export function resolveWorkspaceRoot(startDir = process.cwd()) {
     }
     return path.resolve(startDir);
 }
-export function resolveWorkspaceRootInfo(startDir = process.cwd()) {
-    const envRoot = readFirstEnv(WORKSPACE_ENV_KEYS);
-    if (envRoot) {
-        return { root: path.resolve(envRoot), reason: "env" };
-    }
-    const kbRoot = findUpwards(startDir, ".kb");
-    if (kbRoot) {
-        return { root: kbRoot, reason: "kb" };
-    }
-    const gitRoot = findUpwards(startDir, ".git");
-    if (gitRoot) {
-        return { root: gitRoot, reason: "git" };
-    }
-    return { root: path.resolve(startDir), reason: "cwd" };
-}
+// implements REQ-002, REQ-012
 export function resolveKbPath(workspaceRoot, branch) {
     const envPath = readFirstEnv(KB_PATH_ENV_KEYS);
     if (envPath) {
@@ -64,6 +51,7 @@ export function resolveKbPath(workspaceRoot, branch) {
     }
     return path.join(workspaceRoot, ".kb", "branches", branch);
 }
+// implements REQ-002
 export function resolveEnvFilePath(envFileName, workspaceRoot) {
     if (path.isAbsolute(envFileName)) {
         return envFileName;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-mcp",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
     "ajv": "^8.18.0",
@@ -9,8 +9,8 @@
     "fast-glob": "^3.2.12",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "kibi-cli": "^0.2.5",
-    "kibi-core": "^0.1.8",
+    "kibi-cli": "^0.2.6",
+    "kibi-core": "^0.1.10",
     "mcpcat": "^0.1.12",
     "ts-morph": "^23.0.0",
     "zod": "^4.3.6"

package/dist/tools/branch.js

@@ -1,181 +0,0 @@
-/*
- 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 { execSync } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { resolveKbPath, resolveWorkspaceRoot } from "../workspace.js";
-/**
- * Handle kb_branch_ensure tool calls - create branch KB if not exists
- */
-export async function handleKbBranchEnsure(_prolog, args) {
-    const { branch } = args;
-    if (!branch || branch.trim() === "") {
-        throw new Error("Branch name is required");
-    }
-    // Sanitize branch name (prevent path traversal)
-    const isSafe = (name) => {
-        // No empty or excessively long names
-        if (!name || name.length > 255)
-            return false;
-        // No path traversal or absolute paths
-        if (name.includes("..") || path.isAbsolute(name) || name.startsWith("/")) {
-            return false;
-        }
-        // Whitelist characters (alphanumeric, dot, underscore, hyphen, forward slash)
-        if (!/^[a-zA-Z0-9._\-/]+$/.test(name))
-            return false;
-        // No redundant slashes or trailing slash/dot
-        if (name.includes("//") ||
-            name.endsWith("/") ||
-            name.endsWith(".") ||
-            name.includes("\\")) {
-            return false;
-        }
-        return true;
-    };
-    if (!isSafe(branch)) {
-        throw new Error(`Invalid branch name: ${branch}`);
-    }
-    const safeBranch = branch;
-    try {
-        const workspaceRoot = resolveWorkspaceRoot();
-        const branchPath = resolveKbPath(workspaceRoot, safeBranch);
-        const developPath = resolveKbPath(workspaceRoot, "develop");
-        // Check if branch KB already exists
-        if (fs.existsSync(branchPath)) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Branch KB '${safeBranch}' already exists`,
-                    },
-                ],
-                structuredContent: {
-                    created: false,
-                    path: branchPath,
-                },
-            };
-        }
-        // Ensure develop branch exists
-        if (!fs.existsSync(developPath)) {
-            throw new Error("Develop branch KB does not exist. Run 'kb init' first.");
-        }
-        // Copy develop branch KB to new branch
-        fs.cpSync(developPath, branchPath, { recursive: true });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Created branch KB '${safeBranch}' from develop`,
-                },
-            ],
-            structuredContent: {
-                created: true,
-                path: branchPath,
-            },
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Branch ensure failed: ${message}`);
-    }
-}
-/**
- * Handle kb_branch_gc tool calls - garbage collect stale branch KBs
- */
-export async function handleKbBranchGc(_prolog, args) {
-    const { dry_run = true } = args;
-    try {
-        const workspaceRoot = resolveWorkspaceRoot();
-        const kbRoot = path.dirname(resolveKbPath(workspaceRoot, "develop"));
-        // Check if .kb/branches exists
-        if (!fs.existsSync(kbRoot)) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "No branch KBs found (.kb/branches does not exist)",
-                    },
-                ],
-                structuredContent: {
-                    stale: [],
-                    deleted: 0,
-                },
-            };
-        }
-        let gitBranches;
-        try {
-            execSync("git rev-parse --git-dir", {
-                encoding: "utf-8",
-                cwd: workspaceRoot,
-                stdio: ["pipe", "pipe", "pipe"],
-                env: process.env,
-            });
-            const output = execSync("git branch --format='%(refname:short)'", {
-                encoding: "utf-8",
-                cwd: workspaceRoot,
-                stdio: ["pipe", "pipe", "pipe"],
-                env: process.env,
-            });
-            gitBranches = new Set(output
-                .trim()
-                .split("\n")
-                .map((b) => b.trim().replace(/^'|'$/g, ""))
-                .filter((b) => b));
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`Not in a git repository or git command failed: ${message}`);
-        }
-        // Get all KB branches
-        const kbBranches = fs
-            .readdirSync(kbRoot, { withFileTypes: true })
-            .filter((dirent) => dirent.isDirectory())
-            .map((dirent) => dirent.name);
-        // Find stale branches (KB exists but git branch doesn't, excluding develop)
-        const staleBranches = kbBranches.filter((kb) => kb !== "develop" && !gitBranches.has(kb));
-        // Delete stale branches if not dry run
-        let deletedCount = 0;
-        if (!dry_run && staleBranches.length > 0) {
-            for (const branch of staleBranches) {
-                const branchPath = path.join(kbRoot, branch);
-                fs.rmSync(branchPath, { recursive: true, force: true });
-                deletedCount++;
-            }
-        }
-        const summary = dry_run
-            ? `Found ${staleBranches.length} stale branch KB(s) (dry run - not deleted)`
-            : `Deleted ${deletedCount} stale branch KB(s)`;
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: summary,
-                },
-            ],
-            structuredContent: {
-                stale: staleBranches,
-                deleted: deletedCount,
-            },
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Branch GC failed: ${message}`);
-    }
-}

package/dist/tools/context.js

@@ -1,64 +0,0 @@
-import { parseEntityFromList, parseListOfLists, } from "kibi-cli/prolog/codec";
-export async function handleKbContext(prolog, args) {
-    const { sourceFile } = args;
-    try {
-        const safeSource = sourceFile.replace(/'/g, "\\'");
-        const entityGoal = `findall([Id,Type,Props], (kb_entities_by_source('${safeSource}', SourceIds), member(Id, SourceIds), kb_entity(Id, Type, Props)), Results)`;
-        const entityQueryResult = await prolog.query(entityGoal);
-        const entities = [];
-        const entityIds = [];
-        if (entityQueryResult.success && entityQueryResult.bindings.Results) {
-            const entitiesData = parseListOfLists(entityQueryResult.bindings.Results);
-            for (const data of entitiesData) {
-                const entity = parseEntityFromList(data);
-                entities.push({
-                    id: entity.id,
-                    type: entity.type,
-                    title: entity.title,
-                    status: entity.status,
-                    tags: entity.tags || [],
-                });
-                entityIds.push(entity.id);
-            }
-        }
-        const relationships = [];
-        for (const entityId of entityIds) {
-            const relGoal = `findall([RelType,FromId,ToId], (kb_relationship(RelType, FromId, ToId), (FromId = '${entityId}' ; ToId = '${entityId}')), RelResults)`;
-            const relQueryResult = await prolog.query(relGoal);
-            if (relQueryResult.success && relQueryResult.bindings.RelResults) {
-                const relData = parseListOfLists(relQueryResult.bindings.RelResults);
-                for (const rel of relData) {
-                    relationships.push({
-                        relType: rel[0],
-                        fromId: rel[1],
-                        toId: rel[2],
-                    });
-                }
-            }
-        }
-        const text = entities.length > 0
-            ? `Found ${entities.length} KB entities linked to source file "${sourceFile}": ${entities.map((e) => e.id).join(", ")}`
-            : `No KB entities found for source file "${sourceFile}"`;
-        return {
-            content: [
-                {
-                    type: "text",
-                    text,
-                },
-            ],
-            structuredContent: {
-                sourceFile,
-                entities,
-                relationships,
-                provenance: {
-                    predicate: "kb_entities_by_source",
-                    deterministic: true,
-                },
-            },
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Context query failed: ${message}`);
-    }
-}

package/dist/tools/coverage-report.js

@@ -1,74 +0,0 @@
-import { parseAtomList, parsePairList } from "./prolog-list.js";
-export async function handleKbCoverageReport(prolog, args) {
-    const requested = args.type ?? "all";
-    if (args.type && args.type !== "req" && args.type !== "symbol") {
-        throw new Error("'type' must be one of: req, symbol");
-    }
-    const coverage = {};
-    const predicates = [];
-    if (requested === "all" || requested === "req") {
-        const reqIds = await queryAtoms(prolog, "setof(Req, kb_entity(Req, req, _), Reqs)", "Reqs");
-        const gapPairs = await queryPairs(prolog, "setof([Req,Reason], coverage_gap(Req, Reason), Rows)", "Rows");
-        const gaps = gapPairs.map(([req, reason]) => ({ req, reason }));
-        coverage.requirements = {
-            total: reqIds.length,
-            with_gaps: gaps.length,
-            healthy: Math.max(reqIds.length - gaps.length, 0),
-            gaps,
-        };
-        predicates.push("coverage_gap");
-    }
-    if (requested === "all" || requested === "symbol") {
-        const symbolIds = await queryAtoms(prolog, "setof(Symbol, kb_entity(Symbol, symbol, _), Symbols)", "Symbols");
-        const untestedResult = await prolog.query("untested_symbols(Symbols)");
-        const untestedSymbols = untestedResult.success && untestedResult.bindings.Symbols
-            ? parseAtomList(untestedResult.bindings.Symbols)
-            : [];
-        coverage.symbols = {
-            total: symbolIds.length,
-            untested: untestedSymbols.length,
-            tested: Math.max(symbolIds.length - untestedSymbols.length, 0),
-            untested_symbols: untestedSymbols,
-        };
-        predicates.push("untested_symbols");
-    }
-    const summaryParts = [];
-    if (coverage.requirements) {
-        summaryParts.push(`${coverage.requirements.healthy}/${coverage.requirements.total} requirements healthy`);
-    }
-    if (coverage.symbols) {
-        summaryParts.push(`${coverage.symbols.tested}/${coverage.symbols.total} symbols tested`);
-    }
-    return {
-        content: [
-            {
-                type: "text",
-                text: summaryParts.length > 0
-                    ? `Coverage report: ${summaryParts.join("; ")}.`
-                    : "Coverage report: no data.",
-            },
-        ],
-        structuredContent: {
-            requested_type: requested,
-            coverage,
-            provenance: {
-                deterministic: true,
-                predicates,
-            },
-        },
-    };
-}
-async function queryAtoms(prolog, goal, bindingName) {
-    const result = await prolog.query(goal);
-    if (!result.success || !result.bindings[bindingName]) {
-        return [];
-    }
-    return parseAtomList(result.bindings[bindingName]);
-}
-async function queryPairs(prolog, goal, bindingName) {
-    const result = await prolog.query(goal);
-    if (!result.success || !result.bindings[bindingName]) {
-        return [];
-    }
-    return parsePairList(result.bindings[bindingName]);
-}

package/dist/tools/derive.js

@@ -1,292 +0,0 @@
-import { escapeAtom } from "kibi-cli/prolog/codec";
-import { parseAtomList, parsePairList } from "./prolog-list.js";
-const RULES = [
-    "transitively_implements",
-    "transitively_depends",
-    "impacted_by_change",
-    "affected_symbols",
-    "coverage_gap",
-    "untested_symbols",
-    "stale",
-    "orphaned",
-    "conflicting",
-    "deprecated_still_used",
-    "current_adr",
-    "adr_chain",
-    "superseded_by",
-    "domain_contradictions",
-];
-export async function handleKbDerive(prolog, args) {
-    const params = args.params ?? {};
-    const { rule } = args;
-    if (!RULES.includes(rule)) {
-        throw new Error(`Unsupported rule '${rule}'`);
-    }
-    let rows = [];
-    switch (rule) {
-        case "transitively_implements":
-            rows = await deriveTransitivelyImplements(prolog, params);
-            break;
-        case "transitively_depends":
-            rows = await deriveTransitivelyDepends(prolog, params);
-            break;
-        case "impacted_by_change":
-            rows = await deriveImpactedByChange(prolog, params);
-            break;
-        case "affected_symbols":
-            rows = await deriveAffectedSymbols(prolog, params);
-            break;
-        case "coverage_gap":
-            rows = await deriveCoverageGap(prolog, params);
-            break;
-        case "untested_symbols":
-            rows = await deriveUntestedSymbols(prolog);
-            break;
-        case "stale":
-            rows = await deriveStale(prolog, params);
-            break;
-        case "orphaned":
-            rows = await deriveOrphaned(prolog, params);
-            break;
-        case "conflicting":
-            rows = await deriveConflicting(prolog, params);
-            break;
-        case "deprecated_still_used":
-            rows = await deriveDeprecatedStillUsed(prolog, params);
-            break;
-        case "current_adr":
-            rows = await deriveCurrentAdr(prolog);
-            break;
-        case "adr_chain":
-            rows = await deriveAdrChain(prolog, params);
-            break;
-        case "superseded_by":
-            rows = await deriveSupersededBy(prolog, params);
-            break;
-        case "domain_contradictions":
-            rows = await deriveDomainContradictions(prolog);
-            break;
-    }
-    return {
-        content: [
-            {
-                type: "text",
-                text: `Derived ${rows.length} row(s) for rule '${rule}'.`,
-            },
-        ],
-        structuredContent: {
-            rule,
-            params,
-            count: rows.length,
-            rows,
-            provenance: {
-                predicate: rule,
-                deterministic: true,
-            },
-        },
-    };
-}
-async function deriveTransitivelyImplements(prolog, params) {
-    const symbolFilter = asOptionalString(params.symbol);
-    const reqFilter = asOptionalString(params.req);
-    const cond = makeConjunction([
-        symbolFilter ? `Symbol='${escapeAtom(symbolFilter)}'` : "",
-        reqFilter ? `Req='${escapeAtom(reqFilter)}'` : "",
-    ]);
-    const goal = `setof([Symbol,Req], (transitively_implements(Symbol, Req)${cond}), Rows)`;
-    const pairs = await queryPairRows(prolog, goal, "Rows");
-    return pairs.map(([symbol, req]) => ({ symbol, req }));
-}
-async function deriveTransitivelyDepends(prolog, params) {
-    const req1Filter = asOptionalString(params.req1);
-    const req2Filter = asOptionalString(params.req2);
-    const cond = makeConjunction([
-        req1Filter ? `Req1='${escapeAtom(req1Filter)}'` : "",
-        req2Filter ? `Req2='${escapeAtom(req2Filter)}'` : "",
-    ]);
-    const goal = `setof([Req1,Req2], (transitively_depends(Req1, Req2)${cond}), Rows)`;
-    const pairs = await queryPairRows(prolog, goal, "Rows");
-    return pairs.map(([req1, req2]) => ({ req1, req2 }));
-}
-async function deriveImpactedByChange(prolog, params) {
-    const changed = asRequiredString(params.changed, "params.changed is required");
-    const goal = `setof(Entity, impacted_by_change(Entity, '${escapeAtom(changed)}'), Rows)`;
-    const entities = await queryAtomRows(prolog, goal, "Rows");
-    return entities.map((entity) => ({ changed, entity }));
-}
-async function deriveAffectedSymbols(prolog, params) {
-    const req = asRequiredString(params.req, "params.req is required");
-    const goal = `affected_symbols('${escapeAtom(req)}', Symbols)`;
-    const result = await prolog.query(goal);
-    if (!result.success || !result.bindings.Symbols) {
-        return [];
-    }
-    const symbols = parseAtomList(result.bindings.Symbols);
-    return symbols.map((symbol) => ({ req, symbol }));
-}
-async function deriveCoverageGap(prolog, params) {
-    const reqFilter = asOptionalString(params.req);
-    const cond = reqFilter ? `Req='${escapeAtom(reqFilter)}'` : "";
-    const goal = `setof([Req,Reason], (coverage_gap(Req, Reason)${makeConjunction([cond])}), Rows)`;
-    const pairs = await queryPairRows(prolog, goal, "Rows");
-    return pairs.map(([req, reason]) => ({ req, reason }));
-}
-async function deriveUntestedSymbols(prolog) {
-    const result = await prolog.query("untested_symbols(Symbols)");
-    if (!result.success || !result.bindings.Symbols) {
-        return [];
-    }
-    const symbols = parseAtomList(result.bindings.Symbols);
-    return symbols.map((symbol) => ({ symbol }));
-}
-async function deriveStale(prolog, params) {
-    const maxAgeDays = Number(params.max_age_days ?? params.maxAgeDays);
-    if (!Number.isFinite(maxAgeDays)) {
-        throw new Error("params.max_age_days is required and must be numeric");
-    }
-    const entityFilter = asOptionalString(params.entity);
-    const cond = entityFilter ? `Entity='${escapeAtom(entityFilter)}'` : "";
-    const goal = `setof(Entity, (stale(Entity, ${maxAgeDays})${makeConjunction([cond])}), Rows)`;
-    const entities = await queryAtomRows(prolog, goal, "Rows");
-    return entities.map((entity) => ({ entity, max_age_days: maxAgeDays }));
-}
-async function deriveOrphaned(prolog, params) {
-    const symbolFilter = asOptionalString(params.symbol);
-    const cond = symbolFilter ? `Symbol='${escapeAtom(symbolFilter)}'` : "";
-    const goal = `setof(Symbol, (orphaned(Symbol)${makeConjunction([cond])}), Rows)`;
-    const symbols = await queryAtomRows(prolog, goal, "Rows");
-    return symbols.map((symbol) => ({ symbol }));
-}
-async function deriveConflicting(prolog, params) {
-    const adr1Filter = asOptionalString(params.adr1);
-    const adr2Filter = asOptionalString(params.adr2);
-    const cond = makeConjunction([
-        adr1Filter ? `Adr1='${escapeAtom(adr1Filter)}'` : "",
-        adr2Filter ? `Adr2='${escapeAtom(adr2Filter)}'` : "",
-    ]);
-    const goal = `setof([Adr1,Adr2], (conflicting(Adr1, Adr2)${cond}), Rows)`;
-    const pairs = await queryPairRows(prolog, goal, "Rows");
-    return pairs.map(([adr1, adr2]) => ({ adr1, adr2 }));
-}
-async function deriveDeprecatedStillUsed(prolog, params) {
-    const adrFilter = asOptionalString(params.adr);
-    const goal = adrFilter
-        ? `deprecated_still_used('${escapeAtom(adrFilter)}', Symbols)`
-        : "setof([Adr,Symbols], deprecated_still_used(Adr, Symbols), Rows)";
-    if (adrFilter) {
-        const result = await prolog.query(goal);
-        if (!result.success || !result.bindings.Symbols) {
-            return [];
-        }
-        return [
-            { adr: adrFilter, symbols: parseAtomList(result.bindings.Symbols) },
-        ];
-    }
-    const pairs = await queryPairRows(prolog, goal, "Rows");
-    return pairs.map(([adr, symbolsRaw]) => ({
-        adr,
-        symbols: parseAtomList(symbolsRaw),
-    }));
-}
-async function queryAtomRows(prolog, goal, bindingName) {
-    const result = await prolog.query(goal);
-    if (!result.success || !result.bindings[bindingName]) {
-        return [];
-    }
-    return parseAtomList(result.bindings[bindingName]);
-}
-async function queryPairRows(prolog, goal, bindingName) {
-    const result = await prolog.query(goal);
-    if (!result.success || !result.bindings[bindingName]) {
-        return [];
-    }
-    return parsePairList(result.bindings[bindingName]);
-}
-function asOptionalString(value) {
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function asRequiredString(value, message) {
-    if (typeof value !== "string" || value.length === 0) {
-        throw new Error(message);
-    }
-    return value;
-}
-function makeConjunction(parts) {
-    const filtered = parts.filter((part) => part.length > 0);
-    if (filtered.length === 0) {
-        return "";
-    }
-    return `, ${filtered.join(", ")}`;
-}
-async function deriveCurrentAdr(prolog) {
-    // Query for all current ADRs and their titles
-    const result = await prolog.query("setof([Id,TitleAtom], (kb_entity(Id, adr, Props), memberchk(title=Title, Props), normalize_term_atom(Title, TitleAtom), current_adr(Id)), Rows)");
-    if (!result.success || !result.bindings.Rows) {
-        return [];
-    }
-    const pairs = parsePairList(result.bindings.Rows);
-    return pairs.map(([id, title]) => ({ id, title }));
-}
-async function deriveAdrChain(prolog, params) {
-    const adr = asRequiredString(params.adr, "params.adr is required");
-    // Query for the full chain including status
-    const result = await prolog.query(`findall([Id,TitleAtom,StatusAtom], (kb_entity(Id, adr, Props), memberchk(title=Title, Props), normalize_term_atom(Title, TitleAtom), memberchk(status=Status, Props), normalize_term_atom(Status, StatusAtom), adr_chain('${escapeAtom(adr)}', Chain), member(Id, Chain)), Rows)`);
-    if (!result.success || !result.bindings.Rows) {
-        return [];
-    }
-    // Parse triplets and include status
-    const triplets = parseTripleList(result.bindings.Rows);
-    return triplets.map(([id, title, status]) => ({ id, title, status }));
-}
-async function deriveSupersededBy(prolog, params) {
-    const adr = asRequiredString(params.adr, "params.adr is required");
-    // Query for direct supersession
-    const result = await prolog.query(`superseded_by('${escapeAtom(adr)}', NewAdr), kb_entity(NewAdr, adr, Props), memberchk(title=Title, Props), normalize_term_atom(Title, TitleAtom)`);
-    if (!result.success ||
-        !result.bindings.NewAdr ||
-        !result.bindings.TitleAtom) {
-        return [];
-    }
-    const newAdr = String(result.bindings.NewAdr).replace(/^'|'$/g, "");
-    const newAdrTitle = String(result.bindings.TitleAtom).replace(/^'|'$/g, "");
-    return [
-        {
-            adr,
-            successor_id: newAdr,
-            successor_title: newAdrTitle,
-        },
-    ];
-}
-function parseTripleList(raw) {
-    const match = raw.match(/\[(.*)\]/);
-    if (!match) {
-        return [];
-    }
-    const content = match[1].trim();
-    if (!content) {
-        return [];
-    }
-    // Parse triplets: [[a,b,c],[x,y,z],...]
-    const triplets = [];
-    const tripletRegex = /\[([^,]+),([^,]+),([^\]]+)\]/g;
-    let tripletMatch;
-    do {
-        tripletMatch = tripletRegex.exec(content);
-        if (tripletMatch !== null) {
-            triplets.push([
-                tripletMatch[1].trim().replace(/^'|'$/g, ""),
-                tripletMatch[2].trim().replace(/^'|'$/g, ""),
-                tripletMatch[3].trim().replace(/^'|'$/g, ""),
-            ]);
-        }
-    } while (tripletMatch !== null);
-    return triplets;
-}
-async function deriveDomainContradictions(prolog) {
-    const result = await prolog.query("setof([ReqA,ReqB,Reason], contradicting_reqs(ReqA, ReqB, Reason), Rows)");
-    if (!result.success || !result.bindings.Rows) {
-        return [];
-    }
-    const rows = parseTripleList(result.bindings.Rows);
-    return rows.map(([reqA, reqB, reason]) => ({ reqA, reqB, reason }));
-}

package/dist/tools/impact.js

@@ -1,51 +0,0 @@
-import { escapeAtom } from "kibi-cli/prolog/codec";
-import { parseAtomList } from "./prolog-list.js";
-export async function handleKbImpact(prolog, args) {
-    if (!args.entity || typeof args.entity !== "string") {
-        throw new Error("'entity' is required");
-    }
-    const goal = `setof(Id, (impacted_by_change(Id, '${escapeAtom(args.entity)}'), Id \\= '${escapeAtom(args.entity)}'), Impacted)`;
-    const impactedIds = await queryAtoms(prolog, goal, "Impacted");
-    const impacted = [];
-    for (const id of impactedIds) {
-        const type = await getEntityType(prolog, id);
-        impacted.push({ id, type: type ?? "unknown" });
-    }
-    impacted.sort((a, b) => {
-        if (a.type === b.type) {
-            return a.id.localeCompare(b.id);
-        }
-        return a.type.localeCompare(b.type);
-    });
-    return {
-        content: [
-            {
-                type: "text",
-                text: `Impact analysis for '${args.entity}': ${impacted.length} impacted entity(s).`,
-            },
-        ],
-        structuredContent: {
-            entity: args.entity,
-            impacted,
-            count: impacted.length,
-            provenance: {
-                predicate: "impacted_by_change",
-                deterministic: true,
-            },
-        },
-    };
-}
-async function queryAtoms(prolog, goal, bindingName) {
-    const result = await prolog.query(goal);
-    if (!result.success || !result.bindings[bindingName]) {
-        return [];
-    }
-    return parseAtomList(result.bindings[bindingName]);
-}
-async function getEntityType(prolog, id) {
-    const result = await prolog.query(`kb_entity('${escapeAtom(id)}', Type, _)`);
-    if (!result.success || !result.bindings.Type) {
-        return null;
-    }
-    return result.bindings.Type;
-}

package/dist/tools/list-types.js

@@ -1,58 +0,0 @@
-/**
- * Handle kb_list_entity_types tool calls
- * Returns the static list of supported KB entity type names (req, scenario, test, adr, flag, event, symbol, fact).
- */
-export async function handleKbListEntityTypes() {
-    return {
-        content: [
-            {
-                type: "text",
-                text: "Available entity types: req, scenario, test, adr, flag, event, symbol, fact",
-            },
-        ],
-        structuredContent: {
-            types: [
-                "req",
-                "scenario",
-                "test",
-                "adr",
-                "flag",
-                "event",
-                "symbol",
-                "fact",
-            ],
-        },
-    };
-}
-/**
- * Handle kb_list_relationship_types tool calls
- * Returns the static list of supported KB relationship type names (depends_on, specified_by, verified_by, etc.).
- */
-export async function handleKbListRelationshipTypes() {
-    return {
-        content: [
-            {
-                type: "text",
-                text: "Available relationship types: depends_on, specified_by, verified_by, validates, implements, covered_by, constrained_by, constrains, requires_property, guards, publishes, consumes, supersedes, relates_to",
-            },
-        ],
-        structuredContent: {
-            types: [
-                "depends_on",
-                "specified_by",
-                "verified_by",
-                "validates",
-                "implements",
-                "covered_by",
-                "constrained_by",
-                "constrains",
-                "requires_property",
-                "guards",
-                "publishes",
-                "consumes",
-                "supersedes",
-                "relates_to",
-            ],
-        },
-    };
-}

package/dist/tools/query-relationships.js

@@ -1,159 +0,0 @@
-const VALID_REL_TYPES = [
-    "depends_on",
-    "specified_by",
-    "verified_by",
-    "validates",
-    "implements",
-    "covered_by",
-    "constrained_by",
-    "constrains",
-    "requires_property",
-    "guards",
-    "publishes",
-    "consumes",
-    "supersedes",
-    "relates_to",
-];
-/**
- * Handle kb_query_relationships tool calls.
- * Queries the kb_relationship/3 predicate which has arity (Type, From, To).
- *
- * Note: kb_relationship/3 requires RelType to be bound (atom_concat/3 in Prolog
- * does not work with an unbound first argument). When no type filter is given,
- * we iterate over all known type values.
- */
-export async function handleKbQueryRelationships(prolog, args) {
-    const { from, to, type } = args;
-    if (type && !VALID_REL_TYPES.includes(type)) {
-        throw new Error(`Invalid relationship type '${type}'. Valid types: ${VALID_REL_TYPES.join(", ")}`);
-    }
-    // When type is specified we run one query; otherwise iterate all known types
-    // (kb_relationship/3 requires the type to be bound due to atom_concat/3 in Prolog).
-    const typesToQuery = type ? [type] : VALID_REL_TYPES;
-    const allRelationships = [];
-    for (const relType of typesToQuery) {
-        // We collect what we actually need based on which args are bound.
-        // When both from and to are specified, we just need to check existence.
-        // Otherwise collect the unbound sides.
-        let goal;
-        if (from && to) {
-            // Check if the specific triple exists
-            goal = `(kb_relationship('${relType}', '${from}', '${to}') -> Results = [['${from}','${to}']] ; Results = [])`;
-        }
-        else if (from) {
-            goal = `findall(To, kb_relationship('${relType}', '${from}', To), Results)`;
-        }
-        else if (to) {
-            goal = `findall(From, kb_relationship('${relType}', From, '${to}'), Results)`;
-        }
-        else {
-            goal = `findall([From,To], kb_relationship('${relType}', From, To), Results)`;
-        }
-        const queryResult = await prolog.query(goal);
-        if (!queryResult.success) {
-            throw new Error(queryResult.error || "Relationship query failed");
-        }
-        if (queryResult.bindings.Results) {
-            const raw = queryResult.bindings.Results;
-            if (from && to) {
-                // Results is either [[from,to]] or []
-                const pairs = parsePairResults(raw);
-                for (const [pairFrom, pairTo] of pairs) {
-                    allRelationships.push({ relType, from: pairFrom, to: pairTo });
-                }
-            }
-            else if (from) {
-                // Results is [To, To, ...]
-                const ids = parseIdList(raw);
-                for (const toId of ids) {
-                    allRelationships.push({ relType, from, to: toId });
-                }
-            }
-            else if (to) {
-                // Results is [From, From, ...]
-                const ids = parseIdList(raw);
-                for (const fromId of ids) {
-                    allRelationships.push({ relType, from: fromId, to });
-                }
-            }
-            else {
-                // Results is [[From,To], ...]
-                const pairs = parsePairResults(raw);
-                for (const [pairFrom, pairTo] of pairs) {
-                    allRelationships.push({ relType, from: pairFrom, to: pairTo });
-                }
-            }
-        }
-    }
-    const text = allRelationships.length === 0
-        ? "No relationships found."
-        : `Found ${allRelationships.length} relationship(s): ${allRelationships
-            .map((r) => `${r.from} -[${r.relType}]-> ${r.to}`)
-            .join(", ")}`;
-    return {
-        content: [{ type: "text", text }],
-        structuredContent: {
-            relationships: allRelationships,
-            count: allRelationships.length,
-        },
-    };
-}
-/**
- * Parse a flat Prolog list of atoms "[A,B,C]" into a string array.
- */
-function parseIdList(raw) {
-    const cleaned = raw.trim();
-    if (cleaned === "[]" || cleaned === "")
-        return [];
-    const inner = cleaned.replace(/^\[/, "").replace(/\]$/, "");
-    return inner
-        .split(",")
-        .map((s) => s.trim().replace(/^'|'$/g, "").replace(/^"|"$/g, ""))
-        .filter(Boolean);
-}
-/**
- * Parse Prolog findall result "[[From,To],...]" into [from, to] pairs.
- */
-function parsePairResults(raw) {
-    const cleaned = raw.trim();
-    if (cleaned === "[]" || cleaned === "")
-        return [];
-    const inner = cleaned.replace(/^\[/, "").replace(/\]$/, "");
-    const pairs = [];
-    let depth = 0;
-    let current = "";
-    for (let i = 0; i < inner.length; i++) {
-        const ch = inner[i];
-        if (ch === "[") {
-            depth++;
-            current += ch;
-        }
-        else if (ch === "]") {
-            depth--;
-            current += ch;
-            if (depth === 0) {
-                const pair = parsePair(current.trim());
-                if (pair)
-                    pairs.push(pair);
-                current = "";
-            }
-        }
-        else if (ch === "," && depth === 0) {
-            // top-level separator between pairs — skip
-        }
-        else {
-            current += ch;
-        }
-    }
-    return pairs;
-}
-function parsePair(pairStr) {
-    // expect "[From,To]"
-    const inner = pairStr.replace(/^\[/, "").replace(/\]$/, "").trim();
-    const parts = inner
-        .split(",")
-        .map((s) => s.trim().replace(/^'|'$/g, "").replace(/^"|"$/g, ""));
-    if (parts.length < 2)
-        return null;
-    return [parts[0], parts[1]];
-}

package/dist/tools/suggest-shared-facts.js

@@ -1,121 +0,0 @@
-import { parseAtomList } from "./prolog-list.js";
-/**
- * Handle analyze_shared_facts tool calls
- * Analyzes requirements to suggest shared domain facts for extraction
- */
-export async function handleSuggestSharedFacts(prolog, args) {
-    const minFreq = args.min_frequency ?? 2;
-    try {
-        // Query all requirements with their text properties
-        const reqsResult = await prolog.query("findall([Id,Title], (kb_entity(Id, req, Props), memberchk(title=Title, Props)), Reqs)");
-        if (!reqsResult.success || !reqsResult.bindings.Reqs) {
-            return {
-                content: [{ type: "text", text: "No requirements found in KB" }],
-                structuredContent: { suggestions: [], count: 0 },
-            };
-        }
-        const reqsList = parseAtomList(reqsResult.bindings.Reqs);
-        const requirements = [];
-        // Parse the list-of-lists format from Prolog
-        const reqMatch = reqsList.join("").matchAll(/\[([^,]+),([^\]]+)\]/g);
-        if (reqMatch) {
-            for (const match of reqMatch) {
-                const id = match[1].trim().replace(/^'|'$/g, "");
-                const title = match[2].trim().replace(/^'|'$/g, "");
-                requirements.push({ id, title, description: title });
-            }
-        }
-        // Query all existing facts for context
-        const factsResult = await prolog.query("findall([Id,Title], (kb_entity(Id, fact, Props), memberchk(title=Title, Props)), Facts)");
-        if (!factsResult.success || !factsResult.bindings.Facts) {
-            return {
-                content: [{ type: "text", text: "No facts found in KB" }],
-                structuredContent: { suggestions: [], count: 0 },
-            };
-        }
-        const factsList = parseAtomList(factsResult.bindings.Facts);
-        const existingFacts = new Set();
-        const factMatch = factsList.join("").matchAll(/\[([^,]+),([^\]]+)\]/g);
-        if (factMatch) {
-            for (const match of factMatch) {
-                const title = match[2].trim().replace(/^'|'$/g, "");
-                existingFacts.add(title.toLowerCase());
-            }
-        }
-        // Extract and analyze domain concepts from requirements
-        const suggestions = analyzeSharedConcepts(requirements, existingFacts, minFreq);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Found ${suggestions.length} potential shared fact(s) to consider creating.`,
-                },
-            ],
-            structuredContent: {
-                suggestions,
-                count: suggestions.length,
-            },
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Shared facts analysis failed: ${message}`);
-    }
-}
-/**
- * Lightweight heuristic to identify shared domain concepts
- * Focuses on:
- * - Capitalized terms (possible domain concepts)
- * - Repeated phrases across multiple requirements
- * - Excludes existing facts
- */
-function analyzeSharedConcepts(requirements, existingFacts, minFreq) {
-    const conceptCounts = new Map();
-    for (const req of requirements) {
-        const originalText = `${req.title} ${req.description || ""}`;
-        const text = originalText.toLowerCase();
-        // Extract capitalized terms (potential domain concepts)
-        // Pattern: words starting with capital letters that aren't at sentence start
-        const capitalizedTerms = originalText.matchAll(/\b([A-Z][a-z]+)\b/g);
-        // Extract repeated phrases (2+ words)
-        // Extract repeated phrases (2+ words)
-        const words = text.split(/\s+/).filter((w) => w.length > 3);
-        for (let i = 0; i < words.length - 1; i++) {
-            const phrase = `${words[i]} ${words[i + 1]}`;
-            if (!conceptCounts.has(phrase)) {
-                conceptCounts.set(phrase, new Set());
-            }
-            conceptCounts.get(phrase).add(req.id);
-        }
-        // Also track individual capitalized terms
-        for (const match of capitalizedTerms) {
-            const lowerTerm = match[1].toLowerCase(); // Get the captured group
-            if (!conceptCounts.has(lowerTerm)) {
-                conceptCounts.set(lowerTerm, new Set());
-            }
-            conceptCounts.get(lowerTerm).add(req.id);
-        }
-    }
-    // Generate suggestions
-    const suggestions = [];
-    for (const [concept, reqIds] of conceptCounts) {
-        if (reqIds.size >= minFreq) {
-            // Skip if this concept already exists as a fact
-            if (!existingFacts.has(concept)) {
-                suggestions.push({
-                    concept: capitalizeConcept(concept),
-                    mentions: reqIds.size,
-                    requirements: Array.from(reqIds),
-                });
-            }
-        }
-    }
-    // Sort by frequency (most mentioned first)
-    return suggestions.sort((a, b) => b.mentions - a.mentions);
-}
-function capitalizeConcept(concept) {
-    return concept
-        .split(/\s+/)
-        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-        .join(" ");
-}