oh-my-opencode 4.5.1 → 4.6.0

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

@@ -0,0 +1,361 @@
+export type TextContent = {
+	type: "text";
+	text: string;
+};
+
+export type ImageContent = {
+	type: "image";
+	data: string;
+	mimeType: string;
+};
+
+export type CheckerToolName = "Write" | "Edit" | "MultiEdit";
+
+export type CheckerEdit = {
+	old_string: string;
+	new_string: string;
+};
+
+export type CheckerToolInput = {
+	file_path: string;
+	content?: string;
+	old_string?: string;
+	new_string?: string;
+	edits?: CheckerEdit[];
+};
+
+export type CommentCheckRequest = {
+	sourceToolName: string;
+	toolName: CheckerToolName;
+	filePath: string;
+	toolInput: CheckerToolInput;
+};
+
+export type CommentCheckerHookInput = {
+	session_id: string;
+	tool_name: CheckerToolName;
+	transcript_path: string;
+	cwd: string;
+	hook_event_name: "PostToolUse";
+	tool_input: CheckerToolInput;
+};
+
+export type ToolResultContent = TextContent | ImageContent;
+
+export type ToolResultLike = {
+	toolName: string;
+	input: Record<string, unknown>;
+	content?: ToolResultContent[];
+	isError?: boolean;
+	details?: unknown;
+};
+
+type ApplyPatchAccumulator = {
+	operation: "add" | "delete" | "update";
+	filePath: string;
+	movePath?: string;
+	oldLines: string[];
+	newLines: string[];
+};
+
+type ApplyPatchFileMetadata = {
+	filePath: string;
+	movePath?: string;
+	before: string;
+	after: string;
+	type?: string;
+};
+
+export function extractCommentCheckRequests(event: ToolResultLike): CommentCheckRequest[] {
+	if (event.isError) return [];
+	if (isToolFailureOutput(getContentText(event.content))) return [];
+
+	const toolName = event.toolName.toLowerCase();
+	if (toolName === "write") return extractWriteRequest(event);
+	if (toolName === "edit") return extractEditRequest(event);
+	if (toolName === "multiedit" || toolName === "multi_edit") return extractMultiEditRequest(event);
+	if (toolName === "apply_patch") return extractApplyPatchRequests(event);
+	return [];
+}
+
+export function toHookInput(
+	request: CommentCheckRequest,
+	context: {
+		sessionId: string;
+		cwd: string;
+		transcriptPath?: string;
+	},
+): CommentCheckerHookInput {
+	return {
+		session_id: context.sessionId,
+		tool_name: request.toolName,
+		transcript_path: context.transcriptPath ?? "",
+		cwd: context.cwd,
+		hook_event_name: "PostToolUse",
+		tool_input: request.toolInput,
+	};
+}
+
+export function isToolFailureOutput(text: string): boolean {
+	const lower = text.trim().toLowerCase();
+	return (
+		lower.startsWith("error") ||
+		lower.includes("error:") ||
+		lower.includes("failed to") ||
+		lower.includes("could not")
+	);
+}
+
+function extractWriteRequest(event: ToolResultLike): CommentCheckRequest[] {
+	const filePath = getString(event.input, ["filePath", "file_path", "path"]);
+	const content = getString(event.input, ["content"]);
+	if (!filePath || content === undefined) return [];
+	return [
+		{
+			sourceToolName: event.toolName,
+			toolName: "Write",
+			filePath,
+			toolInput: {
+				file_path: filePath,
+				content,
+			},
+		},
+	];
+}
+
+function extractEditRequest(event: ToolResultLike): CommentCheckRequest[] {
+	const filePath = getString(event.input, ["filePath", "file_path", "path"]);
+	const oldString = getString(event.input, ["oldString", "old_string"]);
+	const newString = getString(event.input, ["newString", "new_string"]);
+	if (!filePath || oldString === undefined || newString === undefined) return [];
+	const toolInput: CheckerToolInput = { file_path: filePath };
+	toolInput.old_string = oldString;
+	toolInput.new_string = newString;
+	return [
+		{
+			sourceToolName: event.toolName,
+			toolName: "Edit",
+			filePath,
+			toolInput,
+		},
+	];
+}
+
+function extractMultiEditRequest(event: ToolResultLike): CommentCheckRequest[] {
+	const filePath = getString(event.input, ["filePath", "file_path", "path"]);
+	const edits = getEdits(event.input["edits"]);
+	if (!filePath || edits.length === 0) return [];
+	return [
+		{
+			sourceToolName: event.toolName,
+			toolName: "MultiEdit",
+			filePath,
+			toolInput: {
+				file_path: filePath,
+				edits,
+			},
+		},
+	];
+}
+
+function extractApplyPatchRequests(event: ToolResultLike): CommentCheckRequest[] {
+	const metadataRequests = extractApplyPatchMetadataRequests(event.details, event.toolName);
+	if (metadataRequests.length > 0) return metadataRequests;
+
+	const patch = getString(event.input, ["input", "patch", "command"]);
+	if (!patch) return [];
+	return parseApplyPatchRequests(patch, event.toolName);
+}
+
+function extractApplyPatchMetadataRequests(details: unknown, sourceToolName: string): CommentCheckRequest[] {
+	const metadataFiles = getApplyPatchMetadataFiles(details);
+	if (metadataFiles.length === 0) return [];
+
+	const requests: CommentCheckRequest[] = [];
+	for (const file of metadataFiles) {
+		if (file.type === "delete") continue;
+		const filePath = file.movePath ?? file.filePath;
+		if (file.before.length === 0) {
+			requests.push({
+				sourceToolName,
+				toolName: "Write",
+				filePath,
+				toolInput: {
+					file_path: filePath,
+					content: file.after,
+				},
+			});
+			continue;
+		}
+		requests.push({
+			sourceToolName,
+			toolName: "Edit",
+			filePath,
+			toolInput: {
+				file_path: filePath,
+				old_string: file.before,
+				new_string: file.after,
+			},
+		});
+	}
+	return requests;
+}
+
+function getApplyPatchMetadataFiles(details: unknown): ApplyPatchFileMetadata[] {
+	if (!isRecord(details)) return [];
+	const direct = readApplyPatchMetadataFiles(details["files"]);
+	if (direct.length > 0) return direct;
+	const resultDetails = details["result"];
+	const result = isRecord(resultDetails) ? readApplyPatchMetadataFiles(resultDetails["files"]) : [];
+	if (result.length > 0) return result;
+	const metadataDetails = details["metadata"];
+	const metadata = isRecord(metadataDetails) ? readApplyPatchMetadataFiles(metadataDetails["files"]) : [];
+	return metadata;
+}
+
+function readApplyPatchMetadataFiles(value: unknown): ApplyPatchFileMetadata[] {
+	if (!Array.isArray(value)) return [];
+	const files: ApplyPatchFileMetadata[] = [];
+	for (const item of value) {
+		if (!isRecord(item)) continue;
+		const filePath = getString(item, ["filePath", "file_path", "path"]);
+		const movePath = getString(item, ["movePath", "move_path"]);
+		const before = getString(item, ["before", "old", "oldString", "old_string"]);
+		const after = getString(item, ["after", "new", "newString", "new_string"]);
+		const type = getString(item, ["type", "operation"]);
+		if (!filePath || before === undefined || after === undefined) continue;
+		files.push({
+			filePath,
+			before,
+			after,
+			...(movePath === undefined ? {} : { movePath }),
+			...(type === undefined ? {} : { type }),
+		});
+	}
+	return files;
+}
+
+export function parseApplyPatchRequests(patch: string, sourceToolName = "apply_patch"): CommentCheckRequest[] {
+	const requests: CommentCheckRequest[] = [];
+	let current: ApplyPatchAccumulator | undefined;
+
+	const flush = (): void => {
+		if (!current) return;
+		if (current.operation === "add") {
+			const content = joinPatchLines(current.newLines);
+			if (content.length > 0) {
+				requests.push({
+					sourceToolName,
+					toolName: "Write",
+					filePath: current.filePath,
+					toolInput: {
+						file_path: current.filePath,
+						content,
+					},
+				});
+			}
+		}
+		if (current.operation === "update") {
+			const newString = joinPatchLines(current.newLines);
+			if (newString.length > 0) {
+				const filePath = current.movePath ?? current.filePath;
+				requests.push({
+					sourceToolName,
+					toolName: "Edit",
+					filePath,
+					toolInput: {
+						file_path: filePath,
+						old_string: joinPatchLines(current.oldLines),
+						new_string: newString,
+					},
+				});
+			}
+		}
+		current = undefined;
+	};
+
+	for (const line of patch.split(/\r?\n/)) {
+		if (line === "*** Begin Patch" || line === "*** End Patch") continue;
+		if (line.startsWith("*** Add File: ")) {
+			flush();
+			current = makeAccumulator("add", line.slice("*** Add File: ".length).trim());
+			continue;
+		}
+		if (line.startsWith("*** Update File: ")) {
+			flush();
+			current = makeAccumulator("update", line.slice("*** Update File: ".length).trim());
+			continue;
+		}
+		if (line.startsWith("*** Delete File: ")) {
+			flush();
+			current = makeAccumulator("delete", line.slice("*** Delete File: ".length).trim());
+			continue;
+		}
+		if (line.startsWith("*** Move to: ")) {
+			if (current?.operation === "update") current.movePath = line.slice("*** Move to: ".length).trim();
+			continue;
+		}
+		if (!current) continue;
+		if (line.startsWith("@@")) continue;
+		if (current.operation === "add") {
+			if (line.startsWith("+")) current.newLines.push(line.slice(1));
+			continue;
+		}
+		if (current.operation === "update") {
+			if (line.startsWith("+")) current.newLines.push(line.slice(1));
+			if (line.startsWith("-")) current.oldLines.push(line.slice(1));
+		}
+	}
+
+	flush();
+	return requests;
+}
+
+function makeAccumulator(operation: ApplyPatchAccumulator["operation"], filePath: string): ApplyPatchAccumulator {
+	return {
+		operation,
+		filePath,
+		oldLines: [],
+		newLines: [],
+	};
+}
+
+function getEdits(value: unknown): CheckerEdit[] {
+	if (!Array.isArray(value)) return [];
+	const edits: CheckerEdit[] = [];
+	for (const item of value) {
+		if (!isRecord(item)) continue;
+		const oldString = getString(item, ["oldString", "old_string"]);
+		const newString = getString(item, ["newString", "new_string"]);
+		if (oldString === undefined || newString === undefined) continue;
+		edits.push({
+			old_string: oldString,
+			new_string: newString,
+		});
+	}
+	return edits;
+}
+
+function getContentText(content: ToolResultContent[] | undefined): string {
+	if (!content) return "";
+	return content
+		.filter((block): block is TextContent => block.type === "text")
+		.map((block) => block.text)
+		.join("\n");
+}
+
+function getString(input: Record<string, unknown>, keys: string[]): string | undefined {
+	for (const key of keys) {
+		const value = input[key];
+		if (typeof value === "string") return value;
+	}
+	return undefined;
+}
+
+function joinPatchLines(lines: string[]): string {
+	return lines.length === 0 ? "" : `${lines.join("\n")}\n`;
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}

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");
+	});
+});