kibi-mcp 0.2.4 → 0.3.0

package/dist/server/tools.js

@@ -0,0 +1,199 @@
+/*
+ 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 process from "node:process";
+import { z } from "zod";
+import { TOOLS } from "../tools-config.js";
+import { handleKbCheck } from "../tools/check.js";
+import { handleKbDelete } from "../tools/delete.js";
+import { handleKbQuery } from "../tools/query.js";
+import { handleKbUpsert } from "../tools/upsert.js";
+import { ensureProlog, inFlightRequests, isShuttingDown } from "./session.js";
+const ACTIVE_TOOLS = TOOLS;
+function debugLog(...args) {
+    if (process.env.KIBI_MCP_DEBUG) {
+        console.error(...args);
+    }
+}
+export function jsonSchemaToZod(schema) {
+    if (!schema || typeof schema !== "object") {
+        return z.any();
+    }
+    const obj = schema;
+    if (Array.isArray(obj.enum) && obj.enum.length > 0) {
+        const description = typeof obj.description === "string" ? obj.description : undefined;
+        const literals = obj.enum.filter((value) => typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean" ||
+            value === null);
+        if (literals.length === 0) {
+            return description ? z.any().describe(description) : z.any();
+        }
+        const literalSchemas = literals.map((value) => z.literal(value));
+        if (literalSchemas.length === 1) {
+            const single = literalSchemas[0];
+            return description ? single.describe(description) : single;
+        }
+        const union = z.union(literalSchemas);
+        return description ? union.describe(description) : union;
+    }
+    const schemaType = typeof obj.type === "string" ? obj.type : undefined;
+    switch (schemaType) {
+        case "object": {
+            const properties = obj.properties && typeof obj.properties === "object"
+                ? obj.properties
+                : {};
+            const required = new Set(Array.isArray(obj.required)
+                ? obj.required.filter((k) => typeof k === "string" && k.length > 0)
+                : []);
+            const shape = {};
+            for (const [key, value] of Object.entries(properties)) {
+                const propSchema = jsonSchemaToZod(value);
+                shape[key] = required.has(key) ? propSchema : propSchema.optional();
+            }
+            let objectSchema = z.object(shape);
+            if (obj.additionalProperties !== false) {
+                objectSchema = objectSchema.passthrough();
+            }
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            return description ? objectSchema.describe(description) : objectSchema;
+        }
+        case "array": {
+            const itemSchema = jsonSchemaToZod(obj.items);
+            let arraySchema = z.array(itemSchema);
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            if (typeof obj.minItems === "number") {
+                arraySchema = arraySchema.min(obj.minItems);
+            }
+            if (typeof obj.maxItems === "number") {
+                arraySchema = arraySchema.max(obj.maxItems);
+            }
+            return description ? arraySchema.describe(description) : arraySchema;
+        }
+        case "string": {
+            let s = z.string();
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            if (typeof obj.minLength === "number") {
+                s = s.min(obj.minLength);
+            }
+            if (typeof obj.maxLength === "number") {
+                s = s.max(obj.maxLength);
+            }
+            return description ? s.describe(description) : s;
+        }
+        case "number": {
+            let n = z.number();
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            if (typeof obj.minimum === "number") {
+                n = n.min(obj.minimum);
+            }
+            if (typeof obj.maximum === "number") {
+                n = n.max(obj.maximum);
+            }
+            return description ? n.describe(description) : n;
+        }
+        case "integer": {
+            let n = z.number().int();
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            if (typeof obj.minimum === "number") {
+                n = n.min(obj.minimum);
+            }
+            if (typeof obj.maximum === "number") {
+                n = n.max(obj.maximum);
+            }
+            return description ? n.describe(description) : n;
+        }
+        case "boolean": {
+            const b = z.boolean();
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            return description ? b.describe(description) : b;
+        }
+        default: {
+            const anySchema = z.any();
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            return description ? anySchema.describe(description) : anySchema;
+        }
+    }
+}
+function addTool(server, name, description, inputSchema, handler) {
+    const wrappedHandler = async (args) => {
+        try {
+            // Validate that args is a valid object
+            if (typeof args !== "object" || args === null) {
+                throw new Error(`Invalid arguments for tool ${name}: expected object, got ${typeof args}`);
+            }
+            const businessArgs = args;
+            // Check if shutting down before processing
+            if (isShuttingDown) {
+                throw new Error(`Tool ${name} rejected: server is shutting down`);
+            }
+            // Extract or generate requestId from args
+            const requestIdArg = businessArgs._requestId;
+            const requestId = typeof requestIdArg === "string"
+                ? requestIdArg
+                : `${name}-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+            // Log tool call for debugging (to stderr to avoid breaking stdio protocol)
+            if (process.env.KIBI_MCP_DEBUG) {
+                console.error(`[KIBI-MCP] Tool called: ${name} (requestId: ${requestId}) with args:`, JSON.stringify(businessArgs));
+            }
+            // Track the handler promise in inFlightRequests Map
+            const handlerPromise = handler(businessArgs);
+            inFlightRequests.set(requestId, handlerPromise);
+            try {
+                // Execute handler
+                return await handlerPromise;
+            }
+            finally {
+                // Always clean up from Map when done (success or failure)
+                inFlightRequests.delete(requestId);
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            console.error(`[KIBI-MCP] Error in tool ${name}:`, err.message);
+            if (err.stack) {
+                debugLog(`[KIBI-MCP] Tool ${name} stack:`, err.stack);
+            }
+            throw new Error(`Tool ${name} failed: ${err.message}`, { cause: err });
+        }
+    };
+    server.registerTool(name, { description, inputSchema: jsonSchemaToZod(inputSchema) }, wrappedHandler);
+}
+export function registerAllTools(server) {
+    const toolDef = (name) => {
+        const t = ACTIVE_TOOLS.find((t) => t.name === name);
+        if (!t)
+            throw new Error(`Unknown tool: ${name}`);
+        return t;
+    };
+    addTool(server, "kb_query", toolDef("kb_query").description, toolDef("kb_query").inputSchema, async (args) => {
+        const prolog = await ensureProlog();
+        return handleKbQuery(prolog, args);
+    });
+    addTool(server, "kb_upsert", toolDef("kb_upsert").description, toolDef("kb_upsert").inputSchema, async (args) => {
+        const prolog = await ensureProlog();
+        return handleKbUpsert(prolog, args);
+    });
+    addTool(server, "kb_delete", toolDef("kb_delete").description, toolDef("kb_delete").inputSchema, async (args) => {
+        const prolog = await ensureProlog();
+        return handleKbDelete(prolog, args);
+    });
+    addTool(server, "kb_check", toolDef("kb_check").description, toolDef("kb_check").inputSchema, async (args) => {
+        const prolog = await ensureProlog();
+        return handleKbCheck(prolog, args);
+    });
+}

package/dist/server/transport.js

@@ -0,0 +1,71 @@
+/*
+ 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 process from "node:process";
+import { initiateGracefulShutdown } from "./session.js";
+function debugLog(...args) {
+    if (process.env.KIBI_MCP_DEBUG) {
+        console.error(...args);
+    }
+}
+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)
+        // and continue reading subsequent messages.
+        if (error.name === "SyntaxError") {
+            debugLog("[KIBI-MCP] Parse error from stdin:", error.message);
+            void transport
+                .send({
+                jsonrpc: "2.0",
+                error: { code: -32700, message: "Parse error" },
+            })
+                .catch((sendError) => {
+                console.error("[KIBI-MCP] Failed to send parse error response:", sendError);
+                initiateGracefulShutdown(1);
+            });
+            return;
+        }
+        if (error.name === "ZodError") {
+            debugLog("[KIBI-MCP] Invalid JSON-RPC message:", error.message);
+            void transport
+                .send({
+                jsonrpc: "2.0",
+                error: { code: -32600, message: "Invalid Request" },
+            })
+                .catch((sendError) => {
+                console.error("[KIBI-MCP] Failed to send invalid request response:", sendError);
+                initiateGracefulShutdown(1);
+            });
+            return;
+        }
+        console.error(`[KIBI-MCP] Transport error: ${error.message}`, error);
+        debugLog("[KIBI-MCP] Transport error stack:", error.stack);
+        initiateGracefulShutdown(1);
+    };
+    transport.onclose = () => {
+        debugLog("[KIBI-MCP] Transport closed");
+        initiateGracefulShutdown(0);
+    };
+    process.on("SIGTERM", () => {
+        debugLog("[KIBI-MCP] Received SIGTERM, initiating graceful shutdown");
+        void initiateGracefulShutdown(0);
+    });
+}
+export async function connectTransport(server, transport) {
+    await server.connect(transport);
+}