oh-my-opencode 4.7.4 → 4.8.0

package/packages/omo-codex/plugin/test/aggregate-manifest.test.mjs

@@ -0,0 +1,73 @@
+import assert from "node:assert/strict";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import test from "node:test";
+
+import { exists, readJson, root } from "./aggregate-plugin-fixture.mjs";
+
+test("#given aggregate plugin manifest #when inspected #then it owns the omo namespace", async () => {
+	// given
+	const manifest = await readJson(".codex-plugin/plugin.json");
+
+	// when
+	const hookPath = manifest.hooks;
+	const skillsPath = manifest.skills;
+	const mcpPath = manifest.mcpServers;
+
+	// then
+	assert.equal(manifest.name, "omo");
+	assert.equal(hookPath, "./hooks/hooks.json");
+	assert.equal(skillsPath, "./skills/");
+	assert.equal(mcpPath, "./.mcp.json");
+});
+
+test("#given aggregate plugin metadata #when inspected #then ulw-loop is the public loop name", async () => {
+	// given
+	const manifestText = await readFile(join(root, ".codex-plugin", "plugin.json"), "utf8");
+	const manifest = JSON.parse(manifestText);
+
+	// when
+	const longDescription = String(manifest.interface?.longDescription ?? "");
+
+	// then
+	assert.match(longDescription, /ulw-loop/);
+});
+
+test("#given component directories #when scanned #then only intentional resource roots declare plugin manifests", async () => {
+	// given
+	const components = await readdir(join(root, "components"), { withFileTypes: true });
+	const expectedComponentManifests = new Map([["rules", { hooks: "./hooks/hooks.json" }]]);
+
+	// when
+	const componentNames = [];
+	for (const entry of components) {
+		if (!entry.isDirectory()) continue;
+		if (!(await exists(join("components", entry.name, "package.json")))) continue;
+		componentNames.push(entry.name);
+	}
+	componentNames.sort();
+
+	// then
+	assert.deepEqual(componentNames, [
+		"comment-checker",
+		"git-bash",
+		"lsp",
+		"rules",
+		"start-work-continuation",
+		"telemetry",
+		"ultrawork",
+		"ulw-loop",
+	]);
+	for (const name of componentNames) {
+		const expectedManifest = expectedComponentManifests.get(name);
+		if (expectedManifest !== undefined) {
+			assert.deepEqual(await readJson(join("components", name, ".codex-plugin", "plugin.json")), expectedManifest);
+			continue;
+		}
+
+		await assert.rejects(
+			readFile(join(root, "components", name, ".codex-plugin", "plugin.json"), "utf8"),
+			/code: 'ENOENT'|ENOENT/,
+		);
+	}
+});

package/packages/omo-codex/plugin/test/aggregate-mcp.test.mjs

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import test from "node:test";
+
+import { exists, readJson, root } from "./aggregate-plugin-fixture.mjs";
+
+const mcpPackageManifestPaths = ["../../lsp-tools-mcp/package.json", "../../ast-grep-mcp/package.json", "../../git-bash-mcp/package.json"];
+const mcpPackageManifestExists = await Promise.all(mcpPackageManifestPaths.map(exists));
+
+test("#given aggregate MCP config #when inspected #then code MCPs reference package runtimes without package names", async () => {
+	// given
+	const packageJson = await readJson("package.json");
+	const mcp = await readJson(".mcp.json");
+	const lspSources = await readdir(join(root, "components", "lsp", "src"));
+	const bundledMcpBuildScript = await readFile(join(root, "scripts", "build-bundled-mcp-runtimes.mjs"), "utf8");
+
+	// when
+	const lspServer = mcp.mcpServers.lsp;
+	const astGrepServer = mcp.mcpServers.ast_grep;
+	const gitBashServer = mcp.mcpServers.git_bash;
+	const codeMcpNames = Object.keys(mcp.mcpServers)
+		.filter((name) => name === "lsp" || name === "ast_grep" || name === "git_bash")
+		.sort();
+	const componentLocalMcpSources = lspSources.filter((name) => name.startsWith("lazy-mcp") || name === "lazy-lsp-mcp.ts");
+
+	// then
+	assert.deepEqual(codeMcpNames, ["ast_grep", "git_bash", "lsp"]);
+	assert.equal(packageJson.workspaces.includes("components/lsp/packages/lsp-tools-mcp"), false);
+	assert.equal(packageJson.workspaces.includes("components/ast-grep/packages/ast-grep-mcp"), false);
+	assert.deepEqual(packageJson.dependencies, { "@oh-my-opencode/shared-skills": "file:../../shared-skills" });
+	assert.match(bundledMcpBuildScript, /ast-grep-mcp/);
+	assert.match(bundledMcpBuildScript, /git-bash-mcp/);
+	assert.doesNotMatch(packageJson.scripts.build, /--workspaces/);
+	assert.equal(lspServer.command, "node");
+	assert.deepEqual(lspServer.args, ["../../lsp-tools-mcp/dist/cli.js", "mcp"]);
+	assert.equal(lspServer.cwd, ".");
+	assert.equal(astGrepServer.command, "node");
+	assert.deepEqual(astGrepServer.args, ["../../ast-grep-mcp/dist/cli.js", "mcp"]);
+	assert.equal(astGrepServer.cwd, ".");
+	assert.equal(gitBashServer.command, "node");
+	assert.deepEqual(gitBashServer.args, ["../../git-bash-mcp/dist/cli.js", "mcp"]);
+	assert.equal(gitBashServer.cwd, ".");
+	assert.deepEqual(componentLocalMcpSources, []);
+});
+
+test(
+	"#given package-level MCP CLIs #when package metadata is inspected #then bin names use the omo prefix",
+	{ skip: mcpPackageManifestExists.some((exists) => !exists) },
+	async () => {
+		// given
+		const [lspPackageJson, astGrepPackageJson, gitBashPackageJson] = await Promise.all(
+			mcpPackageManifestPaths.map((path) => readJson(path)),
+		);
+
+		// when
+		const binNames = [
+			...Object.keys(lspPackageJson.bin ?? {}),
+			...Object.keys(astGrepPackageJson.bin ?? {}),
+			...Object.keys(gitBashPackageJson.bin ?? {}),
+		].sort();
+
+		// then
+		assert.deepEqual(binNames, ["omo-ast-grep", "omo-git-bash", "omo-lsp"]);
+		for (const name of binNames) {
+			assert.match(name, /^omo-/);
+		}
+	},
+);

package/packages/omo-codex/plugin/test/aggregate-model-catalog.test.mjs

@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import test from "node:test";
+
+import { root } from "./aggregate-plugin-fixture.mjs";
+
+test("#given bundled model catalog #when inspected #then default verifier and worker roles are pinned", async () => {
+	const catalog = JSON.parse(await readFile(join(root, "model-catalog.json"), "utf8"));
+
+	assert.equal(catalog.current.model, "gpt-5.5");
+	assert.equal(catalog.current.model_context_window, 400000);
+	assert.equal(catalog.current.model_reasoning_effort, "high");
+	assert.equal(catalog.current.plan_mode_reasoning_effort, "xhigh");
+	assert.deepEqual(catalog.roles.default, catalog.current);
+	assert.deepEqual(catalog.roles.verifier, {
+		model: "gpt-5.5",
+		model_reasoning_effort: "high",
+	});
+	assert.deepEqual(catalog.roles.worker, {
+		model: "gpt-5.5",
+		model_reasoning_effort: "high",
+	});
+});
+
+test("#given bundled model catalog #when inspected #then no role or managed preset uses pure GPT-5.4", async () => {
+	const catalog = JSON.parse(await readFile(join(root, "model-catalog.json"), "utf8"));
+
+	const roleModels = Object.values(catalog.roles).map((role) => role.model);
+	const managedModels = catalog.managedProfiles.map((profile) => profile.match.model);
+
+	assert.equal([...roleModels, ...managedModels].includes("gpt-5.4"), false);
+});
+
+test("#given Codex-facing orchestration surfaces #when inspected #then retired ChatGPT-account model names are not recommended", async () => {
+	const promptFiles = [
+		join(root, "skills", "ulw-loop", "references", "full-workflow.md"),
+		join(root, "components", "ulw-loop", "skills", "ulw-loop", "references", "full-workflow.md"),
+		join(root, "components", "ultrawork", "README.md"),
+		join(root, "components", "ultrawork", "CHANGELOG.md"),
+		join(root, "components", "rules", "src", "post-compact-budget.ts"),
+	];
+
+	const staleReferences = [];
+	for (const promptPath of promptFiles) {
+		const content = await readFile(promptPath, "utf8");
+		if (/gpt-5\.(?:2|3-codex|4(?!-mini))/i.test(content)) {
+			staleReferences.push(`${basename(dirname(promptPath))}/${basename(promptPath)}`);
+		}
+	}
+
+	assert.deepEqual(staleReferences, []);
+});

package/packages/omo-codex/plugin/test/aggregate-plugin-fixture.mjs

@@ -0,0 +1,83 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const root = dirname(dirname(fileURLToPath(import.meta.url)));
+export const repoRoot = join(root, "..", "..", "..");
+
+export async function readJson(relativePath) {
+	return JSON.parse(await readFile(join(root, relativePath), "utf8"));
+}
+
+export async function readRepoJson(relativePath) {
+	return JSON.parse(await readFile(join(repoRoot, relativePath), "utf8"));
+}
+
+export async function readPluginVersion() {
+	return (await readJson(".codex-plugin/plugin.json")).version;
+}
+
+export async function exists(relativePath) {
+	try {
+		await stat(join(root, relativePath));
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
+export async function readComponentHookManifests() {
+	const components = await readdir(join(root, "components"), { withFileTypes: true });
+	const manifests = [];
+	for (const entry of components) {
+		if (!entry.isDirectory()) continue;
+		const source = join("components", entry.name, "hooks", "hooks.json");
+		if (!(await exists(source))) continue;
+		manifests.push({ source, hooks: await readJson(source) });
+	}
+	return manifests.sort((left, right) => left.source.localeCompare(right.source));
+}
+
+export function collectCommandHooks(hooks, source) {
+	const config = hooks.hooks;
+	if (typeof config !== "object" || config === null || Array.isArray(config)) {
+		throw new TypeError(`Invalid hooks manifest: ${source}`);
+	}
+	const commandHooks = [];
+	for (const [eventName, groups] of Object.entries(config)) {
+		if (!Array.isArray(groups)) {
+			throw new TypeError(`Invalid hook groups in ${source}:${eventName}`);
+		}
+		groups.forEach((group, groupIndex) => {
+			if (typeof group !== "object" || group === null || !Array.isArray(group.hooks)) {
+				throw new TypeError(`Invalid hook group in ${source}:${eventName}:${groupIndex}`);
+			}
+			group.hooks.forEach((handler, handlerIndex) => {
+				if (typeof handler !== "object" || handler === null || handler.type !== "command") return;
+				commandHooks.push({ source, eventName, groupIndex, handlerIndex, handler });
+			});
+		});
+	}
+	return commandHooks;
+}
+
+export function hookLocation({ source, eventName, groupIndex, handlerIndex, handler }) {
+	return `${source}:${eventName}:${groupIndex}:${handlerIndex}:${handler.command}`;
+}
+
+export function findInvalidSpawnAgentRoleParameters(content) {
+	return [...content.matchAll(/spawn_agent\([^)\n]*(?:agent_type|model|reasoning_effort)\s*=/g)].map((match) => match[0]);
+}
+
+export function findSpawnAgentCallsWithoutForkTurnsNone(content) {
+	const missingForkTurns = [];
+	const regex = /spawn_agent\(([^)]*)\)/g;
+	for (const match of content.matchAll(regex)) {
+		const call = match[0];
+		if (!/"fork_turns"\s*:\s*"none"|fork_turns:\s*"none"|fork_turns="none"/.test(call)) {
+			missingForkTurns.push(call);
+		}
+	}
+	return missingForkTurns;
+}

package/packages/omo-codex/plugin/test/aggregate-skills.test.mjs

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import test from "node:test";
+
+import {
+	findInvalidSpawnAgentRoleParameters,
+	findSpawnAgentCallsWithoutForkTurnsNone,
+	root,
+} from "./aggregate-plugin-fixture.mjs";
+
+test("#given synced skills with Codex compatibility guidance #when spawn_agent is documented #then invalid role parameters are absent", async () => {
+	const skillsDir = join(root, "skills");
+	const skillEntries = await readdir(skillsDir, { withFileTypes: true });
+	const skillFiles = skillEntries
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => join(skillsDir, entry.name, "SKILL.md"));
+
+	const invalidCalls = [];
+	for (const skillPath of skillFiles) {
+		const content = await readFile(skillPath, "utf8");
+		for (const call of findInvalidSpawnAgentRoleParameters(content)) {
+			invalidCalls.push(`${basename(dirname(skillPath))}/${basename(skillPath)}: ${call}`);
+		}
+	}
+
+	assert.deepEqual(invalidCalls, []);
+});
+
+test('#given synced skills and bundled rules #when role-specific agents are spawned #then they set fork_turns="none"', async () => {
+	const skillsDir = join(root, "skills");
+	const skillEntries = await readdir(skillsDir, { withFileTypes: true });
+	const promptFiles = skillEntries
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => join(skillsDir, entry.name, "SKILL.md"));
+	promptFiles.push(join(root, "components", "rules", "bundled-rules", "hephaestus.md"));
+
+	const missingForkTurns = [];
+	for (const promptPath of promptFiles) {
+		const content = await readFile(promptPath, "utf8");
+		for (const call of findSpawnAgentCallsWithoutForkTurnsNone(content)) {
+			missingForkTurns.push(`${basename(dirname(promptPath))}/${basename(promptPath)}: ${call}`);
+		}
+	}
+
+	assert.deepEqual(missingForkTurns, []);
+});
+
+test("#given long-running orchestration prompts #when waiting on child agents #then parent liveness is surfaced", async () => {
+	const promptFiles = [
+		join(root, "skills", "ulw-loop", "SKILL.md"),
+		join(root, "skills", "ulw-loop", "references", "full-workflow.md"),
+		join(root, "skills", "review-work", "SKILL.md"),
+		join(root, "skills", "start-work", "SKILL.md"),
+		join(root, "components", "rules", "bundled-rules", "hephaestus.md"),
+	];
+
+	const missingLivenessGuidance = [];
+	for (const promptPath of promptFiles) {
+		const content = await readFile(promptPath, "utf8");
+		if (!/active\s+subagent count/.test(content) || !/latest `WORKING:` phase/.test(content)) {
+			missingLivenessGuidance.push(`${basename(dirname(promptPath))}/${basename(promptPath)}`);
+		}
+	}
+
+	assert.deepEqual(missingLivenessGuidance, []);
+});