oh-my-opencode 4.5.1 → 4.5.12

package/packages/omo-codex/plugin/components/rules/test/matcher.test.ts

@@ -0,0 +1,206 @@
+import { describe, expect, it } from "vitest";
+
+import { matchRule, normalizeGlobs } from "../src/rules/matcher.js";
+import type { RuleFrontmatter } from "../src/rules/types.js";
+
+function matchFrontmatter(
+	frontmatter: RuleFrontmatter,
+	pathBases: {
+		projectRelative: string;
+		scopeRelative?: string;
+		basename?: string;
+	},
+): ReturnType<typeof matchRule> {
+	const scopeRelative = pathBases.scopeRelative;
+	const pathBase = {
+		projectRelative: pathBases.projectRelative,
+		basename: pathBases.basename ?? pathBases.projectRelative.split("/").at(-1) ?? pathBases.projectRelative,
+		...(scopeRelative === undefined ? {} : { scopeRelative }),
+	};
+	return matchRule({
+		frontmatter,
+		isSingleFile: false,
+		pathBases: pathBase,
+	});
+}
+
+function matchGlobs(globs: string | string[], projectRelative: string): boolean {
+	return matchFrontmatter({ globs } satisfies RuleFrontmatter, { projectRelative }).matched;
+}
+
+describe("matchRule", () => {
+	it("#given single-file rule #when matching any target #then it always matches", () => {
+		// given
+		const frontmatter = {} satisfies RuleFrontmatter;
+
+		// when
+		const result = matchRule({
+			frontmatter,
+			isSingleFile: true,
+			pathBases: { projectRelative: "docs/readme.md", basename: "readme.md" },
+		});
+
+		// then
+		expect(result).toEqual({ matched: true, reason: "single-file" });
+	});
+
+	it("#given always apply rule #when no glob is configured #then it matches", () => {
+		// given
+		const frontmatter = { alwaysApply: true } satisfies RuleFrontmatter;
+
+		// when
+		const result = matchFrontmatter(frontmatter, { projectRelative: "src/app.ts" });
+
+		// then
+		expect(result).toEqual({ matched: true, reason: "alwaysApply" });
+	});
+
+	it("#given rule without patterns #when target is checked #then no match is returned", () => {
+		// given
+		const frontmatter = {} satisfies RuleFrontmatter;
+
+		// when
+		const result = matchFrontmatter(frontmatter, { projectRelative: "src/app.ts" });
+
+		// then
+		expect(result).toEqual({ matched: false, reason: { kind: "no-match" } });
+	});
+
+	it("#given recursive glob #when target is nested #then matches without runtime dependencies", () => {
+		// given
+		const globs = "**/*.ts";
+
+		// when
+		const matched = matchGlobs(globs, "src/features/app.ts");
+
+		// then
+		expect(matched).toBe(true);
+	});
+
+	it("#given paths alias #when target matches #then glob match is returned", () => {
+		// given
+		const frontmatter = { paths: "src/**/*.ts" } satisfies RuleFrontmatter;
+
+		// when
+		const result = matchFrontmatter(frontmatter, { projectRelative: "src/features/app.ts" });
+
+		// then
+		expect(result).toEqual({ matched: true, reason: { kind: "glob", pattern: "src/**/*.ts" } });
+	});
+
+	it("#given applyTo alias #when basename matches #then glob match is returned", () => {
+		// given
+		const frontmatter = { applyTo: "*.md" } satisfies RuleFrontmatter;
+
+		// when
+		const result = matchFrontmatter(frontmatter, { projectRelative: "docs/README.md" });
+
+		// then
+		expect(result).toEqual({ matched: true, reason: { kind: "glob", pattern: "*.md" } });
+	});
+
+	it("#given scope-relative target #when scoped path matches #then glob match is returned", () => {
+		// given
+		const frontmatter = { globs: "components/**/*.tsx" } satisfies RuleFrontmatter;
+
+		// when
+		const result = matchFrontmatter(frontmatter, {
+			projectRelative: "packages/ui/components/button.tsx",
+			scopeRelative: "components/button.tsx",
+		});
+
+		// then
+		expect(result).toEqual({ matched: true, reason: { kind: "glob", pattern: "components/**/*.tsx" } });
+	});
+
+	it("#given backslash glob and target #when matching #then paths are normalized", () => {
+		// given
+		const frontmatter = { globs: "src\\**\\*.ts" } satisfies RuleFrontmatter;
+
+		// when
+		const result = matchFrontmatter(frontmatter, { projectRelative: "src\\features\\app.ts" });
+
+		// then
+		expect(result).toEqual({ matched: true, reason: { kind: "glob", pattern: "src/**/*.ts" } });
+	});
+
+	it("#given multiple positive globs #when later glob matches #then matching pattern is reported", () => {
+		// given
+		const frontmatter = { globs: ["docs/**/*.md", "src/**/*.ts"] } satisfies RuleFrontmatter;
+
+		// when
+		const result = matchFrontmatter(frontmatter, { projectRelative: "src/features/app.ts" });
+
+		// then
+		expect(result).toEqual({ matched: true, reason: { kind: "glob", pattern: "src/**/*.ts" } });
+	});
+
+	it("#given negative glob #when target is excluded #then no match is returned", () => {
+		// given
+		const globs = ["**/*.ts", "!**/*.test.ts"];
+
+		// when
+		const matched = matchGlobs(globs, "src/features/app.test.ts");
+
+		// then
+		expect(matched).toBe(false);
+	});
+
+	it("#given question-mark glob #when one filename character differs #then target matches", () => {
+		// given
+		const globs = "src/app-?.ts";
+
+		// when
+		const matched = matchGlobs(globs, "src/app-a.ts");
+
+		// then
+		expect(matched).toBe(true);
+	});
+
+	it("#given brace glob #when target extension is listed #then matches", () => {
+		// given
+		const globs = "src/**/*.{ts,tsx}";
+
+		// when
+		const matched = matchGlobs(globs, "src/features/app.tsx");
+
+		// then
+		expect(matched).toBe(true);
+	});
+
+	it("#given character class glob #when matching listed extension #then target matches", () => {
+		// given
+		const globs = "src/**/*.[tj]s";
+
+		// when
+		const matched = matchGlobs(globs, "src/features/app.ts");
+
+		// then
+		expect(matched).toBe(true);
+	});
+
+	it("#given extglob pattern #when matching allowed extension #then target matches", () => {
+		// given
+		const globs = "src/**/*.@(ts|tsx)";
+
+		// when
+		const matched = matchGlobs(globs, "src/features/app.tsx");
+
+		// then
+		expect(matched).toBe(true);
+	});
+
+	it("#given duplicate normalized patterns #when normalizing #then first unique pattern order is kept", () => {
+		// given
+		const frontmatter = {
+			globs: ["src\\**\\*.ts", "src/**/*.ts", "!src/**/*.test.ts"],
+			paths: "!src/**/*.test.ts",
+		} satisfies RuleFrontmatter;
+
+		// when
+		const patterns = normalizeGlobs(frontmatter);
+
+		// then
+		expect(patterns).toEqual(["src/**/*.ts", "!src/**/*.test.ts"]);
+	});
+});

package/packages/omo-codex/plugin/components/rules/test/package-smoke.test.ts

@@ -0,0 +1,151 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+
+type PackageJson = {
+	readonly type: string;
+	readonly packageManager: string;
+	readonly bin: Record<string, string>;
+	readonly files: readonly string[];
+	readonly dependencies?: Record<string, unknown>;
+};
+
+type PluginJson = {
+	readonly hooks: string;
+};
+
+type HookCommand = {
+	readonly command: string;
+};
+
+type HookEntry = {
+	readonly matcher?: string;
+	readonly hooks: readonly HookCommand[];
+};
+
+type HooksJson = {
+	readonly hooks: Record<string, readonly HookEntry[]>;
+};
+
+function readPackageJson(path: string): PackageJson {
+	const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+	if (!isPackageJson(parsed)) throw new TypeError(`Invalid package metadata: ${path}`);
+	return parsed;
+}
+
+function readPluginJson(path: string): PluginJson {
+	const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+	if (!isPluginJson(parsed)) throw new TypeError(`Invalid plugin metadata: ${path}`);
+	return parsed;
+}
+
+function readHooksJson(path: string): HooksJson {
+	const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+	if (!isHooksJson(parsed)) throw new TypeError(`Invalid hooks metadata: ${path}`);
+	return parsed;
+}
+
+describe("plugin package metadata", () => {
+	it("#given packaged plugin files #when validating entrypoints #then hook commands use portable plugin root interpolation", () => {
+		// given
+		const packageJson = readPackageJson("package.json");
+		const pluginJson = readPluginJson(".codex-plugin/plugin.json");
+		const hooksJson = readHooksJson("hooks/hooks.json");
+		const cliSource = readFileSync("src/cli.ts", "utf8");
+
+		// when
+		const hookConfig = hooksJson.hooks;
+		const pluginRoot = ["$", "{PLUGIN_ROOT}"].join("");
+		const commands = [
+			hookConfig["SessionStart"]?.[0]?.hooks[0]?.command,
+			hookConfig["UserPromptSubmit"]?.[0]?.hooks[0]?.command,
+			hookConfig["PostToolUse"]?.[0]?.hooks[0]?.command,
+			hookConfig["PostCompact"]?.[0]?.hooks[0]?.command,
+		];
+		const postToolUseMatcher = hookConfig["PostToolUse"]?.[0]?.matcher ?? "";
+
+		// then
+		expect(packageJson.type).toBe("module");
+		expect(packageJson.packageManager).toBe("npm@11.12.1");
+		expect(packageJson.dependencies ?? {}).toEqual({ picomatch: "^4.0.3" });
+		expect(packageJson.bin["omo-rules"]).toBe("./dist/cli.js");
+		expect(packageJson.files).toContain("bundled-rules");
+		expect(pluginJson.hooks).toBe("./hooks/hooks.json");
+		expect(cliSource.startsWith("#!/usr/bin/env node")).toBe(true);
+		expect(commands).toEqual([
+			`node "${pluginRoot}/dist/cli.js" hook session-start`,
+			`node "${pluginRoot}/dist/cli.js" hook user-prompt-submit`,
+			`node "${pluginRoot}/dist/cli.js" hook post-tool-use`,
+			`node "${pluginRoot}/dist/cli.js" hook post-compact`,
+		]);
+		expect(postToolUseMatcher).toBe("^apply_patch$");
+		const postToolUseMatcherRegex = new RegExp(postToolUseMatcher);
+		expect(postToolUseMatcherRegex.test("apply_patch")).toBe(true);
+		expect(
+			[
+				"read",
+				"Read",
+				"read_file",
+				"mcp__filesystem__read_file",
+				"mcp__filesystem__read_multiple_files",
+				"mcp__filesystem__write_file",
+				"mcp__filesystem__edit_file",
+				"write",
+				"Write",
+				"edit",
+				"Edit",
+				"multi_edit",
+				"MultiEdit",
+				"multiedit",
+				"exec_command",
+				"shell_command",
+				"bash",
+				"Bash",
+			].some((toolName) => postToolUseMatcherRegex.test(toolName)),
+		).toBe(false);
+	});
+});
+
+function isPackageJson(value: unknown): value is PackageJson {
+	if (!isRecord(value)) return false;
+	const dependencies = value["dependencies"];
+	return (
+		value["type"] === "module" &&
+		value["packageManager"] === "npm@11.12.1" &&
+		isStringRecord(value["bin"]) &&
+		isStringArray(value["files"]) &&
+		(dependencies === undefined || isRecord(dependencies))
+	);
+}
+
+function isStringArray(value: unknown): value is readonly string[] {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
+function isPluginJson(value: unknown): value is PluginJson {
+	return isRecord(value) && typeof value["hooks"] === "string";
+}
+
+function isHooksJson(value: unknown): value is HooksJson {
+	if (!isRecord(value) || !isRecord(value["hooks"])) return false;
+	return Object.values(value["hooks"]).every(isHookEntries);
+}
+
+function isHookEntries(value: unknown): value is readonly HookEntry[] {
+	return Array.isArray(value) && value.every(isHookEntry);
+}
+
+function isHookEntry(value: unknown): value is HookEntry {
+	return isRecord(value) && Array.isArray(value["hooks"]) && value["hooks"].every(isHookCommand);
+}
+
+function isHookCommand(value: unknown): value is HookCommand {
+	return isRecord(value) && typeof value["command"] === "string";
+}
+
+function isStringRecord(value: unknown): value is Record<string, string> {
+	return isRecord(value) && Object.values(value).every((item) => typeof item === "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/rules/test/persistent-cache.test.ts

@@ -0,0 +1,63 @@
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+	claimPostCompactPending,
+	isPostCompactPending,
+	isPostCompactRecoveryInProgress,
+	markSessionCompacted,
+	sessionCachePath,
+} from "../src/persistent-cache.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+describe("persistent post-compact state", () => {
+	it("#given post-compact pending state #when static recovery is claimed twice #then only the first caller proceeds", () => {
+		// given
+		const pluginData = mkdtempSync(path.join(tmpdir(), "codex-rules-cache-"));
+		tempDirectories.push(pluginData);
+		const cachePath = sessionCachePath("session-cache-claim", pluginData);
+		markSessionCompacted(cachePath);
+
+		// when
+		const firstClaim = claimPostCompactPending(cachePath, "static");
+		const secondClaim = claimPostCompactPending(cachePath, "static");
+
+		// then
+		expect(firstClaim).toBe("claimed");
+		expect(secondClaim).toBe("not-pending");
+		expect(isPostCompactPending(cachePath, "static")).toBe(false);
+		expect(isPostCompactRecoveryInProgress(cachePath, "static")).toBe(true);
+		expect(isPostCompactPending(cachePath, "dynamic")).toBe(true);
+	});
+
+	it("#given post-compact pending state and contended lock #when static recovery is claimed #then reports contention without consuming pending state", () => {
+		// given
+		const pluginData = mkdtempSync(path.join(tmpdir(), "codex-rules-cache-"));
+		tempDirectories.push(pluginData);
+		const cachePath = sessionCachePath("session-cache-contended", pluginData);
+		markSessionCompacted(cachePath);
+		const lockPath = `${cachePath}.lock`;
+		mkdirSync(lockPath);
+
+		try {
+			// when
+			const claim = claimPostCompactPending(cachePath, "static");
+
+			// then
+			expect(claim).toBe("contended");
+			expect(isPostCompactPending(cachePath, "static")).toBe(true);
+			expect(isPostCompactRecoveryInProgress(cachePath, "static")).toBe(false);
+		} finally {
+			rmSync(lockPath, { recursive: true, force: true });
+		}
+	});
+});

package/packages/omo-codex/plugin/components/rules/test/post-compact-budget.test.ts

@@ -0,0 +1,172 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { withPostCompactBudget } from "../src/post-compact-budget.js";
+import type { PiRulesConfig } from "../src/rules/types.js";
+
+const tempDirectories: string[] = [];
+const CONFIG: PiRulesConfig = {
+	disabled: false,
+	mode: "both",
+	maxRuleChars: 30_000,
+	maxResultChars: 50_000,
+	postCompactMaxRuleChars: 12_000,
+	postCompactMaxResultChars: 20_000,
+	enabledSources: "auto",
+};
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+describe("post-compact context budget", () => {
+	it("#given known model near its context window #when resolving post-compact budget #then shrinks projected rule injection", () => {
+		// given
+		const transcriptPath = writeCompactedTranscript("A".repeat(760_000));
+
+		// when
+		const budget = withPostCompactBudget(CONFIG, { model: "gpt-5.5", transcriptPath });
+
+		// then
+		expect(budget.maxResultChars).toBeLessThan(1_000);
+		expect(budget.maxRuleChars).toBeLessThanOrEqual(budget.maxResultChars);
+	});
+
+	it("#given unknown model near its context window #when resolving post-compact budget #then shrinks projected rule injection conservatively", () => {
+		// given
+		const transcriptPath = writeCompactedTranscript("A".repeat(760_000));
+
+		// when
+		const budget = withPostCompactBudget(CONFIG, { model: "unknown-model", transcriptPath });
+
+		// then
+		expect(budget.maxResultChars).toBeLessThan(1_000);
+		expect(budget.maxRuleChars).toBeLessThanOrEqual(budget.maxResultChars);
+	});
+
+	it("#given known roomy model #when resolving post-compact budget #then keeps configured post-compact cap", () => {
+		// given
+		const transcriptPath = writeCompactedTranscript("small compacted summary");
+
+		// when
+		const budget = withPostCompactBudget(CONFIG, { model: "openai.gpt-5.5", transcriptPath });
+
+		// then
+		expect(budget.maxRuleChars).toBe(CONFIG.postCompactMaxRuleChars);
+		expect(budget.maxResultChars).toBe(CONFIG.postCompactMaxResultChars);
+	});
+
+	it("#given context pressure marker after compaction #when resolving post-compact budget #then shrinks projected rule injection", () => {
+		// given
+		const transcriptPath = writeCompactedPressureTranscript("small compacted summary");
+
+		// when
+		const budget = withPostCompactBudget(CONFIG, { model: "gpt-5.5", transcriptPath });
+
+		// then
+		expect(budget.maxResultChars).toBeLessThan(1_000);
+		expect(budget.maxRuleChars).toBeLessThanOrEqual(budget.maxResultChars);
+	});
+
+	it("#given Codex canonical context-window marker after compaction #when resolving post-compact budget #then shrinks projected rule injection", () => {
+		// given
+		const transcriptPath = writeCompactedCodexContextWindowTranscript("small compacted summary");
+
+		// when
+		const budget = withPostCompactBudget(CONFIG, { model: "gpt-5.5", transcriptPath });
+
+		// then
+		expect(budget.maxResultChars).toBeLessThan(1_000);
+		expect(budget.maxRuleChars).toBeLessThanOrEqual(budget.maxResultChars);
+	});
+});
+
+function writeCompactedTranscript(retainedText: string): string {
+	const root = mkdtempSync(path.join(tmpdir(), "post-compact-budget-"));
+	tempDirectories.push(root);
+	const transcriptPath = path.join(root, "transcript.jsonl");
+	writeFileSync(
+		transcriptPath,
+		`${JSON.stringify({
+			type: "compacted",
+			payload: {
+				message: "summary",
+				replacement_history: [{ type: "message", role: "user", content: retainedText }],
+			},
+		})}\n`,
+	);
+	return transcriptPath;
+}
+
+function writeCompactedPressureTranscript(retainedText: string): string {
+	const root = mkdtempSync(path.join(tmpdir(), "post-compact-budget-"));
+	tempDirectories.push(root);
+	const transcriptPath = path.join(root, "transcript-pressure.jsonl");
+	writeFileSync(
+		transcriptPath,
+		[
+			JSON.stringify({
+				type: "compacted",
+				payload: {
+					message: "summary",
+					replacement_history: [{ type: "message", role: "user", content: retainedText }],
+				},
+			}),
+			JSON.stringify({
+				type: "message",
+				payload: {
+					content: {
+						error: {
+							code: "context_too_large",
+							message:
+								"Your input exceeds the context window of this model. Please adjust your input and try again.",
+						},
+					},
+				},
+			}),
+			"",
+		].join("\n"),
+	);
+	return transcriptPath;
+}
+
+function writeCompactedCodexContextWindowTranscript(retainedText: string): string {
+	const root = mkdtempSync(path.join(tmpdir(), "post-compact-budget-"));
+	tempDirectories.push(root);
+	const transcriptPath = path.join(root, "transcript-codex-context-window.jsonl");
+	writeFileSync(
+		transcriptPath,
+		[
+			JSON.stringify({
+				type: "compacted",
+				payload: {
+					message: "summary",
+					replacement_history: [{ type: "message", role: "user", content: retainedText }],
+				},
+			}),
+			JSON.stringify({
+				type: "message",
+				payload: {
+					content: {
+						error: {
+							code: "context_length_exceeded",
+						},
+					},
+				},
+			}),
+			JSON.stringify({
+				type: "message",
+				payload: {
+					content:
+						"Codex ran out of room in the model's context window. Start a new thread or clear earlier history before retrying.",
+				},
+			}),
+			"",
+		].join("\n"),
+	);
+	return transcriptPath;
+}