kibi-mcp 0.14.1 → 0.14.2

package/dist/server/docs.js

@@ -33,6 +33,7 @@ function renderToolsDoc() {
         const required = Array.isArray(tool.inputSchema?.required)
             ? tool.inputSchema.required.join(", ")
             : "none";
+        lines.push(`| \`${tool.name}\` | ${tool.description} | ${required || "none"} |`);
     }
     lines.push("");
     lines.push("Modeling note: Kibi has eight core entity types grouped into common authoring (req, scenario, test, fact) and supporting/system (adr, flag, event, symbol).");

package/dist/server/tools.js

@@ -10,6 +10,7 @@ import { handleKbGraph } from "../tools/graph.js";
 import { handleKbQuery } from "../tools/query.js";
 import { handleKbSearch } from "../tools/search.js";
 import { handleKbStatus } from "../tools/status.js";
+import { handleKbSkillsList, handleKbSkillsLoad, handleKbSkillsRead, } from "../tools/skills.js";
 import { handleKbUpsert } from "../tools/upsert.js";
 import { handleKbModelRequirement, } from "../tools/model-requirement.js";
 import { handleKbAutopilotGenerate, } from "../tools/autopilot-generate.js";
@@ -59,6 +60,9 @@ const DEFAULT_TOOLS_RUNTIME = {
     handleKbQuery,
     handleKbSearch,
     handleKbStatus,
+    handleKbSkillsList,
+    handleKbSkillsLoad,
+    handleKbSkillsRead,
     handleKbUpsert,
     handleKbModelRequirement,
     handleKbAutopilotGenerate,
@@ -299,6 +303,9 @@ runtime = DEFAULT_TOOLS_RUNTIME) {
         const prolog = await runtime.ensureProlog();
         return runtime.handleKbStatus(prolog, args);
     }, runtime);
+    addTool(server, "kb_skills_list", toolDef("kb_skills_list").description, toolDef("kb_skills_list").inputSchema, async (args) => runtime.handleKbSkillsList(args), runtime);
+    addTool(server, "kb_skills_load", toolDef("kb_skills_load").description, toolDef("kb_skills_load").inputSchema, async (args) => runtime.handleKbSkillsLoad(args), runtime);
+    addTool(server, "kb_skills_read", toolDef("kb_skills_read").description, toolDef("kb_skills_read").inputSchema, async (args) => runtime.handleKbSkillsRead(args), runtime);
     addTool(server, "kb_find_gaps", toolDef("kb_find_gaps").description, toolDef("kb_find_gaps").inputSchema, async (args) => {
         const prolog = await runtime.ensureProlog();
         return runtime.handleKbFindGaps(prolog, args);

package/dist/tools/skills.js

@@ -0,0 +1,71 @@
+import { createHash } from "node:crypto";
+import { listBundledSkills, loadBundledSkill, readBundledSkillResource, } from "kibi-cli/skills";
+// implements REQ-001
+export async function handleKbSkillsList(_args) {
+    try {
+        const skills = listBundledSkills();
+        const ids = skills.map((skill) => skill.id).join(", ") || "none";
+        return {
+            content: [{ type: "text", text: `Found ${skills.length} bundled skills: ${ids}` }],
+            structuredContent: { skills },
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Skills list failed: ${message}`);
+    }
+}
+// implements REQ-001
+export async function handleKbSkillsLoad(args) {
+    try {
+        assertNonEmptyString(args.id, "id");
+        const bundle = loadBundledSkill(args.id);
+        const resources = bundle.manifest.resources ?? [];
+        const payload = {
+            metadata: bundle.manifest,
+            body: bundle.body,
+            resources,
+            contentHash: createHash("sha256").update(bundle.body, "utf8").digest("hex"),
+            sourceType: "bundled",
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Loaded bundled skill ${bundle.manifest.id} with ${resources.length} resources`,
+                },
+            ],
+            structuredContent: payload,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Skills load failed: ${message}`);
+    }
+}
+// implements REQ-001
+export async function handleKbSkillsRead(args) {
+    try {
+        assertNonEmptyString(args.id, "id");
+        assertNonEmptyString(args.resource, "resource");
+        const resourceContent = readBundledSkillResource(args.id, args.resource);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Read bundled skill resource ${args.id}/${args.resource}`,
+                },
+            ],
+            structuredContent: { content: resourceContent },
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Skills read failed: ${message}`);
+    }
+}
+function assertNonEmptyString(value, field) {
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new Error(`${field} must be a non-empty string`);
+    }
+}

package/dist/tools-config.js

@@ -110,6 +110,46 @@ const BASE_TOOLS = [
             properties: {},
         },
     },
+    {
+        name: "kb_skills_list",
+        description: "List bundled Kibi agent skills available for progressive disclosure. Read-only; does not mutate the KB or require Prolog.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "kb_skills_load",
+        description: "Load a bundled Kibi agent skill by ID, returning its manifest metadata, Markdown body, declared resources, content hash, and source type. Read-only; does not execute scripts or require Prolog.",
+        inputSchema: {
+            type: "object",
+            required: ["id"],
+            properties: {
+                id: {
+                    type: "string",
+                    description: "Bundled skill ID to load. Example: 'kibi-usage'.",
+                },
+            },
+        },
+    },
+    {
+        name: "kb_skills_read",
+        description: "Read a declared resource from a bundled Kibi agent skill. Resource paths are restricted to the skill manifest; arbitrary file paths are not exposed. Read-only; does not require Prolog.",
+        inputSchema: {
+            type: "object",
+            required: ["id", "resource"],
+            properties: {
+                id: {
+                    type: "string",
+                    description: "Bundled skill ID. Example: 'kibi-usage'.",
+                },
+                resource: {
+                    type: "string",
+                    description: "Manifest-declared resource path to read. Example: 'resources/workflows.md'.",
+                },
+            },
+        },
+    },
     {
         name: "kb_find_gaps",
         description: "Run bulk missing/present relationship analysis over KB entities. Use for questions like which requirements lack scenarios or tests. No mutation side effects.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-mcp",
-  "version": "0.14.1",
+  "version": "0.14.2",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
     "ajv": "^8.18.0",
@@ -9,7 +9,7 @@
     "fast-glob": "^3.2.12",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "kibi-cli": "^0.11.0",
+    "kibi-cli": "^0.11.1",
     "kibi-core": "^0.5.3",
     "mcpcat": "^0.1.12",
     "ts-morph": "^23.0.0",