oh-my-opencode 4.5.1 → 4.6.0

package/packages/omo-codex/plugin/components/comment-checker/.github/workflows/ci.yml

@@ -0,0 +1,47 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: test (${{ matrix.os }} · node ${{ matrix.node }})
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 15
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        node: ["20", "22"]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+
+      - name: Setup Node ${{ matrix.node }}
+        uses: actions/setup-node@v6
+        with:
+          node-version: ${{ matrix.node }}
+          cache: npm
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Check
+        run: npm run check
+
+      - name: Unit tests
+        run: npm test
+
+      - name: Package smoke
+        run: npm pack --dry-run

package/packages/omo-codex/plugin/components/comment-checker/.github/workflows/publish.yml

@@ -0,0 +1,51 @@
+name: publish
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+
+      - name: Setup Node 22
+        uses: actions/setup-node@v6
+        with:
+          node-version: "22"
+          registry-url: https://registry.npmjs.org
+          cache: npm
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Check
+        run: npm run check
+
+      - name: Unit tests
+        run: npm test
+
+      - name: Package smoke
+        run: npm pack --dry-run
+
+      - name: Publish to npm
+        run: |
+          if [ -z "$NODE_AUTH_TOKEN" ]; then
+            echo "NODE_AUTH_TOKEN is not configured; skipping npm publish."
+            exit 0
+          fi
+          npm publish --access public --provenance
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NODE_AUTH_TOKEN }}

package/packages/omo-codex/plugin/components/comment-checker/AGENTS.md

@@ -0,0 +1,35 @@
+# Repository Conventions
+
+Conventions for human contributors and AI agents working on this repository.
+
+## Style
+
+- Terse technical prose. No emojis in commits, issues, PR comments, or code.
+- TypeScript strict mode. No `any`, no `unknown` casts where avoidable, no `@ts-ignore`, no `@ts-expect-error`, no enums.
+- ESM modules with `.js` suffix in runtime import paths.
+- Tabs for indentation. Double quotes for strings.
+- Tests use vitest with `#given .. #when .. #then` descriptions or plain `// given / // when / // then` body comments.
+
+## Commands
+
+- `npm install` - install dependencies.
+- `npm test` - run vitest once.
+- `npm run typecheck` - strict TypeScript check.
+- `npm run check` - type check, biome, and build.
+- `npm pack --dry-run` - release package smoke test.
+- `node dist/cli.js hook post-tool-use < fixture.json` - smoke-test the Codex hook.
+
+## Constraints
+
+- No Bun APIs. Runtime is Node only because Codex launches plugin hooks with Node.
+- Keep Codex `PostToolUse` hook behavior covered by tests.
+- Keep `apply_patch` extraction covered by tests.
+- `apply_patch` must support Codex `tool_input.command`, raw patch text, and OMO-compatible metadata.
+- Hook output must use the stable Codex hook JSON contract.
+- Do not expose an MCP server or MCP tool from this plugin.
+
+## Don'ts
+
+- No `git add -A` or `git add .`. Stage only the files you changed.
+- No `git commit --no-verify`. No force pushes. No history rewriting on shared branches.
+- Do not couple this package back to pi, omo, or senpi internal source paths.

package/packages/omo-codex/plugin/components/comment-checker/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+## Unreleased
+
+### Added
+
+- Restore `write`, `edit`, `multi_edit`, and `multiedit` PostToolUse coverage alongside `apply_patch`.
+- Forward Codex `transcript_path` into native comment-checker hook input when available.
+- Add package smoke coverage for portable hook entrypoints.
+
+### Changed
+
+- Treat the native checker binary as an optional dependency for unsupported platforms.
+- Cap child process stdout/stderr captured from the native checker.
+- Run CI on Windows in addition to Ubuntu and macOS.
+
+## [0.1.1] - 2026-05-15
+
+### Changed
+
+- Limit automatic comment checking to successful `apply_patch` hook events.
+- Remove the `comment_check` MCP tool and MCP server configuration.
+- Update plugin metadata, docs, and contributor guidance to describe hook-only behavior.
+
+## [0.1.0] - 2026-05-15
+
+### Added
+
+- Initial `codex-comment-checker` Codex plugin.
+- `PostToolUse` hook for `apply_patch`, `write`, `edit`, and `multiedit` style tool calls.
+- Blocking hook feedback when `comment-checker` reports warnings.
+- `comment_check` MCP tool for explicit write/edit/multiedit checks.
+- Codex plugin manifest, local MCP config, bundled skill, and GitHub repository metadata.

package/packages/omo-codex/plugin/components/comment-checker/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yeongyu Kim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/packages/omo-codex/plugin/components/comment-checker/NOTICE

@@ -0,0 +1,6 @@
+codex-comment-checker
+
+This package ports the pi-comment-checker hook into a Codex plugin repository.
+
+The plugin targets Codex plugin manifests and plugin-bundled lifecycle hooks.
+The checker engine is provided by @code-yeongyu/comment-checker.

package/packages/omo-codex/plugin/components/comment-checker/README.md

@@ -0,0 +1,87 @@
+# codex-comment-checker
+
+[![ci](https://github.com/code-yeongyu/codex-comment-checker/actions/workflows/ci.yml/badge.svg)](https://github.com/code-yeongyu/codex-comment-checker/actions/workflows/ci.yml) [![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Codex plugin that runs [`@code-yeongyu/comment-checker`](https://github.com/code-yeongyu/go-claude-code-comment-checker) after successful edit-like `PostToolUse` hook calls.
+
+## Behavior
+
+| Case | Result |
+|------|--------|
+| `apply_patch` succeeds | parses `tool_input.command` and checks added/updated files |
+| `write`, `edit`, `multi_edit`, or `multiedit` succeeds | maps the Codex payload to the native checker hook input |
+| non-edit tool succeeds | ignored |
+| checker exits `2` | returns Codex `PostToolUse` blocking feedback so the model fixes or explains the warning |
+| checker binary missing or unavailable on the current platform | emits no hook output |
+| checker exits unexpectedly | leaves hook output unchanged |
+
+Deletes are ignored because they cannot introduce new comments.
+
+## Codex Plugin
+
+The plugin ships:
+
+- `.codex-plugin/plugin.json` for Codex plugin discovery.
+- `hooks/hooks.json` for the `PostToolUse` hook.
+- `skills/comment-checker/SKILL.md` with usage guidance.
+
+The hook command is:
+
+```bash
+node "${PLUGIN_ROOT}/dist/cli.js" hook post-tool-use
+```
+
+No MCP server or `comment_check` tool is exposed.
+
+## Local Development
+
+```bash
+npm install
+npm test
+npm run typecheck
+npm run check
+npm pack --dry-run
+```
+
+Smoke-test the hook:
+
+```bash
+node dist/cli.js hook post-tool-use < test/fixtures/post-tool-use.json
+```
+
+## Local Codex Installation
+
+```bash
+npx lazycodex-ai install
+```
+
+The installer builds and copies the plugin into `~/.codex/plugins/cache/sisyphuslabs/omo/0.1.0`, registers the `sisyphuslabs` marketplace from the `lazycodex` Git repository, installs runtime dependencies there, and enables:
+
+```toml
+[features]
+plugins = true
+plugin_hooks = true
+
+[plugins."omo@sisyphuslabs"]
+enabled = true
+```
+
+## Branch Rules and Releases
+
+- `main` is protected by `.github/branch-ruleset.json`.
+- CI runs Node 20 and 22 on Ubuntu, macOS, and Windows.
+- Releases are GitHub Releases tagged as `v<semver>`.
+- Publishing runs from the `publish` workflow after a GitHub Release is published.
+
+## Privacy
+
+This plugin runs locally. It sends hook input to the optional local `comment-checker` binary when available and does not call a network service by itself.
+
+## License
+
+[MIT](LICENSE).
+
+## Related
+
+- [pi-comment-checker](https://github.com/code-yeongyu/pi-comment-checker) - source extension this Codex plugin ports.
+- [comment-checker](https://github.com/code-yeongyu/go-claude-code-comment-checker) - native checker binary.

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

@@ -0,0 +1,48 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.4.15/schema.json",
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"recommended": true,
+			"style": {
+				"noDefaultExport": "error",
+				"noEnum": "error",
+				"noNonNullAssertion": "error",
+				"useImportType": "error",
+				"useConst": "error",
+				"useNodejsImportProtocol": "off"
+			},
+			"complexity": {
+				"useLiteralKeys": "off"
+			},
+			"suspicious": {
+				"noExplicitAny": "error",
+				"noTsIgnore": "error",
+				"noControlCharactersInRegex": "off",
+				"noEmptyInterface": "off"
+			}
+		}
+	},
+	"formatter": {
+		"enabled": true,
+		"formatWithErrors": false,
+		"indentStyle": "tab",
+		"indentWidth": 3,
+		"lineWidth": 120
+	},
+	"files": {
+		"includes": ["src/**/*.ts", "test/**/*.ts", "vitest.config.ts", "!**/node_modules/**/*", "!**/dist/**/*"]
+	},
+	"overrides": [
+		{
+			"includes": ["vitest.config.ts"],
+			"linter": {
+				"rules": {
+					"style": {
+						"noDefaultExport": "off"
+					}
+				}
+			}
+		}
+	]
+}

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

@@ -0,0 +1,17 @@
+{
+	"hooks": {
+		"PostToolUse": [
+			{
+				"matcher": "^(apply_patch|write|Write|edit|Edit|multi_edit|multiedit|MultiEdit)$",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use",
+						"timeout": 30,
+						"statusMessage": "LazyCodex(0.1.1): Checking Comments"
+					}
+				]
+			}
+		]
+	}
+}

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

@@ -0,0 +1,57 @@
+{
+	"name": "@code-yeongyu/codex-comment-checker",
+	"version": "0.1.1",
+	"description": "Codex plugin that runs comment-checker after edit-like PostToolUse hooks.",
+	"type": "module",
+	"packageManager": "npm@11.12.1",
+	"license": "MIT",
+	"homepage": "https://github.com/code-yeongyu/codex-comment-checker",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/code-yeongyu/codex-comment-checker.git"
+	},
+	"bugs": {
+		"url": "https://github.com/code-yeongyu/codex-comment-checker/issues"
+	},
+	"keywords": [
+		"codex",
+		"codex-plugin",
+		"comment-checker",
+		"hooks",
+		"typescript"
+	],
+	"bin": {
+		"omo-comment-checker": "./dist/cli.js"
+	},
+	"files": [
+		"dist",
+		"hooks",
+		"skills",
+		".codex-plugin",
+		"LICENSE",
+		"NOTICE",
+		"README.md",
+		"CHANGELOG.md"
+	],
+	"scripts": {
+		"build": "tsc -p tsconfig.build.json",
+		"test": "vitest --run",
+		"test:watch": "vitest",
+		"typecheck": "tsc --noEmit",
+		"lint": "biome check .",
+		"lint:fix": "biome check --write .",
+		"check": "tsc --noEmit && biome check . && npm run build"
+	},
+	"optionalDependencies": {
+		"@code-yeongyu/comment-checker": "^0.8.0"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.4.15",
+		"@types/node": "^25.7.0",
+		"typescript": "^6.0.3",
+		"vitest": "^4.1.5"
+	},
+	"engines": {
+		"node": ">=20.0.0"
+	}
+}

package/packages/omo-codex/plugin/components/comment-checker/skills/comment-checker/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: comment-checker
+description: Use when Codex needs to understand or respond to automatic comment-checker feedback emitted after an edit-like PostToolUse hook.
+---
+
+# Codex Comment Checker
+
+The plugin registers a `PostToolUse` hook for successful `apply_patch`, `write`, `edit`, `multi_edit`, and `multiedit` calls.
+
+When comment-checker reports a warning after a patch, Codex receives blocking feedback and should fix or explain the flagged comment before moving on.
+
+## Scope
+
+- No MCP tool is exposed.
+- Non-edit tools are ignored by this plugin.
+- Missing checker binaries emit no hook output so normal Codex work can continue.

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

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+import { runCodexHookCli } from "./codex-hook.js";
+
+const [command, subcommand] = process.argv.slice(2);
+
+if (command === "hook" && subcommand === "post-tool-use") {
+	await runCodexHookCli();
+} else {
+	process.stderr.write("Usage: omo-comment-checker hook post-tool-use\n");
+	process.exitCode = 2;
+}

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

@@ -0,0 +1,205 @@
+import { readFileSync } from "node:fs";
+import { stdin as processStdin, stdout as processStdout } from "node:process";
+
+import {
+	type CommentCheckRequest,
+	extractCommentCheckRequests,
+	isRecord,
+	type ToolResultContent,
+	type ToolResultLike,
+	toHookInput,
+} from "./core.js";
+import { type CommentCheckerRunner, runCommentChecker } from "./runner.js";
+
+export type CodexPostToolUseInput = {
+	session_id: string;
+	turn_id: string;
+	transcript_path: string | null;
+	cwd: string;
+	hook_event_name: "PostToolUse";
+	model: string;
+	permission_mode: string;
+	tool_name: string;
+	tool_input: Record<string, unknown>;
+	tool_response: unknown;
+	tool_use_id: string;
+};
+
+export type CodexHookOptions = {
+	run?: CommentCheckerRunner;
+};
+
+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",
+] as const;
+
+export function extractCodexCommentCheckRequests(input: CodexPostToolUseInput): CommentCheckRequest[] {
+	return extractCommentCheckRequests(toToolResultLike(input));
+}
+
+export async function runCommentCheckerPostToolUse(
+	input: CodexPostToolUseInput,
+	options: CodexHookOptions = {},
+): Promise<string> {
+	const requests = extractCodexCommentCheckRequests(input);
+	if (requests.length === 0) return "";
+
+	const runner = options.run ?? runCommentChecker;
+	const warnings: Array<{ filePath: string; message: string }> = [];
+
+	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(): Promise<void> {
+	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: string): CodexPostToolUseInput | undefined {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(input);
+	} catch {
+		return undefined;
+	}
+	return isCodexPostToolUseInput(parsed) ? parsed : undefined;
+}
+
+function toToolResultLike(input: CodexPostToolUseInput): ToolResultLike {
+	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: string, toolInput: Record<string, unknown>): Record<string, unknown> {
+	if (toolName === "apply_patch" && typeof toolInput["command"] === "string") {
+		return {
+			...toolInput,
+			input: toolInput["command"],
+			patch: toolInput["command"],
+		};
+	}
+	return toolInput;
+}
+
+function normalizeToolResponse(toolResponse: unknown): ToolResultContent[] {
+	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: unknown): boolean {
+	return isRecord(toolResponse) && toolResponse["is_error"] === true;
+}
+
+function formatWarnings(warnings: Array<{ filePath: string; message: string }>): string {
+	return warnings
+		.map((warning) => `comment-checker found issues in ${warning.filePath}:\n${warning.message}`)
+		.join("\n\n");
+}
+
+function normalizeHookText(value: string): string {
+	return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+}
+
+function hookFeedbackLimit(transcriptPath: string | null): number {
+	return isContextPressureTranscript(transcriptPath)
+		? CONTEXT_PRESSURE_MAX_HOOK_FEEDBACK_CHARS
+		: DEFAULT_MAX_HOOK_FEEDBACK_CHARS;
+}
+
+function isContextPressureTranscript(transcriptPath: string | null): boolean {
+	if (transcriptPath === null) return false;
+	try {
+		return hasContextPressureMarker(readFileSync(transcriptPath, "utf8"));
+	} catch (error) {
+		if (error instanceof Error) return false;
+		throw error;
+	}
+}
+
+function hasContextPressureMarker(text: string): boolean {
+	const normalizedText = text.toLowerCase();
+	return CONTEXT_PRESSURE_MARKERS.some((marker) => normalizedText.includes(marker));
+}
+
+function limitHookText(text: string, maxChars: number): string {
+	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: unknown): value is CodexPostToolUseInput {
+	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(): Promise<string> {
+	return new Promise((resolve, reject) => {
+		let data = "";
+		processStdin.setEncoding("utf-8");
+		processStdin.on("data", (chunk: string) => {
+			data += chunk;
+		});
+		processStdin.once("error", reject);
+		processStdin.once("end", () => {
+			resolve(data);
+		});
+	});
+}