kibi-mcp 0.1.0

package/dist/tools/context.js

@@ -0,0 +1,280 @@
+/*
+ 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/>.
+*/
+export async function handleKbContext(prolog, args, activeBranch) {
+    const { sourceFile, branch } = args;
+    if (branch && activeBranch && branch !== activeBranch) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: branch parameter is not supported server-side; set KIBI_BRANCH at startup or restart server on the desired branch. (Requested: ${branch}, Active: ${activeBranch})`,
+                },
+            ],
+        };
+    }
+    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}`);
+    }
+}
+function parseListOfLists(listStr) {
+    const cleaned = listStr.trim().replace(/^\[/, "").replace(/\]$/, "");
+    if (cleaned === "") {
+        return [];
+    }
+    const results = [];
+    let depth = 0;
+    let current = "";
+    let currentList = [];
+    for (let i = 0; i < cleaned.length; i++) {
+        const char = cleaned[i];
+        if (char === "[") {
+            depth++;
+            if (depth > 1)
+                current += char;
+        }
+        else if (char === "]") {
+            depth--;
+            if (depth === 0) {
+                if (current) {
+                    currentList.push(current.trim());
+                    current = "";
+                }
+                if (currentList.length > 0) {
+                    results.push(currentList);
+                    currentList = [];
+                }
+            }
+            else {
+                current += char;
+            }
+        }
+        else if (char === "," && depth === 1) {
+            if (current) {
+                currentList.push(current.trim());
+                current = "";
+            }
+        }
+        else if (char === "," && depth === 0) {
+        }
+        else {
+            current += char;
+        }
+    }
+    return results;
+}
+function parseEntityFromList(data) {
+    if (data.length < 3) {
+        return {};
+    }
+    const id = data[0].trim();
+    const type = data[1].trim();
+    const propsStr = data[2].trim();
+    const props = parsePropertyList(propsStr);
+    return { ...props, id: normalizeEntityId(stripOuterQuotes(id)), type };
+}
+function parsePropertyList(propsStr) {
+    const props = {};
+    let cleaned = propsStr.trim();
+    if (cleaned.startsWith("[")) {
+        cleaned = cleaned.substring(1);
+    }
+    if (cleaned.endsWith("]")) {
+        cleaned = cleaned.substring(0, cleaned.length - 1);
+    }
+    const pairs = splitTopLevel(cleaned, ",");
+    for (const pair of pairs) {
+        const eqIndex = pair.indexOf("=");
+        if (eqIndex === -1)
+            continue;
+        const key = pair.substring(0, eqIndex).trim();
+        const value = pair.substring(eqIndex + 1).trim();
+        if (key === "..." || value === "..." || value === "...|...") {
+            continue;
+        }
+        const parsed = parsePrologValue(value);
+        props[key] = parsed;
+    }
+    return props;
+}
+function parsePrologValue(valueInput) {
+    const value = valueInput.trim();
+    if (value.startsWith("^^(")) {
+        const innerStart = value.indexOf("(") + 1;
+        let depth = 1;
+        let innerEnd = innerStart;
+        for (let i = innerStart; i < value.length; i++) {
+            if (value[i] === "(")
+                depth++;
+            if (value[i] === ")") {
+                depth--;
+                if (depth === 0) {
+                    innerEnd = i;
+                    break;
+                }
+            }
+        }
+        const innerContent = value.substring(innerStart, innerEnd);
+        const parts = splitTopLevel(innerContent, ",");
+        if (parts.length >= 2) {
+            let literalValue = parts[0].trim();
+            if (literalValue.startsWith('"') && literalValue.endsWith('"')) {
+                literalValue = literalValue.substring(1, literalValue.length - 1);
+            }
+            if (literalValue.startsWith("[") && literalValue.endsWith("]")) {
+                const listContent = literalValue.substring(1, literalValue.length - 1);
+                if (listContent === "") {
+                    return [];
+                }
+                return listContent.split(",").map((item) => item.trim());
+            }
+            return literalValue;
+        }
+    }
+    if (value.startsWith("file:///")) {
+        const lastSlash = value.lastIndexOf("/");
+        if (lastSlash !== -1) {
+            return value.substring(lastSlash + 1);
+        }
+        return value;
+    }
+    if (value.startsWith('"') && value.endsWith('"')) {
+        return value.substring(1, value.length - 1);
+    }
+    if (value.startsWith("'") && value.endsWith("'")) {
+        return value.substring(1, value.length - 1);
+    }
+    if (value.startsWith("[") && value.endsWith("]")) {
+        const listContent = value.substring(1, value.length - 1);
+        if (listContent === "") {
+            return [];
+        }
+        const items = listContent.split(",").map((item) => {
+            return parsePrologValue(item.trim());
+        });
+        return items;
+    }
+    return value;
+}
+function splitTopLevel(str, delimiter) {
+    const results = [];
+    let current = "";
+    let depth = 0;
+    let inQuotes = false;
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        const prevChar = i > 0 ? str[i - 1] : "";
+        if (char === '"' && prevChar !== "\\") {
+            inQuotes = !inQuotes;
+            current += char;
+        }
+        else if (!inQuotes && (char === "[" || char === "(")) {
+            depth++;
+            current += char;
+        }
+        else if (!inQuotes && (char === "]" || char === ")")) {
+            depth--;
+            current += char;
+        }
+        else if (!inQuotes && depth === 0 && char === delimiter) {
+            if (current) {
+                results.push(current);
+                current = "";
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current) {
+        results.push(current);
+    }
+    return results;
+}
+function stripOuterQuotes(value) {
+    if (value.startsWith("'") && value.endsWith("'")) {
+        return value.slice(1, -1);
+    }
+    if (value.startsWith('"') && value.endsWith('"')) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function normalizeEntityId(value) {
+    if (!value.startsWith("file:///")) {
+        return value;
+    }
+    const idx = value.lastIndexOf("/");
+    return idx === -1 ? value : value.slice(idx + 1);
+}

package/dist/tools/coverage-report.js

@@ -0,0 +1,91 @@
+/*
+ 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 { 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/delete.js

@@ -0,0 +1,100 @@
+/*
+ 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/>.
+*/
+/**
+ * Handle kb.delete tool calls
+ * Prevents deletion of entities with dependents (referential integrity)
+ */
+export async function handleKbDelete(prolog, args) {
+    const { ids } = args;
+    if (!ids || ids.length === 0) {
+        throw new Error("At least one ID required for delete");
+    }
+    let deleted = 0;
+    let skipped = 0;
+    const errors = [];
+    try {
+        for (const id of ids) {
+            // Check if entity exists
+            const checkGoal = `kb_entity('${id}', _, _)`;
+            const checkResult = await prolog.query(checkGoal);
+            if (!checkResult.success) {
+                errors.push(`Entity ${id} does not exist`);
+                skipped++;
+                continue;
+            }
+            // Check for dependents (entities that reference this one)
+            // Query each relationship type separately to avoid timeout with unbound Type
+            const relTypes = [
+                "depends_on",
+                "verified_by",
+                "validates",
+                "specified_by",
+                "relates_to",
+                "guards",
+                "publishes",
+                "consumes",
+            ];
+            let hasDependents = false;
+            for (const relType of relTypes) {
+                const dependentsGoal = `findall(From, kb_relationship(${relType}, From, '${id}'), Dependents)`;
+                const dependentsResult = await prolog.query(dependentsGoal);
+                if (dependentsResult.success && dependentsResult.bindings.Dependents) {
+                    const dependentsStr = dependentsResult.bindings.Dependents;
+                    if (dependentsStr !== "[]") {
+                        errors.push(`Cannot delete entity ${id}: has dependents (other entities reference it via ${relType})`);
+                        skipped++;
+                        hasDependents = true;
+                        break;
+                    }
+                }
+            }
+            if (hasDependents) {
+                continue;
+            }
+            // No dependents, safe to delete
+            const deleteGoal = `kb_retract_entity('${id}')`;
+            const deleteResult = await prolog.query(deleteGoal);
+            if (!deleteResult.success) {
+                errors.push(`Failed to delete entity ${id}: ${deleteResult.error || "Unknown error"}`);
+                skipped++;
+            }
+            else {
+                deleted++;
+            }
+        }
+        // Save KB to disk
+        await prolog.query("kb_save");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Deleted ${deleted} entities. Skipped ${skipped}. ${errors.length > 0 ? `Errors: ${errors.join("; ")}` : ""}`,
+                },
+            ],
+            structuredContent: {
+                deleted,
+                skipped,
+                errors,
+            },
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Delete execution failed: ${message}`);
+    }
+}