Merge pull request #2021 from cruzanstx/feat/marketplace-plugin-dispatch

feat(dispatch): wire marketplace plugin commands into slash command dispatch
2026-03-02 23:28:20 +09:00
parent fdd806e729 0dee4377b8
commit 4905e6fc7c
14 changed files with 461 additions and 14 deletions
@@ -3,7 +3,7 @@ export const HOOK_NAME = "auto-slash-command" as const
 export const AUTO_SLASH_COMMAND_TAG_OPEN = "<auto-slash-command>"
 export const AUTO_SLASH_COMMAND_TAG_CLOSE = "</auto-slash-command>"

-export const SLASH_COMMAND_PATTERN = /^\/([a-zA-Z][\w-]*)\s*(.*)/
+export const SLASH_COMMAND_PATTERN = /^\/([a-zA-Z@][\w:@/-]*)\s*(.*)/

 export const EXCLUDED_COMMANDS = new Set([
  "ralph-loop",
@@ -102,6 +102,19 @@ After`
      expect(result?.args).toBe("project")
    })

+    it("should parse namespaced marketplace commands", () => {
+      // given a namespaced command
+      const text = "/daplug:run-prompt build bridge"
+
+      // when parsing
+      const result = parseSlashCommand(text)
+
+      // then should keep full namespaced command
+      expect(result).not.toBeNull()
+      expect(result?.command).toBe("daplug:run-prompt")
+      expect(result?.args).toBe("build bridge")
+    })
+
    it("should return null for non-slash text", () => {
      // given text without slash
      const text = "regular text"
@@ -0,0 +1,168 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test"
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { executeSlashCommand } from "./executor"
+
+const ENV_KEYS = [
+  "CLAUDE_CONFIG_DIR",
+  "CLAUDE_PLUGINS_HOME",
+  "CLAUDE_SETTINGS_PATH",
+  "OPENCODE_CONFIG_DIR",
+] as const
+
+type EnvKey = (typeof ENV_KEYS)[number]
+type EnvSnapshot = Record<EnvKey, string | undefined>
+
+function writePluginFixture(baseDir: string): void {
+  const claudeConfigDir = join(baseDir, "claude-config")
+  const pluginsHome = join(claudeConfigDir, "plugins")
+  const settingsPath = join(claudeConfigDir, "settings.json")
+  const opencodeConfigDir = join(baseDir, "opencode-config")
+  const pluginInstallPath = join(baseDir, "installed-plugins", "daplug")
+  const pluginKey = "daplug@1.0.0"
+
+  mkdirSync(join(pluginInstallPath, ".claude-plugin"), { recursive: true })
+  mkdirSync(join(pluginInstallPath, "commands"), { recursive: true })
+
+  writeFileSync(
+    join(pluginInstallPath, ".claude-plugin", "plugin.json"),
+    JSON.stringify({ name: "daplug", version: "1.0.0" }, null, 2),
+  )
+  writeFileSync(
+    join(pluginInstallPath, "commands", "run-prompt.md"),
+    `---
+description: Run prompt from daplug
+---
+Execute daplug prompt flow.
+`,
+  )
+
+  mkdirSync(pluginsHome, { recursive: true })
+  writeFileSync(
+    join(pluginsHome, "installed_plugins.json"),
+    JSON.stringify(
+      {
+        version: 2,
+        plugins: {
+          [pluginKey]: [
+            {
+              scope: "user",
+              installPath: pluginInstallPath,
+              version: "1.0.0",
+              installedAt: "2026-01-01T00:00:00.000Z",
+              lastUpdated: "2026-01-01T00:00:00.000Z",
+            },
+          ],
+        },
+      },
+      null,
+      2,
+    ),
+  )
+
+  mkdirSync(claudeConfigDir, { recursive: true })
+  writeFileSync(
+    settingsPath,
+    JSON.stringify(
+      {
+        enabledPlugins: {
+          [pluginKey]: true,
+        },
+      },
+      null,
+      2,
+    ),
+  )
+  mkdirSync(opencodeConfigDir, { recursive: true })
+
+  process.env.CLAUDE_CONFIG_DIR = claudeConfigDir
+  process.env.CLAUDE_PLUGINS_HOME = pluginsHome
+  process.env.CLAUDE_SETTINGS_PATH = settingsPath
+  process.env.OPENCODE_CONFIG_DIR = opencodeConfigDir
+}
+
+describe("auto-slash command executor plugin dispatch", () => {
+  let tempDir = ""
+  let envSnapshot: EnvSnapshot
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "omo-executor-plugin-test-"))
+    envSnapshot = {
+      CLAUDE_CONFIG_DIR: process.env.CLAUDE_CONFIG_DIR,
+      CLAUDE_PLUGINS_HOME: process.env.CLAUDE_PLUGINS_HOME,
+      CLAUDE_SETTINGS_PATH: process.env.CLAUDE_SETTINGS_PATH,
+      OPENCODE_CONFIG_DIR: process.env.OPENCODE_CONFIG_DIR,
+    }
+    writePluginFixture(tempDir)
+  })
+
+  afterEach(() => {
+    for (const key of ENV_KEYS) {
+      const previousValue = envSnapshot[key]
+      if (previousValue === undefined) {
+        delete process.env[key]
+      } else {
+        process.env[key] = previousValue
+      }
+    }
+    rmSync(tempDir, { recursive: true, force: true })
+  })
+
+  it("resolves marketplace plugin commands when plugin loading is enabled", async () => {
+    const result = await executeSlashCommand(
+      {
+        command: "daplug:run-prompt",
+        args: "ship it",
+        raw: "/daplug:run-prompt ship it",
+      },
+      {
+        skills: [],
+        pluginsEnabled: true,
+      },
+    )
+
+    expect(result.success).toBe(true)
+    expect(result.replacementText).toContain("# /daplug:run-prompt Command")
+    expect(result.replacementText).toContain("**Scope**: plugin")
+  })
+
+  it("excludes marketplace commands when plugins are disabled via config toggle", async () => {
+    const result = await executeSlashCommand(
+      {
+        command: "daplug:run-prompt",
+        args: "",
+        raw: "/daplug:run-prompt",
+      },
+      {
+        skills: [],
+        pluginsEnabled: false,
+      },
+    )
+
+    expect(result.success).toBe(false)
+    expect(result.error).toBe(
+      'Command "/daplug:run-prompt" not found. Use the skill tool to list available skills and commands.',
+    )
+  })
+
+  it("returns standard not-found for unknown namespaced commands", async () => {
+    const result = await executeSlashCommand(
+      {
+        command: "daplug:missing",
+        args: "",
+        raw: "/daplug:missing",
+      },
+      {
+        skills: [],
+        pluginsEnabled: true,
+      },
+    )
+
+    expect(result.success).toBe(false)
+    expect(result.error).toBe(
+      'Command "/daplug:missing" not found. Use the skill tool to list available skills and commands.',
+    )
+    expect(result.error).not.toContain("Marketplace plugin commands")
+  })
+})
@@ -12,10 +12,15 @@ import { loadBuiltinCommands } from "../../features/builtin-commands"
 import type { CommandFrontmatter } from "../../features/claude-code-command-loader/types"
 import { isMarkdownFile } from "../../shared/file-utils"
 import { discoverAllSkills, type LoadedSkill, type LazyContentLoader } from "../../features/opencode-skill-loader"
+import {
+  discoverInstalledPlugins,
+  loadPluginCommands,
+  loadPluginSkillsAsCommands,
+} from "../../features/claude-code-plugin-loader"
 import type { ParsedSlashCommand } from "./types"

 interface CommandScope {
-  type: "user" | "project" | "opencode" | "opencode-project" | "skill" | "builtin"
+  type: "user" | "project" | "opencode" | "opencode-project" | "skill" | "builtin" | "plugin"
 }

 interface CommandMetadata {
@@ -99,6 +104,36 @@ function skillToCommandInfo(skill: LoadedSkill): CommandInfo {

 export interface ExecutorOptions {
  skills?: LoadedSkill[]
+  pluginsEnabled?: boolean
+  enabledPluginsOverride?: Record<string, boolean>
+}
+
+function discoverPluginCommands(options?: ExecutorOptions): CommandInfo[] {
+  if (options?.pluginsEnabled === false) {
+    return []
+  }
+
+  const { plugins } = discoverInstalledPlugins({
+    enabledPluginsOverride: options?.enabledPluginsOverride,
+  })
+
+  const pluginDefinitions = {
+    ...loadPluginCommands(plugins),
+    ...loadPluginSkillsAsCommands(plugins),
+  }
+
+  return Object.entries(pluginDefinitions).map(([name, definition]) => ({
+    name,
+    metadata: {
+      name,
+      description: definition.description || "",
+      model: definition.model,
+      agent: definition.agent,
+      subtask: definition.subtask,
+    },
+    content: definition.template,
+    scope: "plugin",
+  }))
 }

 async function discoverAllCommands(options?: ExecutorOptions): Promise<CommandInfo[]> {
@@ -128,6 +163,7 @@ async function discoverAllCommands(options?: ExecutorOptions): Promise<CommandIn

  const skills = options?.skills ?? await discoverAllSkills()
  const skillCommands = skills.map(skillToCommandInfo)
+  const pluginCommands = discoverPluginCommands(options)

  return [
    ...builtinCommands,
@@ -136,6 +172,7 @@ async function discoverAllCommands(options?: ExecutorOptions): Promise<CommandIn
    ...opencodeGlobalCommands,
    ...userCommands,
    ...skillCommands,
+    ...pluginCommands,
  ]
 }

@@ -202,9 +239,7 @@ export async function executeSlashCommand(parsed: ParsedSlashCommand, options?:
  if (!command) {
    return {
      success: false,
-      error: parsed.command.includes(":")
-        ? `Marketplace plugin commands like "/${parsed.command}" are not supported. Use .claude/commands/ for custom commands.`
-        : `Command "/${parsed.command}" not found. Use the skill tool to list available skills and commands.`,
+      error: `Command "/${parsed.command}" not found. Use the skill tool to list available skills and commands.`,
    }
  }

@@ -22,11 +22,15 @@ const sessionProcessedCommandExecutions = new Set<string>()

 export interface AutoSlashCommandHookOptions {
  skills?: LoadedSkill[]
+  pluginsEnabled?: boolean
+  enabledPluginsOverride?: Record<string, boolean>
 }

 export function createAutoSlashCommandHook(options?: AutoSlashCommandHookOptions) {
  const executorOptions: ExecutorOptions = {
    skills: options?.skills,
+    pluginsEnabled: options?.pluginsEnabled,
+    enabledPluginsOverride: options?.enabledPluginsOverride,
  }

  return {