@lzehrung/codegraph 2.1.1 → 2.2.0

package/dist/mcp/lifecycleHealth.js

@@ -0,0 +1,37 @@
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+export const MCP_LIFECYCLE_HEALTH_TOKEN_ENV = "CODEGRAPH_MCP_LIFECYCLE_HEALTH_TOKEN";
+const TOKEN_BYTES = 32;
+const CHALLENGE_BYTES = 16;
+const TOKEN_PATTERN = /^[A-Za-z0-9_-]{43}$/;
+export function createMcpLifecycleHealthToken() {
+    return randomBytes(TOKEN_BYTES).toString("base64url");
+}
+export function readMcpLifecycleHealthToken(env = process.env) {
+    const value = env[MCP_LIFECYCLE_HEALTH_TOKEN_ENV];
+    if (!value || !TOKEN_PATTERN.test(value))
+        return undefined;
+    return value;
+}
+export function createMcpLifecycleHealthChallenge() {
+    return randomBytes(CHALLENGE_BYTES).toString("base64url");
+}
+export function createMcpLifecycleHealthProof(token, challenge, identity) {
+    return createHmac("sha256", token).update(serializeHealthIdentity(challenge, identity)).digest("base64url");
+}
+export function matchesMcpLifecycleHealthProof(proof, token, challenge, identity) {
+    if (!proof)
+        return false;
+    const expected = createMcpLifecycleHealthProof(token, challenge, identity);
+    const proofBytes = Buffer.from(proof);
+    const expectedBytes = Buffer.from(expected);
+    return proofBytes.length === expectedBytes.length && timingSafeEqual(proofBytes, expectedBytes);
+}
+function serializeHealthIdentity(challenge, identity) {
+    return JSON.stringify({
+        challenge,
+        pid: identity.pid,
+        root: identity.root,
+        startedAt: identity.startedAt,
+    });
+}
+//# sourceMappingURL=lifecycleHealth.js.map

package/dist/mcp/lifecycleHealth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycleHealth.js","sourceRoot":"","sources":["../../src/mcp/lifecycleHealth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEvE,MAAM,CAAC,MAAM,8BAA8B,GAAG,sCAAsC,CAAC;AAQrF,MAAM,WAAW,GAAG,EAAE,CAAC;AACvB,MAAM,eAAe,GAAG,EAAE,CAAC;AAC3B,MAAM,aAAa,GAAG,qBAAqB,CAAC;AAE5C,MAAM,UAAU,6BAA6B;IAC3C,OAAO,WAAW,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;AACxD,CAAC;AAED,MAAM,UAAU,2BAA2B,CAAC,MAAyB,OAAO,CAAC,GAAG;IAC9E,MAAM,KAAK,GAAG,GAAG,CAAC,8BAA8B,CAAC,CAAC;IAClD,IAAI,CAAC,KAAK,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAC3D,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,UAAU,iCAAiC;IAC/C,OAAO,WAAW,CAAC,eAAe,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;AAC5D,CAAC;AAED,MAAM,UAAU,6BAA6B,CAC3C,KAAa,EACb,SAAiB,EACjB,QAAoC;IAEpC,OAAO,UAAU,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,MAAM,CAAC,uBAAuB,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;AAC9G,CAAC;AAED,MAAM,UAAU,8BAA8B,CAC5C,KAAyB,EACzB,KAAa,EACb,SAAiB,EACjB,QAAoC;IAEpC,IAAI,CAAC,KAAK;QAAE,OAAO,KAAK,CAAC;IACzB,MAAM,QAAQ,GAAG,6BAA6B,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;IAC3E,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACtC,MAAM,aAAa,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC5C,OAAO,UAAU,CAAC,MAAM,KAAK,aAAa,CAAC,MAAM,IAAI,eAAe,CAAC,UAAU,EAAE,aAAa,CAAC,CAAC;AAClG,CAAC;AAED,SAAS,uBAAuB,CAAC,SAAiB,EAAE,QAAoC;IACtF,OAAO,IAAI,CAAC,SAAS,CAAC;QACpB,SAAS;QACT,GAAG,EAAE,QAAQ,CAAC,GAAG;QACjB,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,SAAS,EAAE,QAAQ,CAAC,SAAS;KAC9B,CAAC,CAAC;AACL,CAAC"}

package/dist/mcp/protocol.d.ts

@@ -0,0 +1,35 @@
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+import { type Readable, type Writable } from "node:stream";
+import { Server } from "@modelcontextprotocol/server";
+import { type CodegraphRuntimeIdentity, type InstalledVersionChecker } from "../runtimeIdentity.js";
+import type { CodegraphMcpHandlers } from "./handlers.js";
+export declare const DEFAULT_MCP_TOOL_TIMEOUT_MS: number;
+export declare const DEFAULT_MCP_TOOL_CONCURRENCY = 4;
+export declare function assertMcpToolTimeout(value: number): number;
+export type McpToolOperationTracker = {
+    isAccepting: () => boolean;
+    track: <T>(operation: () => Promise<T>) => Promise<T> | undefined;
+    stop: () => void;
+    drain: () => Promise<void>;
+};
+export type McpToolConcurrencyTracker = {
+    inFlight: number;
+    maximum: number;
+};
+export declare function createCodegraphMcpProtocolServer(handlers: CodegraphMcpHandlers, runtimeIdentity?: CodegraphRuntimeIdentity, installedVersion?: InstalledVersionChecker, toolCallState?: {
+    firstToolCallPending: boolean;
+}, maxConcurrentToolCalls?: number, mcpToolTimeoutMs?: number): Server;
+export declare function createCodegraphMcpProtocolServerWithTracker(handlers: CodegraphMcpHandlers, runtimeIdentity: CodegraphRuntimeIdentity, installedVersion: InstalledVersionChecker, toolCallState: {
+    firstToolCallPending: boolean;
+}, mcpToolTimeoutMs: number, toolOperations: McpToolOperationTracker, toolConcurrency: McpToolConcurrencyTracker): Server;
+export type McpProtocolFactory = {
+    create: () => Server;
+    stop: () => void;
+    drain: () => Promise<void>;
+};
+export declare function createCodegraphMcpProtocolFactory(handlers: CodegraphMcpHandlers, runtimeIdentity: CodegraphRuntimeIdentity, maxConcurrentToolCalls?: number, mcpToolTimeoutMs?: number): McpProtocolFactory;
+export declare function createParseErrorReportingStdin(input: Readable, output: Writable): Readable;
+export declare function awaitMcpToolOperation<T>(signal: AbortSignal | undefined, operation: Promise<T>, onSettled: () => void): Promise<T>;
+export declare function callMcpTool(handlers: CodegraphMcpHandlers, name: string, input: unknown, signal?: AbortSignal): Promise<unknown>;
+export declare function createCodegraphMcpStdioTransport(input: Readable, output: Writable): StdioServerTransport;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/mcp/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../src/mcp/protocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAa,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AACtE,OAAO,EAAoC,MAAM,EAAuB,MAAM,8BAA8B,CAAC;AAgB7G,OAAO,EAGL,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC7B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,oBAAoB,EAAqB,MAAM,eAAe,CAAC;AAG7E,eAAO,MAAM,2BAA2B,QAAiB,CAAC;AAG1D,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAM9C,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAO1D;AACD,MAAM,MAAM,uBAAuB,GAAG;IACpC,WAAW,EAAE,MAAM,OAAO,CAAC;IAC3B,KAAK,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IAClE,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B,CAAC;AA2BF,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAMF,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,oBAAoB,EAC9B,eAAe,GAAE,wBAA2F,EAC5G,gBAAgB,GAAE,uBAAwE,EAC1F,aAAa,GAAE;IAAE,oBAAoB,EAAE,OAAO,CAAA;CAAmC,EACjF,sBAAsB,SAA+B,EACrD,gBAAgB,SAA8B,GAC7C,MAAM,CAUR;AAED,wBAAgB,2CAA2C,CACzD,QAAQ,EAAE,oBAAoB,EAC9B,eAAe,EAAE,wBAAwB,EACzC,gBAAgB,EAAE,uBAAuB,EACzC,aAAa,EAAE;IAAE,oBAAoB,EAAE,OAAO,CAAA;CAAE,EAChD,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,uBAAuB,EACvC,eAAe,EAAE,yBAAyB,GACzC,MAAM,CAuGR;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,MAAM,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B,CAAC;AAEF,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,oBAAoB,EAC9B,eAAe,EAAE,wBAAwB,EACzC,sBAAsB,SAA+B,EACrD,gBAAgB,SAA8B,GAC7C,kBAAkB,CAoBpB;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAG,QAAQ,CAiD1F;AAwCD,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,EACrB,SAAS,EAAE,MAAM,IAAI,GACpB,OAAO,CAAC,CAAC,CAAC,CAGZ;AAgBD,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,oBAAoB,EAC9B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,EACd,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,OAAO,CAAC,CAoElB;AA+SD,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAG,oBAAoB,CAIxG"}

package/dist/mcp/protocol.js

@@ -0,0 +1,577 @@
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+import { Transform } from "node:stream";
+import { ProtocolError, ProtocolErrorCode, Server } from "@modelcontextprotocol/server";
+import { z } from "zod";
+import { MAX_FILE_VIEW_BYTES, MAX_FILE_VIEW_LINES } from "../agent/fileView.js";
+import { MAX_GRAPH_DEPTH } from "../agent/search.js";
+import { errorMessage } from "../util/errors.js";
+import { SymbolKind } from "../indexer/types.js";
+import { MAX_WORKSPACE_SYMBOL_LIMIT } from "../indexer/workspace-symbols.js";
+import { listCodegraphMcpTools, MAX_RENAME_PREVIEW_EDITS, MCP_TOOL_REGISTRY, MAX_REFACTOR_PLAN_LIMIT, } from "./tools.js";
+import { getCurrentNativeBindingOrigin } from "../native/runtime.js";
+import { captureCodegraphRuntimeIdentity, createInstalledVersionChecker, } from "../runtimeIdentity.js";
+import { getLegacyRequestAbortSignal } from "./legacySessions.js";
+export const DEFAULT_MCP_TOOL_TIMEOUT_MS = 30 * 60 * 1000;
+const MAX_MCP_TOOL_TIMEOUT_MS = 2_147_483_647;
+const MAX_MCP_STDIO_FRAME_BYTES = 10 * 1024 * 1024;
+export const DEFAULT_MCP_TOOL_CONCURRENCY = 4;
+function normalizeMcpToolConcurrency(value) {
+    if (!Number.isFinite(value))
+        return DEFAULT_MCP_TOOL_CONCURRENCY;
+    return Math.max(1, Math.floor(value));
+}
+export function assertMcpToolTimeout(value) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > MAX_MCP_TOOL_TIMEOUT_MS) {
+        throw new RangeError(`mcpToolTimeoutMs must be a whole number from 0 through ${MAX_MCP_TOOL_TIMEOUT_MS}; 0 disables the deadline.`);
+    }
+    return value;
+}
+function createMcpToolOperationTracker() {
+    let accepting = true;
+    const operations = new Set();
+    return {
+        isAccepting: () => accepting,
+        track: (operation) => {
+            if (!accepting)
+                return undefined;
+            const tracked = operation();
+            operations.add(tracked);
+            void tracked.then(() => operations.delete(tracked), () => operations.delete(tracked));
+            return tracked;
+        },
+        stop: () => {
+            accepting = false;
+        },
+        drain: async () => {
+            accepting = false;
+            await Promise.allSettled([...operations]);
+        },
+    };
+}
+function createMcpToolConcurrencyTracker(maximum) {
+    return { inFlight: 0, maximum: normalizeMcpToolConcurrency(maximum) };
+}
+export function createCodegraphMcpProtocolServer(handlers, runtimeIdentity = captureCodegraphRuntimeIdentity(getCurrentNativeBindingOrigin()), installedVersion = createInstalledVersionChecker(runtimeIdentity), toolCallState = { firstToolCallPending: true }, maxConcurrentToolCalls = DEFAULT_MCP_TOOL_CONCURRENCY, mcpToolTimeoutMs = DEFAULT_MCP_TOOL_TIMEOUT_MS) {
+    return createCodegraphMcpProtocolServerWithTracker(handlers, runtimeIdentity, installedVersion, toolCallState, assertMcpToolTimeout(mcpToolTimeoutMs), createMcpToolOperationTracker(), createMcpToolConcurrencyTracker(maxConcurrentToolCalls));
+}
+export function createCodegraphMcpProtocolServerWithTracker(handlers, runtimeIdentity, installedVersion, toolCallState, mcpToolTimeoutMs, toolOperations, toolConcurrency) {
+    const server = new Server({
+        name: "codegraph",
+        version: runtimeIdentity.runningVersion,
+    }, {
+        capabilities: { tools: {}, logging: {} },
+    });
+    const activeToolCalls = new Map();
+    server.setNotificationHandler("notifications/cancelled", (notification) => {
+        const requestId = notification.params.requestId;
+        if (requestId !== undefined) {
+            activeToolCalls.get(requestId)?.abort(new Error("MCP tool call was cancelled."));
+        }
+    });
+    server.setRequestHandler("tools/list", () => ({ tools: listCodegraphMcpTools() }));
+    server.setRequestHandler("tools/call", async (request, ctx) => {
+        if (!toolOperations.isAccepting()) {
+            throw new Error("MCP server is shutting down.");
+        }
+        if (toolConcurrency.inFlight >= toolConcurrency.maximum) {
+            throw new Error("MCP tool execution is busy; retry shortly.");
+        }
+        toolConcurrency.inFlight += 1;
+        const isFirstToolCall = toolCallState.firstToolCallPending;
+        toolCallState.firstToolCallPending = false;
+        const progressToken = isFirstToolCall ? getToolCallProgressToken(request.params) : undefined;
+        const emitFirstToolCallVisibility = async (level, progress, message) => {
+            if (!isFirstToolCall)
+                return;
+            try {
+                await ctx.mcpReq.log(level, message, "codegraph");
+                if (progressToken !== undefined) {
+                    await ctx.mcpReq.notify({
+                        method: "notifications/progress",
+                        params: { progressToken, progress, total: 1, message },
+                    });
+                }
+            }
+            catch (error) {
+                console.error(`[codegraph] MCP cold-start visibility failed: ${errorMessage(error)}`);
+            }
+        };
+        await emitFirstToolCallVisibility("info", 0, `Codegraph is warming the first tool call for '${request.params.name}'.`);
+        try {
+            installedVersion.check();
+        }
+        catch (error) {
+            console.error(`[codegraph] installed-version check failed: ${errorMessage(error)}`);
+        }
+        try {
+            const toolCallAbort = createMcpToolAbortSignal([ctx.mcpReq.signal, getLegacyRequestAbortSignal()], request.params.name, mcpToolTimeoutMs);
+            activeToolCalls.set(ctx.mcpReq.id, toolCallAbort);
+            try {
+                const operation = toolOperations.track(() => callMcpTool(handlers, request.params.name, request.params.arguments ?? {}, toolCallAbort.signal));
+                if (operation === undefined) {
+                    toolConcurrency.inFlight -= 1;
+                    throw new Error("MCP server is shutting down.");
+                }
+                const releaseToolCall = () => {
+                    toolConcurrency.inFlight -= 1;
+                };
+                try {
+                    const result = await awaitMcpToolOperation(toolCallAbort.signal, operation, releaseToolCall);
+                    await emitFirstToolCallVisibility("info", 1, `Codegraph finished warming the first tool call for '${request.params.name}'.`);
+                    return toToolResult(result);
+                }
+                catch (error) {
+                    if (error instanceof ProtocolError || toolCallAbort.signal.aborted)
+                        throw error;
+                    return toToolErrorResult(error);
+                }
+            }
+            finally {
+                activeToolCalls.delete(ctx.mcpReq.id);
+                toolCallAbort.dispose();
+            }
+        }
+        catch (error) {
+            await emitFirstToolCallVisibility("error", 1, `Codegraph failed while warming the first tool call for '${request.params.name}'.`);
+            throw error;
+        }
+    });
+    return server;
+}
+export function createCodegraphMcpProtocolFactory(handlers, runtimeIdentity, maxConcurrentToolCalls = DEFAULT_MCP_TOOL_CONCURRENCY, mcpToolTimeoutMs = DEFAULT_MCP_TOOL_TIMEOUT_MS) {
+    const toolConcurrency = createMcpToolConcurrencyTracker(maxConcurrentToolCalls);
+    const installedVersion = createInstalledVersionChecker(runtimeIdentity);
+    const toolCallState = { firstToolCallPending: true };
+    const toolOperations = createMcpToolOperationTracker();
+    const timeout = assertMcpToolTimeout(mcpToolTimeoutMs);
+    return {
+        create: () => createCodegraphMcpProtocolServerWithTracker(handlers, runtimeIdentity, installedVersion, toolCallState, timeout, toolOperations, toolConcurrency),
+        stop: () => toolOperations.stop(),
+        drain: () => toolOperations.drain(),
+    };
+}
+export function createParseErrorReportingStdin(input, output) {
+    let pending = Buffer.alloc(0);
+    const processFrame = (rawFrame, stream) => {
+        const frame = rawFrame.at(-1) === 13 ? rawFrame.subarray(0, -1) : rawFrame;
+        if (!frame.length)
+            return;
+        if (frame.length > MAX_MCP_STDIO_FRAME_BYTES) {
+            return new Error("MCP stdio frame exceeded 10 MiB.");
+        }
+        try {
+            JSON.parse(frame.toString("utf8"));
+            stream.push(frame);
+            stream.push("\n");
+        }
+        catch {
+            output.write(`${JSON.stringify({
+                jsonrpc: "2.0",
+                id: null,
+                error: { code: ProtocolErrorCode.ParseError, message: "Parse error" },
+            })}\n`);
+        }
+    };
+    const filter = new Transform({
+        transform(chunk, _encoding, callback) {
+            pending = Buffer.concat([pending, chunk]);
+            let newline = pending.indexOf(10);
+            while (newline >= 0) {
+                const error = processFrame(pending.subarray(0, newline), this);
+                pending = pending.subarray(newline + 1);
+                if (error !== undefined) {
+                    callback(error);
+                    return;
+                }
+                newline = pending.indexOf(10);
+            }
+            if (pending.length > MAX_MCP_STDIO_FRAME_BYTES) {
+                callback(new Error("MCP stdio frame exceeded 10 MiB."));
+                return;
+            }
+            callback();
+        },
+        flush(callback) {
+            const error = processFrame(pending, this);
+            pending = Buffer.alloc(0);
+            callback(error);
+        },
+    });
+    input.pipe(filter);
+    return filter;
+}
+function createMcpToolAbortSignal(requestSignals, toolName, timeoutMs) {
+    const controller = new AbortController();
+    const listeners = [];
+    for (const requestSignal of requestSignals) {
+        if (requestSignal === undefined)
+            continue;
+        const onAbort = () => {
+            controller.abort(requestSignal.reason);
+        };
+        listeners.push({ signal: requestSignal, onAbort });
+        if (requestSignal.aborted)
+            onAbort();
+        else
+            requestSignal.addEventListener("abort", onAbort, { once: true });
+    }
+    const timeout = timeoutMs > 0
+        ? setTimeout(() => {
+            controller.abort(new Error(`MCP tool '${toolName}' exceeded the configured deadline of ${timeoutMs} ms.`));
+        }, timeoutMs)
+        : undefined;
+    timeout?.unref?.();
+    return {
+        signal: controller.signal,
+        abort: (reason) => controller.abort(reason),
+        dispose: () => {
+            clearTimeout(timeout);
+            for (const listener of listeners)
+                listener.signal.removeEventListener("abort", listener.onAbort);
+        },
+    };
+}
+export function awaitMcpToolOperation(signal, operation, onSettled) {
+    void operation.then(onSettled, onSettled);
+    return withAbortSignal(signal, operation);
+}
+function withAbortSignal(signal, operation) {
+    if (!signal)
+        return operation;
+    const cancellationError = () => {
+        const reason = signal.reason;
+        if (reason instanceof Error && reason.name !== "AbortError")
+            return reason;
+        return new Error("MCP tool call was cancelled.");
+    };
+    if (signal.aborted)
+        return Promise.reject(cancellationError());
+    const cancellation = Promise.withResolvers();
+    const onAbort = () => cancellation.reject(cancellationError());
+    signal.addEventListener("abort", onAbort, { once: true });
+    return Promise.race([operation, cancellation.promise]).finally(() => signal.removeEventListener("abort", onAbort));
+}
+export async function callMcpTool(handlers, name, input, signal) {
+    const tool = MCP_TOOL_REGISTRY.find((entry) => entry.name === name);
+    if (!tool)
+        throw new ProtocolError(ProtocolErrorCode.MethodNotFound, `Unknown MCP tool: ${name}`);
+    switch (tool.dispatch.handler) {
+        case "search":
+            return await handlers.search(parseMcpToolInput(searchSchema, input, name), signal);
+        case "workspace_symbols":
+            return await handlers.workspace_symbols(parseMcpToolInput(workspaceSymbolsSchema, input, name), signal);
+        case "rename_preview":
+            return await handlers.rename_preview(parseMcpToolInput(renamePreviewSchema, input, name), signal);
+        case "refactor_plan":
+            return await handlers.refactor_plan(parseMcpToolInput(refactorPlanSchema, input, name), signal);
+        case "calls":
+            if (tool.dispatch.direction) {
+                return await handlers.calls({ ...parseMcpToolInput(callHierarchySchema, input, name), direction: tool.dispatch.direction }, signal);
+            }
+            return await handlers.calls(parseMcpToolInput(callsSchema, input, name), signal);
+        case "type_hierarchy":
+            if (tool.dispatch.direction) {
+                return await handlers.type_hierarchy({ ...parseMcpToolInput(typeHierarchySchema, input, name), direction: tool.dispatch.direction }, signal);
+            }
+            return await handlers.type_hierarchy(parseMcpToolInput(typeHierarchyUnifiedSchema, input, name), signal);
+        case "implementations":
+            return await handlers.implementations(parseMcpToolInput(implementationsSchema, input, name), signal);
+        case "explore":
+            return await handlers.explore(parseMcpToolInput(exploreSchema, input, name), signal);
+        case "orient":
+            return await handlers.orient(parseMcpToolInput(orientSchema, input, name), signal);
+        case "packet_get":
+            return await handlers.packet_get(parseMcpToolInput(packetGetSchema, input, name), signal);
+        case "get_file":
+            return await handlers.get_file(parseMcpToolInput(getFileSchema, input, name), signal);
+        case "get_symbol":
+            return await handlers.get_symbol(parseMcpToolInput(handleSchema, input, name), signal);
+        case "goto":
+            return await callGotoTool(handlers, input, signal);
+        case "refs":
+            return await callRefsTool(handlers, input, signal);
+        case "file_deps":
+            if (tool.dispatch.direction) {
+                return await handlers.file_deps({ ...parseMcpToolInput(fileGraphSchema, input, name), direction: tool.dispatch.direction }, signal);
+            }
+            return await handlers.file_deps(parseMcpToolInput(fileDepsUnifiedSchema, input, name), signal);
+        case "path":
+            return await handlers.path(parseMcpToolInput(pathSchema, input, name), signal);
+        case "impact":
+            return await handlers.impact(parseMcpToolInput(gitRangeSchema, input, name), signal);
+        case "review":
+            return await handlers.review(parseMcpToolInput(reviewSchema, input, name), signal);
+        case "query_sqlite":
+            return await handlers.query_sqlite(parseMcpToolInput(querySqliteSchema, input, name), {
+                ...(signal ? { signal } : {}),
+            });
+        case "refresh_index":
+            return await handlers.refresh_index(parseMcpToolInput(refreshIndexSchema, input, name), signal);
+        case "artifact_build":
+            return await handlers.artifact_build(parseMcpToolInput(artifactBuildSchema, input, name), signal);
+    }
+}
+async function callGotoTool(handlers, input, signal) {
+    const request = parseMcpToolInput(navigationSchema, input, "goto");
+    if (request.handle !== undefined)
+        return await handlers.goto({ handle: request.handle }, signal);
+    if (request.file === undefined || request.line === undefined || request.column === undefined) {
+        throw new ProtocolError(ProtocolErrorCode.InvalidParams, "goto requires either handle or file, line, and column.");
+    }
+    return await handlers.goto({ file: request.file, line: request.line, column: request.column }, signal);
+}
+async function callRefsTool(handlers, input, signal) {
+    const request = parseMcpToolInput(refsSchema, input, "refs");
+    if (request.handle !== undefined) {
+        return await handlers.refs({ handle: request.handle, ...(request.limit !== undefined ? { limit: request.limit } : {}) }, signal);
+    }
+    if (request.file === undefined || request.line === undefined || request.column === undefined) {
+        throw new ProtocolError(ProtocolErrorCode.InvalidParams, "refs requires either handle or file, line, and column.");
+    }
+    return await handlers.refs({
+        file: request.file,
+        line: request.line,
+        column: request.column,
+        ...(request.limit !== undefined ? { limit: request.limit } : {}),
+    }, signal);
+}
+function toToolResult(value) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(value, null, 2),
+            },
+        ],
+    };
+}
+function toToolErrorResult(error) {
+    const message = errorMessage(error).replace(/(?:[A-Za-z]:)?[/\\][^'"\n]*?(?=(?:[/\\][^'"\n]*)?['"]|$)/g, "<path>");
+    return { isError: true, content: [{ type: "text", text: message }] };
+}
+const mcpProgressTokenSchema = z.union([z.string(), z.number()]);
+const toolCallMetaSchema = z
+    .object({
+    _meta: z.object({ progressToken: mcpProgressTokenSchema.optional() }).passthrough().optional(),
+    progressToken: mcpProgressTokenSchema.optional(),
+})
+    .passthrough();
+function getToolCallProgressToken(params) {
+    const parsed = toolCallMetaSchema.safeParse(params);
+    if (!parsed.success)
+        return undefined;
+    return parsed.data._meta?.progressToken ?? parsed.data.progressToken;
+}
+function formatMcpInvalidParams(toolName, error) {
+    const details = error.issues
+        .map((issue) => {
+        const path = issue.path.length ? issue.path.join(".") : "(root)";
+        return `${path}: ${issue.message}`;
+    })
+        .join("; ");
+    return `Invalid parameters for ${toolName}: ${details}`;
+}
+function parseMcpToolInput(schema, input, toolName) {
+    const parsed = schema.safeParse(input);
+    if (parsed.success)
+        return parsed.data;
+    throw new ProtocolError(ProtocolErrorCode.InvalidParams, formatMcpInvalidParams(toolName, parsed.error));
+}
+const searchSchema = z
+    .object({
+    query: z.string(),
+    mode: z.enum(["hybrid", "symbol", "path", "text", "graph", "sql"]).optional(),
+    from: z.string().optional(),
+    depth: z.number().int().nonnegative().max(MAX_GRAPH_DEPTH).optional(),
+    limit: z.number().int().nonnegative().optional(),
+})
+    .strict();
+const workspaceSymbolsSchema = z
+    .object({
+    query: z.string(),
+    kinds: z.array(z.nativeEnum(SymbolKind)).optional(),
+    exportedOnly: z.boolean().optional(),
+    includeImports: z.boolean().optional(),
+    fileGlob: z.string().optional(),
+    limit: z.number().int().nonnegative().max(MAX_WORKSPACE_SYMBOL_LIMIT).optional(),
+})
+    .strict();
+const renamePreviewSchema = z
+    .object({
+    handle: z.string(),
+    newName: z.string(),
+    includeComments: z.boolean().optional(),
+    includeStrings: z.boolean().optional(),
+    includeFilenames: z.boolean().optional(),
+    maxEdits: z.number().int().min(1).max(MAX_RENAME_PREVIEW_EDITS).optional(),
+})
+    .strict();
+const refactorPlanSchema = z
+    .object({
+    handle: z.string(),
+    renameTo: z.string().optional(),
+    maxReferences: z.number().int().nonnegative().max(MAX_REFACTOR_PLAN_LIMIT).optional(),
+    maxCallers: z.number().int().nonnegative().max(MAX_REFACTOR_PLAN_LIMIT).optional(),
+    maxHierarchy: z.number().int().nonnegative().max(MAX_REFACTOR_PLAN_LIMIT).optional(),
+    includeSource: z.boolean().optional(),
+})
+    .strict();
+const callHierarchySchema = z
+    .object({
+    handle: z.string(),
+    depth: z.number().int().min(1).max(5).optional(),
+    limit: z.number().int().nonnegative().max(500).optional(),
+    includeHeuristic: z.boolean().optional(),
+})
+    .strict();
+const callsSchema = callHierarchySchema
+    .extend({
+    direction: z.enum(["callers", "callees"]),
+})
+    .strict();
+const typeHierarchySchema = z
+    .object({
+    handle: z.string(),
+    depth: z.number().int().min(1).max(10).optional(),
+    limit: z.number().int().nonnegative().max(500).optional(),
+})
+    .strict();
+const typeHierarchyUnifiedSchema = typeHierarchySchema
+    .extend({
+    direction: z.enum(["supertypes", "subtypes"]),
+})
+    .strict();
+const implementationsSchema = z
+    .object({
+    handle: z.string(),
+    limit: z.number().int().nonnegative().max(500).optional(),
+})
+    .strict();
+const exploreSchema = z
+    .object({
+    query: z.string(),
+    limit: z.number().int().nonnegative().max(50).optional(),
+    maxPackets: z.number().int().nonnegative().max(10).optional(),
+    maxPaths: z.number().int().nonnegative().max(10).optional(),
+    includeSource: z.boolean().optional(),
+})
+    .strict();
+const orientSchema = z
+    .object({
+    includeRoots: z.array(z.string()).optional(),
+    budget: z.enum(["small", "medium", "large"]).optional(),
+})
+    .strict();
+const packetGetSchema = z
+    .object({
+    target: z.string(),
+    maxSymbols: z.number().int().positive().max(200).optional(),
+    maxSnippets: z.number().int().positive().max(50).optional(),
+    maxDuplicates: z.number().int().positive().max(20).optional(),
+})
+    .strict();
+const getFileSchema = z
+    .object({
+    file: z.string(),
+    offset: z.number().int().positive().optional(),
+    limit: z.number().int().positive().max(MAX_FILE_VIEW_LINES).optional(),
+    maxBytes: z.number().int().positive().max(MAX_FILE_VIEW_BYTES).optional(),
+    includeGraphContext: z.boolean().optional(),
+    allowSensitive: z.boolean().optional(),
+})
+    .strict();
+const handleSchema = z
+    .object({
+    handle: z.string(),
+})
+    .strict();
+const navigationSchema = z
+    .object({
+    handle: z.string().optional(),
+    file: z.string().optional(),
+    line: z.number().int().positive().optional(),
+    column: z.number().int().nonnegative().optional(),
+})
+    .strict()
+    .refine((request) => {
+    const hasHandle = request.handle !== undefined;
+    const hasAnyPosition = request.file !== undefined || request.line !== undefined || request.column !== undefined;
+    const hasCompletePosition = request.file !== undefined && request.line !== undefined && request.column !== undefined;
+    return hasHandle ? !hasAnyPosition : hasCompletePosition;
+}, { message: "goto requires either handle or file, line, and column." });
+const refsSchema = z
+    .object({
+    handle: z.string().optional(),
+    file: z.string().optional(),
+    line: z.number().int().positive().optional(),
+    column: z.number().int().nonnegative().optional(),
+    limit: z.number().int().nonnegative().optional(),
+})
+    .strict()
+    .refine((request) => {
+    const hasHandle = request.handle !== undefined;
+    const hasAnyPosition = request.file !== undefined || request.line !== undefined || request.column !== undefined;
+    const hasCompletePosition = request.file !== undefined && request.line !== undefined && request.column !== undefined;
+    return hasHandle ? !hasAnyPosition : hasCompletePosition;
+}, {
+    message: "refs requires either handle or file, line, and column.",
+});
+const fileGraphSchema = z
+    .object({
+    file: z.string(),
+    depth: z.number().int().nonnegative().optional(),
+    limit: z.number().int().nonnegative().optional(),
+})
+    .strict();
+const fileDepsUnifiedSchema = fileGraphSchema
+    .extend({
+    direction: z.enum(["deps", "rdeps"]),
+})
+    .strict();
+const pathSchema = z
+    .object({
+    from: z.string(),
+    to: z.string(),
+})
+    .strict();
+const gitRangeSchema = z
+    .object({
+    base: z.string(),
+    head: z.string(),
+})
+    .strict();
+const reviewSchema = z
+    .object({
+    base: z.string(),
+    head: z.string(),
+    reviewDepth: z.enum(["minimal", "standard", "deep"]).optional(),
+})
+    .strict();
+const querySqliteSchema = z
+    .object({
+    query: z.string(),
+    params: z.array(z.union([z.string(), z.number(), z.null()])).optional(),
+    limit: z.number().int().nonnegative().optional(),
+})
+    .strict();
+const refreshIndexSchema = z
+    .object({
+    warmup: z.enum(["off", "base", "symbols"]).optional(),
+})
+    .strict();
+const artifactBuildSchema = z
+    .object({
+    outDir: z.string().optional(),
+    sqlite: z.boolean().optional(),
+    graphJson: z.boolean().optional(),
+    report: z.boolean().optional(),
+    questions: z.boolean().optional(),
+    force: z.boolean().optional(),
+})
+    .strict();
+export function createCodegraphMcpStdioTransport(input, output) {
+    return new StdioServerTransport(createParseErrorReportingStdin(input, output), output, {
+        maxBufferSize: MAX_MCP_STDIO_FRAME_BYTES,
+    });
+}
+//# sourceMappingURL=protocol.js.map