oh-my-opencode 4.12.0 → 4.13.0

package/packages/omo-codex/plugin/components/codegraph/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sisyphuslabs/codex-codegraph",
-	"version": "4.12.0",
+	"version": "4.13.0",
 	"description": "Codex plugin MCP wrapper for CodeGraph.",
 	"type": "module",
 	"private": true,
@@ -8,10 +8,13 @@
 		"omo-codegraph": "./dist/cli.js"
 	},
 	"files": [
-		"dist"
+		"dist",
+		"LICENSE",
+		"NODE-RUNTIME-LICENSES.md",
+		"NOTICE"
 	],
 	"scripts": {
-		"build": "bun build src/serve.ts --target node --format esm --outfile dist/serve.js && bun build src/cli.ts --target node --format esm --outfile dist/cli.js",
+		"build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && bun build src/serve.ts --target node --format esm --outfile dist/serve.js && bun build src/cli.ts --target node --format esm --outfile dist/cli.js",
 		"test": "bun test test/*.test.ts",
 		"typecheck": "tsc --noEmit"
 	},
@@ -21,6 +24,9 @@
 		"bun-types": "^1.3.1",
 		"typescript": "^6.0.3"
 	},
+	"optionalDependencies": {
+		"@colbymchenry/codegraph": "1.0.1"
+	},
 	"engines": {
 		"node": ">=20.0.0"
 	}

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

@@ -5,8 +5,10 @@ import { stderr as processStderr } from "node:process";
 import { fileURLToPath } from "node:url";
 
 import {
+	runCodegraphPostToolUseHookCli,
 	runCodegraphSessionStartHook,
 	runCodegraphSessionStartWorker,
+	type PostToolUseHookOptions,
 	type SessionStartHookOptions,
 	type SessionStartWorkerOptions,
 } from "./hook.js";
@@ -25,6 +27,15 @@ export async function runCodegraphCli(options: RunCodegraphCliOptions = {}): Pro
 		return runCodegraphSessionStartHook(options);
 	}
 
+	if (command === "hook" && subcommand === "post-tool-use") {
+		const hookOptions: PostToolUseHookOptions = {
+			...(options.env === undefined ? {} : { env: options.env }),
+			...(options.stdin === undefined ? {} : { stdin: options.stdin }),
+			...(options.stdout === undefined ? {} : { stdout: options.stdout }),
+		};
+		return runCodegraphPostToolUseHookCli(hookOptions);
+	}
+
 	if (command === "hook" && subcommand === "session-start-worker") {
 		const workerOptions: SessionStartWorkerOptions = {
 			...options.workerOptions,

package/packages/omo-codex/plugin/components/codegraph/src/hook-types.ts

@@ -10,6 +10,7 @@ import type { CodegraphWorkspacePreparation as SharedCodegraphWorkspacePreparati
 import type { CodegraphConfig as SharedCodegraphConfig } from "../../../../../utils/src/omo-config.ts";
 
 export type SessionStartAction = "skipped-disabled" | "spawned";
+export type PostToolUseAction = "emitted-guidance" | "skipped";
 export type WorkerAction = "failed" | "initialized" | "skipped-disabled" | "skipped-status" | "skipped-unavailable" | "skipped-unsupported-node" | "synced";
 
 export interface WorkerSpawnInvocation {
@@ -27,6 +28,11 @@ export interface SessionStartHookResult {
 	readonly exitCode: 0;
 }
 
+export interface PostToolUseHookResult {
+	readonly action: PostToolUseAction;
+	readonly exitCode: 0;
+}
+
 export interface CodegraphCommandResult {
 	readonly exitCode: number;
 	readonly stderr?: string;
@@ -73,6 +79,12 @@ export interface SessionStartHookOptions {
 	readonly workerCliPath?: string;
 }
 
+export interface PostToolUseHookOptions {
+	readonly env?: Record<string, string | undefined>;
+	readonly stdin?: Readable & { readonly isTTY?: boolean };
+	readonly stdout?: HookStdout;
+}
+
 export interface SessionStartWorkerOptions {
 	readonly config?: CodexOmoConfig;
 	readonly cwd?: string;

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

@@ -4,10 +4,13 @@ import { cwd as processCwd, env as processEnv, stdin as processStdin, stdout as
 import type { Readable } from "node:stream";
 import { fileURLToPath } from "node:url";
 
+import { buildCodegraphInitGuidanceForToolResult } from "../../../../../utils/src/codegraph/guidance.ts";
 import { getCodexOmoConfig } from "../../../shared/src/config-loader.ts";
 import { SESSION_START_CWD_ENV } from "./session-start-worker.js";
 import type {
 	HookStdout,
+	PostToolUseHookOptions,
+	PostToolUseHookResult,
 	SessionStartHookOptions,
 	SessionStartHookResult,
 	WorkerSpawnInvocation,
@@ -23,6 +26,8 @@ export type {
 	CodexOmoConfig,
 	HookStdout,
 	OmoConfigSource,
+	PostToolUseHookOptions,
+	PostToolUseHookResult,
 	SessionStartAction,
 	SessionStartHookOptions,
 	SessionStartHookResult,
@@ -38,6 +43,10 @@ export async function runCodegraphSessionStartHook(options: SessionStartHookOpti
 	return (await executeCodegraphSessionStartHook(options)).exitCode;
 }
 
+export async function runCodegraphPostToolUseHookCli(options: PostToolUseHookOptions = {}): Promise<number> {
+	return (await executeCodegraphPostToolUseHook(options)).exitCode;
+}
+
 export async function executeCodegraphSessionStartHook(options: SessionStartHookOptions = {}): Promise<SessionStartHookResult> {
 	const env = options.env ?? processEnv;
 	const input = await readHookInput(options.stdin ?? processStdin);
@@ -58,6 +67,31 @@ export async function executeCodegraphSessionStartHook(options: SessionStartHook
 	return { action: "spawned", exitCode: 0 };
 }
 
+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`;
+}
+
 function writeHookJson(stdout: HookStdout): void {
 	const output = {
 		hookSpecificOutput: {

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

@@ -0,0 +1,75 @@
+import type { Readable, Writable } from "node:stream";
+
+import {
+	errorResponse,
+	isPlainRecord,
+	jsonRpcId,
+	runJsonRpcStdioServer,
+	successResponse,
+	type JsonRpcResponse,
+} from "../../../../../mcp-stdio-core/src/index.ts";
+
+export interface UnavailableCodegraphMcpOptions {
+	readonly input: Readable;
+	readonly output: Writable;
+	readonly reason: string;
+	readonly serverVersion: string;
+}
+
+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,
+	});
+}
+
+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/serve.ts

@@ -7,8 +7,11 @@ import {
 	cwd as processCwd,
 	env as processEnv,
 	execPath as processExecPath,
+	stdin as processStdin,
 	stderr as processStderr,
+	stdout as processStdout,
 } from "node:process";
+import type { Readable, Writable } from "node:stream";
 import { fileURLToPath } from "node:url";
 
 import { buildCodegraphEnv } from "../../../../../utils/src/codegraph/env.ts";
@@ -16,6 +19,10 @@ import {
 	buildCodegraphNodeSkipHint,
 	evaluateCodegraphNodeSupport,
 } from "../../../../../utils/src/codegraph/node-support.ts";
+import {
+	ensureCodegraphProvisioned,
+	type EnsureCodegraphProvisionedOptions,
+} from "../../../../../utils/src/codegraph/provision.ts";
 import {
 	codegraphCommandRequiresSupportedLocalNode,
 	resolveCodegraphCommand,
@@ -24,6 +31,7 @@ import {
 } from "../../../../../utils/src/codegraph/resolve.ts";
 import { getCodexOmoConfig, type CodexOmoConfig } from "../../../shared/src/config-loader.ts";
 import type { CodegraphConfig } from "./hook.js";
+import { runUnavailableCodegraphMcpServer } from "./mcp-unavailable.js";
 
 export type ServeStdio = "inherit";
 
@@ -37,6 +45,9 @@ export type CodegraphServeProcessRunner = (
 	args: readonly string[],
 	options: CodegraphServeProcessOptions,
 ) => Promise<number>;
+export type CodegraphProvisioner = (
+	options: EnsureCodegraphProvisionedOptions,
+) => ReturnType<typeof ensureCodegraphProvisioned>;
 
 export interface ServeProcessInvocation {
 	readonly args: readonly string[];
@@ -54,16 +65,20 @@ export interface RunCodegraphServeOptions {
 	readonly cwd?: string;
 	readonly env?: Record<string, string | undefined>;
 	readonly homeDir?: string;
+	readonly stdin?: Readable;
+	readonly stdout?: Writable;
 	readonly nodeVersion?: string;
 	readonly resolve?: (options: ResolveCodegraphCommandOptions) => ReturnType<typeof resolveCodegraphCommand>;
 	readonly runProcess?: CodegraphServeProcessRunner;
 	readonly stderr?: CodegraphServeStderr;
+	readonly ensureProvisioned?: CodegraphProvisioner;
 }
 
 const CODEGRAPH_SKIP_HINT =
 	"CodeGraph MCP skipped: codegraph binary not found. Install CodeGraph or set OMO_CODEGRAPH_BIN.\n";
 const CODEGRAPH_DISABLED_HINT =
 	"CodeGraph MCP skipped: disabled by OMO SOT config. Set [codex].codegraph.enabled=true to enable it.\n";
+const CODEGRAPH_VERSION = "1.0.1";
 const WINDOWS_CMD_EXTENSIONS = new Set([".bat", ".cmd"]);
 const WINDOWS_NODE_SCRIPT_EXTENSIONS = new Set([".cjs", ".js", ".mjs"]);
 
@@ -73,33 +88,40 @@ export async function runCodegraphServe(options: RunCodegraphServeOptions = {}):
 	const config = options.config ?? getCodexOmoConfig({ cwd: options.cwd ?? processCwd(), env, homeDir });
 	const codegraphConfig = config.codegraph ?? {};
 	if (codegraphConfig.enabled === false) {
-		(options.stderr ?? processStderr).write(CODEGRAPH_DISABLED_HINT);
-		return 1;
+		return runUnavailableMcp(CODEGRAPH_DISABLED_HINT, options);
 	}
 
+	const trustedInstallDir = config.trustedCodegraphInstallDir;
 	const resolutionOptions = {
 		env,
 		homeDir,
-		provisioned: () => provisionedBinFromInstallDir(codegraphConfig.install_dir),
+		provisioned: () => provisionedBinFromInstallDir(trustedInstallDir),
 	} satisfies ResolveCodegraphCommandOptions;
-	const resolution = options.resolve?.(resolutionOptions) ?? resolveCodegraphCommand(resolutionOptions);
+	let resolution = options.resolve?.(resolutionOptions) ?? resolveCodegraphCommand(resolutionOptions);
 	const nodeSupport = evaluateCodegraphNodeSupport({ env, nodeVersion: options.nodeVersion });
 	if (!resolution.exists || shouldSkipResolvedCommand(resolution, options.commandExists ?? existsSync)) {
 		if (resolution.source === "path" && !nodeSupport.supported) {
-			(options.stderr ?? processStderr).write(buildCodegraphNodeSkipHint(nodeSupport));
-			return 1;
+			return runUnavailableMcp(buildCodegraphNodeSkipHint(nodeSupport), options);
+		}
+		const provisioned = await provisionMissingCodegraph({
+			config: codegraphConfig,
+			ensureProvisioned: options.ensureProvisioned ?? ensureCodegraphProvisioned,
+			homeDir,
+			resolution,
+			...(trustedInstallDir === undefined ? {} : { trustedInstallDir }),
+		});
+		if (provisioned === null) {
+			return runUnavailableMcp(CODEGRAPH_SKIP_HINT, options);
 		}
-		(options.stderr ?? processStderr).write(CODEGRAPH_SKIP_HINT);
-		return 1;
+		resolution = provisioned;
 	}
 
 	if (codegraphCommandRequiresSupportedLocalNode(resolution) && !nodeSupport.supported) {
-		(options.stderr ?? processStderr).write(buildCodegraphNodeSkipHint(nodeSupport));
-		return 1;
+		return runUnavailableMcp(buildCodegraphNodeSkipHint(nodeSupport), options);
 	}
 
 	const runProcess = options.runProcess ?? runChildProcess;
-	const codegraphEnv = codegraphEnvForConfig(codegraphConfig, homeDir, options.buildEnv);
+	const codegraphEnv = codegraphEnvForConfig(trustedInstallDir, homeDir, options.buildEnv);
 	const mergedEnv = {
 		...env,
 		...codegraphEnv,
@@ -110,6 +132,37 @@ export async function runCodegraphServe(options: RunCodegraphServeOptions = {}):
 	});
 }
 
+async function runUnavailableMcp(reason: string, options: RunCodegraphServeOptions): Promise<number> {
+	(options.stderr ?? processStderr).write(reason);
+	await runUnavailableCodegraphMcpServer({
+		input: options.stdin ?? processStdin,
+		output: options.stdout ?? processStdout,
+		reason,
+		serverVersion: CODEGRAPH_VERSION,
+	});
+	return 0;
+}
+
+async function provisionMissingCodegraph(options: {
+	readonly config: CodegraphConfig;
+	readonly ensureProvisioned: CodegraphProvisioner;
+	readonly homeDir: string;
+	readonly resolution: CodegraphCommandResolution;
+	readonly trustedInstallDir?: string;
+}): Promise<CodegraphCommandResolution | null> {
+	if (options.resolution.source === "env") return null;
+	if (options.config.auto_provision === false) return null;
+
+	const installDir = options.trustedInstallDir ?? join(options.homeDir, ".omo", "codegraph");
+	const result = await options.ensureProvisioned({
+		installDir,
+		lockDir: join(installDir, ".locks"),
+		version: CODEGRAPH_VERSION,
+	});
+	if (!result.provisioned || result.binPath === undefined) return null;
+	return { argsPrefix: [], command: result.binPath, exists: true, source: "provisioned" };
+}
+
 function shouldSkipResolvedCommand(
 	resolution: CodegraphCommandResolution,
 	commandExists: (filePath: string) => boolean,
@@ -124,12 +177,12 @@ function looksLikePath(command: string): boolean {
 }
 
 function codegraphEnvForConfig(
-	config: CodegraphConfig,
+	trustedInstallDir: string | undefined,
 	homeDir: string,
 	buildEnv: ((options: { readonly homeDir: string }) => Record<string, string>) | undefined,
 ): Record<string, string> {
 	const env = buildEnv?.({ homeDir }) ?? buildCodegraphEnv({ homeDir });
-	return config.install_dir === undefined ? env : { ...env, CODEGRAPH_INSTALL_DIR: config.install_dir };
+	return trustedInstallDir === undefined ? env : { ...env, CODEGRAPH_INSTALL_DIR: trustedInstallDir };
 }
 
 function provisionedBinFromInstallDir(installDir: string | undefined): string | null {

package/packages/omo-codex/plugin/components/codegraph/src/session-start-worker.ts

@@ -28,6 +28,9 @@ export const SESSION_START_CWD_ENV = "OMO_CODEGRAPH_SESSION_START_CWD";
 const CODEGRAPH_VERSION = "1.0.1";
 const COMMAND_TIMEOUT_MS = 60_000;
 const WINDOWS_CMD_EXTENSIONS = new Set([".bat", ".cmd"]);
+type CodegraphBootstrapConfig = CodegraphConfig & {
+	readonly trustedCodegraphInstallDir?: string;
+};
 
 const defaultDeps: CodegraphSessionStartDeps = {
 	ensureGitignored: ensureCodegraphGitignored,
@@ -49,12 +52,16 @@ export async function runCodegraphSessionStartWorker(options: SessionStartWorker
 	}
 
 	const nodeSupport = evaluateCodegraphNodeSupport({ env, nodeVersion: options.nodeVersion });
-	return runBootstrap(projectRoot, config.codegraph ?? {}, env, homeDir, nodeSupport, { ...defaultDeps, ...options.deps }, logOutcome);
+	const bootstrapConfig: CodegraphBootstrapConfig = {
+		...(config.codegraph ?? {}),
+		...(config.trustedCodegraphInstallDir === undefined ? {} : { trustedCodegraphInstallDir: config.trustedCodegraphInstallDir }),
+	};
+	return runBootstrap(projectRoot, bootstrapConfig, env, homeDir, nodeSupport, { ...defaultDeps, ...options.deps }, logOutcome);
 }
 
 async function runBootstrap(
 	projectRoot: string,
-	config: CodegraphConfig,
+	config: CodegraphBootstrapConfig,
 	env: Record<string, string | undefined>,
 	homeDir: string,
 	nodeSupport: CodegraphNodeSupport,
@@ -72,7 +79,7 @@ async function runBootstrap(
 
 		deps.prepareWorkspace(projectRoot, { homeDir });
 		deps.ensureGitignored(projectRoot);
-		const codegraphEnv = config.install_dir === undefined ? buildCodegraphEnv({ homeDir }) : { ...buildCodegraphEnv({ homeDir }), CODEGRAPH_INSTALL_DIR: config.install_dir };
+		const codegraphEnv = codegraphEnvForConfig(config, homeDir);
 		const status = await deps.runCommand(projectRoot, command.resolution.command, [...command.resolution.argsPrefix, "status", "--json"], { env: codegraphEnv, timeoutMs: COMMAND_TIMEOUT_MS });
 		const decision = decideStartupAction(status);
 		if (decision.kind === "skip") return finish("skipped-status", { error: decision.reason, projectRoot }, logOutcome);
@@ -97,29 +104,36 @@ type ResolutionResult =
 
 async function resolveOrProvisionCommand(
 	deps: CodegraphSessionStartDeps,
-	config: CodegraphConfig,
+	config: CodegraphBootstrapConfig,
 	env: Record<string, string | undefined>,
 	homeDir: string,
 	nodeSupport: CodegraphNodeSupport,
 ): Promise<ResolutionResult> {
-	const resolved = deps.resolveCommand({ env, homeDir, provisioned: () => provisionedBinFromInstallDir(config.install_dir) });
-	if (resolved.exists) {
-		if (codegraphCommandRequiresSupportedLocalNode(resolved) && !nodeSupport.supported) {
-			return { kind: "unsupported-node" };
-		}
+	const trustedInstallDir = config.trustedCodegraphInstallDir;
+	const resolved = deps.resolveCommand({ env, homeDir, provisioned: () => provisionedBinFromInstallDir(trustedInstallDir) });
+	if (resolved.exists && canUseResolvedCommand(resolved, nodeSupport)) {
 		return { kind: "resolved", resolution: resolved };
 	}
-	if (!nodeSupport.supported) return { kind: "unsupported-node" };
+	if (resolved.exists && config.auto_provision === false) return { kind: "unsupported-node" };
 	if (config.auto_provision === false) return { error: "codegraph binary unavailable and auto_provision is disabled", kind: "unavailable", source: resolved.source };
 
-	const installDir = config.install_dir ?? join(homeDir, ".omo", "codegraph");
-	const provisioned = await deps.ensureProvisioned({ installDir, lockDir: join(installDir, "locks"), version: CODEGRAPH_VERSION });
+	const installDir = trustedInstallDir ?? join(homeDir, ".omo", "codegraph");
+	const provisioned = await deps.ensureProvisioned({ installDir, lockDir: join(installDir, ".locks"), version: CODEGRAPH_VERSION });
 	if (!provisioned.provisioned || provisioned.binPath === undefined) {
 		return { error: provisioned.error ?? "provisioning did not produce a binary", kind: "unavailable", source: resolved.source };
 	}
 	return { kind: "resolved", resolution: { argsPrefix: [], command: provisioned.binPath, exists: true, source: "provisioned" } };
 }
 
+function codegraphEnvForConfig(config: CodegraphBootstrapConfig, homeDir: string): Record<string, string> {
+	const env = buildCodegraphEnv({ homeDir });
+	return config.trustedCodegraphInstallDir === undefined ? env : { ...env, CODEGRAPH_INSTALL_DIR: config.trustedCodegraphInstallDir };
+}
+
+function canUseResolvedCommand(resolved: CodegraphCommandResolution, nodeSupport: CodegraphNodeSupport): boolean {
+	return !codegraphCommandRequiresSupportedLocalNode(resolved) || nodeSupport.supported;
+}
+
 function decideStartupAction(status: CodegraphCommandResult): { readonly kind: "init" } | { readonly kind: "skip"; readonly reason: string } | { readonly kind: "sync" } {
 	if (status.timedOut) return { kind: "skip", reason: "status timed out" };
 	const text = `${status.stdout}\n${status.stderr ?? ""}`.toLowerCase();