kibi-mcp 0.17.5 → 0.19.2

package/dist/server/tool-registration.js

@@ -1,3 +1,4 @@
+import { getSpec } from "kibi-cli/operations";
 // implements REQ-002, REQ-013
 export function registerConfiguredTools(server, runtime, registerTool) {
     const toolDef = (name) => {
@@ -6,9 +7,23 @@ export function registerConfiguredTools(server, runtime, registerTool) {
             throw new Error(`Unknown tool: ${name}`);
         return t;
     };
-    const register = ({ name, handler }) => {
+    const prologFor = (context) => {
+        const prolog = runtime.operationRuntime.sessionProlog(context);
+        if (!prolog) {
+            throw new Error("Operation requires a session Prolog process");
+        }
+        return prolog;
+    };
+    const register = ({ name, execute }) => {
         const definition = toolDef(name);
-        registerTool(server, name, definition.description, definition.inputSchema, handler, runtime);
+        const publicSpec = getSpec(name);
+        const spec = {
+            name,
+            effects: publicSpec.effects,
+            requiresProlog: publicSpec.requiresProlog,
+            execute: (args, context) => execute(context, args),
+        };
+        registerTool(server, name, definition.description, definition.inputSchema, async () => undefined, runtime, spec, definition.annotations);
     };
     // INTENTIONAL ARGUMENT CASTS: The `args as (unknown as)? XyzArgs` casts below
     // bridge the generic ToolHandler (which receives Record<string, unknown>) to the
@@ -16,113 +31,74 @@ export function registerConfiguredTools(server, runtime, registerTool) {
     // (via jsonSchemaToZod) before the handler is invoked, so the casts are safe at runtime.
     register({
         name: "kb_query",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbQuery(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbQuery(prologFor(context), args),
     });
     register({
         name: "kb_search",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbSearch(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbSearch(prologFor(context), args),
     });
     register({
         name: "kb_status",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbStatus(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbStatus(prologFor(context), args),
     });
     register({
         name: "kb_skills_list",
-        handler: async (args) => runtime.handleKbSkillsList(args),
+        execute: async (_context, args) => runtime.handleKbSkillsList(args),
     });
     register({
         name: "kb_skills_load",
-        handler: async (args) => runtime.handleKbSkillsLoad(args),
+        execute: async (_context, args) => runtime.handleKbSkillsLoad(args),
     });
     register({
         name: "kb_skills_read",
-        handler: async (args) => runtime.handleKbSkillsRead(args),
+        execute: async (_context, args) => runtime.handleKbSkillsRead(args),
     });
     register({
         name: "kb_find_gaps",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbFindGaps(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbFindGaps(prologFor(context), args),
     });
     register({
         name: "kb_coverage",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbCoverage(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbCoverage(prologFor(context), args),
     });
     register({
         name: "kb_graph",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbGraph(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbGraph(prologFor(context), args),
     });
     register({
         name: "kb_sparql_remote",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleSparql(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleSparql(args, context),
     });
     register({
         name: "kb_semantic_advisor",
-        handler: async (args) => runtime.handleKbSemanticAdvisor(args),
+        execute: async (_context, args) => runtime.handleKbSemanticAdvisor(args),
     });
     register({
         name: "kb_upsert",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbUpsert(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbUpsert(prologFor(context), args),
     });
     register({
         name: "kb_validate_upsert",
-        handler: async (args) => runtime.handleKbValidateUpsert(args),
+        execute: async (context, args) => runtime.handleKbValidateUpsert(prologFor(context), args),
     });
     register({
         name: "kb_delete",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbDelete(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbDelete(prologFor(context), args),
     });
     register({
         name: "kb_check",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbCheck(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbCheck(prologFor(context), args),
     });
     register({
         name: "kb_model_requirement",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbModelRequirement(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbModelRequirement(prologFor(context), args),
     });
     register({
         name: "kb_suggest_predicates",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbSuggestPredicates(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbSuggestPredicates(prologFor(context), args),
     });
     register({
         name: "kb_autopilot_generate",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbAutopilotGenerate(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbAutopilotGenerate(args, context),
     });
 }

package/dist/server/tools-runtime.js

@@ -1,4 +1,7 @@
+import { getSpec } from "kibi-cli/operations";
 import { DIAGNOSTIC_MODE_ENABLED, appendUsageLogLine, classifyDiagnosticError, deriveDiagnosticFields, extractToolCallPayload, } from "../diagnostics.js";
+import { isMcpDebugEnabled } from "../env.js";
+import { createMcpRuntime } from "../runtime/mcp-runtime.js";
 import { TOOLS } from "../tools-config.js";
 import { handleKbAutopilotGenerate } from "../tools/autopilot-generate.js";
 import { handleKbCheck } from "../tools/check.js";
@@ -11,15 +14,17 @@ import { handleKbQuery } from "../tools/query.js";
 import { handleKbSearch } from "../tools/search.js";
 import { handleKbSemanticAdvisor } from "../tools/semantic-advisor.js";
 import { handleKbSkillsList, handleKbSkillsLoad, handleKbSkillsRead, } from "../tools/skills.js";
-import { handleSparql } from "../tools/sparql.js";
 import { handleKbStatus } from "../tools/status.js";
 import { handleKbSuggestPredicates } from "../tools/suggest-predicates.js";
 import { handleKbUpsert } from "../tools/upsert.js";
 import { handleKbValidateUpsert } from "../tools/validate-upsert.js";
+import { resolveWorkspaceRoot } from "../workspace.js";
+import { readBranchKbStamp } from "./kb-freshness.js";
 const defaultToolsServerDeps = {
     getSessionModule: () => import("./session.js"),
 };
 let sessionModulePromise = null;
+const prologPorts = new WeakMap();
 // implements REQ-008
 export function _setToolsServerDepsForTests(deps, resetPromise = false) {
     defaultToolsServerDeps.getSessionModule =
@@ -39,6 +44,50 @@ async function getSessionModule() {
     sessionModulePromise ??= defaultToolsServerDeps.getSessionModule();
     return sessionModulePromise;
 }
+function adaptProlog(prolog) {
+    const existing = prologPorts.get(prolog);
+    if (existing) {
+        return existing;
+    }
+    let lastResult = null;
+    const port = {
+        query: async (goal) => {
+            lastResult = await prolog.query(goal);
+            return lastResult;
+        },
+        nextSolution: async () => {
+            const result = lastResult;
+            lastResult = null;
+            return result;
+        },
+        save: () => prolog.query("kb_save"),
+    };
+    prologPorts.set(prolog, port);
+    return port;
+}
+const operationRuntime = createMcpRuntime({
+    workspaceRoot: resolveWorkspaceRoot(),
+    activeBranchName: async () => (await getSessionModule()).activeBranchName,
+    attachedBranchKbPath: async () => (await getSessionModule()).attachedBranchKbPath,
+    ensureProlog: async () => (await getSessionModule()).ensureProlog(),
+    adaptProlog,
+    net: { fetch: (input, init) => globalThis.fetch(input, init) },
+    refreshAttachedBranchStamp: async () => {
+        const session = await getSessionModule();
+        const kbPath = session.attachedBranchKbPath;
+        if (kbPath) {
+            try {
+                session.updateAttachedBranchStamp(await readBranchKbStamp(kbPath));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                if (isMcpDebugEnabled()) {
+                    console.warn("[KIBI-MCP] Attached branch stamp refresh failed:", message);
+                }
+            }
+        }
+    },
+});
 export const DEFAULT_TOOLS_RUNTIME = {
     diagnosticModeEnabled: () => DIAGNOSTIC_MODE_ENABLED,
     appendUsageLogLine,
@@ -55,12 +104,13 @@ export const DEFAULT_TOOLS_RUNTIME = {
     inFlightRequests: async () => (await getSessionModule()).inFlightRequests,
     isShuttingDown: async () => (await getSessionModule()).isShuttingDown,
     prologProcess: async () => (await getSessionModule()).prologProcess,
+    operationRuntime,
     handleKbCheck,
     handleKbCoverage,
     handleKbDelete,
     handleKbFindGaps,
     handleKbGraph,
-    handleSparql,
+    handleSparql: (args, context) => getSpec("kb_sparql_remote").execute(args, context),
     handleKbQuery,
     handleKbSearch,
     handleKbStatus,

package/dist/server/tools.js

@@ -16,6 +16,7 @@
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 import process from "node:process";
+import { executeOperation, } from "kibi-cli/operations/runtime-types";
 import { isMcpDebugEnabled } from "../env.js";
 import { appendDiagnosticErrorUsage, appendDiagnosticSuccessUsage, } from "./diagnostic-usage.js";
 import { jsonSchemaToZod } from "./json-schema-to-zod.js";
@@ -73,7 +74,7 @@ export function addTool(server, name, description, inputSchema, handler,
 // INTENTIONAL: DEFAULT_TOOLS_RUNTIME is typed as ToolsRuntime<PrologProcess>; the
 // generic TProlog parameter exists so tests can inject a mock type. The cast is safe
 // because the runtime object satisfies the full ToolsRuntime contract at runtime.
-runtime = DEFAULT_TOOLS_RUNTIME) {
+runtime = DEFAULT_TOOLS_RUNTIME, spec, annotations) {
     const wrappedHandler = async (args) => {
         const startedAt = new Date();
         const diagnosticModeEnabled = runtime.diagnosticModeEnabled();
@@ -100,21 +101,30 @@ runtime = DEFAULT_TOOLS_RUNTIME) {
             }
             // Track the handler promise in inFlightRequests Map
             const trackedRequests = await runtime.inFlightRequests();
-            const handlerPromise = handler(businessArgs);
+            const controller = new AbortController();
+            const operationSpec = spec ?? {
+                name,
+                effects: ["local-read"],
+                requiresProlog: false,
+                execute: async (input, _context) => handler(input),
+            };
+            const handlerPromise = executeOperation(runtime.operationRuntime, operationSpec, businessArgs, { signal: controller.signal });
             trackedRequests.set(requestId, handlerPromise);
             let resetAttempted = false;
             let resetSucceeded = false;
             let resetError = null;
             try {
                 // Execute handler
-                const result = await withToolTimeout(name, handlerPromise, async () => {
+                const result = await withToolTimeout(name, handlerPromise, async (error) => {
                     resetAttempted = true;
+                    controller.abort(error);
                     try {
                         await runtime.resetProlog(`tool timeout: ${name}`);
                         resetSucceeded = true;
                     }
                     catch (error) {
-                        resetError = error instanceof Error ? error.message : String(error);
+                        resetError =
+                            error instanceof Error ? error.message : String(error);
                     }
                 });
                 // Log usage in diagnostic mode
@@ -163,7 +173,11 @@ runtime = DEFAULT_TOOLS_RUNTIME) {
             throw new Error(`Tool ${name} failed: ${err.message}`, { cause: err });
         }
     };
-    server.registerTool(name, { description, inputSchema: jsonSchemaToZod(inputSchema) }, wrappedHandler);
+    server.registerTool(name, {
+        description,
+        inputSchema: jsonSchemaToZod(inputSchema),
+        ...(annotations ? { annotations } : {}),
+    }, wrappedHandler);
 }
 // implements REQ-002, REQ-013
 export function registerAllTools(server, 

package/dist/server/transport.js

@@ -23,7 +23,7 @@ function debugLog(...args) {
         console.error(...args);
     }
 }
-export function setupTransportHandlers(server, transport) {
+export function setupTransportHandlers(_server, transport) {
     transport.onerror = (error) => {
         // Stdio transport surfaces JSON parse / schema validation failures via onerror.
         // Those errors should not crash the server: emit a JSON-RPC error (id omitted)
@@ -62,11 +62,15 @@ export function setupTransportHandlers(server, transport) {
         debugLog("[KIBI-MCP] Transport closed");
         initiateGracefulShutdown(0);
     };
-    process.on("SIGTERM", () => {
-        debugLog("[KIBI-MCP] Received SIGTERM, initiating graceful shutdown");
-        void initiateGracefulShutdown(0);
-    });
+    for (const signal of ["SIGINT", "SIGTERM"]) {
+        process.on(signal, () => {
+            debugLog(`[KIBI-MCP] Received ${signal}, initiating graceful shutdown`);
+            void initiateGracefulShutdown(0);
+        });
+    }
 }
+// implements REQ-002
+// covered_by TEST-mcp-kb-freshness
 export async function connectTransport(server, transport) {
     await server.connect(transport);
 }