@every-env/compound-plugin 0.9.0 → 0.12.0

package/tests/detect-tools.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, test } from "bun:test"
+import { promises as fs } from "fs"
+import path from "path"
+import os from "os"
+import { detectInstalledTools, getDetectedTargetNames } from "../src/utils/detect-tools"
+
+describe("detectInstalledTools", () => {
+  test("detects tools when config directories exist", async () => {
+    const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "detect-tools-"))
+    const tempCwd = await fs.mkdtemp(path.join(os.tmpdir(), "detect-tools-cwd-"))
+
+    // Create directories for some tools
+    await fs.mkdir(path.join(tempHome, ".codex"), { recursive: true })
+    await fs.mkdir(path.join(tempCwd, ".cursor"), { recursive: true })
+    await fs.mkdir(path.join(tempCwd, ".gemini"), { recursive: true })
+
+    const results = await detectInstalledTools(tempHome, tempCwd)
+
+    const codex = results.find((t) => t.name === "codex")
+    expect(codex?.detected).toBe(true)
+    expect(codex?.reason).toContain(".codex")
+
+    const cursor = results.find((t) => t.name === "cursor")
+    expect(cursor?.detected).toBe(true)
+    expect(cursor?.reason).toContain(".cursor")
+
+    const gemini = results.find((t) => t.name === "gemini")
+    expect(gemini?.detected).toBe(true)
+    expect(gemini?.reason).toContain(".gemini")
+
+    // Tools without directories should not be detected
+    const opencode = results.find((t) => t.name === "opencode")
+    expect(opencode?.detected).toBe(false)
+
+    const droid = results.find((t) => t.name === "droid")
+    expect(droid?.detected).toBe(false)
+
+    const pi = results.find((t) => t.name === "pi")
+    expect(pi?.detected).toBe(false)
+  })
+
+  test("returns all tools with detected=false when no directories exist", async () => {
+    const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "detect-empty-"))
+    const tempCwd = await fs.mkdtemp(path.join(os.tmpdir(), "detect-empty-cwd-"))
+
+    const results = await detectInstalledTools(tempHome, tempCwd)
+
+    expect(results.length).toBe(6)
+    for (const tool of results) {
+      expect(tool.detected).toBe(false)
+      expect(tool.reason).toBe("not found")
+    }
+  })
+
+  test("detects home-based tools", async () => {
+    const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "detect-home-"))
+    const tempCwd = await fs.mkdtemp(path.join(os.tmpdir(), "detect-home-cwd-"))
+
+    await fs.mkdir(path.join(tempHome, ".config", "opencode"), { recursive: true })
+    await fs.mkdir(path.join(tempHome, ".factory"), { recursive: true })
+    await fs.mkdir(path.join(tempHome, ".pi"), { recursive: true })
+
+    const results = await detectInstalledTools(tempHome, tempCwd)
+
+    expect(results.find((t) => t.name === "opencode")?.detected).toBe(true)
+    expect(results.find((t) => t.name === "droid")?.detected).toBe(true)
+    expect(results.find((t) => t.name === "pi")?.detected).toBe(true)
+  })
+})
+
+describe("getDetectedTargetNames", () => {
+  test("returns only names of detected tools", async () => {
+    const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "detect-names-"))
+    const tempCwd = await fs.mkdtemp(path.join(os.tmpdir(), "detect-names-cwd-"))
+
+    await fs.mkdir(path.join(tempHome, ".codex"), { recursive: true })
+    await fs.mkdir(path.join(tempCwd, ".gemini"), { recursive: true })
+
+    const names = await getDetectedTargetNames(tempHome, tempCwd)
+
+    expect(names).toContain("codex")
+    expect(names).toContain("gemini")
+    expect(names).not.toContain("opencode")
+    expect(names).not.toContain("droid")
+    expect(names).not.toContain("pi")
+    expect(names).not.toContain("cursor")
+  })
+
+  test("returns empty array when nothing detected", async () => {
+    const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "detect-none-"))
+    const tempCwd = await fs.mkdtemp(path.join(os.tmpdir(), "detect-none-cwd-"))
+
+    const names = await getDetectedTargetNames(tempHome, tempCwd)
+    expect(names).toEqual([])
+  })
+})

package/tests/openclaw-converter.test.ts

@@ -0,0 +1,200 @@
+import { describe, expect, test } from "bun:test"
+import { convertClaudeToOpenClaw } from "../src/converters/claude-to-openclaw"
+import { parseFrontmatter } from "../src/utils/frontmatter"
+import type { ClaudePlugin } from "../src/types/claude"
+
+const fixturePlugin: ClaudePlugin = {
+  root: "/tmp/plugin",
+  manifest: { name: "compound-engineering", version: "1.0.0", description: "A plugin" },
+  agents: [
+    {
+      name: "security-reviewer",
+      description: "Security-focused agent",
+      capabilities: ["Threat modeling", "OWASP"],
+      model: "claude-sonnet-4-20250514",
+      body: "Focus on vulnerabilities in ~/.claude/settings.",
+      sourcePath: "/tmp/plugin/agents/security-reviewer.md",
+    },
+  ],
+  commands: [
+    {
+      name: "workflows:plan",
+      description: "Planning command",
+      argumentHint: "[FOCUS]",
+      model: "inherit",
+      allowedTools: ["Read"],
+      body: "Plan the work. See ~/.claude/settings for config.",
+      sourcePath: "/tmp/plugin/commands/workflows/plan.md",
+    },
+    {
+      name: "disabled-cmd",
+      description: "Disabled command",
+      model: "inherit",
+      allowedTools: [],
+      body: "Should be excluded.",
+      disableModelInvocation: true,
+      sourcePath: "/tmp/plugin/commands/disabled-cmd.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: {
+    local: { command: "npx", args: ["-y", "some-mcp-server"] },
+    remote: { url: "https://mcp.example.com/api", headers: { Authorization: "Bearer token" } },
+  },
+}
+
+const defaultOptions = {
+  agentMode: "subagent" as const,
+  inferTemperature: false,
+  permissions: "none" as const,
+}
+
+describe("convertClaudeToOpenClaw", () => {
+  test("converts agents to skill files with SKILL.md content", () => {
+    const bundle = convertClaudeToOpenClaw(fixturePlugin, defaultOptions)
+
+    const skill = bundle.skills.find((s) => s.name === "security-reviewer")
+    expect(skill).toBeDefined()
+    expect(skill!.dir).toBe("agent-security-reviewer")
+    const parsed = parseFrontmatter(skill!.content)
+    expect(parsed.data.name).toBe("security-reviewer")
+    expect(parsed.data.description).toBe("Security-focused agent")
+    expect(parsed.data.model).toBe("claude-sonnet-4-20250514")
+    expect(parsed.body).toContain("Focus on vulnerabilities")
+  })
+
+  test("converts commands to skill files (excluding disableModelInvocation)", () => {
+    const bundle = convertClaudeToOpenClaw(fixturePlugin, defaultOptions)
+
+    const cmdSkill = bundle.skills.find((s) => s.name === "workflows:plan")
+    expect(cmdSkill).toBeDefined()
+    expect(cmdSkill!.dir).toBe("cmd-workflows:plan")
+
+    const disabledSkill = bundle.skills.find((s) => s.name === "disabled-cmd")
+    expect(disabledSkill).toBeUndefined()
+  })
+
+  test("commands list excludes disableModelInvocation commands", () => {
+    const bundle = convertClaudeToOpenClaw(fixturePlugin, defaultOptions)
+
+    const cmd = bundle.commands.find((c) => c.name === "workflows-plan")
+    expect(cmd).toBeDefined()
+    expect(cmd!.description).toBe("Planning command")
+    expect(cmd!.acceptsArgs).toBe(true)
+
+    const disabled = bundle.commands.find((c) => c.name === "disabled-cmd")
+    expect(disabled).toBeUndefined()
+  })
+
+  test("command colons are replaced with dashes in command registrations", () => {
+    const bundle = convertClaudeToOpenClaw(fixturePlugin, defaultOptions)
+
+    const cmd = bundle.commands.find((c) => c.name === "workflows-plan")
+    expect(cmd).toBeDefined()
+    expect(cmd!.name).not.toContain(":")
+  })
+
+  test("manifest includes plugin id, display name, and skills list", () => {
+    const bundle = convertClaudeToOpenClaw(fixturePlugin, defaultOptions)
+
+    expect(bundle.manifest.id).toBe("compound-engineering")
+    expect(bundle.manifest.name).toBe("Compound Engineering")
+    expect(bundle.manifest.kind).toBe("tool")
+    expect(bundle.manifest.skills).toContain("skills/agent-security-reviewer")
+    expect(bundle.manifest.skills).toContain("skills/cmd-workflows:plan")
+    expect(bundle.manifest.skills).toContain("skills/existing-skill")
+  })
+
+  test("package.json uses plugin name and version", () => {
+    const bundle = convertClaudeToOpenClaw(fixturePlugin, defaultOptions)
+
+    expect(bundle.packageJson.name).toBe("openclaw-compound-engineering")
+    expect(bundle.packageJson.version).toBe("1.0.0")
+    expect(bundle.packageJson.type).toBe("module")
+  })
+
+  test("skillDirCopies includes original skill directories", () => {
+    const bundle = convertClaudeToOpenClaw(fixturePlugin, defaultOptions)
+
+    const copy = bundle.skillDirCopies.find((s) => s.name === "existing-skill")
+    expect(copy).toBeDefined()
+    expect(copy!.sourceDir).toBe("/tmp/plugin/skills/existing-skill")
+  })
+
+  test("stdio MCP servers included in openclaw config", () => {
+    const bundle = convertClaudeToOpenClaw(fixturePlugin, defaultOptions)
+
+    expect(bundle.openclawConfig).toBeDefined()
+    const mcp = (bundle.openclawConfig!.mcpServers as Record<string, unknown>)
+    expect(mcp.local).toBeDefined()
+    expect((mcp.local as any).type).toBe("stdio")
+    expect((mcp.local as any).command).toBe("npx")
+  })
+
+  test("HTTP MCP servers included as http type in openclaw config", () => {
+    const bundle = convertClaudeToOpenClaw(fixturePlugin, defaultOptions)
+
+    const mcp = (bundle.openclawConfig!.mcpServers as Record<string, unknown>)
+    expect(mcp.remote).toBeDefined()
+    expect((mcp.remote as any).type).toBe("http")
+    expect((mcp.remote as any).url).toBe("https://mcp.example.com/api")
+  })
+
+  test("paths are rewritten from .claude/ to .openclaw/ in skill content", () => {
+    const bundle = convertClaudeToOpenClaw(fixturePlugin, defaultOptions)
+
+    const agentSkill = bundle.skills.find((s) => s.name === "security-reviewer")
+    expect(agentSkill!.content).toContain("~/.openclaw/settings")
+    expect(agentSkill!.content).not.toContain("~/.claude/settings")
+
+    const cmdSkill = bundle.skills.find((s) => s.name === "workflows:plan")
+    expect(cmdSkill!.content).toContain("~/.openclaw/settings")
+    expect(cmdSkill!.content).not.toContain("~/.claude/settings")
+  })
+
+  test("generateEntryPoint uses JSON.stringify for safe string escaping", () => {
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      commands: [
+        {
+          name: "tricky-cmd",
+          description: 'Has "quotes" and \\backslashes\\ and\nnewlines',
+          model: "inherit",
+          allowedTools: [],
+          body: "body",
+          sourcePath: "/tmp/cmd.md",
+        },
+      ],
+    }
+    const bundle = convertClaudeToOpenClaw(plugin, defaultOptions)
+
+    // Entry point must be valid JS/TS — JSON.stringify handles all special chars
+    expect(bundle.entryPoint).toContain('"tricky-cmd"')
+    expect(bundle.entryPoint).toContain('\\"quotes\\"')
+    expect(bundle.entryPoint).toContain("\\\\backslashes\\\\")
+    expect(bundle.entryPoint).toContain("\\n")
+    // No raw unescaped newline inside a string literal
+    const lines = bundle.entryPoint.split("\n")
+    const nameLine = lines.find((l) => l.includes("tricky-cmd") && l.includes("name:"))
+    expect(nameLine).toBeDefined()
+  })
+
+  test("generateEntryPoint emits typed skills record", () => {
+    const bundle = convertClaudeToOpenClaw(fixturePlugin, defaultOptions)
+    expect(bundle.entryPoint).toContain("const skills: Record<string, string> = {}")
+  })
+
+  test("plugin without MCP servers has no openclawConfig", () => {
+    const plugin: ClaudePlugin = { ...fixturePlugin, mcpServers: undefined }
+    const bundle = convertClaudeToOpenClaw(plugin, defaultOptions)
+    expect(bundle.openclawConfig).toBeUndefined()
+  })
+})

package/tests/opencode-writer.test.ts

@@ -21,6 +21,7 @@ describe("writeOpenCodeBundle", () => {
       config: { $schema: "https://opencode.ai/config.json" },
       agents: [{ name: "agent-one", content: "Agent content" }],
       plugins: [{ name: "hook.ts", content: "export {}" }],
+      commandFiles: [],
       skillDirs: [
         {
           name: "skill-one",
@@ -44,6 +45,7 @@ describe("writeOpenCodeBundle", () => {
       config: { $schema: "https://opencode.ai/config.json" },
       agents: [{ name: "agent-one", content: "Agent content" }],
       plugins: [],
+      commandFiles: [],
       skillDirs: [
         {
           name: "skill-one",
@@ -68,6 +70,7 @@ describe("writeOpenCodeBundle", () => {
       config: { $schema: "https://opencode.ai/config.json" },
       agents: [{ name: "agent-one", content: "Agent content" }],
       plugins: [],
+      commandFiles: [],
       skillDirs: [
         {
           name: "skill-one",
@@ -85,28 +88,35 @@ describe("writeOpenCodeBundle", () => {
     expect(await exists(path.join(outputRoot, ".opencode"))).toBe(false)
   })
 
-  test("backs up existing opencode.json before overwriting", async () => {
+  test("merges plugin config into existing opencode.json without destroying user keys", async () => {
     const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-backup-"))
     const outputRoot = path.join(tempRoot, ".opencode")
     const configPath = path.join(outputRoot, "opencode.json")
 
-    // Create existing config
+    // Create existing config with user keys
     await fs.mkdir(outputRoot, { recursive: true })
     const originalConfig = { $schema: "https://opencode.ai/config.json", custom: "value" }
     await fs.writeFile(configPath, JSON.stringify(originalConfig, null, 2))
 
+    // Bundle adds mcp server but keeps user's custom key
     const bundle: OpenCodeBundle = {
-      config: { $schema: "https://opencode.ai/config.json", new: "config" },
+      config: { 
+        $schema: "https://opencode.ai/config.json", 
+        mcp: { "plugin-server": { type: "local", command: "uvx", args: ["plugin-srv"] } } 
+      },
       agents: [],
       plugins: [],
+      commandFiles: [],
       skillDirs: [],
     }
 
     await writeOpenCodeBundle(outputRoot, bundle)
 
-    // New config should be written
+    // Merged config should have both user key and plugin key
     const newConfig = JSON.parse(await fs.readFile(configPath, "utf8"))
-    expect(newConfig.new).toBe("config")
+    expect(newConfig.custom).toBe("value")  // user key preserved
+    expect(newConfig.mcp).toBeDefined()
+    expect(newConfig.mcp["plugin-server"]).toBeDefined()
 
     // Backup should exist with original content
     const files = await fs.readdir(outputRoot)
@@ -116,4 +126,131 @@ describe("writeOpenCodeBundle", () => {
     const backupContent = JSON.parse(await fs.readFile(path.join(outputRoot, backupFileName!), "utf8"))
     expect(backupContent.custom).toBe("value")
   })
+
+  test("merges mcp servers without overwriting user entry", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-merge-mcp-"))
+    const outputRoot = path.join(tempRoot, ".opencode")
+    const configPath = path.join(outputRoot, "opencode.json")
+
+    // Create existing config with user's mcp server
+    await fs.mkdir(outputRoot, { recursive: true })
+    const existingConfig = { 
+      mcp: { "user-server": { type: "local", command: "uvx", args: ["user-srv"] } } 
+    }
+    await fs.writeFile(configPath, JSON.stringify(existingConfig, null, 2))
+
+    // Bundle adds plugin server AND has conflicting user-server with different args
+    const bundle: OpenCodeBundle = {
+      config: { 
+        $schema: "https://opencode.ai/config.json",
+        mcp: { 
+          "plugin-server": { type: "local", command: "uvx", args: ["plugin-srv"] },
+          "user-server": { type: "local", command: "uvx", args: ["plugin-override"] }  // conflict
+        } 
+      },
+      agents: [],
+      plugins: [],
+      commandFiles: [],
+      skillDirs: [],
+    }
+
+    await writeOpenCodeBundle(outputRoot, bundle)
+
+    // Merged config should have both servers, with user-server keeping user's original args
+    const mergedConfig = JSON.parse(await fs.readFile(configPath, "utf8"))
+    expect(mergedConfig.mcp).toBeDefined()
+    expect(mergedConfig.mcp["plugin-server"]).toBeDefined()
+    expect(mergedConfig.mcp["user-server"]).toBeDefined()
+    expect(mergedConfig.mcp["user-server"].args[0]).toBe("user-srv")  // user wins on conflict
+    expect(mergedConfig.mcp["plugin-server"].args[0]).toBe("plugin-srv")  // plugin entry present
+  })
+
+  test("preserves unrelated user keys when merging opencode.json", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-preserve-"))
+    const outputRoot = path.join(tempRoot, ".opencode")
+    const configPath = path.join(outputRoot, "opencode.json")
+
+    // Create existing config with multiple user keys
+    await fs.mkdir(outputRoot, { recursive: true })
+    const existingConfig = { 
+      model: "my-model",
+      theme: "dark",
+      mcp: {}
+    }
+    await fs.writeFile(configPath, JSON.stringify(existingConfig, null, 2))
+
+    // Bundle adds plugin-specific keys
+    const bundle: OpenCodeBundle = {
+      config: { 
+        $schema: "https://opencode.ai/config.json",
+        mcp: { "plugin-server": { type: "local", command: "uvx", args: ["plugin-srv"] } },
+        permission: { "bash": "allow" }
+      },
+      agents: [],
+      plugins: [],
+      commandFiles: [],
+      skillDirs: [],
+    }
+
+    await writeOpenCodeBundle(outputRoot, bundle)
+
+    // All user keys preserved
+    const mergedConfig = JSON.parse(await fs.readFile(configPath, "utf8"))
+    expect(mergedConfig.model).toBe("my-model")
+    expect(mergedConfig.theme).toBe("dark")
+    expect(mergedConfig.mcp["plugin-server"]).toBeDefined()
+    expect(mergedConfig.permission["bash"]).toBe("allow")
+  })
+
+  test("writes command files as .md in commands/ directory", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-cmd-"))
+    const outputRoot = path.join(tempRoot, ".config", "opencode")
+    const bundle: OpenCodeBundle = {
+      config: { $schema: "https://opencode.ai/config.json" },
+      agents: [],
+      plugins: [],
+      commandFiles: [{ name: "my-cmd", content: "---\ndescription: Test\n---\n\nDo something." }],
+      skillDirs: [],
+    }
+
+    await writeOpenCodeBundle(outputRoot, bundle)
+
+    const cmdPath = path.join(outputRoot, "commands", "my-cmd.md")
+    expect(await exists(cmdPath)).toBe(true)
+
+    const content = await fs.readFile(cmdPath, "utf8")
+    expect(content).toBe("---\ndescription: Test\n---\n\nDo something.\n")
+  })
+
+  test("backs up existing command .md file before overwriting", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-cmd-backup-"))
+    const outputRoot = path.join(tempRoot, ".opencode")
+    const commandsDir = path.join(outputRoot, "commands")
+    await fs.mkdir(commandsDir, { recursive: true })
+
+    const cmdPath = path.join(commandsDir, "my-cmd.md")
+    await fs.writeFile(cmdPath, "old content\n")
+
+    const bundle: OpenCodeBundle = {
+      config: { $schema: "https://opencode.ai/config.json" },
+      agents: [],
+      plugins: [],
+      commandFiles: [{ name: "my-cmd", content: "---\ndescription: New\n---\n\nNew content." }],
+      skillDirs: [],
+    }
+
+    await writeOpenCodeBundle(outputRoot, bundle)
+
+    // New content should be written
+    const content = await fs.readFile(cmdPath, "utf8")
+    expect(content).toBe("---\ndescription: New\n---\n\nNew content.\n")
+
+    // Backup should exist
+    const files = await fs.readdir(commandsDir)
+    const backupFileName = files.find((f) => f.startsWith("my-cmd.md.bak."))
+    expect(backupFileName).toBeDefined()
+
+    const backupContent = await fs.readFile(path.join(commandsDir, backupFileName!), "utf8")
+    expect(backupContent).toBe("old content\n")
+  })
 })