oh-my-opencode 4.5.1 → 4.6.0

package/packages/omo-codex/plugin/test/node-install-surface.test.mjs

@@ -0,0 +1,48 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const repoRoot = join(pluginRoot, "..", "..", "..");
+
+test("#given Codex Light install docs #when inspected #then lazycodex is npm-first and Bun-free", async () => {
+	// given
+	const files = [
+		join(repoRoot, "README.md"),
+		join(repoRoot, "docs", "guide", "installation.md"),
+		join(repoRoot, "packages", "omo-codex", "README.md"),
+		join(repoRoot, "packages", "omo-codex", "MARKETPLACE.md"),
+		join(pluginRoot, "components", "ultrawork", "README.md"),
+		join(pluginRoot, "components", "ulw-loop", "README.md"),
+	];
+
+	// when
+	const docs = await Promise.all(files.map(async (path) => [path, await readFile(path, "utf8")]));
+
+	// then
+	for (const [path, text] of docs) {
+		assert.match(text, /\bnpx lazycodex-ai install\b/, `${path} should document the Node/npm install command`);
+		assert.doesNotMatch(text, /\bbunx lazycodex-ai\b/, `${path} should not require Bun for lazycodex`);
+	}
+});
+
+test("#given cleanup troubleshooting docs #when inspected #then project-local cleanup and command delegation are documented", async () => {
+	// given
+	const files = [
+		join(repoRoot, "README.md"),
+		join(repoRoot, "docs", "guide", "installation.md"),
+		join(repoRoot, "packages", "omo-codex", "README.md"),
+	];
+
+	// when
+	const docs = await Promise.all(files.map(async (path) => [path, await readFile(path, "utf8")]));
+
+	// then
+	for (const [path, text] of docs) {
+		assert.match(text, /\bnpx lazycodex-ai cleanup\b/, `${path} should document the LazyCodex cleanup command`);
+		assert.match(text, /project-local .*\.codex\/config\.toml/i, `${path} should mention project-local config repair`);
+		assert.match(text, /\.codex.*\.omx|\.omx.*\.codex/s, `${path} should distinguish project-local .codex and .omx artifacts`);
+	}
+});

package/packages/omo-codex/plugin/test/subagent-guidance.test.mjs

@@ -0,0 +1,76 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+
+const SKILLS = [
+	"review-work",
+	"start-work",
+	"ulw-loop",
+];
+
+const AGENT_FILES = [
+	"components/ultrawork/agents/codex-ultrawork-reviewer.toml",
+	"components/ultrawork/agents/plan.toml",
+];
+
+test("#given orchestration skills #when inspected #then Codex subagent delegation is hardened", async () => {
+	// given
+	const skillPaths = SKILLS.map((skillName) => join("skills", skillName, "SKILL.md"));
+
+	// when
+	const missing = [];
+	for (const skillPath of skillPaths) {
+		const text = await readFile(join(root, skillPath), "utf8");
+		if (
+			!/TASK:/.test(text) ||
+			!/fork_turns:\s*"none"/.test(text) ||
+			!/wait_agent.*signal, not proof/s.test(text) ||
+			!/one targeted followup/.test(text) ||
+			!/respawn.*smaller/s.test(text) ||
+			!/model.*reasoning_effort.*default agent/s.test(text) ||
+			!/Plan and reviewer agents may run for a long time/.test(text) ||
+			!/short wait_agent cycles/.test(text) ||
+			!/single long blocking wait/.test(text)
+		) {
+			missing.push(skillPath);
+		}
+	}
+
+	// then
+	assert.deepEqual(missing, []);
+});
+
+test("#given ultrawork directive #when inspected #then reviewer fallback keeps an agent role", async () => {
+	// given
+	const directivePath = "components/ultrawork/directive.md";
+
+	// when
+	const text = await readFile(join(root, directivePath), "utf8");
+
+	// then
+	assert.doesNotMatch(text, /any `gpt-5\.2`\s+xhigh reviewer/);
+	assert.match(text, /codex-ultrawork-reviewer/);
+	assert.match(text, /agent_type.*worker/s);
+	assert.match(text, /model.*reasoning_effort.*default agent/s);
+});
+
+test("#given ultrawork agents #when inspected #then inter-agent commentary is treated as assignments", async () => {
+	// given
+	const agentPaths = AGENT_FILES;
+
+	// when
+	const missing = [];
+	for (const agentPath of agentPaths) {
+		const text = await readFile(join(root, agentPath), "utf8");
+		if (!/TASK:|active review assignment/.test(text) || !/context|commentary/.test(text)) {
+			missing.push(agentPath);
+		}
+	}
+
+	// then
+	assert.deepEqual(missing, []);
+});

package/packages/omo-codex/plugin/test/sync-hook-status-messages.test.mjs

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import test from "node:test";
+
+import { syncHookStatusMessages } from "../scripts/sync-hook-status-messages.mjs";
+
+async function writeJson(path, value) {
+	await writeFile(path, `${JSON.stringify(value, null, "\t")}\n`);
+}
+
+async function readJson(path) {
+	return JSON.parse(await readFile(path, "utf8"));
+}
+
+test("#given a component without hooks #when hook status messages sync #then build-time version sync skips it", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-hook-status-"));
+	await mkdir(join(root, ".codex-plugin"), { recursive: true });
+	await mkdir(join(root, "hooks"), { recursive: true });
+	await mkdir(join(root, "components", "comment-checker", "hooks"), { recursive: true });
+	await mkdir(join(root, "components", "git-bash"), { recursive: true });
+	await writeJson(join(root, ".codex-plugin", "plugin.json"), { version: "0.1.0" });
+	await writeJson(join(root, "components", "comment-checker", "package.json"), { version: "0.1.1" });
+	await writeJson(join(root, "components", "git-bash", "package.json"), { version: "0.3.0" });
+	await writeJson(join(root, "hooks", "hooks.json"), {
+		hooks: {
+			PostToolUse: [
+				{
+					hooks: [
+						{
+							type: "command",
+							command: 'node "${PLUGIN_ROOT}/components/comment-checker/dist/cli.js" hook post-tool-use',
+							statusMessage: "LazyCodex(0.1.0): Checking Comments",
+						},
+					],
+				},
+			],
+		},
+	});
+	await writeJson(join(root, "components", "comment-checker", "hooks", "hooks.json"), {
+		hooks: {
+			PostToolUse: [
+				{
+					hooks: [
+						{
+							type: "command",
+							command: 'node "${PLUGIN_ROOT}/dist/cli.js" hook post-tool-use',
+							statusMessage: "LazyCodex(0.1.0): Checking Comments",
+						},
+					],
+				},
+			],
+		},
+	});
+
+	// when
+	await syncHookStatusMessages(root);
+
+	// then
+	const aggregateHooks = await readJson(join(root, "hooks", "hooks.json"));
+	const componentHooks = await readJson(join(root, "components", "comment-checker", "hooks", "hooks.json"));
+	assert.equal(aggregateHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "LazyCodex(0.1.1): Checking Comments");
+	assert.equal(componentHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "LazyCodex(0.1.1): Checking Comments");
+});

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

@@ -0,0 +1,229 @@
+import assert from "node:assert/strict";
+import { readdir, readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { sharedSkillsRootPath } from "@oh-my-opencode/shared-skills";
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const repoRoot = join(root, "..", "..", "..");
+const CONTEXT_PRESSURE_SKILL_BUDGET_BYTES = 25_000;
+
+const expectedSkills = [
+	"comment-checker",
+	"debugging",
+	"frontend-ui-ux",
+	"init-deep",
+	"lsp",
+	"programming",
+	"refactor",
+	"remove-ai-slops",
+	"review-work",
+	"rules",
+	"start-work",
+	"ulw-loop",
+	"ulw-plan",
+];
+
+const componentSkillSources = [
+	["comment-checker", "components/comment-checker/skills/comment-checker"],
+	["lsp", "components/lsp/skills/lsp"],
+	["rules", "components/rules/skills/rules"],
+	["ulw-loop", "components/ulw-loop/skills/ulw-loop"],
+];
+
+const codexCompatibilityEndMarkers = [
+	"When translating `load_skills=[...]`, include the requested skill names in the spawned agent's `message`. If a code block below conflicts with this section, this section wins.\n\n",
+	"When translating `load_skills=[...]`, name the skills inside the spawned agent's `message`. If a code block below conflicts with this section, this section wins.\n\n",
+];
+
+function removeCodexCompatibilityGuidance(content) {
+	const start = content.indexOf("## Codex Harness Tool Compatibility\n\n");
+	if (start === -1) return content;
+	const endMarker = codexCompatibilityEndMarkers.find((marker) => content.indexOf(marker, start) !== -1);
+	assert.notEqual(endMarker, undefined, "Codex compatibility guidance block is missing its terminator");
+	const end = content.indexOf(endMarker, start);
+	assert.notEqual(end, -1, "Codex compatibility guidance block is missing its terminator");
+	return `${content.slice(0, start)}${content.slice(end + endMarker.length)}`;
+}
+
+test("#given synced aggregate Codex skills #when inspected #then component and shared skills are present", async () => {
+	// given
+	const skillsRoot = join(root, "skills");
+
+	// when
+	const skillNames = (await readdir(skillsRoot, { withFileTypes: true }))
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => entry.name)
+		.sort();
+
+	// then
+	assert.deepEqual(skillNames, expectedSkills);
+	for (const skillName of expectedSkills) {
+		const content = await readFile(join(skillsRoot, skillName, "SKILL.md"), "utf8");
+		assert.match(removeCodexCompatibilityGuidance(content), /^---\r?\n/);
+	}
+});
+
+test("#given aggregate Codex skills #when source wiring is inspected #then shared skills are imported from the shared-skills package", async () => {
+	// given
+	const pluginPackageJson = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+	const sharedPackageJson = JSON.parse(await readFile(join(root, "..", "..", "shared-skills", "package.json"), "utf8"));
+	const rootPackageJson = JSON.parse(await readFile(join(repoRoot, "package.json"), "utf8"));
+	const syncScript = await readFile(join(root, "scripts", "sync-skills.mjs"), "utf8");
+
+	// when
+	const sharedSkillDependency = pluginPackageJson.dependencies?.["@oh-my-opencode/shared-skills"];
+	const rootPackageFiles = rootPackageJson.files ?? [];
+
+	// then
+	assert.equal(sharedPackageJson.exports?.["."], "./index.mjs");
+	assert.equal(sharedPackageJson.files?.includes("skills"), true);
+	assert.equal(rootPackageFiles.includes("packages/shared-skills/package.json"), true);
+	assert.equal(rootPackageFiles.includes("packages/shared-skills/index.mjs"), true);
+	assert.equal(rootPackageFiles.includes("packages/shared-skills/skills"), true);
+	assert.equal(sharedSkillDependency, "file:../../shared-skills");
+	assert.match(syncScript, /from "@oh-my-opencode\/shared-skills"/);
+	assert.doesNotMatch(syncScript, /shared-skills",\s*"skills"/);
+});
+
+test("#given shared skill package source #when aggregate Codex shared skills are inspected #then generated copies have no hand-authored drift", async () => {
+	// given
+	const sharedSkillsRoot = sharedSkillsRootPath();
+	const aggregateSkillsRoot = join(root, "skills");
+	const sharedSkillNames = (await readdir(sharedSkillsRoot, { withFileTypes: true }))
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => entry.name)
+		.sort();
+
+	// when / then
+	for (const skillName of sharedSkillNames) {
+		const sharedContent = await readFile(join(sharedSkillsRoot, skillName, "SKILL.md"), "utf8");
+		const aggregateContent = await readFile(join(aggregateSkillsRoot, skillName, "SKILL.md"), "utf8");
+		assert.equal(
+			removeCodexCompatibilityGuidance(aggregateContent),
+			removeCodexCompatibilityGuidance(sharedContent),
+			`${skillName} drifted from shared-skills`,
+		);
+	}
+});
+
+test("#given component skill sources #when aggregate Codex component skills are inspected #then generated copies have no hand-authored drift", async () => {
+	// given
+	const aggregateSkillsRoot = join(root, "skills");
+
+	// when / then
+	for (const [skillName, sourcePath] of componentSkillSources) {
+		const sourceContent = await readFile(join(root, sourcePath, "SKILL.md"), "utf8");
+		const aggregateContent = await readFile(join(aggregateSkillsRoot, skillName, "SKILL.md"), "utf8");
+		assert.equal(
+			removeCodexCompatibilityGuidance(aggregateContent),
+			removeCodexCompatibilityGuidance(sourceContent),
+			`${skillName} drifted from its component skill source`,
+		);
+	}
+});
+
+test("#given synced ulw-loop skill #when Codex hint metadata is inspected #then ulw-loop surfaces the ulw-loop alias", async () => {
+	// given
+	const skillRoot = join(root, "skills", "ulw-loop");
+
+	// when
+	const skill = await readFile(join(skillRoot, "SKILL.md"), "utf8");
+	const interfaceMetadata = await readFile(join(skillRoot, "agents", "openai.yaml"), "utf8");
+
+	// then
+	assert.match(skill, /^---\r?\nname: ulw-loop\r?\n/m);
+	assert.match(skill, /Goal-like loop that uses ultrawork mode to decompose work into systematic, evidence-bound steps\./);
+	assert.match(interfaceMetadata, /display_name: "ulw-loop \(omo\)"/);
+	assert.doesNotMatch(interfaceMetadata, /ulw-loop \/ ulw-loop/);
+	assert.match(interfaceMetadata, /short_description: "Goal-like ultrawork loop for systematic decomposition"/);
+	assert.match(interfaceMetadata, /default_prompt: "Use \$ulw-loop/);
+});
+
+test("#given synced ulw-loop skill #when Codex hint metadata is inspected #then ulw-loop remains discoverable as an alias", async () => {
+	// given
+	const skillRoot = join(root, "skills", "ulw-loop");
+
+	// when
+	const interfaceMetadata = await readFile(join(skillRoot, "agents", "openai.yaml"), "utf8");
+
+	// then
+	assert.match(interfaceMetadata, /search_terms:/);
+	assert.match(interfaceMetadata, /- "ulw-loop"/);
+});
+
+test("#given synced ulw-loop skill #when worker guidance is inspected #then context-hygiene guidance matches the source", async () => {
+	// given
+	const sourceSkill = await readFile(
+		join(root, "components", "ulw-loop", "skills", "ulw-loop", "references", "full-workflow.md"),
+		"utf8",
+	);
+	const syncedSkill = await readFile(join(root, "skills", "ulw-loop", "SKILL.md"), "utf8");
+	const syncedWorkflow = await readFile(join(root, "skills", "ulw-loop", "references", "full-workflow.md"), "utf8");
+	const requiredPatterns = [
+		["list_agents polling guard", /list_agents/],
+		["status polling warning", /polling or status tool/],
+		["large payload replay risk", /replay large agent status and latest-message payloads/],
+		["local spawned-name tracking", /Track spawned agent names locally/],
+		["wait_agent completion path", /wait_agent.*completion/],
+		["targeted followups", /targeted followups only when needed/],
+		["close_agent cleanup", /close_agent.*after integrating each result/],
+		["long-running plan/reviewer background guidance", /Plan and reviewer agents may run for a long time/],
+		["bounded plan/reviewer polling", /short wait_agent cycles/],
+		["single long wait guard", /single long blocking wait/],
+	];
+
+	// when / then
+	for (const [label, pattern] of requiredPatterns) {
+		assert.match(sourceSkill, pattern, `source skill missing ${label}`);
+		assert.match(syncedWorkflow, pattern, `synced workflow missing ${label}`);
+	}
+	assert.match(syncedSkill, /references\/full-workflow\.md/);
+	assert.match(syncedSkill, /wait_agent/);
+	assert.match(syncedSkill, /close_agent/);
+});
+
+test("#given context-pressure-prone skills #when bundled for Codex #then the eagerly loaded payload stays budgeted", async () => {
+	// given
+	const skillsRoot = join(root, "skills");
+	const skillNames = ["debugging", "ulw-loop"];
+
+	// when
+	let totalBytes = 0;
+	for (const skillName of skillNames) {
+		const content = await readFile(join(skillsRoot, skillName, "SKILL.md"), "utf8");
+		totalBytes += Buffer.byteLength(content, "utf8");
+	}
+
+	// then
+	assert.ok(
+		totalBytes <= CONTEXT_PRESSURE_SKILL_BUDGET_BYTES,
+		`debugging + ulw-loop eager payload is ${totalBytes} bytes, above ${CONTEXT_PRESSURE_SKILL_BUDGET_BYTES}`,
+	);
+});
+
+test("#given synced aggregate Codex skills #when they contain OpenCode orchestration examples #then Codex tool compatibility guidance is injected", async () => {
+	// given
+	const skillsRoot = join(root, "skills");
+	const opencodeOnlyToolPattern = /\b(?:call_omo_agent|background_output|team_[a-z_]+|task)\s*\(/;
+
+	// when
+	const skillNames = (await readdir(skillsRoot, { withFileTypes: true }))
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => entry.name)
+		.sort();
+
+	// then
+	for (const skillName of skillNames) {
+		const content = await readFile(join(skillsRoot, skillName, "SKILL.md"), "utf8");
+		if (!opencodeOnlyToolPattern.test(content)) continue;
+
+		const compatibilityIndex = content.indexOf("## Codex Harness Tool Compatibility");
+		assert.notEqual(compatibilityIndex, -1, `${skillName} is missing Codex compatibility guidance`);
+		assert.ok(
+			compatibilityIndex < content.search(opencodeOnlyToolPattern),
+			`${skillName} must explain Codex tool translation before OpenCode-only examples`,
+		);
+	}
+});

package/packages/omo-codex/scripts/install/agents.mjs

@@ -0,0 +1,84 @@
+import { basename, join } from "node:path";
+import { copyFile, lstat, mkdir, readdir, rm, symlink, writeFile } from "node:fs/promises";
+
+import { exists } from "./utils.mjs";
+
+const MANIFEST_FILE = ".installed-agents.json";
+
+export async function linkCachedPluginAgents({ codexHome, pluginRoot, platform = process.platform }) {
+	const bundledAgents = await discoverBundledAgents(pluginRoot);
+	if (bundledAgents.length === 0) {
+		await writeManifest(pluginRoot, []);
+		return [];
+	}
+
+	const agentsDir = join(codexHome, "agents");
+	await mkdir(agentsDir, { recursive: true });
+	const linked = [];
+	for (const agentPath of bundledAgents) {
+		const linkPath = join(agentsDir, basename(agentPath));
+		if (platform === "win32") {
+			await replaceWithCopy(linkPath, agentPath);
+		} else {
+			await replaceWithSymlink(linkPath, agentPath);
+		}
+		linked.push({ name: basename(agentPath), path: linkPath, target: agentPath });
+	}
+	await writeManifest(pluginRoot, linked.map((entry) => entry.path));
+	return linked;
+}
+
+async function discoverBundledAgents(pluginRoot) {
+	const componentsRoot = join(pluginRoot, "components");
+	if (!(await exists(componentsRoot))) return [];
+
+	const componentEntries = await readdir(componentsRoot, { withFileTypes: true });
+	const agents = [];
+	for (const entry of componentEntries) {
+		if (!entry.isDirectory()) continue;
+		const agentsRoot = join(componentsRoot, entry.name, "agents");
+		if (!(await exists(agentsRoot))) continue;
+		const agentEntries = await readdir(agentsRoot, { withFileTypes: true });
+		for (const file of agentEntries) {
+			if (!file.isFile() || !file.name.endsWith(".toml")) continue;
+			agents.push(join(agentsRoot, file.name));
+		}
+	}
+	agents.sort();
+	return agents;
+}
+
+async function replaceWithSymlink(linkPath, target) {
+	await prepareReplacement(linkPath);
+	await symlink(target, linkPath);
+}
+
+async function replaceWithCopy(linkPath, target) {
+	await prepareReplacement(linkPath);
+	await copyFile(target, linkPath);
+}
+
+async function prepareReplacement(linkPath) {
+	if (!(await lstatExists(linkPath))) return;
+	const entryStat = await lstat(linkPath);
+	if (entryStat.isDirectory() && !entryStat.isSymbolicLink()) {
+		throw new Error(`${linkPath} already exists and is a directory; refusing to replace`);
+	}
+	await rm(linkPath, { force: true });
+}
+
+async function writeManifest(pluginRoot, agentPaths) {
+	const manifestPath = join(pluginRoot, MANIFEST_FILE);
+	const payload = { agents: [...agentPaths].sort() };
+	await writeFile(manifestPath, `${JSON.stringify(payload, null, "\t")}\n`);
+}
+
+async function lstatExists(path) {
+	try {
+		await lstat(path);
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}