kibi-mcp 0.17.4 → 0.19.0

package/dist/tools/check-config.js

@@ -0,0 +1,67 @@
+/*
+ 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 { readFile } from "node:fs/promises";
+import * as path from "node:path";
+import { DEFAULT_CHECKS_CONFIG, RULE_NAMES, } from "kibi-cli/public/check-types";
+// implements REQ-002
+export async function loadChecksConfig(workspaceRoot) {
+    const configPath = path.join(workspaceRoot, ".kb", "config.json");
+    try {
+        const content = await readFile(configPath, "utf8");
+        const parsed = JSON.parse(content);
+        const parsedRules = parsed.checks?.rules;
+        const normalizedRules = {
+            ...DEFAULT_CHECKS_CONFIG.rules,
+        };
+        if (parsedRules && typeof parsedRules === "object") {
+            for (const [key, value] of Object.entries(parsedRules)) {
+                if (typeof value === "boolean") {
+                    normalizedRules[key] = value;
+                }
+            }
+        }
+        const parsedSt = parsed.checks?.symbolTraceability;
+        const normalizedSt = { ...DEFAULT_CHECKS_CONFIG.symbolTraceability };
+        if (parsedSt &&
+            typeof parsedSt === "object" &&
+            typeof parsedSt.requireAdr === "boolean") {
+            normalizedSt.requireAdr = parsedSt.requireAdr;
+        }
+        return {
+            rules: normalizedRules,
+            symbolTraceability: normalizedSt,
+        };
+    }
+    catch {
+        return DEFAULT_CHECKS_CONFIG;
+    }
+}
+// implements REQ-002
+export function getEffectiveRules(configRules, requestedRules) {
+    if (requestedRules && requestedRules.length > 0) {
+        return new Set(requestedRules.filter((rule) => RULE_NAMES.has(rule)));
+    }
+    const effective = new Set();
+    for (const rule of RULE_NAMES) {
+        const enabled = configRules[rule] ?? true;
+        if (enabled) {
+            effective.add(rule);
+        }
+    }
+    return effective;
+}

package/dist/tools/check-format.js

@@ -0,0 +1,92 @@
+function formatDiagnosticsForMcp(diagnostics) {
+    return diagnostics.map((d) => ({
+        category: d.category,
+        severity: d.severity,
+        message: d.message,
+        ...(d.file !== undefined ? { file: d.file } : {}),
+        ...(d.suggestion !== undefined ? { suggestion: d.suggestion } : {}),
+    }));
+}
+export function formatImpactText(impactResult) {
+    if (impactResult.impactDiagnostics.length === 0) {
+        return "No impact diagnostics found";
+    }
+    const details = impactResult.impactDiagnostics.map((diagnostic) => {
+        const files = diagnostic.files.length > 0
+            ? diagnostic.files.join(", ")
+            : "unknown-source";
+        return `- ${diagnostic.id} | ${diagnostic.severity} | ${files} | ${diagnostic.message} Suggestion: ${diagnostic.suggestion}`;
+    });
+    return `${impactResult.impactDiagnostics.length} impact diagnostics found\n${details.join("\n")}`;
+}
+function formatOptionalList(label, values) {
+    if (values === undefined || values.length === 0) {
+        return [];
+    }
+    return [`${label}: ${values.join(", ")}`];
+}
+export function formatQualityDiagnosticsText(diagnostics) {
+    if (diagnostics.length === 0) {
+        return "No quality diagnostics found";
+    }
+    const details = diagnostics.map((diagnostic) => {
+        const parts = [
+            diagnostic.id,
+            diagnostic.severity,
+            diagnostic.category,
+            diagnostic.message,
+        ];
+        const metadata = [
+            `Blocking: ${diagnostic.blocking ? "yes" : "no"}`,
+            ...formatOptionalList("Files", diagnostic.files),
+            ...formatOptionalList("Docs", diagnostic.docs),
+            ...(diagnostic.entityId !== undefined
+                ? [`Entity: ${diagnostic.entityId}`]
+                : []),
+            ...(diagnostic.source !== undefined
+                ? [`Source: ${diagnostic.source}`]
+                : []),
+            `Suggestion: ${diagnostic.suggestion}`,
+        ];
+        return `- ${parts.join(" | ")}\n  ${metadata.join("\n  ")}`;
+    });
+    return `${diagnostics.length} quality diagnostic${diagnostics.length === 1 ? "" : "s"} found\n${details.join("\n")}`;
+}
+export function buildStructuredContent(input) {
+    const qualityDiagnostics = input.qualityDiagnostics ?? [];
+    return {
+        violations: [...input.violations],
+        count: input.violations.length,
+        diagnostics: formatDiagnosticsForMcp(input.diagnostics),
+        ...(qualityDiagnostics.length > 0
+            ? { qualityDiagnostics: [...qualityDiagnostics] }
+            : {}),
+        ...(input.impactResult
+            ? {
+                impactDiagnostics: input.impactResult.impactDiagnostics,
+                sourceFiles: input.impactResult.sourceFiles,
+                extractedSymbols: input.impactResult.extractedSymbols,
+                linkedEntities: input.impactResult.linkedEntities,
+                nextActions: input.impactResult.nextActions,
+            }
+            : {}),
+    };
+}
+export function formatViolationText(violations) {
+    if (violations.length === 0) {
+        return "No violations found";
+    }
+    const details = violations.map((violation) => {
+        const parts = [
+            violation.rule,
+            violation.entityId,
+            violation.source ?? "unknown-source",
+            violation.description,
+        ];
+        if (violation.suggestion) {
+            parts.push(`Suggestion: ${violation.suggestion}`);
+        }
+        return `- ${parts.join(" | ")}`;
+    });
+    return `${violations.length} violations found\n${details.join("\n")}`;
+}

package/dist/tools/check-impact.js

@@ -0,0 +1,45 @@
+/*
+ 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 { analyzeChangedFileImpact, } from "kibi-cli/public/impact-diagnostics";
+export function hasImpactOptions(args) {
+    return Boolean(args.includeImpactDiagnostics ||
+        args.staged ||
+        args.includeWorkingTreeDiff ||
+        (args.sourceFiles && args.sourceFiles.length > 0));
+}
+export function analyzeKbCheckImpact(workspaceRoot, args) {
+    if (!hasImpactOptions(args)) {
+        return undefined;
+    }
+    return analyzeChangedFileImpact({
+        workspaceRoot,
+        ...(args.sourceFiles !== undefined
+            ? { sourceFiles: args.sourceFiles }
+            : {}),
+        ...(args.staged !== undefined ? { staged: args.staged } : {}),
+        ...(args.includeWorkingTreeDiff !== undefined
+            ? { includeWorkingTreeDiff: args.includeWorkingTreeDiff }
+            : {}),
+        ...(args.includeImpactDiagnostics !== undefined
+            ? { includeImpactDiagnostics: args.includeImpactDiagnostics }
+            : {}),
+        ...(args.maxDiagnostics !== undefined
+            ? { maxDiagnostics: args.maxDiagnostics }
+            : {}),
+    });
+}

package/dist/tools/check-prolog.js

@@ -0,0 +1,51 @@
+import { resolveCorePlPath } from "./core-module.js";
+import { collectQueryPlanSafetyViolations } from "./query-plan-safety.js";
+// implements REQ-002
+export async function runAggregatedChecks(prolog, rulesAllowlist, requireAdr) {
+    const violations = [];
+    const checksPlPath = resolveCorePlPath("checks.pl");
+    if (rulesAllowlist.has("query-plan-safety")) {
+        violations.push(...collectQueryPlanSafetyViolations(checksPlPath));
+    }
+    const normalizedChecksPlPath = checksPlPath.replace(/\\/g, "/");
+    const checksPlPathEscaped = normalizedChecksPlPath.replace(/'/g, "''");
+    const requireAdrStr = requireAdr ? "true" : "false";
+    const query = `(load_files('${checksPlPathEscaped}', [if(changed)]),
+    (   predicate_property(checks:check_all_json_with_options(_, _), _)
+    ->  call(checks:check_all_json_with_options(JsonString, ${requireAdrStr}))
+    ;   call(checks:check_all_json(JsonString))
+    ))`;
+    const result = await prolog.query(query);
+    if (!result.success) {
+        throw new Error(`Aggregated checks query failed: ${result.error || "Unknown error"}`);
+    }
+    const violationsDict = parseViolations(result.bindings.JsonString);
+    for (const ruleViolations of Object.values(violationsDict)) {
+        for (const v of ruleViolations) {
+            const isAllowed = rulesAllowlist.has(v.rule);
+            if (isAllowed) {
+                violations.push({
+                    rule: v.rule,
+                    entityId: v.entityId,
+                    description: v.description,
+                    ...(v.suggestion ? { suggestion: v.suggestion } : {}),
+                    ...(v.source ? { source: v.source } : {}),
+                });
+            }
+        }
+    }
+    return violations;
+}
+function parseViolations(jsonString) {
+    try {
+        if (!jsonString || typeof jsonString !== "string") {
+            throw new Error("No JSON string in binding");
+        }
+        const parsed = JSON.parse(jsonString);
+        const violations = typeof parsed === "string" ? JSON.parse(parsed) : parsed;
+        return violations;
+    }
+    catch (parseError) {
+        throw new Error(`Failed to parse violations JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+    }
+}

package/dist/tools/check-types.js

@@ -0,0 +1 @@
+export {};

package/dist/tools/check.js

@@ -1,99 +1,24 @@
-/*
- 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 { readFile } from "node:fs/promises";
-import * as path from "node:path";
-import { DEFAULT_CHECKS_CONFIG, RULE_NAMES, } from "kibi-cli/public/check-types";
+import { collectFullKbQualityDiagnostics, } from "kibi-cli/public/impact-diagnostics";
 import { resolveWorkspaceRoot } from "../workspace.js";
-import { resolveCorePlPath } from "./core-module.js";
-function formatDiagnosticsForMcp(diagnostics) {
-    return diagnostics.map((d) => ({
-        category: d.category,
-        severity: d.severity,
-        message: d.message,
-        ...(d.file !== undefined ? { file: d.file } : {}),
-        ...(d.suggestion !== undefined ? { suggestion: d.suggestion } : {}),
-    }));
-}
-function formatViolationText(violations) {
-    if (violations.length === 0) {
-        return "No violations found";
-    }
-    const details = violations.map((violation) => {
-        const parts = [
-            violation.rule,
-            violation.entityId,
-            violation.source ?? "unknown-source",
-            violation.description,
-        ];
-        if (violation.suggestion) {
-            parts.push(`Suggestion: ${violation.suggestion}`);
-        }
-        return `- ${parts.join(" | ")}`;
-    });
-    return `${violations.length} violations found\n${details.join("\n")}`;
-}
-// implements REQ-002
-async function loadChecksConfig(workspaceRoot) {
-    const configPath = path.join(workspaceRoot, ".kb", "config.json");
-    try {
-        const content = await readFile(configPath, "utf8");
-        const parsed = JSON.parse(content);
-        const parsedRules = parsed.checks?.rules;
-        const normalizedRules = {
-            ...DEFAULT_CHECKS_CONFIG.rules,
-        };
-        if (parsedRules && typeof parsedRules === "object") {
-            for (const [key, value] of Object.entries(parsedRules)) {
-                if (typeof value === "boolean") {
-                    normalizedRules[key] = value;
-                }
-                // Ignore non-boolean values (they are not added to normalizedRules, preserving defaults)
-            }
-        }
-        const parsedSt = parsed.checks?.symbolTraceability;
-        const normalizedSt = { ...DEFAULT_CHECKS_CONFIG.symbolTraceability };
-        if (parsedSt && typeof parsedSt === "object") {
-            if (typeof parsedSt.requireAdr === "boolean") {
-                normalizedSt.requireAdr = parsedSt.requireAdr;
-            }
-        }
-        return {
-            rules: normalizedRules,
-            symbolTraceability: normalizedSt,
-        };
-    }
-    catch {
-        return DEFAULT_CHECKS_CONFIG;
+import { getEffectiveRules, loadChecksConfig } from "./check-config.js";
+import { buildStructuredContent, formatImpactText, formatQualityDiagnosticsText, formatViolationText, } from "./check-format.js";
+import { analyzeKbCheckImpact } from "./check-impact.js";
+import { runAggregatedChecks } from "./check-prolog.js";
+function qualityDiagnosticsFromImpact(impactResult) {
+    if (impactResult === undefined) {
+        return [];
     }
+    return impactResult.impactDiagnostics.filter((diagnostic) => !diagnostic.blocking && diagnostic.severity !== "error");
 }
-// implements REQ-002
-function getEffectiveRules(configRules, requestedRules) {
-    if (requestedRules && requestedRules.length > 0) {
-        return new Set(requestedRules.filter((rule) => RULE_NAMES.has(rule)));
+function buildSummary(input) {
+    const sections = [formatViolationText(input.violations)];
+    if (input.impactResult !== undefined) {
+        sections.push(formatImpactText(input.impactResult));
     }
-    const effective = new Set();
-    for (const rule of RULE_NAMES) {
-        const enabled = configRules[rule] ?? true;
-        if (enabled) {
-            effective.add(rule);
-        }
+    if (input.qualityDiagnostics.length > 0) {
+        sections.push(formatQualityDiagnosticsText(input.qualityDiagnostics));
     }
-    return effective;
+    return sections.join("\n");
 }
 /**
  * Handle kb_check tool calls - run validation rules on the KB
@@ -102,18 +27,41 @@ function getEffectiveRules(configRules, requestedRules) {
 // implements REQ-002
 export async function handleKbCheck(prolog, args) {
     const { rules, workspaceRoot: workspaceOverride } = args;
+    const hasExplicitRules = rules !== undefined;
     try {
         const workspaceRoot = workspaceOverride ?? resolveWorkspaceRoot();
         const checksConfig = await loadChecksConfig(workspaceRoot);
         const rulesAllowlist = getEffectiveRules(checksConfig.rules, rules);
+        const impactResult = analyzeKbCheckImpact(workspaceRoot, args);
+        const impactQualityDiagnostics = qualityDiagnosticsFromImpact(impactResult);
         if (rulesAllowlist.size === 0) {
+            const qualityDiagnostics = hasExplicitRules
+                ? []
+                : impactResult
+                    ? impactQualityDiagnostics
+                    : await collectFullKbQualityDiagnostics({
+                        prolog,
+                        ...(args.maxDiagnostics !== undefined
+                            ? { maxDiagnostics: args.maxDiagnostics }
+                            : {}),
+                    });
             return {
-                content: [{ type: "text", text: "No violations found" }],
-                structuredContent: {
+                content: [
+                    {
+                        type: "text",
+                        text: buildSummary({
+                            violations: [],
+                            impactResult,
+                            qualityDiagnostics,
+                        }),
+                    },
+                ],
+                structuredContent: buildStructuredContent({
                     violations: [],
-                    count: 0,
                     diagnostics: [],
-                },
+                    qualityDiagnostics,
+                    impactResult,
+                }),
             };
         }
         // Ensure we read the latest KB state, not a cached snapshot.
@@ -128,7 +76,22 @@ export async function handleKbCheck(prolog, args) {
             ...(v.source !== undefined ? { file: v.source } : {}),
             ...(v.suggestion !== undefined ? { suggestion: v.suggestion } : {}),
         }));
-        const summary = formatViolationText(aggregatedViolations);
+        const qualityDiagnostics = hasExplicitRules
+            ? impactQualityDiagnostics
+            : impactResult
+                ? impactQualityDiagnostics
+                : await collectFullKbQualityDiagnostics({
+                    prolog,
+                    hardViolationEntityIds: new Set(aggregatedViolations.map((violation) => violation.entityId)),
+                    ...(args.maxDiagnostics !== undefined
+                        ? { maxDiagnostics: args.maxDiagnostics }
+                        : {}),
+                });
+        const summary = buildSummary({
+            violations: aggregatedViolations,
+            impactResult,
+            qualityDiagnostics,
+        });
         return {
             content: [
                 {
@@ -136,11 +99,12 @@ export async function handleKbCheck(prolog, args) {
                     text: summary,
                 },
             ],
-            structuredContent: {
+            structuredContent: buildStructuredContent({
                 violations: aggregatedViolations,
-                count: aggregatedViolations.length,
-                diagnostics: formatDiagnosticsForMcp(diagnostics),
-            },
+                diagnostics,
+                qualityDiagnostics,
+                impactResult,
+            }),
         };
     }
     catch (error) {
@@ -148,51 +112,3 @@ export async function handleKbCheck(prolog, args) {
         throw new Error(`Check execution failed: ${message}`);
     }
 }
-// implements REQ-002
-async function runAggregatedChecks(prolog, rulesAllowlist, requireAdr) {
-    const violations = [];
-    const checksPlPath = resolveCorePlPath("checks.pl");
-    const normalizedChecksPlPath = checksPlPath.replace(/\\/g, "/");
-    const checksPlPathEscaped = normalizedChecksPlPath.replace(/'/g, "''");
-    // Use check_all_json_with_options if available, otherwise fall back to check_all_json
-    const requireAdrStr = requireAdr ? "true" : "false";
-    const query = `(use_module('${checksPlPathEscaped}'),
-    (   predicate_property(checks:check_all_json_with_options(_, _), _)
-    ->  call(checks:check_all_json_with_options(JsonString, ${requireAdrStr}))
-    ;   call(checks:check_all_json(JsonString))
-    ))`;
-    const result = await prolog.query(query);
-    if (!result.success) {
-        throw new Error(`Aggregated checks query failed: ${result.error || "Unknown error"}`);
-    }
-    let violationsDict;
-    try {
-        const jsonString = result.bindings.JsonString;
-        if (!jsonString) {
-            throw new Error("No JSON string in binding");
-        }
-        let parsed = JSON.parse(jsonString);
-        if (typeof parsed === "string") {
-            parsed = JSON.parse(parsed);
-        }
-        violationsDict = parsed;
-    }
-    catch (parseError) {
-        throw new Error(`Failed to parse violations JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
-    }
-    for (const ruleViolations of Object.values(violationsDict)) {
-        for (const v of ruleViolations) {
-            const isAllowed = rulesAllowlist.has(v.rule);
-            if (isAllowed) {
-                violations.push({
-                    rule: v.rule,
-                    entityId: v.entityId,
-                    description: v.description,
-                    ...(v.suggestion ? { suggestion: v.suggestion } : {}),
-                    ...(v.source ? { source: v.source } : {}),
-                });
-            }
-        }
-    }
-    return violations;
-}

package/dist/tools/query-plan-safety.js

@@ -0,0 +1,58 @@
+import fs from "node:fs";
+const GENERATOR_PATTERN = /\b(?:kb_entity|kb_relationship|member|memberchk|findall|setof|bagof)\s*\(/;
+const NEGATION_PATTERN = /\\\+\s*/;
+export function collectQueryPlanSafetyViolations(checksPlPath) {
+    const source = fs.readFileSync(checksPlPath, "utf8");
+    return analyzeSource(source).map((violation) => ({
+        rule: "query-plan-safety",
+        entityId: violation.predicate,
+        description: violation.description,
+        suggestion: violation.suggestion,
+        source: `${checksPlPath}:${violation.line}`,
+    }));
+}
+function analyzeSource(source) {
+    const lines = source.split(/\r?\n/);
+    const violations = [];
+    let clauseStart = 0;
+    let predicate = "unknown";
+    let clauseLines = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        if (clauseLines.length === 0 && line.trim().length === 0) {
+            continue;
+        }
+        if (clauseLines.length === 0) {
+            clauseStart = index + 1;
+            predicate = predicateNameFrom(line) ?? "unknown";
+        }
+        clauseLines.push(line);
+        if (line.trim().endsWith(".")) {
+            const violation = analyzeClause(predicate, clauseStart, clauseLines);
+            if (violation)
+                violations.push(violation);
+            clauseLines = [];
+        }
+    }
+    return violations;
+}
+function predicateNameFrom(line) {
+    const match = line.match(/^\s*([a-z][a-zA-Z0-9_]*)\s*\(/);
+    return match?.[1] ?? null;
+}
+function analyzeClause(predicate, startLine, lines) {
+    const negationIndex = lines.findIndex((line) => NEGATION_PATTERN.test(line));
+    if (negationIndex < 0)
+        return null;
+    const hasLaterGenerator = lines
+        .slice(negationIndex + 1)
+        .some((line) => GENERATOR_PATTERN.test(line));
+    if (!hasLaterGenerator)
+        return null;
+    return {
+        predicate,
+        line: startLine + negationIndex,
+        description: "Negation appears before later generator calls in the same clause.",
+        suggestion: "Move kb_entity/kb_relationship/member/findall generators before \\+/1 so variables are bound before negation.",
+    };
+}