fix(plugin): register builtin skill commands

Author: muwenyan521

packages/omo-opencode/src/plugin-handlers/command-config-handler.test.ts

@@ -1,16 +1,16 @@
 /// <reference types="bun-types" />
 
 import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import type { OhMyOpenCodeConfig } from "../config";
 import * as builtinCommands from "../features/builtin-commands";
 import * as commandLoader from "../features/claude-code-command-loader";
 import * as skillLoader from "../features/opencode-skill-loader";
-import type { OhMyOpenCodeConfig } from "../config";
-import type { PluginComponents } from "./plugin-components-loader";
-import { applyCommandConfig } from "./command-config-handler";
 import {
   getAgentDisplayName,
   getAgentListDisplayName,
 } from "../shared/agent-display-names";
+import { applyCommandConfig } from "./command-config-handler";
+import type { PluginComponents } from "./plugin-components-loader";
 
 function createPluginComponents(): PluginComponents {
   return {
@@ -24,13 +24,14 @@ function createPluginComponents(): PluginComponents {
   };
 }
 
-function createPluginConfig(): OhMyOpenCodeConfig {
+function createPluginConfig(overrides: Partial<OhMyOpenCodeConfig> = {}): OhMyOpenCodeConfig {
   return {
     git_master: {
       commit_footer: true,
       include_co_authored_by: true,
       git_env_prefix: "GIT_MASTER=1",
     },
+    ...overrides,
   };
 }
 
@@ -78,6 +79,156 @@ describe("applyCommandConfig", () => {
     loadGlobalAgentsSkillsSpy.mockRestore();
   });
 
+  test("includes builtin skills in command config", async () => {
+    // given
+    const config: Record<string, unknown> = { command: {} };
+
+    // when
+    await applyCommandConfig({
+      config,
+      pluginConfig: createPluginConfig(),
+      ctx: { directory: "/tmp" },
+      pluginComponents: createPluginComponents(),
+    });
+
+    // then
+    const commandConfig = config.command as Record<string, { description?: string; template?: string }>;
+    expect(commandConfig["init-deep"]?.description).toContain("hierarchical AGENTS.md");
+    expect(commandConfig["init-deep"]?.template).toContain("Generate hierarchical AGENTS.md files");
+  });
+
+  test("excludes disabled builtin skills from command config", async () => {
+    // given
+    const config: Record<string, unknown> = { command: {} };
+
+    // when
+    await applyCommandConfig({
+      config,
+      pluginConfig: createPluginConfig({ disabled_skills: ["init-deep"] }),
+      ctx: { directory: "/tmp" },
+      pluginComponents: createPluginComponents(),
+    });
+
+    // then
+    const commandConfig = config.command as Record<string, unknown>;
+    expect(commandConfig["init-deep"]).toBeUndefined();
+  });
+
+  test("keeps builtin command precedence over same-name builtin skills", async () => {
+    // given
+    loadBuiltinCommandsSpy.mockReturnValue({
+      "remove-ai-slops": {
+        name: "remove-ai-slops",
+        description: "Builtin command wins",
+        template: "command template",
+      },
+    });
+    const config: Record<string, unknown> = { command: {} };
+
+    // when
+    await applyCommandConfig({
+      config,
+      pluginConfig: createPluginConfig(),
+      ctx: { directory: "/tmp" },
+      pluginComponents: createPluginComponents(),
+    });
+
+    // then
+    const commandConfig = config.command as Record<string, { description?: string; template?: string }>;
+    expect(commandConfig["remove-ai-slops"]?.description).toBe("Builtin command wins");
+    expect(commandConfig["remove-ai-slops"]?.template).toBe("command template");
+  });
+
+  test("allows higher-precedence project skills to override builtin skill commands", async () => {
+    // given
+    loadProjectSkillsSpy.mockResolvedValue({
+      "init-deep": {
+        description: "Project init-deep skill",
+        template: "project template",
+      },
+    });
+    const config: Record<string, unknown> = { command: {} };
+
+    // when
+    await applyCommandConfig({
+      config,
+      pluginConfig: createPluginConfig(),
+      ctx: { directory: "/tmp" },
+      pluginComponents: createPluginComponents(),
+    });
+
+    // then
+    const commandConfig = config.command as Record<string, { description?: string; template?: string }>;
+    expect(commandConfig["init-deep"]?.description).toBe("Project init-deep skill");
+    expect(commandConfig["init-deep"]?.template).toBe("project template");
+  });
+
+  test("uses browser provider gating for builtin skill commands", async () => {
+    // given
+    const defaultConfig: Record<string, unknown> = { command: {} };
+    const agentBrowserConfig: Record<string, unknown> = { command: {} };
+
+    // when
+    await applyCommandConfig({
+      config: defaultConfig,
+      pluginConfig: createPluginConfig(),
+      ctx: { directory: "/tmp" },
+      pluginComponents: createPluginComponents(),
+    });
+    await applyCommandConfig({
+      config: agentBrowserConfig,
+      pluginConfig: createPluginConfig({ browser_automation_engine: { provider: "agent-browser" } }),
+      ctx: { directory: "/tmp" },
+      pluginComponents: createPluginComponents(),
+    });
+
+    // then
+    const defaultCommands = defaultConfig.command as Record<string, unknown>;
+    const agentBrowserCommands = agentBrowserConfig.command as Record<string, unknown>;
+    expect(defaultCommands.playwright).toBeDefined();
+    expect(defaultCommands["agent-browser"]).toBeUndefined();
+    expect(agentBrowserCommands["agent-browser"]).toBeDefined();
+    expect(agentBrowserCommands.playwright).toBeUndefined();
+  });
+
+  test("uses team-mode gating for builtin skill commands", async () => {
+    // given
+    const defaultConfig: Record<string, unknown> = { command: {} };
+    const teamModeConfig: Record<string, unknown> = { command: {} };
+    const disabledTeamModeConfig: Record<string, unknown> = { command: {} };
+
+    // when
+    await applyCommandConfig({
+      config: defaultConfig,
+      pluginConfig: createPluginConfig(),
+      ctx: { directory: "/tmp" },
+      pluginComponents: createPluginComponents(),
+    });
+    await applyCommandConfig({
+      config: teamModeConfig,
+      pluginConfig: createPluginConfig({ team_mode: { enabled: true } }),
+      ctx: { directory: "/tmp" },
+      pluginComponents: createPluginComponents(),
+    });
+    await applyCommandConfig({
+      config: disabledTeamModeConfig,
+      pluginConfig: createPluginConfig({
+        disabled_skills: ["team-mode"],
+        team_mode: { enabled: true },
+      }),
+      ctx: { directory: "/tmp" },
+      pluginComponents: createPluginComponents(),
+    });
+
+    // then
+    const defaultCommands = defaultConfig.command as Record<string, unknown>;
+    const teamModeCommands = teamModeConfig.command as Record<string, unknown>;
+    const disabledTeamModeCommands = disabledTeamModeConfig.command as Record<string, unknown>;
+    expect(defaultCommands["team-mode"]).toBeUndefined();
+    expect(teamModeCommands["team-mode"]).toBeDefined();
+    expect(disabledTeamModeCommands["team-mode"]).toBeUndefined();
+  });
+
   test("includes .agents skills in command config", async () => {
     // given
     loadProjectAgentsSkillsSpy.mockResolvedValue({

packages/omo-opencode/src/plugin-handlers/command-config-handler.ts

@@ -1,32 +1,34 @@
 import type { OhMyOpenCodeConfig } from "../config";
+import { loadBuiltinCommands } from "../features/builtin-commands";
+import { createBuiltinSkills } from "../features/builtin-skills";
 import {
-  getAgentConfigKey,
-  getAgentListDisplayName,
-} from "../shared/agent-display-names";
-import {
-  loadUserCommands,
-  loadProjectCommands,
   loadOpencodeGlobalCommands,
   loadOpencodeProjectCommands,
+  loadProjectCommands,
+  loadUserCommands,
 } from "../features/claude-code-command-loader";
-import { loadBuiltinCommands } from "../features/builtin-commands";
 import {
   discoverConfigSourceSkills,
   loadGlobalAgentsSkills,
-  loadProjectAgentsSkills,
-  loadUserSkills,
-  loadProjectSkills,
   loadOpencodeGlobalSkills,
   loadOpencodeProjectSkills,
+  loadProjectAgentsSkills,
+  loadProjectSkills,
+  loadUserSkills,
   skillsToCommandDefinitionRecord,
 } from "../features/opencode-skill-loader";
+import { builtinToLoadedSkill } from "../features/opencode-skill-loader/merger/builtin-skill-converter";
 import {
   detectExternalSkillPlugin,
   getSkillPluginConflictWarning,
   log,
 } from "../shared";
-import type { PluginComponents } from "./plugin-components-loader";
+import {
+  getAgentConfigKey,
+  getAgentListDisplayName,
+} from "../shared/agent-display-names";
 import { adaptHostSkillConfig } from "../shared/host-skill-config";
+import type { PluginComponents } from "./plugin-components-loader";
 
 export async function applyCommandConfig(params: {
   config: Record<string, unknown>;
@@ -38,6 +40,13 @@ export async function applyCommandConfig(params: {
     useRegisteredAgents: true,
     teamModeEnabled: params.pluginConfig.team_mode?.enabled ?? false,
   });
+  const builtinSkillCommands = skillsToCommandDefinitionRecord(
+    createBuiltinSkills({
+      browserProvider: params.pluginConfig.browser_automation_engine?.provider ?? "playwright",
+      disabledSkills: new Set(params.pluginConfig.disabled_skills ?? []),
+      teamModeEnabled: params.pluginConfig.team_mode?.enabled ?? false,
+    }).map(builtinToLoadedSkill),
+  );
   const systemCommands = (params.config.command as Record<string, unknown>) ?? {};
 
   const includeClaudeCommands = params.pluginConfig.claude_code?.commands ?? true;
@@ -84,6 +93,7 @@ export async function applyCommandConfig(params: {
   ]);
 
   params.config.command = {
+    ...builtinSkillCommands,
     ...builtinCommands,
     ...skillsToCommandDefinitionRecord(configSourceSkills),
     ...skillsToCommandDefinitionRecord(hostConfigSkills),