@every-env/compound-plugin 0.2.0 → 0.5.0

package/src/types/cursor.ts

@@ -0,0 +1,29 @@
+export type CursorRule = {
+  name: string
+  content: string
+}
+
+export type CursorCommand = {
+  name: string
+  content: string
+}
+
+export type CursorSkillDir = {
+  name: string
+  sourceDir: string
+}
+
+export type CursorMcpServer = {
+  command?: string
+  args?: string[]
+  env?: Record<string, string>
+  url?: string
+  headers?: Record<string, string>
+}
+
+export type CursorBundle = {
+  rules: CursorRule[]
+  commands: CursorCommand[]
+  skillDirs: CursorSkillDir[]
+  mcpServers?: Record<string, CursorMcpServer>
+}

package/src/types/droid.ts

@@ -0,0 +1,20 @@
+export type DroidCommandFile = {
+  name: string
+  content: string
+}
+
+export type DroidAgentFile = {
+  name: string
+  content: string
+}
+
+export type DroidSkillDir = {
+  name: string
+  sourceDir: string
+}
+
+export type DroidBundle = {
+  commands: DroidCommandFile[]
+  droids: DroidAgentFile[]
+  skillDirs: DroidSkillDir[]
+}

package/tests/claude-parser.test.ts

@@ -15,8 +15,8 @@ describe("loadClaudePlugin", () => {
 
     expect(plugin.manifest.name).toBe("compound-engineering")
     expect(plugin.agents.length).toBe(2)
-    expect(plugin.commands.length).toBe(6)
-    expect(plugin.skills.length).toBe(1)
+    expect(plugin.commands.length).toBe(7)
+    expect(plugin.skills.length).toBe(2)
     expect(plugin.hooks).toBeDefined()
     expect(plugin.mcpServers).toBeDefined()
 
@@ -55,6 +55,28 @@ describe("loadClaudePlugin", () => {
     expect(plugin.mcpServers?.context7?.url).toBe("https://mcp.context7.com/mcp")
   })
 
+  test("parses disable-model-invocation from commands", async () => {
+    const plugin = await loadClaudePlugin(fixtureRoot)
+
+    const disabledCommand = plugin.commands.find((command) => command.name === "deploy-docs")
+    expect(disabledCommand).toBeDefined()
+    expect(disabledCommand?.disableModelInvocation).toBe(true)
+
+    const normalCommand = plugin.commands.find((command) => command.name === "workflows:review")
+    expect(normalCommand?.disableModelInvocation).toBeUndefined()
+  })
+
+  test("parses disable-model-invocation from skills", async () => {
+    const plugin = await loadClaudePlugin(fixtureRoot)
+
+    const disabledSkill = plugin.skills.find((skill) => skill.name === "disabled-skill")
+    expect(disabledSkill).toBeDefined()
+    expect(disabledSkill?.disableModelInvocation).toBe(true)
+
+    const normalSkill = plugin.skills.find((skill) => skill.name === "skill-one")
+    expect(normalSkill?.disableModelInvocation).toBeUndefined()
+  })
+
   test("loads MCP servers from .mcp.json when manifest is empty", async () => {
     const plugin = await loadClaudePlugin(mcpFixtureRoot)
     expect(plugin.mcpServers?.remote?.url).toBe("https://example.com/stream")

package/tests/codex-converter.test.ts

@@ -172,6 +172,106 @@ Don't confuse with file paths like /tmp/output.md or /dev/null.`,
     expect(parsed.body).toContain("/dev/null")
   })
 
+  test("excludes commands with disable-model-invocation from prompts and skills", () => {
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      commands: [
+        {
+          name: "normal-command",
+          description: "Normal command",
+          body: "Normal body.",
+          sourcePath: "/tmp/plugin/commands/normal.md",
+        },
+        {
+          name: "disabled-command",
+          description: "Disabled command",
+          disableModelInvocation: true,
+          body: "Disabled body.",
+          sourcePath: "/tmp/plugin/commands/disabled.md",
+        },
+      ],
+      agents: [],
+      skills: [],
+    }
+
+    const bundle = convertClaudeToCodex(plugin, {
+      agentMode: "subagent",
+      inferTemperature: false,
+      permissions: "none",
+    })
+
+    // Only normal command should produce a prompt
+    expect(bundle.prompts).toHaveLength(1)
+    expect(bundle.prompts[0].name).toBe("normal-command")
+
+    // Only normal command should produce a generated skill
+    const commandSkills = bundle.generatedSkills.filter((s) => s.name === "normal-command" || s.name === "disabled-command")
+    expect(commandSkills).toHaveLength(1)
+    expect(commandSkills[0].name).toBe("normal-command")
+  })
+
+  test("rewrites .claude/ paths to .codex/ in command skill bodies", () => {
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      commands: [
+        {
+          name: "review",
+          description: "Review command",
+          body: `Read \`compound-engineering.local.md\` in the project root.
+
+If no settings file exists, auto-detect project type.
+
+Run \`/compound-engineering-setup\` to create a settings file.`,
+          sourcePath: "/tmp/plugin/commands/review.md",
+        },
+      ],
+      agents: [],
+      skills: [],
+    }
+
+    const bundle = convertClaudeToCodex(plugin, {
+      agentMode: "subagent",
+      inferTemperature: false,
+      permissions: "none",
+    })
+
+    const commandSkill = bundle.generatedSkills.find((s) => s.name === "review")
+    expect(commandSkill).toBeDefined()
+    const parsed = parseFrontmatter(commandSkill!.content)
+
+    // Tool-agnostic path in project root — no rewriting needed
+    expect(parsed.body).toContain("compound-engineering.local.md")
+  })
+
+  test("rewrites .claude/ paths in agent skill bodies", () => {
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      commands: [],
+      skills: [],
+      agents: [
+        {
+          name: "config-reader",
+          description: "Reads config",
+          body: "Read `compound-engineering.local.md` for config.",
+          sourcePath: "/tmp/plugin/agents/config-reader.md",
+        },
+      ],
+    }
+
+    const bundle = convertClaudeToCodex(plugin, {
+      agentMode: "subagent",
+      inferTemperature: false,
+      permissions: "none",
+    })
+
+    const agentSkill = bundle.generatedSkills.find((s) => s.name === "config-reader")
+    expect(agentSkill).toBeDefined()
+    const parsed = parseFrontmatter(agentSkill!.content)
+
+    // Tool-agnostic path in project root — no rewriting needed
+    expect(parsed.body).toContain("compound-engineering.local.md")
+  })
+
   test("truncates generated skill descriptions to Codex limits and single line", () => {
     const longDescription = `Line one\nLine two ${"a".repeat(2000)}`
     const plugin: ClaudePlugin = {

package/tests/converter.test.ts

@@ -3,6 +3,7 @@ import path from "path"
 import { loadClaudePlugin } from "../src/parsers/claude"
 import { convertClaudeToOpenCode } from "../src/converters/claude-to-opencode"
 import { parseFrontmatter } from "../src/utils/frontmatter"
+import type { ClaudePlugin } from "../src/types/claude"
 
 const fixtureRoot = path.join(import.meta.dir, "fixtures", "sample-plugin")
 
@@ -168,4 +169,79 @@ describe("convertClaudeToOpenCode", () => {
     const parsed = parseFrontmatter(agentFile!.content)
     expect(parsed.data.mode).toBe("primary")
   })
+
+  test("excludes commands with disable-model-invocation from command map", async () => {
+    const plugin = await loadClaudePlugin(fixtureRoot)
+    const bundle = convertClaudeToOpenCode(plugin, {
+      agentMode: "subagent",
+      inferTemperature: false,
+      permissions: "none",
+    })
+
+    // deploy-docs has disable-model-invocation: true, should be excluded
+    expect(bundle.config.command?.["deploy-docs"]).toBeUndefined()
+
+    // Normal commands should still be present
+    expect(bundle.config.command?.["workflows:review"]).toBeDefined()
+  })
+
+  test("rewrites .claude/ paths to .opencode/ in command bodies", () => {
+    const plugin: ClaudePlugin = {
+      root: "/tmp/plugin",
+      manifest: { name: "fixture", version: "1.0.0" },
+      agents: [],
+      commands: [
+        {
+          name: "review",
+          description: "Review command",
+          body: `Read \`compound-engineering.local.md\` in the project root.
+
+If no settings file exists, auto-detect project type.
+
+Run \`/compound-engineering-setup\` to create a settings file.`,
+          sourcePath: "/tmp/plugin/commands/review.md",
+        },
+      ],
+      skills: [],
+    }
+
+    const bundle = convertClaudeToOpenCode(plugin, {
+      agentMode: "subagent",
+      inferTemperature: false,
+      permissions: "none",
+    })
+
+    const template = bundle.config.command?.["review"]?.template ?? ""
+
+    // Tool-agnostic path in project root — no rewriting needed
+    expect(template).toContain("compound-engineering.local.md")
+  })
+
+  test("rewrites .claude/ paths in agent bodies", () => {
+    const plugin: ClaudePlugin = {
+      root: "/tmp/plugin",
+      manifest: { name: "fixture", version: "1.0.0" },
+      agents: [
+        {
+          name: "test-agent",
+          description: "Test agent",
+          body: "Read `compound-engineering.local.md` for config.",
+          sourcePath: "/tmp/plugin/agents/test-agent.md",
+        },
+      ],
+      commands: [],
+      skills: [],
+    }
+
+    const bundle = convertClaudeToOpenCode(plugin, {
+      agentMode: "subagent",
+      inferTemperature: false,
+      permissions: "none",
+    })
+
+    const agentFile = bundle.agents.find((a) => a.name === "test-agent")
+    expect(agentFile).toBeDefined()
+    // Tool-agnostic path in project root — no rewriting needed
+    expect(agentFile!.content).toContain("compound-engineering.local.md")
+  })
 })

package/tests/cursor-converter.test.ts

@@ -0,0 +1,347 @@
+import { describe, expect, test, spyOn } from "bun:test"
+import { convertClaudeToCursor, transformContentForCursor } from "../src/converters/claude-to-cursor"
+import { parseFrontmatter } from "../src/utils/frontmatter"
+import type { ClaudePlugin } from "../src/types/claude"
+
+const fixturePlugin: ClaudePlugin = {
+  root: "/tmp/plugin",
+  manifest: { name: "fixture", version: "1.0.0" },
+  agents: [
+    {
+      name: "Security Reviewer",
+      description: "Security-focused code review agent",
+      capabilities: ["Threat modeling", "OWASP"],
+      model: "claude-sonnet-4-20250514",
+      body: "Focus on vulnerabilities.",
+      sourcePath: "/tmp/plugin/agents/security-reviewer.md",
+    },
+  ],
+  commands: [
+    {
+      name: "workflows:plan",
+      description: "Planning command",
+      argumentHint: "[FOCUS]",
+      model: "inherit",
+      allowedTools: ["Read"],
+      body: "Plan the work.",
+      sourcePath: "/tmp/plugin/commands/workflows/plan.md",
+    },
+  ],
+  skills: [
+    {
+      name: "existing-skill",
+      description: "Existing skill",
+      sourceDir: "/tmp/plugin/skills/existing-skill",
+      skillPath: "/tmp/plugin/skills/existing-skill/SKILL.md",
+    },
+  ],
+  hooks: undefined,
+  mcpServers: undefined,
+}
+
+const defaultOptions = {
+  agentMode: "subagent" as const,
+  inferTemperature: false,
+  permissions: "none" as const,
+}
+
+describe("convertClaudeToCursor", () => {
+  test("converts agents to rules with .mdc frontmatter", () => {
+    const bundle = convertClaudeToCursor(fixturePlugin, defaultOptions)
+
+    expect(bundle.rules).toHaveLength(1)
+    const rule = bundle.rules[0]
+    expect(rule.name).toBe("security-reviewer")
+
+    const parsed = parseFrontmatter(rule.content)
+    expect(parsed.data.description).toBe("Security-focused code review agent")
+    expect(parsed.data.alwaysApply).toBe(false)
+    // globs is omitted (Agent Requested mode doesn't need it)
+    expect(parsed.body).toContain("Capabilities")
+    expect(parsed.body).toContain("Threat modeling")
+    expect(parsed.body).toContain("Focus on vulnerabilities.")
+  })
+
+  test("agent with empty description gets default", () => {
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      agents: [
+        {
+          name: "basic-agent",
+          body: "Do things.",
+          sourcePath: "/tmp/plugin/agents/basic.md",
+        },
+      ],
+    }
+
+    const bundle = convertClaudeToCursor(plugin, defaultOptions)
+    const parsed = parseFrontmatter(bundle.rules[0].content)
+    expect(parsed.data.description).toBe("Converted from Claude agent basic-agent")
+  })
+
+  test("agent with empty body gets default body", () => {
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      agents: [
+        {
+          name: "empty-agent",
+          description: "Empty agent",
+          body: "",
+          sourcePath: "/tmp/plugin/agents/empty.md",
+        },
+      ],
+    }
+
+    const bundle = convertClaudeToCursor(plugin, defaultOptions)
+    const parsed = parseFrontmatter(bundle.rules[0].content)
+    expect(parsed.body).toContain("Instructions converted from the empty-agent agent.")
+  })
+
+  test("agent capabilities are prepended to body", () => {
+    const bundle = convertClaudeToCursor(fixturePlugin, defaultOptions)
+    const parsed = parseFrontmatter(bundle.rules[0].content)
+    expect(parsed.body).toMatch(/## Capabilities\n- Threat modeling\n- OWASP/)
+  })
+
+  test("agent model field is silently dropped", () => {
+    const bundle = convertClaudeToCursor(fixturePlugin, defaultOptions)
+    const parsed = parseFrontmatter(bundle.rules[0].content)
+    expect(parsed.data.model).toBeUndefined()
+  })
+
+  test("flattens namespaced command names", () => {
+    const bundle = convertClaudeToCursor(fixturePlugin, defaultOptions)
+
+    expect(bundle.commands).toHaveLength(1)
+    const command = bundle.commands[0]
+    expect(command.name).toBe("plan")
+  })
+
+  test("commands are plain markdown without frontmatter", () => {
+    const bundle = convertClaudeToCursor(fixturePlugin, defaultOptions)
+    const command = bundle.commands[0]
+
+    // Should NOT start with ---
+    expect(command.content.startsWith("---")).toBe(false)
+    // Should include the description as a comment
+    expect(command.content).toContain("<!-- Planning command -->")
+    expect(command.content).toContain("Plan the work.")
+  })
+
+  test("command name collision after flattening is deduplicated", () => {
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      commands: [
+        {
+          name: "workflows:plan",
+          description: "Workflow plan",
+          body: "Plan body.",
+          sourcePath: "/tmp/plugin/commands/workflows/plan.md",
+        },
+        {
+          name: "plan",
+          description: "Top-level plan",
+          body: "Top plan body.",
+          sourcePath: "/tmp/plugin/commands/plan.md",
+        },
+      ],
+      agents: [],
+      skills: [],
+    }
+
+    const bundle = convertClaudeToCursor(plugin, defaultOptions)
+    const names = bundle.commands.map((c) => c.name)
+    expect(names).toEqual(["plan", "plan-2"])
+  })
+
+  test("command with disable-model-invocation is still included", () => {
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      commands: [
+        {
+          name: "setup",
+          description: "Setup command",
+          disableModelInvocation: true,
+          body: "Setup body.",
+          sourcePath: "/tmp/plugin/commands/setup.md",
+        },
+      ],
+      agents: [],
+      skills: [],
+    }
+
+    const bundle = convertClaudeToCursor(plugin, defaultOptions)
+    expect(bundle.commands).toHaveLength(1)
+    expect(bundle.commands[0].name).toBe("setup")
+  })
+
+  test("command allowedTools is silently dropped", () => {
+    const bundle = convertClaudeToCursor(fixturePlugin, defaultOptions)
+    const command = bundle.commands[0]
+    expect(command.content).not.toContain("allowedTools")
+    expect(command.content).not.toContain("Read")
+  })
+
+  test("command with argument-hint gets Arguments section", () => {
+    const bundle = convertClaudeToCursor(fixturePlugin, defaultOptions)
+    const command = bundle.commands[0]
+    expect(command.content).toContain("## Arguments")
+    expect(command.content).toContain("[FOCUS]")
+  })
+
+  test("passes through skill directories", () => {
+    const bundle = convertClaudeToCursor(fixturePlugin, defaultOptions)
+
+    expect(bundle.skillDirs).toHaveLength(1)
+    expect(bundle.skillDirs[0].name).toBe("existing-skill")
+    expect(bundle.skillDirs[0].sourceDir).toBe("/tmp/plugin/skills/existing-skill")
+  })
+
+  test("converts MCP servers to JSON config", () => {
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      agents: [],
+      commands: [],
+      skills: [],
+      mcpServers: {
+        playwright: {
+          command: "npx",
+          args: ["-y", "@anthropic/mcp-playwright"],
+          env: { DISPLAY: ":0" },
+        },
+      },
+    }
+
+    const bundle = convertClaudeToCursor(plugin, defaultOptions)
+    expect(bundle.mcpServers).toBeDefined()
+    expect(bundle.mcpServers!.playwright.command).toBe("npx")
+    expect(bundle.mcpServers!.playwright.args).toEqual(["-y", "@anthropic/mcp-playwright"])
+    expect(bundle.mcpServers!.playwright.env).toEqual({ DISPLAY: ":0" })
+  })
+
+  test("MCP headers pass through for remote servers", () => {
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      agents: [],
+      commands: [],
+      skills: [],
+      mcpServers: {
+        remote: {
+          url: "https://mcp.example.com/sse",
+          headers: { Authorization: "Bearer token" },
+        },
+      },
+    }
+
+    const bundle = convertClaudeToCursor(plugin, defaultOptions)
+    expect(bundle.mcpServers!.remote.url).toBe("https://mcp.example.com/sse")
+    expect(bundle.mcpServers!.remote.headers).toEqual({ Authorization: "Bearer token" })
+  })
+
+  test("warns when hooks are present", () => {
+    const warnSpy = spyOn(console, "warn").mockImplementation(() => {})
+
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      agents: [],
+      commands: [],
+      skills: [],
+      hooks: {
+        hooks: {
+          PreToolUse: [{ matcher: "Bash", hooks: [{ type: "command", command: "echo test" }] }],
+        },
+      },
+    }
+
+    convertClaudeToCursor(plugin, defaultOptions)
+    expect(warnSpy).toHaveBeenCalledWith(
+      "Warning: Cursor does not support hooks. Hooks were skipped during conversion.",
+    )
+
+    warnSpy.mockRestore()
+  })
+
+  test("no warning when hooks are absent", () => {
+    const warnSpy = spyOn(console, "warn").mockImplementation(() => {})
+
+    convertClaudeToCursor(fixturePlugin, defaultOptions)
+    expect(warnSpy).not.toHaveBeenCalled()
+
+    warnSpy.mockRestore()
+  })
+
+  test("plugin with zero agents produces empty rules array", () => {
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      agents: [],
+    }
+
+    const bundle = convertClaudeToCursor(plugin, defaultOptions)
+    expect(bundle.rules).toHaveLength(0)
+  })
+
+  test("plugin with only skills works", () => {
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      agents: [],
+      commands: [],
+    }
+
+    const bundle = convertClaudeToCursor(plugin, defaultOptions)
+    expect(bundle.rules).toHaveLength(0)
+    expect(bundle.commands).toHaveLength(0)
+    expect(bundle.skillDirs).toHaveLength(1)
+  })
+})
+
+describe("transformContentForCursor", () => {
+  test("rewrites .claude/ paths to .cursor/", () => {
+    const input = "Read `.claude/compound-engineering.local.md` for config."
+    const result = transformContentForCursor(input)
+    expect(result).toContain(".cursor/compound-engineering.local.md")
+    expect(result).not.toContain(".claude/")
+  })
+
+  test("rewrites ~/.claude/ paths to ~/.cursor/", () => {
+    const input = "Global config at ~/.claude/settings.json"
+    const result = transformContentForCursor(input)
+    expect(result).toContain("~/.cursor/settings.json")
+    expect(result).not.toContain("~/.claude/")
+  })
+
+  test("transforms Task agent calls to skill references", () => {
+    const input = `Run agents:
+
+- Task repo-research-analyst(feature_description)
+- Task learnings-researcher(feature_description)
+
+Task best-practices-researcher(topic)`
+
+    const result = transformContentForCursor(input)
+    expect(result).toContain("Use the repo-research-analyst skill to: feature_description")
+    expect(result).toContain("Use the learnings-researcher skill to: feature_description")
+    expect(result).toContain("Use the best-practices-researcher skill to: topic")
+    expect(result).not.toContain("Task repo-research-analyst(")
+  })
+
+  test("flattens slash commands", () => {
+    const input = `1. Run /deepen-plan to enhance
+2. Start /workflows:work to implement
+3. File at /tmp/output.md`
+
+    const result = transformContentForCursor(input)
+    expect(result).toContain("/deepen-plan")
+    expect(result).toContain("/work")
+    expect(result).not.toContain("/workflows:work")
+    // File paths preserved
+    expect(result).toContain("/tmp/output.md")
+  })
+
+  test("transforms @agent references to rule references", () => {
+    const input = "Have @security-sentinel and @dhh-rails-reviewer check the code."
+    const result = transformContentForCursor(input)
+    expect(result).toContain("the security-sentinel rule")
+    expect(result).toContain("the dhh-rails-reviewer rule")
+    expect(result).not.toContain("@security-sentinel")
+  })
+})