oh-my-opencode 4.5.1 → 4.5.12

package/packages/omo-codex/plugin/components/comment-checker/src/runner.ts

@@ -0,0 +1,195 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+
+import type { CommentCheckerHookInput } from "./core.js";
+
+export type ProcessResult = {
+	exitCode: number | null;
+	stdout: string;
+	stderr: string;
+};
+
+export const MAX_PROCESS_OUTPUT_BYTES = 64 * 1024;
+
+export type ProcessExecutor = (command: string, args: string[], stdin: string) => Promise<ProcessResult>;
+
+export type RunCommentCheckerOptions = {
+	binaryPath?: string;
+	customPrompt?: string;
+	resolveBinary?: () => string | undefined;
+	executor?: ProcessExecutor;
+};
+
+export type CommentCheckerRunResult = {
+	status: "pass" | "warning" | "error" | "missing";
+	message: string;
+	binaryPath?: string;
+	exitCode?: number | null;
+	stdout?: string;
+	stderr?: string;
+};
+
+export type CommentCheckerRunner = (input: CommentCheckerHookInput) => Promise<CommentCheckerRunResult>;
+
+export async function runCommentChecker(
+	input: CommentCheckerHookInput,
+	options: RunCommentCheckerOptions = {},
+): Promise<CommentCheckerRunResult> {
+	const binaryPath =
+		options.binaryPath ?? (options.resolveBinary ? options.resolveBinary() : resolveCommentCheckerBinary());
+	if (!binaryPath) {
+		return {
+			status: "missing",
+			message: "comment-checker binary not found. Run npm install for the codex-comment-checker plugin.",
+		};
+	}
+
+	const args = ["check"];
+	if (options.customPrompt) {
+		args.push("--prompt", options.customPrompt);
+	}
+
+	const executor = options.executor ?? spawnProcess;
+	const result = await executor(binaryPath, args, JSON.stringify(input));
+	const message = result.stderr || result.stdout;
+	if (result.exitCode === 0) {
+		return {
+			status: "pass",
+			message: "",
+			binaryPath,
+			exitCode: result.exitCode,
+			stdout: result.stdout,
+			stderr: result.stderr,
+		};
+	}
+	if (result.exitCode === 2) {
+		return {
+			status: "warning",
+			message,
+			binaryPath,
+			exitCode: result.exitCode,
+			stdout: result.stdout,
+			stderr: result.stderr,
+		};
+	}
+	return {
+		status: "error",
+		message,
+		binaryPath,
+		exitCode: result.exitCode,
+		stdout: result.stdout,
+		stderr: result.stderr,
+	};
+}
+
+export function resolveCommentCheckerBinary(): string | undefined {
+	const binaryName = process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
+	const fromPackageApi = resolvePackageApiBinary();
+	if (fromPackageApi) return fromPackageApi;
+	const fromPackage = resolvePackageBinary(binaryName);
+	if (fromPackage) return fromPackage;
+	return undefined;
+}
+
+function resolvePackageApiBinary(): string | undefined {
+	try {
+		const require = createRequire(import.meta.url);
+		const packageExports: unknown = require("@code-yeongyu/comment-checker");
+		if (!isCommentCheckerPackage(packageExports)) return undefined;
+		const binaryPath = packageExports.getBinaryPath();
+		return existsSync(binaryPath) ? binaryPath : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function resolvePackageBinary(binaryName: string): string | undefined {
+	try {
+		const require = createRequire(import.meta.url);
+		const packagePath = require.resolve("@code-yeongyu/comment-checker/package.json");
+		const binaryPath = join(dirname(packagePath), "bin", binaryName);
+		return existsSync(binaryPath) ? binaryPath : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function isCommentCheckerPackage(value: unknown): value is { getBinaryPath: () => string } {
+	return isRecord(value) && typeof value["getBinaryPath"] === "function";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+interface OutputAccumulator {
+	text: string;
+	bytes: number;
+	truncated: boolean;
+}
+
+function appendOutput(output: OutputAccumulator, chunk: string, maxOutputBytes: number): void {
+	if (output.truncated) return;
+
+	const remainingBytes = maxOutputBytes - output.bytes;
+	const chunkBytes = Buffer.byteLength(chunk, "utf8");
+	if (chunkBytes <= remainingBytes) {
+		output.text += chunk;
+		output.bytes += chunkBytes;
+		return;
+	}
+
+	if (remainingBytes > 0) {
+		output.text += Buffer.from(chunk, "utf8").subarray(0, remainingBytes).toString("utf8");
+		output.bytes += remainingBytes;
+	}
+	output.truncated = true;
+}
+
+function formatOutput(output: OutputAccumulator, streamName: "stdout" | "stderr", maxOutputBytes: number): string {
+	if (!output.truncated) return output.text;
+	return `${output.text}\n[${streamName} truncated after ${maxOutputBytes} bytes]`;
+}
+
+export function spawnProcess(
+	command: string,
+	args: string[],
+	stdin: string,
+	maxOutputBytes: number = MAX_PROCESS_OUTPUT_BYTES,
+): Promise<ProcessResult> {
+	return new Promise((resolve) => {
+		const outputByteLimit = Number.isFinite(maxOutputBytes) && maxOutputBytes > 0 ? Math.floor(maxOutputBytes) : 0;
+		const proc = spawn(command, args, {
+			stdio: ["pipe", "pipe", "pipe"],
+		});
+		const stdout: OutputAccumulator = { text: "", bytes: 0, truncated: false };
+		const stderr: OutputAccumulator = { text: "", bytes: 0, truncated: false };
+
+		proc.stdout.setEncoding("utf-8");
+		proc.stderr.setEncoding("utf-8");
+		proc.stdout.on("data", (chunk: string) => {
+			appendOutput(stdout, chunk, outputByteLimit);
+		});
+		proc.stderr.on("data", (chunk: string) => {
+			appendOutput(stderr, chunk, outputByteLimit);
+		});
+		proc.once("error", (error) => {
+			appendOutput(stderr, error.message, outputByteLimit);
+			resolve({
+				exitCode: null,
+				stdout: formatOutput(stdout, "stdout", outputByteLimit),
+				stderr: formatOutput(stderr, "stderr", outputByteLimit),
+			});
+		});
+		proc.once("close", (exitCode) => {
+			resolve({
+				exitCode,
+				stdout: formatOutput(stdout, "stdout", outputByteLimit),
+				stderr: formatOutput(stderr, "stderr", outputByteLimit),
+			});
+		});
+		proc.stdin.end(stdin);
+	});
+}

package/packages/omo-codex/plugin/components/comment-checker/test/codex-hook-newline.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from "vitest";
+
+import { type CodexPostToolUseInput, runCommentCheckerPostToolUse } from "../src/codex-hook.ts";
+
+function postToolUseInput(): CodexPostToolUseInput {
+	return {
+		session_id: "thread-1",
+		turn_id: "turn-1",
+		transcript_path: null,
+		cwd: "/repo",
+		hook_event_name: "PostToolUse",
+		model: "gpt-5.5",
+		permission_mode: "never",
+		tool_name: "apply_patch",
+		tool_input: {
+			command: [
+				"*** Begin Patch",
+				"*** Update File: src/example.ts",
+				"@@",
+				"-const value = 1;",
+				"+// explains value",
+				"+const value = 2;",
+				"*** End Patch",
+			].join("\n"),
+		},
+		tool_response: "Success. Updated files.",
+		tool_use_id: "call-1",
+	};
+}
+
+describe("comment-checker hook newline rendering", () => {
+	it("#given checker warning with CRLF and bare CR #when hook runs #then returns normalized blocking feedback JSON", async () => {
+		// given
+		const output = await runCommentCheckerPostToolUse(postToolUseInput(), {
+			run: async () => ({
+				status: "warning",
+				message: "\r\nfirst warning line\r\n  indented detail\rthird warning line\r\n",
+			}),
+		});
+
+		// when
+		const parsed: unknown = JSON.parse(output);
+
+		// then
+		expect(parsed).toEqual({
+			decision: "block",
+			reason:
+				"comment-checker found issues in src/example.ts:\nfirst warning line\n  indented detail\nthird warning line",
+		});
+		expect(output).not.toContain("\r");
+	});
+});

package/packages/omo-codex/plugin/components/comment-checker/test/codex-hook.test.ts

@@ -0,0 +1,368 @@
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+	type CodexPostToolUseInput,
+	extractCodexCommentCheckRequests,
+	runCommentCheckerPostToolUse,
+} from "../src/codex-hook.ts";
+
+type CliResult = {
+	exitCode: number | null;
+	stdout: string;
+	stderr: string;
+};
+
+const CLI_PATH = fileURLToPath(new URL("../dist/cli.js", import.meta.url));
+const tempDirs: string[] = [];
+
+afterEach(() => {
+	for (const tempDir of tempDirs.splice(0)) {
+		rmSync(tempDir, { recursive: true, force: true });
+	}
+});
+
+function runHookCli(input: string): Promise<CliResult> {
+	return new Promise((resolve, reject) => {
+		const child = spawn(process.execPath, [CLI_PATH, "hook", "post-tool-use"], {
+			stdio: ["pipe", "pipe", "pipe"],
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout.setEncoding("utf8");
+		child.stderr.setEncoding("utf8");
+		child.stdout.on("data", (chunk: string) => {
+			stdout += chunk;
+		});
+		child.stderr.on("data", (chunk: string) => {
+			stderr += chunk;
+		});
+		child.once("error", reject);
+		child.once("close", (exitCode) => {
+			resolve({ exitCode, stdout, stderr });
+		});
+		child.stdin.end(input);
+	});
+}
+
+function postToolUseInput(overrides: Partial<CodexPostToolUseInput> = {}): CodexPostToolUseInput {
+	return {
+		session_id: "thread-1",
+		turn_id: "turn-1",
+		transcript_path: null,
+		cwd: "/repo",
+		hook_event_name: "PostToolUse",
+		model: "gpt-5.5",
+		permission_mode: "never",
+		tool_name: "apply_patch",
+		tool_input: {
+			command: [
+				"*** Begin Patch",
+				"*** Update File: src/example.ts",
+				"@@",
+				"-const value = 1;",
+				"+// explains value",
+				"+const value = 2;",
+				"*** End Patch",
+			].join("\n"),
+		},
+		tool_response: "Success. Updated files.",
+		tool_use_id: "call-1",
+		...overrides,
+	};
+}
+
+describe("extractCodexCommentCheckRequests", () => {
+	it("#given codex apply_patch command #when extracting #then returns edit request for changed file", () => {
+		const requests = extractCodexCommentCheckRequests(postToolUseInput());
+
+		expect(requests).toEqual([
+			{
+				sourceToolName: "apply_patch",
+				toolName: "Edit",
+				filePath: "src/example.ts",
+				toolInput: {
+					file_path: "src/example.ts",
+					old_string: "const value = 1;\n",
+					new_string: "// explains value\nconst value = 2;\n",
+				},
+			},
+		]);
+	});
+
+	it("#given unsupported post tool event #when extracting #then returns no requests", () => {
+		const requests = extractCodexCommentCheckRequests(
+			postToolUseInput({
+				tool_name: "read",
+				tool_input: { file_path: "src/example.ts", content: "// hi\nconst value = 1;\n" },
+			}),
+		);
+
+		expect(requests).toEqual([]);
+	});
+
+	it("#given codex write payload #when extracting #then returns write request", () => {
+		const requests = extractCodexCommentCheckRequests(
+			postToolUseInput({
+				tool_name: "write",
+				tool_input: {
+					file_path: "src/example.ts",
+					content: "// explains value\nconst value = 1;\n",
+				},
+			}),
+		);
+
+		expect(requests).toEqual([
+			{
+				sourceToolName: "write",
+				toolName: "Write",
+				filePath: "src/example.ts",
+				toolInput: {
+					file_path: "src/example.ts",
+					content: "// explains value\nconst value = 1;\n",
+				},
+			},
+		]);
+	});
+
+	it("#given codex edit payload #when extracting #then returns edit request", () => {
+		const requests = extractCodexCommentCheckRequests(
+			postToolUseInput({
+				tool_name: "edit",
+				tool_input: {
+					path: "src/example.ts",
+					oldString: "const value = 1;\n",
+					newString: "// explains value\nconst value = 2;\n",
+				},
+			}),
+		);
+
+		expect(requests).toEqual([
+			{
+				sourceToolName: "edit",
+				toolName: "Edit",
+				filePath: "src/example.ts",
+				toolInput: {
+					file_path: "src/example.ts",
+					old_string: "const value = 1;\n",
+					new_string: "// explains value\nconst value = 2;\n",
+				},
+			},
+		]);
+	});
+
+	it("#given one-sided codex edit payload #when extracting #then returns no requests", () => {
+		const requests = extractCodexCommentCheckRequests(
+			postToolUseInput({
+				tool_name: "edit",
+				tool_input: {
+					path: "src/example.ts",
+					oldString: "const value = 1;\n",
+				},
+			}),
+		);
+
+		expect(requests).toEqual([]);
+	});
+
+	it("#given codex multi_edit payload #when extracting #then returns multiedit request", () => {
+		const requests = extractCodexCommentCheckRequests(
+			postToolUseInput({
+				tool_name: "multi_edit",
+				tool_input: {
+					filePath: "src/example.ts",
+					edits: [
+						{ old_string: "const a = 1;\n", new_string: "// explains a\nconst a = 2;\n" },
+						{ oldString: "const b = 1;\n", newString: "// explains b\nconst b = 2;\n" },
+					],
+				},
+			}),
+		);
+
+		expect(requests).toEqual([
+			{
+				sourceToolName: "multi_edit",
+				toolName: "MultiEdit",
+				filePath: "src/example.ts",
+				toolInput: {
+					file_path: "src/example.ts",
+					edits: [
+						{ old_string: "const a = 1;\n", new_string: "// explains a\nconst a = 2;\n" },
+						{ old_string: "const b = 1;\n", new_string: "// explains b\nconst b = 2;\n" },
+					],
+				},
+			},
+		]);
+	});
+});
+
+describe("runCommentCheckerPostToolUse", () => {
+	it("#given checker warning #when hook runs #then returns blocking feedback JSON", async () => {
+		const output = await runCommentCheckerPostToolUse(postToolUseInput(), {
+			run: async () => ({
+				status: "warning",
+				message: "comment warning: explain less",
+			}),
+		});
+
+		expect(JSON.parse(output)).toEqual({
+			decision: "block",
+			reason: "comment-checker found issues in src/example.ts:\ncomment warning: explain less",
+		});
+	});
+
+	it("#given missing checker binary #when hook runs #then emits no hook output", async () => {
+		const output = await runCommentCheckerPostToolUse(postToolUseInput(), {
+			run: async () => ({
+				status: "missing",
+				message: "not installed",
+			}),
+		});
+
+		expect(output).toBe("");
+	});
+
+	it("#given transcript path #when hook runs #then forwards it to checker input", async () => {
+		let transcriptPath = "";
+
+		await runCommentCheckerPostToolUse(
+			postToolUseInput({
+				transcript_path: "/tmp/codex-comment-checker-transcript.jsonl",
+				tool_name: "write",
+				tool_input: {
+					file_path: "src/example.ts",
+					content: "// explains value\nconst value = 1;\n",
+				},
+			}),
+			{
+				run: async (input) => {
+					transcriptPath = input.transcript_path;
+					return {
+						status: "pass",
+						message: "",
+					};
+				},
+			},
+		);
+
+		expect(transcriptPath).toBe("/tmp/codex-comment-checker-transcript.jsonl");
+	});
+
+	it("#given null transcript path #when hook runs #then forwards empty string fallback", async () => {
+		let transcriptPath = "unset";
+
+		await runCommentCheckerPostToolUse(
+			postToolUseInput({
+				transcript_path: null,
+				tool_name: "write",
+				tool_input: {
+					file_path: "src/example.ts",
+					content: "// explains value\nconst value = 1;\n",
+				},
+			}),
+			{
+				run: async (input) => {
+					transcriptPath = input.transcript_path;
+					return {
+						status: "pass",
+						message: "",
+					};
+				},
+			},
+		);
+
+		expect(transcriptPath).toBe("");
+	});
+
+	it("#given Codex canonical context-window transcript and long checker warning #when hook blocks #then it caps feedback", async () => {
+		const root = mkdtempSync(path.join(tmpdir(), "codex-comment-checker-context-pressure-"));
+		tempDirs.push(root);
+		const transcriptPath = path.join(root, "transcript.jsonl");
+		writeFileSync(
+			transcriptPath,
+			[
+				"context_length_exceeded",
+				"Codex ran out of room in the model's context window. Start a new thread before retrying.",
+				"",
+			].join("\n"),
+		);
+
+		const output = await runCommentCheckerPostToolUse(postToolUseInput({ transcript_path: transcriptPath }), {
+			run: async () => ({
+				status: "warning",
+				message: `comment warning: explain less\n${"x".repeat(10_000)}`,
+			}),
+		});
+
+		const parsed: unknown = JSON.parse(output);
+		if (!isBlockingOutput(parsed)) throw new TypeError("Expected blocking output");
+
+		expect(parsed.reason.length).toBeLessThanOrEqual(1200);
+		expect(parsed.reason).toContain("comment-checker found issues in src/example.ts");
+		expect(parsed.reason).toContain("[Truncated hook output");
+	});
+});
+
+describe("runCodexHookCli", () => {
+	it("#given malformed post-tool-use stdin #when hook CLI runs #then it no-ops without stderr", async () => {
+		// given
+		const input = "break;\n";
+
+		// when
+		const result = await runHookCli(input);
+
+		// then
+		expect(result).toEqual({
+			exitCode: 0,
+			stdout: "",
+			stderr: "",
+		});
+	});
+
+	it("#given non-object post-tool-use JSON #when hook CLI runs #then it no-ops without stderr", async () => {
+		// given
+		const input = '"break;"\n';
+
+		// when
+		const result = await runHookCli(input);
+
+		// then
+		expect(result).toEqual({
+			exitCode: 0,
+			stdout: "",
+			stderr: "",
+		});
+	});
+
+	it("#given non-string transcript path #when hook CLI runs #then it no-ops without stderr", async () => {
+		// given
+		const input = `${JSON.stringify({ ...postToolUseInput(), transcript_path: 42 })}\n`;
+
+		// when
+		const result = await runHookCli(input);
+
+		// then
+		expect(result).toEqual({
+			exitCode: 0,
+			stdout: "",
+			stderr: "",
+		});
+	});
+});
+
+interface BlockingOutput {
+	readonly decision: "block";
+	readonly reason: string;
+}
+
+function isBlockingOutput(value: unknown): value is BlockingOutput {
+	return isRecord(value) && value["decision"] === "block" && typeof value["reason"] === "string";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/omo-codex/plugin/components/comment-checker/test/fixtures/post-tool-use.json

@@ -0,0 +1,15 @@
+{
+	"session_id": "00000000-0000-0000-0000-000000000000",
+	"turn_id": "00000000-0000-0000-0000-000000000001",
+	"transcript_path": "/tmp/codex-comment-checker-transcript.jsonl",
+	"cwd": ".",
+	"hook_event_name": "PostToolUse",
+	"model": "gpt-5.5",
+	"permission_mode": "default",
+	"tool_name": "apply_patch",
+	"tool_input": {
+		"command": "*** Begin Patch\n*** Add File: src/example.ts\n+export const meaning = 42;\n*** End Patch\n"
+	},
+	"tool_response": "Success. Updated files.",
+	"tool_use_id": "toolu_000000000000000000000000"
+}