oh-my-opencode 4.5.1 → 4.5.12

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

@@ -0,0 +1,192 @@
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+
+import { createEngine, defaultConfig, type EngineDeps } from "../src/rules/engine.js";
+import { matchRule as defaultMatchRule } from "../src/rules/matcher.js";
+import type { RuleCandidate } from "../src/rules/types.js";
+
+const projectRoot = "/tmp/codex-rules-engine";
+
+function makeCandidate(): RuleCandidate {
+	return {
+		path: join(projectRoot, ".omo", "rules", "typescript.md"),
+		realPath: join(projectRoot, ".omo", "rules", "typescript.md"),
+		source: ".omo/rules",
+		distance: 0,
+		isGlobal: false,
+		isSingleFile: false,
+		relativePath: ".omo/rules/typescript.md",
+	};
+}
+
+describe("rule engine dynamic matching", () => {
+	it("#given duplicate target paths #when loading dynamic rules #then repeated discovery and parsing work is avoided", () => {
+		// given
+		const targetPath = join(projectRoot, "src", "app.ts");
+		const candidate = makeCandidate();
+		const counters = {
+			findProjectRoot: 0,
+			findCandidates: 0,
+			readFile: 0,
+		};
+		const deps = {
+			findProjectRoot: () => {
+				counters.findProjectRoot += 1;
+				return projectRoot;
+			},
+			findCandidates: () => {
+				counters.findCandidates += 1;
+				return [candidate];
+			},
+			readFile: () => {
+				counters.readFile += 1;
+				return ["---", "globs: **/*.ts", "---", "", "Prefer strict TypeScript."].join("\n");
+			},
+		} satisfies EngineDeps;
+		const engine = createEngine(defaultConfig(), deps);
+
+		// when
+		const result = engine.loadDynamicRules(projectRoot, [targetPath, targetPath, targetPath]);
+
+		// then
+		expect(result.rules).toHaveLength(1);
+		expect(counters).toEqual({
+			findProjectRoot: 1,
+			findCandidates: 1,
+			readFile: 1,
+		});
+	});
+
+	it("#given distinct target files in same directory #when loading dynamic rules #then candidate discovery is reused", () => {
+		// given
+		const firstTarget = join(projectRoot, "src", "first.ts");
+		const secondTarget = join(projectRoot, "src", "second.ts");
+		const thirdTarget = join(projectRoot, "src", "third.ts");
+		const candidate = makeCandidate();
+		let findCandidatesCalls = 0;
+		const deps = {
+			findProjectRoot: () => projectRoot,
+			findCandidates: () => {
+				findCandidatesCalls += 1;
+				return [candidate];
+			},
+			readFile: () => ["---", "globs: **/*.ts", "---", "", "Prefer strict TypeScript."].join("\n"),
+		} satisfies EngineDeps;
+		const engine = createEngine(defaultConfig(), deps);
+
+		// when
+		const result = engine.loadDynamicRules(projectRoot, [firstTarget, secondTarget, thirdTarget]);
+
+		// then
+		expect(result.rules).toHaveLength(1);
+		expect(findCandidatesCalls).toBe(1);
+	});
+
+	it("#given same rule content and target across loads #when loading dynamic rules repeats #then cached match decision is reused", () => {
+		// given
+		const targetPath = join(projectRoot, "src", "app.ts");
+		const candidate = makeCandidate();
+		let matchCalls = 0;
+		const deps = {
+			findProjectRoot: () => projectRoot,
+			findCandidates: () => [candidate],
+			readFile: () => ["---", "globs: **/*.ts", "---", "", "Prefer strict TypeScript."].join("\n"),
+			matchRule: (input) => {
+				matchCalls += 1;
+				return defaultMatchRule(input);
+			},
+		} satisfies EngineDeps;
+		const engine = createEngine(defaultConfig(), deps);
+
+		// when
+		const firstResult = engine.loadDynamicRules(projectRoot, [targetPath]);
+		const secondResult = engine.loadDynamicRules(projectRoot, [targetPath]);
+
+		// then
+		expect(firstResult.rules).toHaveLength(1);
+		expect(secondResult.rules).toHaveLength(1);
+		expect(matchCalls).toBe(1);
+	});
+
+	it("#given same rule path changes body #when loading dynamic rules repeats #then cached match decision invalidates", () => {
+		// given
+		const targetPath = join(projectRoot, "src", "app.ts");
+		const candidate = makeCandidate();
+		let body = "Prefer strict TypeScript.";
+		let matchCalls = 0;
+		const deps = {
+			findProjectRoot: () => projectRoot,
+			findCandidates: () => [candidate],
+			readFile: () => ["---", "globs: **/*.ts", "---", "", body].join("\n"),
+			matchRule: (input) => {
+				matchCalls += 1;
+				return defaultMatchRule(input);
+			},
+		} satisfies EngineDeps;
+		const engine = createEngine(defaultConfig(), deps);
+
+		// when
+		engine.loadDynamicRules(projectRoot, [targetPath]);
+		body = "Prefer readonly TypeScript.";
+		engine.loadDynamicRules(projectRoot, [targetPath]);
+
+		// then
+		expect(matchCalls).toBe(2);
+	});
+
+	it("#given same rule path changes frontmatter #when loading dynamic rules repeats #then cached match decision invalidates", () => {
+		// given
+		const targetPath = join(projectRoot, "src", "app.ts");
+		const candidate = makeCandidate();
+		let globs = "**/*.ts";
+		let matchCalls = 0;
+		const deps = {
+			findProjectRoot: () => projectRoot,
+			findCandidates: () => [candidate],
+			readFile: () => ["---", `globs: ${globs}`, "---", "", "Prefer strict TypeScript."].join("\n"),
+			matchRule: (input) => {
+				matchCalls += 1;
+				return defaultMatchRule(input);
+			},
+		} satisfies EngineDeps;
+		const engine = createEngine(defaultConfig(), deps);
+
+		// when
+		const firstResult = engine.loadDynamicRules(projectRoot, [targetPath]);
+		globs = "**/*.tsx";
+		const secondResult = engine.loadDynamicRules(projectRoot, [targetPath]);
+
+		// then
+		expect(firstResult.rules).toHaveLength(1);
+		expect(secondResult.rules).toHaveLength(0);
+		expect(matchCalls).toBe(2);
+	});
+
+	it("#given same rule and different targets #when loading dynamic rules repeats #then target-specific decisions do not leak", () => {
+		// given
+		const sourceTarget = join(projectRoot, "src", "app.ts");
+		const testTarget = join(projectRoot, "src", "app.test.ts");
+		const candidate = makeCandidate();
+		let matchCalls = 0;
+		const deps = {
+			findProjectRoot: () => projectRoot,
+			findCandidates: () => [candidate],
+			readFile: () =>
+				["---", 'globs: ["**/*.ts", "!**/*.test.ts"]', "---", "", "Prefer strict TypeScript."].join("\n"),
+			matchRule: (input) => {
+				matchCalls += 1;
+				return defaultMatchRule(input);
+			},
+		} satisfies EngineDeps;
+		const engine = createEngine(defaultConfig(), deps);
+
+		// when
+		const sourceResult = engine.loadDynamicRules(projectRoot, [sourceTarget]);
+		const testResult = engine.loadDynamicRules(projectRoot, [testTarget]);
+
+		// then
+		expect(sourceResult.rules).toHaveLength(1);
+		expect(testResult.rules).toHaveLength(0);
+		expect(matchCalls).toBe(2);
+	});
+});

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

@@ -0,0 +1,102 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { findRuleCandidates } from "../src/rules/finder.js";
+import type { RuleCandidate } from "../src/rules/types.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+function makeProject(): { projectRoot: string; homeRoot: string; targetPath: string } {
+	const projectRoot = mkdtempSync(join(tmpdir(), "codex-rules-finder-project-"));
+	const homeRoot = mkdtempSync(join(tmpdir(), "codex-rules-finder-home-"));
+	tempDirectories.push(projectRoot, homeRoot);
+	mkdirSync(join(projectRoot, "src", ".omo", "rules"), { recursive: true });
+	mkdirSync(join(projectRoot, ".omo", "rules"), { recursive: true });
+	mkdirSync(join(homeRoot, ".opencode", "rules"), { recursive: true });
+	mkdirSync(join(homeRoot, ".config", "opencode"), { recursive: true });
+	writeFileSync(join(projectRoot, "package.json"), JSON.stringify({ name: "fixture" }));
+	writeFileSync(join(projectRoot, "AGENTS.md"), "Project rule\n");
+	writeFileSync(join(projectRoot, "src", ".omo", "rules", "local.md"), "Local rule\n");
+	writeFileSync(join(projectRoot, ".omo", "rules", "root.md"), "Root rule\n");
+	writeFileSync(join(homeRoot, ".opencode", "rules", "global.md"), "Global rule\n");
+	writeFileSync(join(homeRoot, ".config", "opencode", "AGENTS.md"), "Home rule\n");
+	const targetPath = join(projectRoot, "src", "app.ts");
+	writeFileSync(targetPath, "export const app = true;\n");
+	return { projectRoot, homeRoot, targetPath };
+}
+
+function candidateSummary(candidate: RuleCandidate): string {
+	return `${candidate.source}:${candidate.distance}:${candidate.relativePath}`;
+}
+
+describe("findRuleCandidates", () => {
+	it("#given project and user-home rules #when target file is inside project #then candidates keep source distance", () => {
+		// given
+		const { projectRoot, homeRoot, targetPath } = makeProject();
+
+		// when
+		const candidates = findRuleCandidates({
+			projectRoot,
+			targetFile: targetPath,
+			homeDir: homeRoot,
+			disabledSources: new Set(["plugin-bundled"]),
+		});
+
+		// then
+		expect(candidates.map(candidateSummary)).toEqual([
+			".omo/rules:0:src/.omo/rules/local.md",
+			".omo/rules:1:.omo/rules/root.md",
+			"AGENTS.md:1:AGENTS.md",
+			"~/.opencode/rules:9999:.opencode/rules/global.md",
+			"~/.config/opencode/AGENTS.md:9999:.config/opencode/AGENTS.md",
+		]);
+	});
+
+	it("#given disabled source #when finding candidates #then matching source is omitted", () => {
+		// given
+		const { projectRoot, homeRoot, targetPath } = makeProject();
+
+		// when
+		const candidates = findRuleCandidates({
+			projectRoot,
+			targetFile: targetPath,
+			homeDir: homeRoot,
+			disabledSources: new Set([".omo/rules", "~/.opencode/rules", "plugin-bundled"]),
+		});
+
+		// then
+		expect(candidates.map(candidateSummary)).toEqual([
+			"AGENTS.md:1:AGENTS.md",
+			"~/.config/opencode/AGENTS.md:9999:.config/opencode/AGENTS.md",
+		]);
+	});
+
+	it("#given skip user home #when finding candidates #then only project rules are returned", () => {
+		// given
+		const { projectRoot, homeRoot, targetPath } = makeProject();
+
+		// when
+		const candidates = findRuleCandidates({
+			projectRoot,
+			targetFile: targetPath,
+			homeDir: homeRoot,
+			skipUserHome: true,
+			disabledSources: new Set(["plugin-bundled"]),
+		});
+
+		// then
+		expect(candidates.map(candidateSummary)).toEqual([
+			".omo/rules:0:src/.omo/rules/local.md",
+			".omo/rules:1:.omo/rules/root.md",
+			"AGENTS.md:1:AGENTS.md",
+		]);
+	});
+});

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

@@ -0,0 +1,168 @@
+import { describe, expect, it } from "vitest";
+
+import { formatDynamicBlock, formatStaticBlock } from "../src/rules/formatter.js";
+import type { LoadedRule, MatchReason, RuleSource } from "../src/rules/types.js";
+
+const FORMAT_OPTIONS = {
+	maxRuleChars: 10_000,
+	maxResultChars: 10_000,
+};
+
+describe("rules formatter hook context", () => {
+	it("#given multiline dynamic rules #when formatting PostToolUse context #then labels and bodies render on separate lines", () => {
+		// given
+		const rule = loadedRule({
+			path: "/repo/packages/AGENTS.md",
+			relativePath: "packages/AGENTS.md",
+			body: ["# packages", "", "## OVERVIEW", "23 sibling packages.", "", "## CONVENTIONS", "Use npm."].join("\n"),
+		});
+
+		// when
+		const block = formatDynamicBlock(
+			[rule],
+			"packages/omo-codex/plugin/components/ulw-loop/src/paths.ts",
+			FORMAT_OPTIONS,
+		);
+
+		// then
+		expect(block).toBe(
+			[
+				"Additional project instructions matched for packages/omo-codex/plugin/components/ulw-loop/src/paths.ts:",
+				"",
+				"Instructions from: /repo/packages/AGENTS.md",
+				"",
+				"# packages",
+				"",
+				"## OVERVIEW",
+				"23 sibling packages.",
+				"",
+				"## CONVENTIONS",
+				"Use npm.",
+			].join("\n"),
+		);
+	});
+
+	it("#given static rules #when formatting SessionStart context #then it avoids leading blank lines", () => {
+		// given
+		const rule = loadedRule({
+			path: "/repo/AGENTS.md",
+			relativePath: "AGENTS.md",
+			body: "Keep generated hook context readable.",
+		});
+
+		// when
+		const block = formatStaticBlock([rule], FORMAT_OPTIONS);
+
+		// then
+		expect(block).toBe(
+			[
+				"## Project Instructions",
+				"",
+				"Instructions from: /repo/AGENTS.md",
+				"",
+				"Keep generated hook context readable.",
+			].join("\n"),
+		);
+	});
+
+	it("#given CRLF and bare CR rule bodies #when formatting context #then it normalizes line endings", () => {
+		// given
+		const rule = loadedRule({
+			body: "First line\r\n  indented second line\rThird line",
+		});
+
+		// when
+		const block = formatDynamicBlock([rule], "src/app.ts", FORMAT_OPTIONS);
+
+		// then
+		expect(block).toContain("First line\n  indented second line\nThird line");
+		expect(block).not.toContain("\r");
+	});
+
+	it("#given duplicate static rules with different line endings #when formatting context #then it renders one copy", () => {
+		// given
+		const lfRule = loadedRule({
+			path: "/repo/AGENTS.md",
+			relativePath: "AGENTS.md",
+			body: "Shared rule\nKeep one copy.",
+		});
+		const crlfRule = loadedRule({
+			path: "/repo/packages/AGENTS.md",
+			relativePath: "packages/AGENTS.md",
+			body: "Shared rule\r\nKeep one copy.",
+		});
+
+		// when
+		const block = formatStaticBlock([lfRule, crlfRule], FORMAT_OPTIONS);
+
+		// then
+		expect(occurrenceCount(block, "Shared rule\nKeep one copy.")).toBe(1);
+		expect(block).not.toContain("/repo/packages/AGENTS.md");
+	});
+
+	it("#given multiple oversized rules #when formatting under a tight result budget #then every rule receives a fair truncated share with a read-full guide", () => {
+		// given
+		const rules = [
+			loadedRule({ path: "/repo/alpha.md", relativePath: "alpha.md", body: `alpha-${"A".repeat(500)}` }),
+			loadedRule({ path: "/repo/beta.md", relativePath: "beta.md", body: `beta-${"B".repeat(500)}` }),
+			loadedRule({ path: "/repo/gamma.md", relativePath: "gamma.md", body: `gamma-${"C".repeat(500)}` }),
+		];
+
+		// when
+		const block = formatDynamicBlock(rules, "src/app.ts", {
+			maxRuleChars: 10_000,
+			maxResultChars: 900,
+		});
+
+		// then
+		expect(block).toContain("Instructions from: /repo/alpha.md");
+		expect(block).toContain("Instructions from: /repo/beta.md");
+		expect(block).toContain("Instructions from: /repo/gamma.md");
+		expect(block).toContain("[Truncated. Full: alpha.md]");
+		expect(block).toContain("[Truncated. Full: beta.md]");
+		expect(block).toContain("[Truncated. Full: gamma.md]");
+		expect(occurrenceCount(block, "[Truncated. Full:")).toBe(3);
+	});
+
+	it("#given no matching rules #when formatting hook context #then it emits no context", () => {
+		// given
+		const rules: LoadedRule[] = [];
+
+		// when
+		const dynamicBlock = formatDynamicBlock(rules, "src/app.ts", FORMAT_OPTIONS);
+		const staticBlock = formatStaticBlock(rules, FORMAT_OPTIONS);
+
+		// then
+		expect(dynamicBlock).toBe("");
+		expect(staticBlock).toBe("");
+	});
+});
+
+function loadedRule(input: {
+	readonly body: string;
+	readonly path?: string;
+	readonly relativePath?: string;
+	readonly source?: RuleSource;
+	readonly matchReason?: MatchReason;
+}): LoadedRule {
+	const path = input.path ?? "/repo/AGENTS.md";
+	const relativePath = input.relativePath ?? "AGENTS.md";
+	const source = input.source ?? "AGENTS.md";
+	return {
+		path,
+		realPath: path,
+		source,
+		distance: 0,
+		isGlobal: false,
+		isSingleFile: true,
+		relativePath,
+		frontmatter: {},
+		body: input.body,
+		contentHash: "hash",
+		matchReason: input.matchReason ?? "single-file",
+	};
+}
+
+function occurrenceCount(value: string, search: string): number {
+	return value.split(search).length - 1;
+}

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

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+
+import { formatAdditionalContextOutput } from "../src/hook-output.js";
+
+describe("formatAdditionalContextOutput", () => {
+	it("#given context with outer whitespace and CRLF #when serializing hook JSON #then additional context is newline-normalized", () => {
+		// given
+		const context = "\r\n\r\nFirst line\r\nSecond line\rThird line\r\n";
+
+		// when
+		const output = formatAdditionalContextOutput("PostToolUse", context);
+		const parsed: unknown = JSON.parse(output);
+
+		// then
+		expect(readAdditionalContext(parsed)).toBe("First line\nSecond line\nThird line");
+		expect(output.endsWith("\n")).toBe(true);
+	});
+
+	it("#given blank context #when serializing hook JSON #then it emits no hook output", () => {
+		// given
+		const context = "\r\n \n";
+
+		// when
+		const output = formatAdditionalContextOutput("SessionStart", context);
+
+		// then
+		expect(output).toBe("");
+	});
+});
+
+function readAdditionalContext(value: unknown): string {
+	if (!isRecord(value)) throw new TypeError("Expected hook output object");
+	const hookSpecificOutput = value["hookSpecificOutput"];
+	if (!isRecord(hookSpecificOutput)) throw new TypeError("Expected hookSpecificOutput object");
+	const additionalContext = hookSpecificOutput["additionalContext"];
+	if (typeof additionalContext !== "string") throw new TypeError("Expected additionalContext string");
+	return additionalContext;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}