kibi-mcp 0.2.4 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-mcp",
-  "version": "0.2.4",
+  "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.3",
-    "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,208 +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/>.
-*/
-/*
- 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";
-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,270 +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/>.
-*/
-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}`);
-    }
-}
-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

@@ -1,91 +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 { 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]);
-}