kibi-mcp 0.2.2 → 0.2.4

package/dist/tools/check.js

@@ -42,8 +42,29 @@
       fi
     done
 */
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import * as path from "node:path";
 import { parsePairList } from "./prolog-list.js";
+const require = createRequire(import.meta.url);
+function resolveChecksPlPath() {
+    const overrideChecksPath = process.env.KIBI_CHECKS_PL_PATH;
+    if (overrideChecksPath && existsSync(overrideChecksPath)) {
+        return overrideChecksPath;
+    }
+    try {
+        const installedChecksPl = require.resolve("kibi-core/src/checks.pl");
+        if (existsSync(installedChecksPl)) {
+            return installedChecksPl;
+        }
+    }
+    catch { }
+    const localChecksPl = path.join(process.cwd(), "packages/core/src/checks.pl");
+    if (existsSync(localChecksPl)) {
+        return localChecksPl;
+    }
+    throw new Error("Unable to resolve checks.pl path");
+}
 function formatDiagnosticsForMcp(diagnostics) {
     return diagnostics.map((d) => ({
         category: d.category,
@@ -61,7 +82,7 @@ export async function handleKbCheck(prolog, args) {
     const { rules } = args;
     try {
         const violations = [];
-        const allEntityIds = await getAllEntityIds(prolog);
+        let allEntityIds = null;
         // Run all validation rules (or specific rules if provided)
         const allRules = [
             "must-priority-coverage",
@@ -71,6 +92,33 @@ export async function handleKbCheck(prolog, args) {
             "symbol-coverage",
         ];
         const rulesToRun = rules && rules.length > 0 ? rules : allRules;
+        const rulesAllowlist = new Set(rulesToRun);
+        const aggregatedViolations = await runAggregatedChecks(prolog, rulesAllowlist);
+        if (aggregatedViolations) {
+            const diagnostics = aggregatedViolations.map((v) => ({
+                category: "SYNC_ERROR",
+                severity: "error",
+                message: v.description,
+                file: v.source,
+                suggestion: v.suggestion,
+            }));
+            const summary = aggregatedViolations.length === 0
+                ? "No violations found"
+                : `${aggregatedViolations.length} violations found`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: summary,
+                    },
+                ],
+                structuredContent: {
+                    violations: aggregatedViolations,
+                    count: aggregatedViolations.length,
+                    diagnostics: formatDiagnosticsForMcp(diagnostics),
+                },
+            };
+        }
         if (rulesToRun.includes("must-priority-coverage")) {
             violations.push(...(await checkMustPriorityCoverage(prolog)));
         }
@@ -81,6 +129,9 @@ export async function handleKbCheck(prolog, args) {
             violations.push(...(await checkNoCycles(prolog)));
         }
         if (rulesToRun.includes("required-fields")) {
+            if (!allEntityIds) {
+                allEntityIds = await getAllEntityIds(prolog);
+            }
             violations.push(...(await checkRequiredFields(prolog, allEntityIds)));
         }
         if (rulesToRun.includes("symbol-coverage")) {
@@ -115,6 +166,72 @@ export async function handleKbCheck(prolog, args) {
         throw new Error(`Check execution failed: ${message}`);
     }
 }
+async function runAggregatedChecks(prolog, rulesAllowlist) {
+    const checksPlPath = resolveChecksPlPath();
+    const normalizedChecksPlPath = checksPlPath.replace(/\\/g, "/");
+    const checksPlPathEscaped = normalizedChecksPlPath.replace(/'/g, "''");
+    const violations = [];
+    const ruleToPredicate = {
+        "must-priority-coverage": "check_must_priority_coverage",
+        "no-dangling-refs": "check_no_dangling_refs",
+        "no-cycles": "check_no_cycles",
+        "required-fields": "check_required_fields",
+        "symbol-coverage": "check_symbol_coverage",
+    };
+    for (const rule of rulesAllowlist) {
+        const predicate = ruleToPredicate[rule];
+        if (!predicate) {
+            continue;
+        }
+        const query = `(use_module('${checksPlPathEscaped}'), call(checks:${predicate}(Violations)), findall(_{rule:Rule,entityId:EntityId,description:Description,suggestion:Suggestion,source:Source}, member(violation(Rule, EntityId, Description, Suggestion, Source), Violations), Rows), call(checks:atom_json_dict(JsonString, Rows, [])))`;
+        const result = await prolog.query(query);
+        if (!result.success || !result.bindings.JsonString) {
+            return null;
+        }
+        let parsedRows;
+        try {
+            parsedRows = JSON.parse(result.bindings.JsonString);
+            if (typeof parsedRows === "string") {
+                parsedRows = JSON.parse(parsedRows);
+            }
+        }
+        catch {
+            return null;
+        }
+        if (!Array.isArray(parsedRows)) {
+            return null;
+        }
+        for (const row of parsedRows) {
+            if (!row || typeof row !== "object") {
+                continue;
+            }
+            const raw = row;
+            const rule = typeof raw.rule === "string" ? raw.rule : "";
+            if (!rulesAllowlist.has(rule)) {
+                continue;
+            }
+            const entityId = typeof raw.entityId === "string"
+                ? raw.entityId
+                : typeof raw.entity_id === "string"
+                    ? raw.entity_id
+                    : "";
+            const description = typeof raw.description === "string" ? raw.description : "";
+            const suggestion = typeof raw.suggestion === "string" ? raw.suggestion : undefined;
+            const source = typeof raw.source === "string" ? raw.source : undefined;
+            if (!rule || !entityId || !description) {
+                continue;
+            }
+            violations.push({
+                rule,
+                entityId,
+                description,
+                suggestion,
+                source,
+            });
+        }
+    }
+    return violations;
+}
 async function checkMustPriorityCoverage(prolog) {
     const violations = [];
     const gapsResult = await prolog.query("setof([Req,Reason], coverage_gap(Req, Reason), Rows)");

package/dist/tools/delete.js

@@ -16,7 +16,7 @@
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 function escapeAtom(value) {
-    return value.replace(/'/g, "\\'");
+    return value.replace(/'/g, "''");
 }
 /**
  * Handle kb.delete tool calls
@@ -32,8 +32,9 @@ export async function handleKbDelete(prolog, args) {
     const errors = [];
     try {
         for (const id of ids) {
+            const safeId = escapeAtom(id);
             // Check if entity exists
-            const checkGoal = `once(kb_entity('${escapeAtom(id)}', _, _))`;
+            const checkGoal = `once(kb_entity('${safeId}', _, _))`;
             const checkResult = await prolog.query(checkGoal);
             if (!checkResult.success) {
                 errors.push(`Entity ${id} does not exist`);
@@ -41,36 +42,24 @@ export async function handleKbDelete(prolog, args) {
                 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;
-                    }
-                }
+            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 deleteGoal = `kb_retract_entity('${id}')`;
+            const deleteGoal = `kb_retract_entity('${safeId}')`;
             const deleteResult = await prolog.query(deleteGoal);
             if (!deleteResult.success) {
                 errors.push(`Failed to delete entity ${id}: ${deleteResult.error || "Unknown error"}`);
@@ -82,6 +71,7 @@ export async function handleKbDelete(prolog, args) {
         }
         // Save KB to disk
         await prolog.query("kb_save");
+        prolog.invalidateCache();
         return {
             content: [
                 {

package/dist/tools/query.js

@@ -15,6 +15,13 @@
  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/>.
 */
+/**
+ * Escape a string for embedding inside a single-quoted Prolog atom.
+ * Doubles single-quote characters per ISO Prolog standard.
+ */
+function escapeAtomContent(value) {
+    return value.replace(/'/g, "''");
+}
 export const VALID_ENTITY_TYPES = [
     "req",
     "scenario",
@@ -42,58 +49,63 @@ export async function handleKbQuery(prolog, args) {
         // Build Prolog query
         let goal;
         if (sourceFile) {
-            const safeSource = sourceFile.replace(/'/g, "\\'");
+            const safeSource = escapeAtomContent(sourceFile);
             if (type) {
-                goal = `findall([Id,'${type}',Props], (kb_entities_by_source('${safeSource}', SourceIds), member(Id, SourceIds), kb_entity(Id, '${type}', Props)), Results)`;
+                const safeType = escapeAtomContent(type);
+                goal = `findall([Id,'${safeType}',Props], (kb_entities_by_source('${safeSource}', SourceIds), member(Id, SourceIds), kb_entity(Id, '${safeType}', Props)), Results)`;
             }
             else {
                 goal = `findall([Id,Type,Props], (kb_entities_by_source('${safeSource}', SourceIds), member(Id, SourceIds), kb_entity(Id, Type, Props)), Results)`;
             }
         }
         else if (id && type) {
-            goal = `kb_entity('${id}', '${type}', Props), Id = '${id}', Type = '${type}', Result = [Id, Type, Props]`;
+            const safeId = escapeAtomContent(id);
+            const safeType = escapeAtomContent(type);
+            goal = `findall(['${safeId}','${safeType}',Props], kb_entity('${safeId}', '${safeType}', Props), Results)`;
         }
         else if (id) {
-            goal = `findall(['${id}',Type,Props], kb_entity('${id}', Type, Props), Results)`;
+            const safeId = escapeAtomContent(id);
+            goal = `findall(['${safeId}',Type,Props], kb_entity('${safeId}', Type, Props), Results)`;
         }
         else if (tags && tags.length > 0) {
-            const tagList = `[${tags.map((t) => `'${t}'`).join(",")}]`;
+            // TODO: Reintroduce server-side (Prolog) tag filtering once normalization
+            // issues with tag list formats are resolved, to avoid fetching all entities
+            // before filtering in JS for large knowledge bases.
             if (type) {
-                goal = `findall([Id,'${type}',Props], (kb_entity(Id, '${type}', Props), memberchk(tags=Tags, Props), member(Tag, Tags), member(Tag, ${tagList})), Results)`;
+                const safeType = escapeAtomContent(type);
+                goal = `findall([Id,'${safeType}',Props], kb_entity(Id, '${safeType}', Props), Results)`;
             }
             else {
-                goal = `findall([Id,Type,Props], (kb_entity(Id, Type, Props), memberchk(tags=Tags, Props), member(Tag, Tags), member(Tag, ${tagList})), Results)`;
+                goal = "findall([Id,Type,Props], kb_entity(Id, Type, Props), Results)";
             }
         }
         else if (type) {
-            goal = `findall([Id,'${type}',Props], kb_entity(Id, '${type}', Props), Results)`;
+            const safeType = escapeAtomContent(type);
+            goal = `findall([Id,'${safeType}',Props], kb_entity(Id, '${safeType}', Props), Results)`;
         }
         else {
             goal = "findall([Id,Type,Props], kb_entity(Id, Type, Props), Results)";
         }
         const queryResult = await prolog.query(goal);
         if (queryResult.success) {
-            if (id && type) {
-                // Single entity query
-                if (queryResult.bindings.Result) {
-                    const entity = parseEntityFromBinding(queryResult.bindings.Result);
-                    results = [entity];
+            if (queryResult.bindings.Results) {
+                const entitiesData = parseListOfLists(queryResult.bindings.Results);
+                for (const data of entitiesData) {
+                    const entity = parseEntityFromList(data);
+                    results.push(entity);
                 }
             }
-            else {
-                // Multiple entities query
-                if (queryResult.bindings.Results) {
-                    const entitiesData = parseListOfLists(queryResult.bindings.Results);
-                    for (const data of entitiesData) {
-                        const entity = parseEntityFromList(data);
-                        results.push(entity);
-                    }
-                }
+            else if (queryResult.bindings.Result) {
+                const entity = parseEntityFromBinding(queryResult.bindings.Result);
+                results = [entity];
             }
         }
         else {
             throw new Error(queryResult.error || "Query failed with unknown error");
         }
+        if (tags && tags.length > 0) {
+            results = dedupeEntities(results.filter((entity) => hasAnyTag(entity, tags)));
+        }
         // Apply pagination
         const paginated = results.slice(offset, offset + limit);
         // Build human-readable text with entity IDs and titles
@@ -131,6 +143,37 @@ export async function handleKbQuery(prolog, args) {
         throw new Error(`Query execution failed: ${message}`);
     }
 }
+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();
+}
+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;
+}
 /**
  * Parse a Prolog list of lists into a JavaScript array.
  * Input: "[[a,b,c],[d,e,f]]"

package/dist/tools/upsert.js

@@ -20,7 +20,13 @@ import entitySchema from "kibi-cli/schemas/entity";
 import relationshipSchema from "kibi-cli/schemas/relationship";
 import { refreshCoordinatesForSymbolId } from "./symbols.js";
 function escapeAtom(value) {
-    return value.replace(/'/g, "\\'");
+    return value.replace(/'/g, "''");
+}
+function toPrologAtom(value) {
+    const simplePrologAtom = /^[a-z][a-zA-Z0-9_]*$/;
+    return simplePrologAtom.test(value)
+        ? value
+        : `'${value.replace(/'/g, "''")}'`;
 }
 const ajv = new Ajv({ strict: false });
 const validateEntity = ajv.compile(entitySchema);
@@ -118,6 +124,7 @@ export async function handleKbUpsert(prolog, args) {
         }
         // Save KB to disk
         await prolog.query("kb_save");
+        prolog.invalidateCache();
         let contradictionPairsDetected;
         if (type === "req") {
             contradictionPairsDetected = await detectContradictionPairs(prolog, id);
@@ -189,13 +196,13 @@ function buildPropertyList(entity) {
             continue;
         let prologValue;
         if (key === "id" && typeof value === "string") {
-            prologValue = `'${value}'`;
+            prologValue = `'${value.replace(/'/g, "''")}'`;
         }
         else if (Array.isArray(value)) {
             prologValue = JSON.stringify(value);
         }
         else if (ATOM_FIELDS.includes(key) && typeof value === "string") {
-            prologValue = value;
+            prologValue = toPrologAtom(value);
         }
         else if (STRING_FIELDS.includes(key) && typeof value === "string") {
             prologValue = `"${escapeQuotes(value)}"`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-mcp",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
     "ajv": "^8.18.0",
@@ -10,7 +10,7 @@
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
     "kibi-cli": "^0.2.3",
-    "kibi-core": "^0.1.7",
+    "kibi-core": "^0.1.8",
     "mcpcat": "^0.1.12",
     "ts-morph": "^23.0.0",
     "zod": "^4.3.6"