kibi-mcp 0.17.5 → 0.19.2

package/dist/tools/coverage.js

@@ -1,28 +1,14 @@
-import { runJsonModuleQuery, toPrologList } from "./core-module.js";
+import { executeCoverage } from "kibi-cli/operations";
 // implements REQ-002, REQ-013
 export async function handleKbCoverage(prolog, args) {
-    const by = args.by ?? "req";
-    const limit = args.limit ?? 100;
-    const offset = args.offset ?? 0;
-    const includePassing = args.includePassing ?? false;
-    const includeTransitive = args.includeTransitive ?? true;
-    try {
-        const payload = await runJsonModuleQuery(prolog, "discovery.pl", `discovery:coverage_report_json('${by}', ${toPrologList(args.tags)}, ${includePassing}, ${includeTransitive}, ${limit}, ${offset}, JsonString)`, "Coverage execution");
-        const summary = payload?.summary ?? {};
-        const fullyCovered = Number(summary.fullyCovered ?? 0);
-        const total = Number(summary.total ?? 0);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Coverage summary: ${fullyCovered} fully covered out of ${total}.`,
-                },
-            ],
-            ...(payload !== undefined ? { structuredContent: payload } : {}),
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Coverage execution failed: ${message}`);
-    }
+    return executeCoverage({ ...args }, {
+        workspaceRoot: process.cwd(),
+        signal: new AbortController().signal,
+        clock: () => new Date(),
+        prolog: {
+            query: (goal) => prolog.query(goal),
+            nextSolution: async () => null,
+            save: () => prolog.query("kb_save"),
+        },
+    });
 }

package/dist/tools/delete.js

@@ -1,113 +1,6 @@
-import { escapeAtom, parseEntityFromList, parseListOfLists, } from "kibi-cli/prolog/codec";
-/**
- * Handle kb.delete tool calls
- * Prevents deletion of entities with dependents (referential integrity)
- */
-export async function handleKbDelete(
-// implements REQ-002, REQ-011
-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) {
-            const safeId = escapeAtom(id);
-            // Check if entity exists
-            const checkGoal = `once(kb_entity('${safeId}', _, _))`;
-            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)
-            const dependentsGoal = `findall([RelType,From], (member(RelType, [depends_on, verified_by, validates, specified_by, relates_to, guards, publishes, consumes]), kb_relationship(RelType, From, '${safeId}')), Dependents)`;
-            const dependentsResult = await prolog.query(dependentsGoal);
-            if (!dependentsResult.success) {
-                errors.push(`Failed to inspect dependents for entity ${id}: ${dependentsResult.error ?? "Query failed"}`);
-                skipped++;
-                continue;
-            }
-            const hasDependents = dependentsResult.bindings.Dependents !== undefined &&
-                dependentsResult.bindings.Dependents !== "[]";
-            if (hasDependents) {
-                errors.push(`Cannot delete entity ${id}: has dependents (other entities reference it)`);
-                skipped++;
-            }
-            if (hasDependents) {
-                continue;
-            }
-            // No dependents, safe to delete
-            const entityMetadata = await loadEntityMetadataForDelete(prolog, id, safeId);
-            const deleteGoal = buildDeleteGoal(safeId, entityMetadata);
-            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
-        const saveResult = await prolog.query("kb_save");
-        if (!saveResult.success) {
-            throw new Error(`Failed to save KB after delete: ${saveResult.error || "Unknown error"}`);
-        }
-        prolog.invalidateCache();
-        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}`);
-    }
-}
-async function loadEntityMetadataForDelete(prolog, id, safeId) {
-    const result = await prolog.query(`findall(['${safeId}',Type,Props], kb_entity('${safeId}', Type, Props), Results)`);
-    if (!result.success) {
-        throw new Error(`Failed to load metadata for entity ${id}: ${result.error || "Unknown error"}`);
-    }
-    const rows = result.bindings.Results
-        ? parseListOfLists(result.bindings.Results)
-        : [];
-    if (rows.length === 0) {
-        throw new Error(`Failed to load metadata for entity ${id}: Entity not found`);
-    }
-    const entity = parseEntityFromList(rows[0] ?? []);
-    const type = String(entity.type ?? "unknown");
-    const { id: _entityId, type: _entityType, ...props } = entity;
-    return { type, props };
-}
-function buildDeleteGoal(safeId, metadata) {
-    const auditProps = [
-        `id='${safeId}'`,
-        ...serializeDeleteProps(metadata.props),
-    ];
-    return `kb_retract_entity('${safeId}', ${metadata.type}, [${auditProps.join(", ")}])`;
-}
-function serializeDeleteProps(props) {
-    const orderedKeys = ["title", "source", "text_ref"];
-    return orderedKeys.flatMap((key) => {
-        const value = props[key];
-        if (typeof value !== "string") {
-            return [];
-        }
-        return `${key}=${JSON.stringify(value)}`;
-    });
+import { deleteSpec } from "kibi-cli/operations";
+import { createMutationContext } from "./mutation-context.js";
+// implements REQ-kibi-operation-interface-parity
+export async function handleKbDelete(prolog, args) {
+    return deleteSpec.execute(args, createMutationContext(prolog));
 }

package/dist/tools/discovery-adapter.js

@@ -0,0 +1,23 @@
+import { resolveWorkspaceRoot } from "../workspace.js";
+export function createDiscoveryContext(prolog) {
+    // implements REQ-kibi-operation-interface-parity
+    let lastResult = null;
+    const port = {
+        query: async (goal) => {
+            lastResult = await prolog.query(goal);
+            return lastResult;
+        },
+        nextSolution: async () => {
+            const result = lastResult;
+            lastResult = null;
+            return result;
+        },
+        save: () => prolog.query("kb_save"),
+    };
+    return {
+        workspaceRoot: resolveWorkspaceRoot(),
+        signal: new AbortController().signal,
+        clock: () => new Date(),
+        prolog: port,
+    };
+}

package/dist/tools/entity-query.js

@@ -1,111 +1 @@
-import { escapeAtomContent, parseEntityFromBinding, parseEntityFromList, parseListOfLists, } from "kibi-cli/prolog/codec";
-export const VALID_ENTITY_TYPES = [
-    // implements REQ-002
-    "req",
-    "scenario",
-    "test",
-    "adr",
-    "flag",
-    "event",
-    "symbol",
-    "fact",
-];
-// implements REQ-002, REQ-013
-export function validateEntityType(type) {
-    if (type && !VALID_ENTITY_TYPES.includes(type)) {
-        throw new Error(`Invalid type '${type}'. Valid types: ${VALID_ENTITY_TYPES.join(", ")}. Use a single type value, or omit this parameter to query all entities.`);
-    }
-}
-// implements REQ-002, REQ-013
-export function buildEntityGoal(args) {
-    const { type, id, tags, sourceFile } = args;
-    if (sourceFile) {
-        const safeSource = escapeAtomContent(sourceFile);
-        if (type) {
-            const safeType = escapeAtomContent(type);
-            return `findall([Id,'${safeType}',Props], (kb_entities_by_source('${safeSource}', SourceIds), member(Id, SourceIds), kb_entity(Id, '${safeType}', Props)), Results)`;
-        }
-        return `findall([Id,Type,Props], (kb_entities_by_source('${safeSource}', SourceIds), member(Id, SourceIds), kb_entity(Id, Type, Props)), Results)`;
-    }
-    if (id && type) {
-        const safeId = escapeAtomContent(id);
-        const safeType = escapeAtomContent(type);
-        return `findall(['${safeId}','${safeType}',Props], kb_entity('${safeId}', '${safeType}', Props), Results)`;
-    }
-    if (id) {
-        const safeId = escapeAtomContent(id);
-        return `findall(['${safeId}',Type,Props], kb_entity('${safeId}', Type, Props), Results)`;
-    }
-    if (tags && tags.length > 0) {
-        if (type) {
-            const safeType = escapeAtomContent(type);
-            return `findall([Id,'${safeType}',Props], kb_entity(Id, '${safeType}', Props), Results)`;
-        }
-        return "findall([Id,Type,Props], kb_entity(Id, Type, Props), Results)";
-    }
-    if (type) {
-        const safeType = escapeAtomContent(type);
-        return `findall([Id,'${safeType}',Props], kb_entity(Id, '${safeType}', Props), Results)`;
-    }
-    return "findall([Id,Type,Props], kb_entity(Id, Type, Props), Results)";
-}
-// implements REQ-002, REQ-013
-export async function loadEntities(prolog, args) {
-    validateEntityType(args.type);
-    const goal = buildEntityGoal(args);
-    const queryResult = await prolog.query(goal);
-    let results = [];
-    if (!queryResult.success) {
-        throw new Error(queryResult.error || "Query failed with unknown error");
-    }
-    if (queryResult.bindings.Results) {
-        const entitiesData = parseListOfLists(queryResult.bindings.Results);
-        for (const data of entitiesData) {
-            results.push(parseEntityFromList(data));
-        }
-    }
-    else if (queryResult.bindings.Result) {
-        results = [parseEntityFromBinding(queryResult.bindings.Result)];
-    }
-    if (args.tags && args.tags.length > 0) {
-        const requestedTags = args.tags;
-        results = dedupeEntities(results.filter((entity) => hasAnyTag(entity, requestedTags)));
-    }
-    return dedupeEntities(results);
-}
-// implements REQ-002
-export function paginateResults(results, limit = 100, offset = 0) {
-    return results.slice(offset, offset + limit);
-}
-function hasAnyTag(entity, requestedTags) {
-    const expected = new Set(requestedTags.map(normalizeTagValue));
-    const rawTags = entity.tags;
-    if (!Array.isArray(rawTags) || rawTags.length === 0) {
-        return false;
-    }
-    for (const tag of rawTags) {
-        if (expected.has(normalizeTagValue(tag))) {
-            return true;
-        }
-    }
-    return false;
-}
-function normalizeTagValue(tag) {
-    return String(tag).trim();
-}
-// implements REQ-002
-export function dedupeEntities(entities) {
-    const seen = new Set();
-    const deduped = [];
-    for (const entity of entities) {
-        const id = String(entity.id ?? "");
-        const type = String(entity.type ?? "");
-        const key = `${type}::${id}`;
-        if (seen.has(key)) {
-            continue;
-        }
-        seen.add(key);
-        deduped.push(entity);
-    }
-    return deduped;
-}
+export { VALID_ENTITY_TYPES, buildEntityGoal, dedupeEntities, loadEntities, paginateResults, validateEntityType, } from "kibi-cli/operations";

package/dist/tools/find-gaps.js

@@ -1,29 +1,14 @@
-import { runJsonModuleQuery, toPrologAtom, toPrologList, } from "./core-module.js";
-import { validateEntityType } from "./entity-query.js";
+import { executeFindGaps } from "kibi-cli/operations";
 // implements REQ-002, REQ-013
 export async function handleKbFindGaps(prolog, args) {
-    validateEntityType(args.type);
-    const limit = args.limit ?? 100;
-    const offset = args.offset ?? 0;
-    try {
-        const payload = await runJsonModuleQuery(prolog, "discovery.pl", `discovery:find_gaps_json(${toPrologAtom(args.type)}, ${toPrologList(args.missingRelationships)}, ${toPrologList(args.presentRelationships)}, ${toPrologList(args.tags)}, ${toPrologAtom(args.sourceFile)}, ${limit}, ${offset}, JsonString)`, "Find-gaps execution");
-        const rows = payload?.rows ?? [];
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: rows.length === 0
-                        ? "No matching gaps found."
-                        : `Found ${payload?.count ?? rows.length} gap rows. Showing ${rows.length}: ${rows
-                            .map((row) => row.id)
-                            .join(", ")}`,
-                },
-            ],
-            ...(payload !== undefined ? { structuredContent: payload } : {}),
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Find-gaps execution failed: ${message}`);
-    }
+    return executeFindGaps({ ...args }, {
+        workspaceRoot: process.cwd(),
+        signal: new AbortController().signal,
+        clock: () => new Date(),
+        prolog: {
+            query: (goal) => prolog.query(goal),
+            nextSolution: async () => null,
+            save: () => prolog.query("kb_save"),
+        },
+    });
 }

package/dist/tools/graph.js

@@ -1,27 +1,14 @@
-import { runJsonModuleQuery, toPrologList } from "./core-module.js";
+import { executeGraph } from "kibi-cli/operations";
 // implements REQ-002, REQ-013
 export async function handleKbGraph(prolog, args) {
-    const direction = args.direction ?? "outgoing";
-    const depth = args.depth ?? 1;
-    const maxNodes = args.maxNodes ?? 200;
-    const maxEdges = args.maxEdges ?? 500;
-    try {
-        const payload = await runJsonModuleQuery(prolog, "discovery.pl", `discovery:graph_expand_json(${toPrologList(args.seedIds)}, ${toPrologList(args.relationships)}, '${direction}', ${depth}, ${toPrologList(args.entityTypes)}, ${maxNodes}, ${maxEdges}, JsonString)`, "Graph execution");
-        const nodes = payload?.nodes ?? [];
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: nodes.length === 0
-                        ? "Graph traversal returned no nodes."
-                        : `Graph traversal returned ${nodes.length} nodes and ${(payload?.edges ?? []).length} edges from ${args.seedIds.join(", ")}.`,
-                },
-            ],
-            ...(payload !== undefined ? { structuredContent: payload } : {}),
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Graph execution failed: ${message}`);
-    }
+    return executeGraph({ ...args }, {
+        workspaceRoot: process.cwd(),
+        signal: new AbortController().signal,
+        clock: () => new Date(),
+        prolog: {
+            query: (goal) => prolog.query(goal),
+            nextSolution: async () => null,
+            save: () => prolog.query("kb_save"),
+        },
+    });
 }