oh-my-opencode 4.8.0 → 4.9.0

package/packages/omo-codex/plugin/components/comment-checker/dist/codex-hook.js

@@ -0,0 +1,165 @@
+import { readFileSync } from "node:fs";
+import { stdin as processStdin, stdout as processStdout } from "node:process";
+import { extractCommentCheckRequests, isRecord, toHookInput, } from "./core.js";
+import { runCommentChecker } from "./runner.js";
+const DEFAULT_MAX_HOOK_FEEDBACK_CHARS = 8000;
+const CONTEXT_PRESSURE_MAX_HOOK_FEEDBACK_CHARS = 1200;
+const CONTEXT_PRESSURE_MARKERS = [
+    "context compacted",
+    "context_length_exceeded",
+    "skill descriptions were shortened",
+    "context_too_large",
+    "codex ran out of room in the model's context window",
+    "your input exceeds the context window",
+    "long threads and multiple compactions",
+];
+export function extractCodexCommentCheckRequests(input) {
+    return extractCommentCheckRequests(toToolResultLike(input));
+}
+export async function runCommentCheckerPostToolUse(input, options = {}) {
+    const requests = extractCodexCommentCheckRequests(input);
+    if (requests.length === 0)
+        return "";
+    const runner = options.run ?? runCommentChecker;
+    const warnings = [];
+    for (const request of requests) {
+        const context = {
+            sessionId: input.session_id,
+            cwd: input.cwd,
+            ...(input.transcript_path === null ? {} : { transcriptPath: input.transcript_path }),
+        };
+        const result = await runner(toHookInput(request, context));
+        if (result.status === "missing" || result.status === "pass")
+            continue;
+        if (result.status === "error")
+            continue;
+        const message = normalizeHookText(result.message);
+        if (message.length > 0) {
+            warnings.push({ filePath: request.filePath, message });
+        }
+    }
+    if (warnings.length === 0)
+        return "";
+    return JSON.stringify({
+        decision: "block",
+        reason: limitHookText(formatWarnings(warnings), hookFeedbackLimit(input.transcript_path)),
+    });
+}
+export async function runCodexHookCli() {
+    const input = await readStdin();
+    if (input.trim().length === 0)
+        return;
+    const parsed = parseCodexPostToolUseInput(input);
+    if (!parsed)
+        return;
+    const output = await runCommentCheckerPostToolUse(parsed);
+    if (output.length > 0) {
+        processStdout.write(output);
+        processStdout.write("\n");
+    }
+}
+export function parseCodexPostToolUseInput(input) {
+    let parsed;
+    try {
+        parsed = JSON.parse(input);
+    }
+    catch {
+        return undefined;
+    }
+    return isCodexPostToolUseInput(parsed) ? parsed : undefined;
+}
+function toToolResultLike(input) {
+    return {
+        toolName: input.tool_name,
+        input: normalizeToolInput(input.tool_name, input.tool_input),
+        content: normalizeToolResponse(input.tool_response),
+        isError: isErrorResponse(input.tool_response),
+        details: isRecord(input.tool_response) ? input.tool_response : undefined,
+    };
+}
+function normalizeToolInput(toolName, toolInput) {
+    if (toolName === "apply_patch" && typeof toolInput["command"] === "string") {
+        return {
+            ...toolInput,
+            input: toolInput["command"],
+            patch: toolInput["command"],
+        };
+    }
+    return toolInput;
+}
+function normalizeToolResponse(toolResponse) {
+    if (typeof toolResponse === "string") {
+        return [{ type: "text", text: toolResponse }];
+    }
+    if (isRecord(toolResponse) && typeof toolResponse["text"] === "string") {
+        return [{ type: "text", text: toolResponse["text"] }];
+    }
+    return [];
+}
+function isErrorResponse(toolResponse) {
+    return isRecord(toolResponse) && toolResponse["is_error"] === true;
+}
+function formatWarnings(warnings) {
+    return warnings
+        .map((warning) => `comment-checker found issues in ${warning.filePath}:\n${warning.message}`)
+        .join("\n\n");
+}
+function normalizeHookText(value) {
+    return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+}
+function hookFeedbackLimit(transcriptPath) {
+    return isContextPressureTranscript(transcriptPath)
+        ? CONTEXT_PRESSURE_MAX_HOOK_FEEDBACK_CHARS
+        : DEFAULT_MAX_HOOK_FEEDBACK_CHARS;
+}
+function isContextPressureTranscript(transcriptPath) {
+    if (transcriptPath === null)
+        return false;
+    try {
+        return hasContextPressureMarker(readFileSync(transcriptPath, "utf8"));
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return false;
+        throw error;
+    }
+}
+function hasContextPressureMarker(text) {
+    const normalizedText = text.toLowerCase();
+    return CONTEXT_PRESSURE_MARKERS.some((marker) => normalizedText.includes(marker));
+}
+function limitHookText(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const marker = `\n\n[Truncated hook output to ${maxChars} chars to avoid Codex context overflow.]`;
+    if (marker.length >= maxChars)
+        return marker.slice(0, maxChars);
+    const head = text.slice(0, maxChars - marker.length).replace(/[ \t\r\n]+$/, "");
+    return `${head}${marker}`;
+}
+function isCodexPostToolUseInput(value) {
+    return (isRecord(value) &&
+        value["hook_event_name"] === "PostToolUse" &&
+        typeof value["session_id"] === "string" &&
+        typeof value["turn_id"] === "string" &&
+        (typeof value["transcript_path"] === "string" || value["transcript_path"] === null) &&
+        typeof value["cwd"] === "string" &&
+        typeof value["model"] === "string" &&
+        typeof value["permission_mode"] === "string" &&
+        typeof value["tool_name"] === "string" &&
+        isRecord(value["tool_input"]) &&
+        typeof value["tool_use_id"] === "string");
+}
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        processStdin.setEncoding("utf-8");
+        processStdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        processStdin.once("error", reject);
+        processStdin.once("end", () => {
+            resolve(data);
+        });
+    });
+}

package/packages/omo-codex/plugin/components/comment-checker/dist/core-values.d.ts

@@ -0,0 +1 @@
+export { getString, isRecord } from "./record.js";

package/packages/omo-codex/plugin/components/comment-checker/dist/core-values.js

@@ -0,0 +1 @@
+export { getString, isRecord } from "./record.js";

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

@@ -0,0 +1,5 @@
+export { parseApplyPatchRequests } from "./apply-patch.js";
+export { toHookInput } from "./hook-input.js";
+export { isRecord } from "./record.js";
+export { extractCommentCheckRequests, isToolFailureOutput } from "./request-extractor.js";
+export type { CheckerEdit, CheckerToolInput, CheckerToolName, CommentCheckerHookInput, CommentCheckRequest, ImageContent, TextContent, ToolResultContent, ToolResultLike, } from "./types.js";

package/packages/omo-codex/plugin/components/comment-checker/dist/core.js

@@ -0,0 +1,4 @@
+export { parseApplyPatchRequests } from "./apply-patch.js";
+export { toHookInput } from "./hook-input.js";
+export { isRecord } from "./record.js";
+export { extractCommentCheckRequests, isToolFailureOutput } from "./request-extractor.js";

package/packages/omo-codex/plugin/components/comment-checker/dist/hook-input.d.ts

@@ -0,0 +1,6 @@
+import type { CommentCheckerHookInput, CommentCheckRequest } from "./types.js";
+export declare function toHookInput(request: CommentCheckRequest, context: {
+    readonly sessionId: string;
+    readonly cwd: string;
+    readonly transcriptPath?: string;
+}): CommentCheckerHookInput;

package/packages/omo-codex/plugin/components/comment-checker/dist/hook-input.js

@@ -0,0 +1,10 @@
+export function toHookInput(request, context) {
+    return {
+        session_id: context.sessionId,
+        tool_name: request.toolName,
+        transcript_path: context.transcriptPath ?? "",
+        cwd: context.cwd,
+        hook_event_name: "PostToolUse",
+        tool_input: request.toolInput,
+    };
+}

package/packages/omo-codex/plugin/components/comment-checker/dist/record.d.ts

@@ -0,0 +1,2 @@
+export declare function getString(input: Record<string, unknown>, keys: readonly string[]): string | undefined;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/packages/omo-codex/plugin/components/comment-checker/dist/record.js

@@ -0,0 +1,11 @@
+export function getString(input, keys) {
+    for (const key of keys) {
+        const value = input[key];
+        if (typeof value === "string")
+            return value;
+    }
+    return undefined;
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/packages/omo-codex/plugin/components/comment-checker/dist/request-extractor.d.ts

@@ -0,0 +1,3 @@
+import type { CommentCheckRequest, ToolResultLike } from "./types.js";
+export declare function extractCommentCheckRequests(event: ToolResultLike): CommentCheckRequest[];
+export declare function isToolFailureOutput(text: string): boolean;

package/packages/omo-codex/plugin/components/comment-checker/dist/request-extractor.js

@@ -0,0 +1,104 @@
+import { extractApplyPatchRequests } from "./apply-patch.js";
+import { getString, isRecord } from "./record.js";
+export function extractCommentCheckRequests(event) {
+    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 isToolFailureOutput(text) {
+    const lower = text.trim().toLowerCase();
+    return (lower.startsWith("error") ||
+        lower.includes("error:") ||
+        lower.includes("failed to") ||
+        lower.includes("could not"));
+}
+function extractWriteRequest(event) {
+    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) {
+    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 [];
+    return [
+        {
+            sourceToolName: event.toolName,
+            toolName: "Edit",
+            filePath,
+            toolInput: {
+                file_path: filePath,
+                old_string: oldString,
+                new_string: newString,
+            },
+        },
+    ];
+}
+function extractMultiEditRequest(event) {
+    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 getEdits(value) {
+    if (!Array.isArray(value))
+        return [];
+    const edits = [];
+    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) {
+    if (!content)
+        return "";
+    return content
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("\n");
+}

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

@@ -0,0 +1,26 @@
+import type { CommentCheckerHookInput } from "./core.js";
+export type ProcessResult = {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+};
+export declare const MAX_PROCESS_OUTPUT_BYTES: number;
+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 declare function runCommentChecker(input: CommentCheckerHookInput, options?: RunCommentCheckerOptions): Promise<CommentCheckerRunResult>;
+export declare function resolveCommentCheckerBinary(): string | undefined;
+export declare function spawnProcess(command: string, args: string[], stdin: string, maxOutputBytes?: number): Promise<ProcessResult>;

package/packages/omo-codex/plugin/components/comment-checker/dist/runner.js

@@ -0,0 +1,144 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+export const MAX_PROCESS_OUTPUT_BYTES = 64 * 1024;
+export async function runCommentChecker(input, options = {}) {
+    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() {
+    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() {
+    try {
+        const require = createRequire(import.meta.url);
+        const packageExports = 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) {
+    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) {
+    return isRecord(value) && typeof value["getBinaryPath"] === "function";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function appendOutput(output, chunk, maxOutputBytes) {
+    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, streamName, maxOutputBytes) {
+    if (!output.truncated)
+        return output.text;
+    return `${output.text}\n[${streamName} truncated after ${maxOutputBytes} bytes]`;
+}
+export function spawnProcess(command, args, stdin, maxOutputBytes = MAX_PROCESS_OUTPUT_BYTES) {
+    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 = { text: "", bytes: 0, truncated: false };
+        const stderr = { text: "", bytes: 0, truncated: false };
+        proc.stdout.setEncoding("utf-8");
+        proc.stderr.setEncoding("utf-8");
+        proc.stdout.on("data", (chunk) => {
+            appendOutput(stdout, chunk, outputByteLimit);
+        });
+        proc.stderr.on("data", (chunk) => {
+            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/dist/types.d.ts

@@ -0,0 +1,43 @@
+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;
+};

package/packages/omo-codex/plugin/components/comment-checker/dist/types.js

@@ -0,0 +1 @@
+export {};

package/packages/omo-codex/plugin/components/comment-checker/hooks/hooks.json

@@ -8,7 +8,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use",
 						"timeout": 30,
-						"statusMessage": "LazyCodex(0.1.1): Checking Comments"
+						"statusMessage": "LazyCodex(4.9.0): Checking Comments"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/comment-checker/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-comment-checker",
-	"version": "0.1.1",
+	"version": "4.9.0",
 	"description": "Codex plugin that runs comment-checker after edit-like PostToolUse hooks.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/git-bash/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/packages/omo-codex/plugin/components/git-bash/dist/cli.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import { runGitBashHookCli } from "./codex-hook.js";
+const TOP_LEVEL_HELP = "Usage:\n  omo-git-bash-hook hook pre-tool-use\n  omo-git-bash-hook hook post-compact\n  omo-git-bash-hook help | --help | -h\n";
+async function main() {
+    const argv = process.argv.slice(2);
+    const command = argv[0];
+    if (command === undefined || command === "help" || command === "--help" || command === "-h") {
+        process.stdout.write(TOP_LEVEL_HELP);
+        return 0;
+    }
+    if (command === "hook" && argv[1] === "pre-tool-use") {
+        await runGitBashHookCli(process.stdin, process.stdout, "pre-tool-use");
+        return 0;
+    }
+    if (command === "hook" && argv[1] === "post-compact") {
+        await runGitBashHookCli(process.stdin, process.stdout, "post-compact");
+        return 0;
+    }
+    process.stderr.write(`[omo-git-bash-hook] unknown command: ${argv.join(" ")}\n${TOP_LEVEL_HELP}`);
+    return 1;
+}
+main()
+    .then((code) => {
+    process.exit(code);
+})
+    .catch((error) => {
+    process.stderr.write(`[omo-git-bash-hook] ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+});

package/packages/omo-codex/plugin/components/git-bash/dist/codex-hook.d.ts

@@ -0,0 +1,28 @@
+export interface PreToolUsePayload {
+    readonly cwd: string;
+    readonly hook_event_name: "PreToolUse";
+    readonly model: string;
+    readonly permission_mode: string;
+    readonly session_id: string;
+    readonly tool_input: unknown;
+    readonly tool_name: string;
+    readonly tool_use_id: string;
+    readonly transcript_path: string | null;
+    readonly turn_id: string;
+}
+export interface GitBashHookOptions {
+    readonly env?: NodeJS.ProcessEnv;
+    readonly platform?: NodeJS.Platform | string;
+    readonly pluginDataRoot?: string;
+}
+export interface PostCompactPayload {
+    readonly hook_event_name: "PostCompact";
+    readonly session_id: string;
+    readonly transcript_path?: string | null;
+    readonly trigger?: string;
+}
+export declare function parsePreToolUsePayload(raw: string): PreToolUsePayload | null;
+export declare function parsePostCompactPayload(raw: string): PostCompactPayload | null;
+export declare function applyGitBashPreToolUseReminder(payload: PreToolUsePayload, options?: GitBashHookOptions): string;
+export declare function applyGitBashPostCompactReset(payload: PostCompactPayload, options?: GitBashHookOptions): string;
+export declare function runGitBashHookCli(stdin: NodeJS.ReadableStream, stdout: NodeJS.WritableStream, eventName?: "pre-tool-use" | "post-compact", options?: GitBashHookOptions): Promise<void>;