kibi-mcp 0.1.6 → 0.2.0

package/dist/server.js

@@ -15,6 +15,7 @@
  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 fs from "node:fs";
 import { createRequire } from "node:module";
 /*
  How to apply this header to source files (examples)
@@ -47,22 +48,14 @@ import process from "node:process";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { PrologProcess } from "kibi-cli/prolog";
+import { copyCleanSnapshot, getBranchDiagnostic, isValidBranchName, resolveActiveBranch, } from "kibi-cli/public/branch-resolver";
 import { z } from "zod";
 import { loadDefaultEnvFile } from "./env.js";
 import { attachMcpcat } from "./mcpcat.js";
 import { TOOLS } from "./tools-config.js";
-import { handleKbBranchEnsure, handleKbBranchGc, } from "./tools/branch.js";
 import { handleKbCheck } from "./tools/check.js";
-import { handleKbContext } from "./tools/context.js";
-import { handleKbCoverageReport, } from "./tools/coverage-report.js";
 import { handleKbDelete } from "./tools/delete.js";
-import { handleKbDerive } from "./tools/derive.js";
-import { handleKbImpact } from "./tools/impact.js";
-import { handleKbListEntityTypes, handleKbListRelationshipTypes, } from "./tools/list-types.js";
-import { handleKbQueryRelationships, } from "./tools/query-relationships.js";
 import { handleKbQuery } from "./tools/query.js";
-import { handleSuggestSharedFacts, } from "./tools/suggest-shared-facts.js";
-import { handleKbSymbolsRefresh, } from "./tools/symbols.js";
 import { handleKbUpsert } from "./tools/upsert.js";
 import { resolveKbPath, resolveWorkspaceRoot } from "./workspace.js";
 function renderToolsDoc() {
@@ -93,9 +86,9 @@ const PROMPTS = [
             "",
             "- Encode requirements as linked facts: `req --constrains--> fact` plus `req --requires_property--> fact`.",
             "- Reuse canonical fact IDs across requirements; shared constrained facts make contradictions detectable.",
-            "- Use read tools first (`kb_query`, `kb_query_relationships`, `kbcontext`) to establish context.",
-            "- Use mutation tools (`kb_upsert`, `kb_delete`, branch tools) only after you can justify the change.",
-            "- Use inference tools (`kb_derive`, `kb_impact`, `kb_coverage_report`) for deterministic analysis.",
+            "- Use `kb_query` first to confirm current state before any mutation.",
+            "- Use `kb_upsert` and `kb_delete` only for intentional, traceable KB changes.",
+            "- 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.",
         ].join("\n"),
@@ -108,15 +101,13 @@ const PROMPTS = [
             "",
             "Follow this sequence for reliable operation:",
             "",
-            "1. **Discover**: Call `kb_list_entity_types`/`kb_list_relationship_types` if you are unsure about allowed values.",
-            "2. **Inspect**: Call `kb_query` or `kbcontext` to confirm current state before any mutation.",
-            "3. **Model requirements as facts**: For new/updated reqs, create/reuse fact entities first, then express req semantics with `constrains` + `requires_property`.",
-            "4. **Validate intent**: If creating links, call `kb_query` for both endpoint IDs first.",
-            "5. **Mutate**: Call `kb_upsert` for create/update, or `kb_delete` for explicit removals.",
-            "6. **Verify integrity**: Call `kb_check` after mutations.",
-            "7. **Assess impact**: Call `kb_impact`, `kb_derive`, or `kb_coverage_report` as needed.",
+            "1. **Inspect**: Call `kb_query` to confirm current state before any mutation.",
+            "2. **Model requirements as facts**: For new/updated reqs, create/reuse fact entities first, then express req semantics with `constrains` + `requires_property`.",
+            "3. **Validate intent**: If creating links, call `kb_query` for both endpoint IDs first.",
+            "4. **Mutate**: Call `kb_upsert` for create/update, or `kb_delete` for explicit removals.",
+            "5. **Verify integrity**: Call `kb_check` after mutations.",
             "",
-            "If a tool returns empty results, do not assume failure. Re-check filters (type, id, tags, sourceFile, or relationship type).",
+            "If a tool returns empty results, do not assume failure. Re-check filters (type, id, tags, sourceFile, limit, or offset).",
         ].join("\n"),
     },
     {
@@ -129,10 +120,8 @@ const PROMPTS = [
             "",
             "- `kb_upsert` validates entity and relationship payloads against JSON Schema.",
             "- `kb_delete` blocks deletion when dependents still reference the entity.",
-            "- `kb_branch_gc` may permanently remove stale branch KB directories when `dry_run` is `false`.",
             "- Relationship and rule names are strict enums; unknown values fail validation.",
-            "- Branch names are sanitized; path traversal patterns are rejected.",
-            "- `kb_symbols_refresh` can rewrite the symbols manifest unless `dryRun` is enabled.",
+            "- Branch KB setup is automatic at server startup; lifecycle maintenance stays outside the public MCP tool surface.",
         ].join("\n"),
     },
 ];
@@ -144,9 +133,8 @@ function registerDocResources() {
         "",
         "Scope:",
         "- Entity CRUD-like operations for KB records",
-        "- Relationship inspection",
-        "- Validation and branch KB maintenance",
-        "- Deterministic inference for traceability and impact analysis",
+        "- Validation of KB integrity after changes",
+        "- Automatic branch-local attachment for the active workspace",
         "",
         "Use this server when you need branch-local, machine-readable project memory.",
     ].join("\n");
@@ -157,7 +145,7 @@ function registerDocResources() {
         "",
         "- `-32602 INVALID_PARAMS`: Tool arguments are missing/invalid. Recover by checking enum values and required fields.",
         "- `-32601 METHOD_NOT_FOUND`: Unknown MCP method. Recover by using supported methods (`tools/*`, `prompts/*`, `resources/*`).",
-        "- `-32000 PROLOG_QUERY_FAILED`: Prolog query failed. Recover by validating IDs, rule names, and relationship types.",
+        "- `-32000 PROLOG_QUERY_FAILED`: Prolog query failed. Recover by validating IDs, rule names, and branch KB availability.",
         "- `VALIDATION_ERROR` message: `kb_upsert` payload failed schema checks. Recover by fixing required fields and enum values.",
         "- Delete blocked by dependents: `kb_delete` detected incoming references. Recover by removing/rewiring relationships first.",
         "- Empty results: filters may be too strict. Recover by loosening type/id/tags/source filters and retrying.",
@@ -171,20 +159,10 @@ function registerDocResources() {
         "3. Reuse the same constrained fact ID across related requirements; vary property facts only when semantics differ",
         '4. `kb_check` with `{ "rules": ["required-fields","no-dangling-refs"] }`',
         "",
-        "## Discover requirement coverage gaps",
-        '1. `kb_query` with `{ "type": "req", "limit": 20 }`',
-        '2. `kb_coverage_report` with `{ "type": "req" }`',
-        '3. `kb_derive` with `{ "rule": "coverage_gap" }`',
-        "",
         "## Add a requirement and link it to a test",
         "1. `kb_query` for existing IDs to avoid collisions",
         "2. `kb_upsert` with entity payload and `relationships` containing `verified_by`",
         '3. `kb_check` with `{ "rules": ["required-fields","no-dangling-refs"] }`',
-        "",
-        "## Safe cleanup of stale branch KBs",
-        '1. `kb_branch_gc` with `{ "dry_run": true }`',
-        "2. Review `structuredContent.stale`",
-        '3. `kb_branch_gc` with `{ "dry_run": false }` only when deletion is intended',
     ].join("\n");
     return [
         {
@@ -265,6 +243,22 @@ let activeBranchName = "develop";
 let isShuttingDown = false;
 let shutdownTimeout = null;
 const inFlightRequests = new Map();
+function ensureBranchKbExists(workspaceRoot, branch) {
+    if (!isValidBranchName(branch)) {
+        throw new Error(`Invalid branch name: ${branch}`);
+    }
+    const branchPath = resolveKbPath(workspaceRoot, branch);
+    if (fs.existsSync(branchPath)) {
+        return;
+    }
+    const templateBranch = ["develop", "main"].find((candidate) => candidate !== branch &&
+        fs.existsSync(resolveKbPath(workspaceRoot, candidate)));
+    if (!templateBranch) {
+        throw new Error(`No template branch KB found for '${branch}'. Expected '.kb/branches/develop' or '.kb/branches/main'.`);
+    }
+    // Use clean snapshot copy that excludes volatile artifacts
+    copyCleanSnapshot(resolveKbPath(workspaceRoot, templateBranch), branchPath);
+}
 function debugLog(...args) {
     if (process.env.KIBI_MCP_DEBUG) {
         console.error(...args);
@@ -316,9 +310,55 @@ async function initiateGracefulShutdown(exitCode = 0) {
     process.exit(exitCode);
 }
 async function ensureProlog() {
+    const workspaceRoot = resolveWorkspaceRoot();
+    // Determine target branch: respect KIBI_BRANCH override or resolve from git
+    const envBranch = process.env.KIBI_BRANCH?.trim();
+    let targetBranch;
+    if (envBranch) {
+        // KIBI_BRANCH override is set - use it without re-resolving from git
+        if (!isValidBranchName(envBranch)) {
+            throw new Error(`Invalid branch name from KIBI_BRANCH: '${envBranch}'`);
+        }
+        targetBranch = envBranch;
+    }
+    else {
+        // No override - resolve active branch from git (may change between requests)
+        const branchResult = resolveActiveBranch(workspaceRoot);
+        if ("error" in branchResult) {
+            const diagnostic = getBranchDiagnostic(undefined, branchResult.error);
+            console.error(`[KIBI-MCP] ${diagnostic}`);
+            throw new Error(`Failed to resolve active branch: ${branchResult.error}`);
+        }
+        targetBranch = branchResult.branch;
+    }
+    // Check if we need to switch branches
     if (isInitialized && prologProcess?.isRunning()) {
+        if (targetBranch === activeBranchName) {
+            // Still on the same branch - return existing connection
+            return prologProcess;
+        }
+        // Branch changed - need to detach and re-attach
+        debugLog(`[KIBI-MCP] Branch changed: ${activeBranchName} -> ${targetBranch}`);
+        // Detach from old KB
+        const detachResult = await prologProcess.query("kb_detach");
+        if (!detachResult.success) {
+            debugLog(`[KIBI-MCP] Warning: failed to detach from old KB: ${detachResult.error || "Unknown error"}`);
+            // Continue anyway - we'll try to attach to the new KB
+        }
+        // Ensure new branch KB exists
+        ensureBranchKbExists(workspaceRoot, targetBranch);
+        const newKbPath = resolveKbPath(workspaceRoot, targetBranch);
+        // Attach to new branch KB
+        const attachResult = await prologProcess.query(`kb_attach('${newKbPath}')`);
+        if (!attachResult.success) {
+            throw new Error(`Failed to attach to new branch KB: ${attachResult.error || "Unknown error"}`);
+        }
+        activeBranchName = targetBranch;
+        debugLog(`[KIBI-MCP] Re-attached to branch: ${targetBranch}`);
+        debugLog(`[KIBI-MCP] KB path: ${newKbPath}`);
         return prologProcess;
     }
+    // First initialization
     debugLog("[KIBI-MCP] Initializing Prolog process...");
     prologProcess = new PrologProcess({ timeout: 120000 });
     await prologProcess.start();
@@ -355,33 +395,12 @@ async function ensureProlog() {
             debugLog("[KIBI-MCP] Failed to create require() for debug lookup:", err.message);
         }
     }
-    const workspaceRoot = resolveWorkspaceRoot();
-    let branch = process.env.KIBI_BRANCH || "develop";
-    let gitBranch;
-    if (!process.env.KIBI_BRANCH) {
-        try {
-            const { execSync } = await import("node:child_process");
-            const detected = execSync("git branch --show-current", {
-                cwd: workspaceRoot,
-                encoding: "utf8",
-                timeout: 3000,
-            }).trim();
-            if (detected) {
-                gitBranch = detected === "master" ? "develop" : detected;
-                branch = gitBranch;
-            }
-        }
-        catch {
-            // fall back to develop
-        }
-    }
     debugLog("[KIBI-MCP] Branch selection:");
     debugLog(`[KIBI-MCP]   KIBI_BRANCH env: ${process.env.KIBI_BRANCH || "not set"}`);
-    debugLog(`[KIBI-MCP]   Git branch: ${gitBranch || "n/a"}`);
-    debugLog(`[KIBI-MCP]   Attached to: ${branch}`);
-    debugLog("[KIBI-MCP] To change branch: set KIBI_BRANCH=<branch> and restart");
-    activeBranchName = branch;
-    const kbPath = resolveKbPath(workspaceRoot, branch);
+    debugLog(`[KIBI-MCP]   Resolved branch: ${targetBranch}`);
+    activeBranchName = targetBranch;
+    ensureBranchKbExists(workspaceRoot, targetBranch);
+    const kbPath = resolveKbPath(workspaceRoot, targetBranch);
     const attachResult = await prologProcess.query(`kb_attach('${kbPath}')`);
     if (!attachResult.success) {
         throw new Error(`Failed to attach KB: ${attachResult.error || "Unknown error"}`);
@@ -537,7 +556,7 @@ function addTool(server, name, description, inputSchema, handler) {
 }
 export async function startServer() {
     loadDefaultEnvFile();
-    const server = new McpServer({ name: "kibi-mcp", version: "0.1.0" });
+    const server = new McpServer({ name: "kibi-mcp", version: "0.2.0" });
     attachMcpcat(server);
     for (const prompt of PROMPTS) {
         server.prompt(prompt.name, prompt.description, async () => ({
@@ -582,49 +601,6 @@ export async function startServer() {
         const prolog = await ensureProlog();
         return handleKbCheck(prolog, args);
     });
-    addTool(server, "kb_branch_ensure", toolDef("kb_branch_ensure").description, toolDef("kb_branch_ensure").inputSchema, async (args) => {
-        const prolog = await ensureProlog();
-        return handleKbBranchEnsure(prolog, args);
-    });
-    addTool(server, "kb_branch_gc", toolDef("kb_branch_gc").description, toolDef("kb_branch_gc").inputSchema, async (args) => {
-        const prolog = await ensureProlog();
-        return handleKbBranchGc(prolog, args);
-    });
-    addTool(server, "kb_query_relationships", toolDef("kb_query_relationships").description, toolDef("kb_query_relationships").inputSchema, async (args) => {
-        const prolog = await ensureProlog();
-        return handleKbQueryRelationships(prolog, args);
-    });
-    addTool(server, "kb_derive", toolDef("kb_derive").description, toolDef("kb_derive").inputSchema, async (args) => {
-        const prolog = await ensureProlog();
-        return handleKbDerive(prolog, args);
-    });
-    addTool(server, "kb_impact", toolDef("kb_impact").description, toolDef("kb_impact").inputSchema, async (args) => {
-        const prolog = await ensureProlog();
-        return handleKbImpact(prolog, args);
-    });
-    addTool(server, "kb_coverage_report", toolDef("kb_coverage_report").description, toolDef("kb_coverage_report").inputSchema, async (args) => {
-        const prolog = await ensureProlog();
-        return handleKbCoverageReport(prolog, args);
-    });
-    addTool(server, "kb_symbols_refresh", toolDef("kb_symbols_refresh").description, toolDef("kb_symbols_refresh").inputSchema, async (args) => handleKbSymbolsRefresh(args));
-    addTool(server, "kb_list_entity_types", toolDef("kb_list_entity_types").description, toolDef("kb_list_entity_types").inputSchema, handleKbListEntityTypes);
-    addTool(server, "kb_list_relationship_types", toolDef("kb_list_relationship_types").description, toolDef("kb_list_relationship_types").inputSchema, handleKbListRelationshipTypes);
-    addTool(server, "kbcontext", toolDef("kbcontext").description, toolDef("kbcontext").inputSchema, async (args) => {
-        const prolog = await ensureProlog();
-        return handleKbContext(prolog, args, activeBranchName);
-    });
-    addTool(server, "get_help", toolDef("get_help").description, toolDef("get_help").inputSchema, async (args) => {
-        const topic = typeof args?.topic === "string" ? args.topic : undefined;
-        const text = getHelpText(topic);
-        return {
-            content: [{ type: "text", text }],
-            structuredContent: { topic: topic ?? "overview" },
-        };
-    });
-    addTool(server, "analyze_shared_facts", toolDef("analyze_shared_facts").description, toolDef("analyze_shared_facts").inputSchema, async (args) => {
-        const prolog = await ensureProlog();
-        return handleSuggestSharedFacts(prolog, args);
-    });
     const transport = new StdioServerTransport();
     transport.onerror = (error) => {
         // Stdio transport surfaces JSON parse / schema validation failures via onerror.

package/dist/tools/check.js

@@ -44,6 +44,15 @@
 */
 import * as path from "node:path";
 import { parsePairList } from "./prolog-list.js";
+function formatDiagnosticsForMcp(diagnostics) {
+    return diagnostics.map((d) => ({
+        category: d.category,
+        severity: d.severity,
+        message: d.message,
+        file: d.file,
+        suggestion: d.suggestion,
+    }));
+}
 /**
  * Handle kb_check tool calls - run validation rules on the KB
  * Reuses validation logic from CLI check command
@@ -77,7 +86,13 @@ export async function handleKbCheck(prolog, args) {
         if (rulesToRun.includes("symbol-coverage")) {
             violations.push(...(await checkSymbolCoverage(prolog)));
         }
-        // Return MCP structured response
+        const diagnostics = violations.map((v) => ({
+            category: "SYNC_ERROR",
+            severity: "error",
+            message: v.description,
+            file: v.source,
+            suggestion: v.suggestion,
+        }));
         const summary = violations.length === 0
             ? "No violations found"
             : `${violations.length} violations found`;
@@ -91,6 +106,7 @@ export async function handleKbCheck(prolog, args) {
             structuredContent: {
                 violations,
                 count: violations.length,
+                diagnostics: formatDiagnosticsForMcp(diagnostics),
             },
         };
     }

package/dist/tools/context.js

@@ -15,18 +15,8 @@
  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/>.
 */
-export async function handleKbContext(prolog, args, activeBranch) {
-    const { sourceFile, branch } = args;
-    if (branch && activeBranch && branch !== activeBranch) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error: branch parameter is not supported server-side; set KIBI_BRANCH at startup or restart server on the desired branch. (Requested: ${branch}, Active: ${activeBranch})`,
-                },
-            ],
-        };
-    }
+export async function handleKbContext(prolog, args) {
+    const { sourceFile } = args;
     try {
         const safeSource = sourceFile.replace(/'/g, "\\'");
         const entityGoal = `findall([Id,Type,Props], (kb_entities_by_source('${safeSource}', SourceIds), member(Id, SourceIds), kb_entity(Id, Type, Props)), Results)`;

package/dist/tools-config.js

@@ -234,215 +234,19 @@ export const TOOLS = [
             properties: {
                 rules: {
                     type: "array",
-                    items: { type: "string" },
+                    items: {
+                        type: "string",
+                        enum: [
+                            "must-priority-coverage",
+                            "no-dangling-refs",
+                            "no-cycles",
+                            "required-fields",
+                            "symbol-coverage",
+                        ],
+                    },
                     description: "Optional rule subset. Allowed: must-priority-coverage, no-dangling-refs, no-cycles, required-fields, symbol-coverage. If omitted, server runs all.",
                 },
             },
         },
     },
-    {
-        name: "kb_branch_ensure",
-        description: "Ensure a branch KB exists, creating it from develop when missing. Use when targeting non-develop branches. Do not use to switch git branches. Side effects: creates .kb/branches/<branch>.",
-        inputSchema: {
-            type: "object",
-            required: ["branch"],
-            properties: {
-                branch: {
-                    type: "string",
-                    description: "Required git branch name. Example: 'feature/auth-hardening'. Path traversal patterns are rejected.",
-                },
-            },
-        },
-    },
-    {
-        name: "kb_branch_gc",
-        description: "Find or delete stale branch KB directories not present in git. Use for repository hygiene. Do not use if you need historical branch KBs. Side effects: can delete branch KB folders when dry_run is false.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                dry_run: {
-                    type: "boolean",
-                    default: true,
-                    description: "Optional safety flag. true = report only; false = delete stale branch KBs. Default: true.",
-                },
-            },
-        },
-    },
-    {
-        name: "kb_query_relationships",
-        description: "Read relationship edges with optional from/to/type filters. Use for traceability traversal. Do not use to create links. No mutation side effects.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                from: {
-                    type: "string",
-                    description: "Optional source entity ID filter. Example: 'REQ-001'.",
-                },
-                to: {
-                    type: "string",
-                    description: "Optional target entity ID filter. Example: 'TEST-010'.",
-                },
-                type: {
-                    type: "string",
-                    enum: [
-                        "depends_on",
-                        "specified_by",
-                        "verified_by",
-                        "validates",
-                        "implements",
-                        "covered_by",
-                        "constrained_by",
-                        "constrains",
-                        "requires_property",
-                        "guards",
-                        "publishes",
-                        "consumes",
-                        "supersedes",
-                        "relates_to",
-                    ],
-                    description: "Optional relationship type filter. Allowed enum values only. Example: 'implements'.",
-                },
-            },
-        },
-    },
-    {
-        name: "kb_derive",
-        description: "Run deterministic inference predicates and return rows. Use for impact, coverage, and consistency analysis. Do not use for entity CRUD. No mutation side effects.",
-        inputSchema: {
-            type: "object",
-            required: ["rule"],
-            properties: {
-                rule: {
-                    type: "string",
-                    enum: [
-                        "transitively_implements",
-                        "transitively_depends",
-                        "impacted_by_change",
-                        "affected_symbols",
-                        "coverage_gap",
-                        "untested_symbols",
-                        "stale",
-                        "orphaned",
-                        "conflicting",
-                        "deprecated_still_used",
-                        "current_adr",
-                        "adr_chain",
-                        "superseded_by",
-                        "domain_contradictions",
-                    ],
-                    description: "Required inference rule name. Allowed values are the enum options. Example: 'coverage_gap'.",
-                },
-                params: {
-                    type: "object",
-                    description: "Optional rule-specific parameters. Example: { changed: 'REQ-001' } for impacted_by_change.",
-                },
-            },
-        },
-    },
-    {
-        name: "kb_impact",
-        description: "Return entities impacted by a changed entity ID. Use for quick change blast radius checks. Do not use for general querying. No mutation side effects.",
-        inputSchema: {
-            type: "object",
-            required: ["entity"],
-            properties: {
-                entity: {
-                    type: "string",
-                    description: "Required changed entity ID. Example: 'REQ-001'.",
-                },
-            },
-        },
-    },
-    {
-        name: "kb_coverage_report",
-        description: "Compute aggregate traceability coverage for requirements and/or symbols. Use for health snapshots. Do not use for raw entity dumps. No mutation side effects.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                type: {
-                    type: "string",
-                    enum: ["req", "symbol"],
-                    description: "Optional focus scope: 'req' or 'symbol'. Omit to include both.",
-                },
-            },
-        },
-    },
-    {
-        name: "kb_symbols_refresh",
-        description: "Refresh generated symbol coordinates in the symbols manifest. Use after refactors that move symbols. Do not use for semantic edits. Side effects: may rewrite symbols.yaml unless dryRun is true.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                dryRun: {
-                    type: "boolean",
-                    default: false,
-                    description: "Optional preview mode. true = report only, false = apply file updates. Default: false.",
-                },
-            },
-        },
-    },
-    {
-        name: "kb_list_entity_types",
-        description: "List supported entity type names. Use when building valid tool arguments. Do not use for entity data retrieval. No mutation side effects.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "kb_list_relationship_types",
-        description: "List supported relationship type names. Use before asserting or filtering relationships. Do not use for graph traversal. No mutation side effects.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "kbcontext",
-        description: "Return KB entities linked to a source file plus first-hop relationships. Use for file-centric traceability. Do not use for cross-repo search. No mutation side effects.",
-        inputSchema: {
-            type: "object",
-            required: ["sourceFile"],
-            properties: {
-                sourceFile: {
-                    type: "string",
-                    description: "Required source path substring. Example: 'src/auth/login.ts'.",
-                },
-                branch: {
-                    type: "string",
-                    description: "Optional branch hint for clients. Must match the server's active branch or will return an error.",
-                },
-            },
-        },
-    },
-    {
-        name: "get_help",
-        description: "Returns documentation for this MCP server. Call this first if you are unsure how to proceed or which tool to use. Available topics: overview, tools, workflow, constraints, examples, errors.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                topic: {
-                    type: "string",
-                    enum: [
-                        "overview",
-                        "tools",
-                        "workflow",
-                        "constraints",
-                        "examples",
-                        "errors",
-                        "branching",
-                    ],
-                    description: "Optional documentation section. Omit to return overview. Example: 'workflow'.",
-                },
-            },
-        },
-    },
-    {
-        name: "analyze_shared_facts",
-        description: "Analyze requirements and suggest shared domain facts for extraction. LLMs call this to identify missed semantic opportunities before upserting. Lightweight heuristic: finds overlapping capitalized terms and repeated phrases across requirements.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                min_frequency: {
-                    type: "number",
-                    default: 2,
-                    description: "Minimum frequency threshold for shared concepts. Default: 2. Example: 3 to only show concepts mentioned in 3+ requirements.",
-                },
-            },
-        },
-    },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-mcp",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "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.1.7",
+    "kibi-cli": "^0.2.0",
     "kibi-core": "^0.1.6",
     "mcpcat": "^0.1.12",
     "ts-morph": "^23.0.0",