kibi-mcp 0.5.0 → 0.6.0

package/dist/diagnostics.js

@@ -88,6 +88,11 @@ export function deriveDiagnosticFields(toolName, args, telemetry, result) {
     const fields = {
         telemetry_status: telemetry ? "provided" : "missing",
     };
+    if (telemetry) {
+        fields.telemetry_is_autonomous = telemetry.is_autonomous ?? null;
+        fields.telemetry_confidence_score = telemetry.confidence_score ?? null;
+        fields.telemetry_attempt_number = telemetry.attempt_number ?? null;
+    }
     const structuredContent = result && typeof result === "object" && "structuredContent" in result
         ? result
             .structuredContent

package/dist/server/docs.js

@@ -30,8 +30,9 @@ function renderToolsDoc() {
         const required = Array.isArray(tool.inputSchema?.required)
             ? tool.inputSchema.required.join(", ")
             : "none";
-        lines.push(`| ${tool.name} | ${tool.description} | ${required} |`);
     }
+    lines.push("");
+    lines.push("Modeling note: Prefer query-first discovery; create `fact` entities before `req` entities and express semantics via `constrains` + `requires_property`.");
     return lines.join("\n");
 }
 export const PROMPTS = [
@@ -124,6 +125,8 @@ export const PROMPTS = [
             "- Run `kb_check` after meaningful mutations to catch integrity issues early.",
             "- Prefer explicit IDs and enum values to avoid invalid parameters.",
             "- Assume every write can affect downstream traceability queries.",
+            "- Model requirements by first creating/reusing fact entities, then express req semantics with `constrains` + `requires_property` relationships (create-before-link).",
+            "- flag gates runtime/config behavior; use `fact` with `fact_kind: observation` or `meta` for bug and workaround notes.",
         ].join("\n"),
     },
     {
@@ -131,7 +134,6 @@ export const PROMPTS = [
         description: "Step-by-step call order for discovery, mutation, and verification.",
         text: [
             "# kibi-mcp Workflow",
-            "",
             "Follow this sequence for reliable operation:",
             "",
             "1. **Discover first**: Call `kb_search` for exploratory discovery, then `kb_query` to confirm exact current state before mutation.",
@@ -206,6 +208,13 @@ function registerDocResources() {
         "4. Reuse the same constrained fact ID across related requirements; vary property facts only when semantics differ",
         '5. `kb_check` with `{ "rules": ["required-fields","no-dangling-refs"] }` for targeted validation',
         "",
+        "Note: Create or reuse `fact` entities first, then create `req` entities and link with `constrains` and `requires_property` (create-before-link). Use `flag` for runtime/config gates; use `fact` with `fact_kind: observation` or `meta` for bug and workaround notes.",
+        "",
+        "## Find missing coverage",
+        '1. `kb_find_gaps` with `{ "type": "req", "missingRelationships": ["specified_by", "verified_by"] }` to find under-linked requirements',
+        "",
+        "## Find missing coverage",
+        "",
         "## Find missing coverage",
         '1. `kb_find_gaps` with `{ "type": "req", "missingRelationships": ["specified_by", "verified_by"] }` to find under-linked requirements',
         '2. `kb_coverage` with `{ "by": "req", "includePassing": false }` to review evaluated coverage rows',

package/dist/tools/check.js

@@ -16,31 +16,10 @@
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 import { existsSync, readFileSync } from "node:fs";
-import { createRequire } from "node:module";
 import * as path from "node:path";
 import { DEFAULT_CHECKS_CONFIG, RULE_NAMES, } from "kibi-cli/public/check-types";
 import { resolveWorkspaceRoot } from "../workspace.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 {
-        // require.resolve not available or package not installed
-    }
-    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");
-}
+import { resolveCorePlPath } from "./core-module.js";
 function formatDiagnosticsForMcp(diagnostics) {
     return diagnostics.map((d) => ({
         category: d.category,
@@ -173,7 +152,7 @@ export async function handleKbCheck(prolog, args) {
 // implements REQ-002
 async function runAggregatedChecks(prolog, rulesAllowlist, requireAdr) {
     const violations = [];
-    const checksPlPath = resolveChecksPlPath();
+    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

package/dist/tools/core-module.js

@@ -1,9 +1,7 @@
 import { existsSync } from "node:fs";
-import { createRequire } from "node:module";
 import path from "node:path";
-import { PrologProcess } from "kibi-cli/prolog";
+import { PrologProcess, resolveKbPlPath } from "kibi-cli/prolog";
 import { escapeAtomContent } from "kibi-cli/prolog/codec";
-const require = createRequire(import.meta.url);
 // implements REQ-002, REQ-013
 export function resolveCorePlPath(fileName) {
     const envKey = `KIBI_${fileName.replace(/\W/g, "_").toUpperCase()}_PATH`;
@@ -11,20 +9,12 @@ export function resolveCorePlPath(fileName) {
     if (override && existsSync(override)) {
         return override;
     }
-    try {
-        const installedPath = require.resolve(`kibi-core/src/${fileName}`);
-        if (existsSync(installedPath)) {
-            return installedPath;
-        }
-    }
-    catch {
-        // require.resolve not available or package not installed
-    }
-    const localPath = path.join(process.cwd(), "packages/core/src", fileName);
-    if (existsSync(localPath)) {
-        return localPath;
+    const kbPlPath = resolveKbPlPath();
+    const sibling = path.join(path.dirname(kbPlPath), fileName);
+    if (existsSync(sibling)) {
+        return sibling;
     }
-    throw new Error(`Unable to resolve core module path for ${fileName}`);
+    throw new Error(`Root-consistency error: resolveKbPlPath() resolved to '${kbPlPath}' but sibling '${fileName}' not found at '${sibling}'`);
 }
 // implements REQ-002, REQ-013
 export async function runJsonModuleQuery(prolog, fileName, goal, errorLabel) {

package/dist/tools/symbols.js

@@ -45,6 +45,7 @@ const SOURCE_EXTENSIONS = new Set([
     ".cjs",
 ]);
 export async function handleKbSymbolsRefresh(args) {
+    // implements REQ-vscode-traceability
     const dryRun = args.dryRun === true;
     const workspaceRoot = resolveWorkspaceRoot();
     const manifestPath = resolveManifestPath(workspaceRoot);
@@ -112,6 +113,7 @@ export async function handleKbSymbolsRefresh(args) {
     };
 }
 export async function refreshCoordinatesForSymbolId(symbolId, workspaceRoot = resolveWorkspaceRoot()) {
+    // implements REQ-vscode-traceability
     const manifestPath = resolveManifestPath(workspaceRoot);
     const rawContent = readFileSync(manifestPath, "utf8");
     const parsed = parseYAML(rawContent);

package/dist/tools/upsert.js

@@ -20,6 +20,7 @@ import { escapeAtom, toPrologAtom, toPrologString, } from "kibi-cli/prolog/codec
 import entitySchema from "kibi-cli/schemas/entity";
 import relationshipSchema from "kibi-cli/schemas/relationship";
 import { refreshCoordinatesForSymbolId } from "./symbols.js";
+let refreshCoordinatesForSymbolIdImpl = refreshCoordinatesForSymbolId;
 const ajv = new Ajv({ strict: false });
 const validateEntity = ajv.compile(entitySchema);
 const validateRelationship = ajv.compile(relationshipSchema);
@@ -155,7 +156,7 @@ export async function handleKbUpsert(prolog, args) {
         }
         if (type === "symbol") {
             try {
-                await refreshCoordinatesForSymbolId(id);
+                await refreshCoordinatesForSymbolIdImpl(id);
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
@@ -183,6 +184,12 @@ export async function handleKbUpsert(prolog, args) {
         throw new Error(`Upsert execution failed: ${message}`);
     }
 }
+export const __test__ = {
+    // implements REQ-vscode-traceability
+    setRefreshCoordinatesForSymbolIdForTests(fn) {
+        refreshCoordinatesForSymbolIdImpl = fn ?? refreshCoordinatesForSymbolId;
+    },
+};
 /**
  * Build Prolog property list from entity object
  * Returns simple Key=Value format without typed literals
@@ -216,6 +223,8 @@ function buildPropertyList(entity) {
     for (const [key, value] of Object.entries(entity)) {
         if (key === "type")
             continue;
+        if (value === undefined || value === null)
+            continue;
         let prologValue;
         if (key === "id" && typeof value === "string") {
             prologValue = `'${value.replace(/'/g, "''")}'`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-mcp",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "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.4.0",
-    "kibi-core": "^0.3.0",
+    "kibi-cli": "^0.5.0",
+    "kibi-core": "^0.4.0",
     "mcpcat": "^0.1.12",
     "ts-morph": "^23.0.0",
     "zod": "^4.3.6"