lazycodex-ai 5.0.0-beta.9 → 5.0.0

package/packages/omo-codex/plugin/components/codegraph/src/mcp-bridge.ts

@@ -1,309 +0,0 @@
-import { spawn, type ChildProcess } from "node:child_process";
-import type { Readable, Writable } from "node:stream";
-
-import {
-	createParentWatchdog,
-	errorResponse,
-	isPlainRecord,
-	jsonRpcId,
-	readStdioJsonRpcMessages,
-	writeStdioJsonRpcResponse,
-	type StdioJsonRpcResponseMode,
-} from "../../../../../mcp-stdio-core/src/index.ts";
-import type { CodegraphServeProcessOptions } from "./serve.js";
-import { resolveServeProcessInvocation } from "./serve-invocation.js";
-
-class CodegraphBridgeStdioError extends Error {
-	override readonly name = "CodegraphBridgeStdioError";
-
-	constructor(readonly streamName: string) {
-		super(`CodeGraph MCP bridge missing child ${streamName}`);
-	}
-}
-
-interface PendingClientResponse {
-	readonly method: string | null;
-	readonly responseMode: StdioJsonRpcResponseMode;
-	readonly toolName: string | null;
-}
-
-const CODEGRAPH_NODE_DESCRIPTION =
-	"Inspect one named symbol or file. In symbol mode, includeCode=true includes leaf-symbol source when available. Container symbols such as classes, interfaces, structs, enums, modules, and namespaces return structural outlines with member lists by design. For container source, request a specific member symbol or use file mode with symbolsOnly=false plus offset/limit.";
-
-const CODEGRAPH_NODE_INCLUDE_CODE_DESCRIPTION =
-	"Symbol mode: include leaf-symbol source when available. Container symbols such as classes, interfaces, structs, enums, modules, and namespaces intentionally return structural outlines with members; request a specific member symbol or use file mode with symbolsOnly=false plus offset/limit for source.";
-
-const CODEGRAPH_CONTAINER_OUTLINE_GUIDANCE =
-	"Container symbols intentionally return structural outlines with members. For source, request a specific member symbol or call codegraph_node in file mode with symbolsOnly=false plus offset/limit around the symbol location.";
-
-const SIGKILL_ESCALATION_MS = 2_000;
-
-export async function runBridgedCodegraphProcess(
-	command: string,
-	args: readonly string[],
-	options: CodegraphServeProcessOptions,
-): Promise<number> {
-	const invocation = resolveServeProcessInvocation(command, args);
-	const child = spawn(invocation.command, invocation.args, {
-		cwd: options.cwd,
-		env: options.env,
-		stdio: ["pipe", "pipe", "inherit"],
-	});
-	const childInput = child.stdin;
-	const childOutput = child.stdout;
-	if (childInput === null) throw new CodegraphBridgeStdioError("stdin");
-	if (childOutput === null) throw new CodegraphBridgeStdioError("stdout");
-
-	const pendingResponses = new Map<string, PendingClientResponse>();
-	let defaultResponseMode: StdioJsonRpcResponseMode = "framed";
-	const childExit = new Promise<number>((resolveExit, reject) => {
-		child.once("error", reject);
-		child.once("exit", (code, signal) => {
-			if (code !== null) {
-				resolveExit(code);
-				return;
-			}
-			resolveExit(signal === null ? 0 : 1);
-		});
-	});
-	const destroyChildPipes = (): void => {
-		childInput.destroy();
-		childOutput.destroy();
-	};
-	void childExit.then(destroyChildPipes, destroyChildPipes);
-	// Parent-liveness watchdog: when the parent dies while holding our stdio
-	// open, the client stream never sees EOF, so the only settle path is to
-	// drop the client input, close the child pipes, and terminate the child.
-	// The bridge then resolves through the normal child-exit path, and the
-	// destroyed input releases its read handle so the process can actually
-	// exit (same teardown pattern as runJsonRpcStdioServer's own watchdog).
-	// In daemon mode the child is the upstream lightweight proxy, so killing
-	// it on parent death is correct; the detached daemon is a separate process
-	// and is never touched.
-	let parentWatchdogFired = false;
-	const parentWatchdog = createParentWatchdog(options.parentWatchdog, () => {
-		parentWatchdogFired = true;
-		options.input.destroy();
-		destroyChildPipes();
-		terminateCodegraphChild(child);
-	});
-	const clientForwardingDone = forwardClientToCodegraph(
-		options.input,
-		childInput,
-		pendingResponses,
-		(mode) => {
-			defaultResponseMode = mode;
-		},
-		() => parentWatchdogFired,
-	);
-	const responseForwardingDone = forwardCodegraphToClient(
-		childOutput,
-		options.output,
-		pendingResponses,
-		() => defaultResponseMode,
-		() => parentWatchdogFired,
-	);
-	const bridgeDone = Promise.all([clientForwardingDone, responseForwardingDone]);
-	const childAndResponsesDone = Promise.all([childExit, responseForwardingDone]).then(([exitCode]) => exitCode);
-	try {
-		return await Promise.race([childAndResponsesDone, bridgeDone.then(() => childExit)]);
-	} catch (error) {
-		destroyChildPipes();
-		if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
-		await childExit.catch(() => undefined);
-		throw error;
-	} finally {
-		parentWatchdog.clear();
-	}
-}
-
-function terminateCodegraphChild(child: ChildProcess): void {
-	if (child.exitCode !== null || child.signalCode !== null) return;
-	child.kill("SIGTERM");
-	const escalation = setTimeout(() => {
-		if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
-	}, SIGKILL_ESCALATION_MS);
-	escalation.unref();
-}
-
-// Stream errors raised by the watchdog's own teardown (input destroy, child
-// pipe destroy) while a forwarder is parked on that stream.
-function isWatchdogTeardownError(error: unknown): boolean {
-	if (!(error instanceof Error) || !("code" in error)) return false;
-	return (
-		error.code === "ERR_STREAM_PREMATURE_CLOSE" ||
-		error.code === "ERR_STREAM_DESTROYED" ||
-		error.code === "ERR_STREAM_WRITE_AFTER_END" ||
-		error.code === "EPIPE"
-	);
-}
-
-async function forwardClientToCodegraph(
-	input: Readable,
-	childInput: Writable,
-	pendingResponses: Map<string, PendingClientResponse>,
-	setDefaultResponseMode: (mode: StdioJsonRpcResponseMode) => void,
-	tolerateWatchdogClose: () => boolean,
-): Promise<void> {
-	try {
-		for await (const message of readStdioJsonRpcMessages(input)) {
-			if (message.kind === "parse_error") {
-				continue;
-			}
-			const responseMode = message.responseMode;
-			setDefaultResponseMode(responseMode);
-			const key = responseModeKey(message.payload);
-			if (key !== null) {
-				pendingResponses.set(key, {
-					method: jsonRpcMethod(message.payload),
-					responseMode,
-					toolName: jsonRpcToolName(message.payload),
-				});
-			}
-			await writeLine(childInput, JSON.stringify(message.payload));
-		}
-		childInput.end();
-	} catch (error) {
-		// The parent watchdog destroys the client input and child pipes while
-		// this forwarder is parked on a read or write; that teardown is
-		// self-inflicted, so settle quietly and let the child-exit path report
-		// the outcome.
-		if (!(tolerateWatchdogClose() && isWatchdogTeardownError(error))) throw error;
-	}
-}
-
-async function forwardCodegraphToClient(
-	childOutput: Readable,
-	output: Writable,
-	pendingResponses: Map<string, PendingClientResponse>,
-	defaultResponseMode: () => StdioJsonRpcResponseMode,
-	tolerateWatchdogClose: () => boolean,
-): Promise<void> {
-	try {
-		for await (const message of readStdioJsonRpcMessages(childOutput)) {
-			if (message.kind === "parse_error") {
-				await writeStdioJsonRpcResponse(output, errorResponse(null, -32700, "Parse error", message.message), defaultResponseMode());
-				continue;
-			}
-			const key = responseModeKey(message.payload);
-			const pendingResponse = key === null ? undefined : pendingResponses.get(key);
-			const responseMode = pendingResponse?.responseMode ?? defaultResponseMode();
-			if (key !== null) pendingResponses.delete(key);
-			await writeStdioJsonRpcResponse(output, clarifyCodegraphResponse(message.payload, pendingResponse), responseMode);
-		}
-	} catch (error) {
-		// The parent watchdog destroys the child pipes while this forwarder is
-		// parked on a read; that close is self-inflicted, so settle quietly and
-		// let the child-exit path report the outcome.
-		if (!(tolerateWatchdogClose() && isWatchdogTeardownError(error))) throw error;
-	}
-}
-
-function responseModeKey(payload: unknown): string | null {
-	if (!isPlainRecord(payload) || !("id" in payload)) return null;
-	const id = jsonRpcId(payload["id"]);
-	return `${typeof id}:${String(id)}`;
-}
-
-function jsonRpcMethod(payload: unknown): string | null {
-	if (!isPlainRecord(payload)) return null;
-	const method = payload["method"];
-	return typeof method === "string" ? method : null;
-}
-
-function jsonRpcToolName(payload: unknown): string | null {
-	if (jsonRpcMethod(payload) !== "tools/call" || !isPlainRecord(payload)) return null;
-	const params = payload["params"];
-	if (!isPlainRecord(params)) return null;
-	const name = params["name"];
-	return typeof name === "string" ? name : null;
-}
-
-function clarifyCodegraphResponse(payload: unknown, pendingResponse: PendingClientResponse | undefined): unknown {
-	if (pendingResponse?.method === "tools/list") return clarifyCodegraphToolsList(payload);
-	if (pendingResponse?.method === "tools/call" && pendingResponse.toolName === "codegraph_node") {
-		return clarifyCodegraphNodeCallResult(payload);
-	}
-	return payload;
-}
-
-function clarifyCodegraphToolsList(payload: unknown): unknown {
-	if (!isPlainRecord(payload)) return payload;
-	const result = payload["result"];
-	if (!isPlainRecord(result) || !Array.isArray(result["tools"])) return payload;
-
-	let changed = false;
-	const tools = result["tools"].map((tool) => {
-		if (!isPlainRecord(tool) || tool["name"] !== "codegraph_node") return tool;
-		if (!hasCodegraphNodeContractMetadata(tool)) return tool;
-		changed = true;
-		return clarifyCodegraphNodeTool(tool);
-	});
-	if (!changed) return payload;
-	return { ...payload, result: { ...result, tools } };
-}
-
-function clarifyCodegraphNodeTool(tool: Record<string, unknown>): Record<string, unknown> {
-	const clarified: Record<string, unknown> = {
-		...tool,
-		description: CODEGRAPH_NODE_DESCRIPTION,
-	};
-	const inputSchema = tool["inputSchema"];
-	if (isPlainRecord(inputSchema)) clarified["inputSchema"] = clarifyCodegraphNodeInputSchema(inputSchema);
-	return clarified;
-}
-
-function hasCodegraphNodeContractMetadata(tool: Record<string, unknown>): boolean {
-	if (typeof tool["description"] === "string") return true;
-	const inputSchema = tool["inputSchema"];
-	if (!isPlainRecord(inputSchema)) return false;
-	const properties = inputSchema["properties"];
-	return isPlainRecord(properties) && isPlainRecord(properties["includeCode"]);
-}
-
-function clarifyCodegraphNodeInputSchema(inputSchema: Record<string, unknown>): Record<string, unknown> {
-	const properties = inputSchema["properties"];
-	if (!isPlainRecord(properties)) return inputSchema;
-	const includeCode = properties["includeCode"];
-	if (!isPlainRecord(includeCode)) return inputSchema;
-	return {
-		...inputSchema,
-		properties: {
-			...properties,
-			includeCode: {
-				...includeCode,
-				description: CODEGRAPH_NODE_INCLUDE_CODE_DESCRIPTION,
-			},
-		},
-	};
-}
-
-function clarifyCodegraphNodeCallResult(payload: unknown): unknown {
-	if (!isPlainRecord(payload)) return payload;
-	const result = payload["result"];
-	if (!isPlainRecord(result) || !Array.isArray(result["content"])) return payload;
-
-	let changed = false;
-	const content = result["content"].map((item) => {
-		if (!isPlainRecord(item) || item["type"] !== "text" || typeof item["text"] !== "string") return item;
-		const text = clarifyContainerOutlineGuidance(item["text"]);
-		if (text === item["text"]) return item;
-		changed = true;
-		return { ...item, text };
-	});
-	if (!changed) return payload;
-	return { ...payload, result: { ...result, content } };
-}
-
-function clarifyContainerOutlineGuidance(text: string): string {
-	if (!text.includes("Structural outline only")) return text;
-	return text.replace(/Structural outline only[^\n]*(?:\n[^\n]*(?:Read|read)[^\n]*)?/g, CODEGRAPH_CONTAINER_OUTLINE_GUIDANCE);
-}
-
-async function writeLine(output: Writable, line: string): Promise<void> {
-	if (output.write(`${line}\n`)) return;
-	await new Promise<void>((resolveDrain, reject) => {
-		output.once("drain", resolveDrain);
-		output.once("error", reject);
-	});
-}

package/packages/omo-codex/plugin/components/codegraph/src/mcp-unavailable.ts

@@ -1,80 +0,0 @@
-import type { Readable, Writable } from "node:stream";
-
-import {
-	errorResponse,
-	isPlainRecord,
-	jsonRpcId,
-	runJsonRpcStdioServer,
-	successResponse,
-	type JsonRpcResponse,
-	type ParentWatchdogConfig,
-} from "../../../../../mcp-stdio-core/src/index.ts";
-
-export interface UnavailableCodegraphMcpOptions {
-	readonly input: Readable;
-	readonly output: Writable;
-	readonly reason: string;
-	readonly serverVersion: string;
-	// Test seam: production callers leave this unset so the watchdog uses its
-	// defaults (parentPid = process.ppid, 30s poll).
-	readonly parentWatchdog?: ParentWatchdogConfig;
-}
-
-interface UnavailableCodegraphMcpHandlerOptions {
-	readonly reason: string;
-	readonly serverVersion: string;
-}
-
-export async function runUnavailableCodegraphMcpServer(
-	options: UnavailableCodegraphMcpOptions,
-): Promise<void> {
-	await runJsonRpcStdioServer({
-		handler: handleUnavailableCodegraphMcpRequest,
-		handlerOptions: {
-			reason: options.reason.trim(),
-			serverVersion: options.serverVersion,
-		},
-		input: options.input,
-		output: options.output,
-		parentWatchdog: options.parentWatchdog ?? {},
-	});
-}
-
-async function handleUnavailableCodegraphMcpRequest(
-	input: unknown,
-	options: UnavailableCodegraphMcpHandlerOptions,
-): Promise<JsonRpcResponse | undefined> {
-	if (!isPlainRecord(input)) {
-		return errorResponse(null, -32600, "Invalid Request");
-	}
-
-	const id = jsonRpcId(input["id"]);
-	const method = input["method"];
-	if (method === "notifications/initialized") return undefined;
-	if (method === "ping") return successResponse(id, {});
-	if (method === "initialize") {
-		return successResponse(id, {
-			capabilities: { tools: { listChanged: false } },
-			protocolVersion: requestedProtocolVersion(input["params"]),
-			serverInfo: { name: "codegraph", version: options.serverVersion },
-		});
-	}
-
-	if (method === "tools/list") {
-		return successResponse(id, { tools: [] });
-	}
-
-	if (method === "tools/call") {
-		return successResponse(id, {
-			content: [{ text: options.reason, type: "text" }],
-			isError: true,
-		});
-	}
-
-	return errorResponse(id, -32601, `Method not found: ${String(method)}`);
-}
-
-function requestedProtocolVersion(params: unknown): string {
-	if (!isPlainRecord(params) || typeof params["protocolVersion"] !== "string") return "2024-11-05";
-	return params["protocolVersion"];
-}

package/packages/omo-codex/plugin/components/codegraph/src/post-tool-use-hook.ts

@@ -1,34 +0,0 @@
-import { env as processEnv, stdin as processStdin, stdout as processStdout } from "node:process";
-
-import { buildCodegraphInitGuidanceForToolResult } from "../../../../../utils/src/codegraph/guidance.ts";
-import { isRecord, readHookInput, resolveHomeDir } from "./hook-input.js";
-import type { PostToolUseHookOptions, PostToolUseHookResult } from "./hook-types.js";
-
-export async function runCodegraphPostToolUseHookCli(options: PostToolUseHookOptions = {}): Promise<number> {
-	return (await executeCodegraphPostToolUseHook(options)).exitCode;
-}
-
-export async function executeCodegraphPostToolUseHook(options: PostToolUseHookOptions = {}): Promise<PostToolUseHookResult> {
-	const env = options.env ?? processEnv;
-	const input = await readHookInput(options.stdin ?? processStdin);
-	const output = runCodegraphPostToolUseHook(input, { homeDir: resolveHomeDir(env) });
-	if (output.length === 0) return { action: "skipped", exitCode: 0 };
-
-	(options.stdout ?? processStdout).write(output);
-	return { action: "emitted-guidance", exitCode: 0 };
-}
-
-export function runCodegraphPostToolUseHook(input: unknown, options: { readonly homeDir?: string } = {}): string {
-	const toolName = isRecord(input) ? input["tool_name"] : undefined;
-	const cwd = isRecord(input) ? input["cwd"] : undefined;
-	const toolOutput = isRecord(input) ? (input["tool_response"] ?? input["tool_output"] ?? input["response"]) : input;
-	const guidance = buildCodegraphInitGuidanceForToolResult({ cwd, toolName, toolOutput }, options);
-	if (guidance === null) return "";
-
-	return `${JSON.stringify({
-		hookSpecificOutput: {
-			hookEventName: "PostToolUse",
-			additionalContext: guidance,
-		},
-	})}\n`;
-}

package/packages/omo-codex/plugin/components/codegraph/src/serve-invocation.ts

@@ -1,29 +0,0 @@
-import { extname } from "node:path";
-import { execPath as processExecPath } from "node:process";
-
-export interface ServeProcessInvocation {
-	readonly args: readonly string[];
-	readonly command: string;
-}
-
-const WINDOWS_CMD_EXTENSIONS = new Set([".bat", ".cmd"]);
-const WINDOWS_NODE_SCRIPT_EXTENSIONS = new Set([".cjs", ".js", ".mjs"]);
-
-export function resolveServeProcessInvocation(
-	command: string,
-	args: readonly string[],
-	platform: NodeJS.Platform = process.platform,
-): ServeProcessInvocation {
-	if (platform !== "win32") return { args: [...args], command };
-
-	const extension = extname(command).toLowerCase();
-	if (WINDOWS_NODE_SCRIPT_EXTENSIONS.has(extension)) {
-		return { args: [command, ...args], command: processExecPath };
-	}
-
-	if (WINDOWS_CMD_EXTENSIONS.has(extension)) {
-		return { args: ["/d", "/s", "/c", command, ...args], command: "cmd.exe" };
-	}
-
-	return { args: [...args], command };
-}