compound-engineering-pi 0.2.3

package/src/commands/convert.ts

@@ -0,0 +1,183 @@
+import { defineCommand } from "citty"
+import os from "os"
+import path from "path"
+import { loadClaudePlugin } from "../parsers/claude"
+import { targets } from "../targets"
+import type { PermissionMode } from "../converters/claude-to-opencode"
+import { ensureCodexAgentsFile } from "../utils/codex-agents"
+
+const permissionModes: PermissionMode[] = ["none", "broad", "from-commands"]
+
+export default defineCommand({
+  meta: {
+    name: "convert",
+    description: "Convert a Claude Code plugin into another format",
+  },
+  args: {
+    source: {
+      type: "positional",
+      required: true,
+      description: "Path to the Claude plugin directory",
+    },
+    to: {
+      type: "string",
+      default: "opencode",
+      description: "Target format (opencode | codex | pi)",
+    },
+    output: {
+      type: "string",
+      alias: "o",
+      description: "Output directory (project root)",
+    },
+    codexHome: {
+      type: "string",
+      alias: "codex-home",
+      description: "Write Codex output to this .codex root (ex: ~/.codex)",
+    },
+    piHome: {
+      type: "string",
+      alias: "pi-home",
+      description: "Write Pi output to this Pi root (ex: ~/.pi/agent or ./.pi)",
+    },
+    also: {
+      type: "string",
+      description: "Comma-separated extra targets to generate (ex: codex)",
+    },
+    permissions: {
+      type: "string",
+      default: "broad",
+      description: "Permission mapping: none | broad | from-commands",
+    },
+    agentMode: {
+      type: "string",
+      default: "subagent",
+      description: "Default agent mode: primary | subagent",
+    },
+    inferTemperature: {
+      type: "boolean",
+      default: true,
+      description: "Infer agent temperature from name/description",
+    },
+  },
+  async run({ args }) {
+    const targetName = String(args.to)
+    const target = targets[targetName]
+    if (!target) {
+      throw new Error(`Unknown target: ${targetName}`)
+    }
+
+    if (!target.implemented) {
+      throw new Error(`Target ${targetName} is registered but not implemented yet.`)
+    }
+
+    const permissions = String(args.permissions)
+    if (!permissionModes.includes(permissions as PermissionMode)) {
+      throw new Error(`Unknown permissions mode: ${permissions}`)
+    }
+
+    const plugin = await loadClaudePlugin(String(args.source))
+    const outputRoot = resolveOutputRoot(args.output)
+    const codexHome = resolveCodexRoot(args.codexHome)
+    const piHome = resolvePiRoot(args.piHome)
+
+    const agentMode = String(args.agentMode) === "primary" ? "primary" : "subagent"
+    const options = {
+      agentMode,
+      inferTemperature: Boolean(args.inferTemperature),
+      permissions: permissions as PermissionMode,
+    }
+
+    const primaryOutputRoot =
+      targetName === "codex"
+        ? codexHome
+        : targetName === "pi"
+          ? piHome
+          : outputRoot
+    const bundle = target.convert(plugin, options)
+    if (!bundle) {
+      throw new Error(`Target ${targetName} did not return a bundle.`)
+    }
+
+    await target.write(primaryOutputRoot, bundle)
+    console.log(`Converted ${plugin.manifest.name} to ${targetName} at ${primaryOutputRoot}`)
+
+    const extraTargets = parseExtraTargets(args.also)
+    const allTargets = [targetName, ...extraTargets]
+    for (const extra of extraTargets) {
+      const handler = targets[extra]
+      if (!handler) {
+        console.warn(`Skipping unknown target: ${extra}`)
+        continue
+      }
+      if (!handler.implemented) {
+        console.warn(`Skipping ${extra}: not implemented yet.`)
+        continue
+      }
+      const extraBundle = handler.convert(plugin, options)
+      if (!extraBundle) {
+        console.warn(`Skipping ${extra}: no output returned.`)
+        continue
+      }
+      const extraRoot =
+        extra === "codex"
+          ? codexHome
+          : extra === "pi"
+            ? piHome
+            : path.join(outputRoot, extra)
+      await handler.write(extraRoot, extraBundle)
+      console.log(`Converted ${plugin.manifest.name} to ${extra} at ${extraRoot}`)
+    }
+
+    if (allTargets.includes("codex")) {
+      await ensureCodexAgentsFile(codexHome)
+    }
+  },
+})
+
+function parseExtraTargets(value: unknown): string[] {
+  if (!value) return []
+  return String(value)
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean)
+}
+
+function resolveCodexHome(value: unknown): string | null {
+  if (!value) return null
+  const raw = String(value).trim()
+  if (!raw) return null
+  const expanded = expandHome(raw)
+  return path.resolve(expanded)
+}
+
+function resolveCodexRoot(value: unknown): string {
+  return resolveCodexHome(value) ?? path.join(os.homedir(), ".codex")
+}
+
+function resolvePiHome(value: unknown): string | null {
+  if (!value) return null
+  const raw = String(value).trim()
+  if (!raw) return null
+  const expanded = expandHome(raw)
+  return path.resolve(expanded)
+}
+
+function resolvePiRoot(value: unknown): string {
+  return resolvePiHome(value) ?? path.join(os.homedir(), ".pi", "agent")
+}
+
+function expandHome(value: string): string {
+  if (value === "~") return os.homedir()
+  if (value.startsWith(`~${path.sep}`)) {
+    return path.join(os.homedir(), value.slice(2))
+  }
+  return value
+}
+
+function resolveOutputRoot(value: unknown): string {
+  if (value && String(value).trim()) {
+    const expanded = expandHome(String(value).trim())
+    return path.resolve(expanded)
+  }
+  return process.cwd()
+}

package/src/commands/install.ts

@@ -0,0 +1,273 @@
+import { defineCommand } from "citty"
+import { promises as fs } from "fs"
+import os from "os"
+import path from "path"
+import { loadClaudePlugin } from "../parsers/claude"
+import { targets } from "../targets"
+import { pathExists } from "../utils/files"
+import type { PermissionMode } from "../converters/claude-to-opencode"
+import { ensureCodexAgentsFile } from "../utils/codex-agents"
+
+const permissionModes: PermissionMode[] = ["none", "broad", "from-commands"]
+
+export default defineCommand({
+  meta: {
+    name: "install",
+    description: "Install and convert a Claude plugin",
+  },
+  args: {
+    plugin: {
+      type: "positional",
+      required: true,
+      description: "Plugin name or path",
+    },
+    to: {
+      type: "string",
+      default: "opencode",
+      description: "Target format (opencode | codex | pi)",
+    },
+    output: {
+      type: "string",
+      alias: "o",
+      description: "Output directory (project root)",
+    },
+    codexHome: {
+      type: "string",
+      alias: "codex-home",
+      description: "Write Codex output to this .codex root (ex: ~/.codex)",
+    },
+    piHome: {
+      type: "string",
+      alias: "pi-home",
+      description: "Write Pi output to this Pi root (ex: ~/.pi/agent or ./.pi)",
+    },
+    also: {
+      type: "string",
+      description: "Comma-separated extra targets to generate (ex: codex)",
+    },
+    permissions: {
+      type: "string",
+      default: "broad",
+      description: "Permission mapping: none | broad | from-commands",
+    },
+    agentMode: {
+      type: "string",
+      default: "subagent",
+      description: "Default agent mode: primary | subagent",
+    },
+    inferTemperature: {
+      type: "boolean",
+      default: true,
+      description: "Infer agent temperature from name/description",
+    },
+  },
+  async run({ args }) {
+    const targetName = String(args.to)
+    const target = targets[targetName]
+    if (!target) {
+      throw new Error(`Unknown target: ${targetName}`)
+    }
+    if (!target.implemented) {
+      throw new Error(`Target ${targetName} is registered but not implemented yet.`)
+    }
+
+    const permissions = String(args.permissions)
+    if (!permissionModes.includes(permissions as PermissionMode)) {
+      throw new Error(`Unknown permissions mode: ${permissions}`)
+    }
+
+    const resolvedPlugin = await resolvePluginPath(String(args.plugin))
+
+    try {
+      const plugin = await loadClaudePlugin(resolvedPlugin.path)
+      const outputRoot = resolveOutputRoot(args.output)
+      const codexHome = resolveCodexRoot(args.codexHome)
+      const piHome = resolvePiRoot(args.piHome)
+
+      const agentMode = String(args.agentMode) === "primary" ? "primary" : "subagent"
+      const options = {
+        agentMode,
+        inferTemperature: Boolean(args.inferTemperature),
+        permissions: permissions as PermissionMode,
+      }
+
+      const bundle = target.convert(plugin, options)
+      if (!bundle) {
+        throw new Error(`Target ${targetName} did not return a bundle.`)
+      }
+      const primaryOutputRoot =
+        targetName === "codex"
+          ? codexHome
+          : targetName === "pi"
+            ? piHome
+            : outputRoot
+      await target.write(primaryOutputRoot, bundle)
+      console.log(`Installed ${plugin.manifest.name} to ${primaryOutputRoot}`)
+
+      const extraTargets = parseExtraTargets(args.also)
+      const allTargets = [targetName, ...extraTargets]
+      for (const extra of extraTargets) {
+        const handler = targets[extra]
+        if (!handler) {
+          console.warn(`Skipping unknown target: ${extra}`)
+          continue
+        }
+        if (!handler.implemented) {
+          console.warn(`Skipping ${extra}: not implemented yet.`)
+          continue
+        }
+        const extraBundle = handler.convert(plugin, options)
+        if (!extraBundle) {
+          console.warn(`Skipping ${extra}: no output returned.`)
+          continue
+        }
+        const extraRoot =
+          extra === "codex"
+            ? codexHome
+            : extra === "pi"
+              ? piHome
+              : path.join(outputRoot, extra)
+        await handler.write(extraRoot, extraBundle)
+        console.log(`Installed ${plugin.manifest.name} to ${extraRoot}`)
+      }
+
+      if (allTargets.includes("codex")) {
+        await ensureCodexAgentsFile(codexHome)
+      }
+    } finally {
+      if (resolvedPlugin.cleanup) {
+        await resolvedPlugin.cleanup()
+      }
+    }
+  },
+})
+
+type ResolvedPluginPath = {
+  path: string
+  cleanup?: () => Promise<void>
+}
+
+async function resolvePluginPath(input: string): Promise<ResolvedPluginPath> {
+  const raw = input.trim()
+  if (!raw) {
+    throw new Error("Plugin name or path is required.")
+  }
+
+  const likelyPath =
+    raw.startsWith(".") ||
+    raw.startsWith("/") ||
+    raw.startsWith("~") ||
+    raw.includes(path.sep)
+
+  const directPath = path.resolve(expandHome(raw))
+  const pluginsPath = path.join(process.cwd(), "plugins", raw)
+
+  // If user passed an explicit path, honor it first.
+  if (likelyPath && (await pathExists(directPath))) {
+    return { path: directPath }
+  }
+
+  // For named installs, prefer bundled ./plugins/<name> to avoid collisions
+  // with similarly named directories in the repo root.
+  if (await pathExists(pluginsPath)) {
+    return { path: pluginsPath }
+  }
+
+  if (!likelyPath && (await pathExists(directPath))) {
+    return { path: directPath }
+  }
+
+  return await resolveGitHubPluginPath(raw)
+}
+
+function parseExtraTargets(value: unknown): string[] {
+  if (!value) return []
+  return String(value)
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean)
+}
+
+function resolveCodexHome(value: unknown): string | null {
+  if (!value) return null
+  const raw = String(value).trim()
+  if (!raw) return null
+  const expanded = expandHome(raw)
+  return path.resolve(expanded)
+}
+
+function resolveCodexRoot(value: unknown): string {
+  return resolveCodexHome(value) ?? path.join(os.homedir(), ".codex")
+}
+
+function resolvePiHome(value: unknown): string | null {
+  if (!value) return null
+  const raw = String(value).trim()
+  if (!raw) return null
+  const expanded = expandHome(raw)
+  return path.resolve(expanded)
+}
+
+function resolvePiRoot(value: unknown): string {
+  return resolvePiHome(value) ?? path.join(os.homedir(), ".pi", "agent")
+}
+
+function expandHome(value: string): string {
+  if (value === "~") return os.homedir()
+  if (value.startsWith(`~${path.sep}`)) {
+    return path.join(os.homedir(), value.slice(2))
+  }
+  return value
+}
+
+function resolveOutputRoot(value: unknown): string {
+  if (value && String(value).trim()) {
+    const expanded = expandHome(String(value).trim())
+    return path.resolve(expanded)
+  }
+  // OpenCode global config lives at ~/.config/opencode per XDG spec
+  // See: https://opencode.ai/docs/config/
+  return path.join(os.homedir(), ".config", "opencode")
+}
+
+async function resolveGitHubPluginPath(pluginName: string): Promise<ResolvedPluginPath> {
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "compound-plugin-"))
+  const source = resolveGitHubSource()
+  try {
+    await cloneGitHubRepo(source, tempRoot)
+  } catch (error) {
+    await fs.rm(tempRoot, { recursive: true, force: true })
+    throw error
+  }
+
+  const pluginPath = path.join(tempRoot, "plugins", pluginName)
+  if (!(await pathExists(pluginPath))) {
+    await fs.rm(tempRoot, { recursive: true, force: true })
+    throw new Error(`Could not find plugin ${pluginName} in ${source}.`)
+  }
+
+  return {
+    path: pluginPath,
+    cleanup: async () => {
+      await fs.rm(tempRoot, { recursive: true, force: true })
+    },
+  }
+}
+
+function resolveGitHubSource(): string {
+  const override = process.env.COMPOUND_PLUGIN_GITHUB_SOURCE
+  if (override && override.trim()) return override.trim()
+  return "https://github.com/EveryInc/compound-engineering-plugin"
+}
+
+async function cloneGitHubRepo(source: string, destination: string): Promise<void> {
+  const proc = Bun.spawn(["git", "clone", "--depth", "1", source, destination], {
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+  const exitCode = await proc.exited
+  const stderr = await new Response(proc.stderr).text()
+  if (exitCode !== 0) {
+    throw new Error(`Failed to clone ${source}. ${stderr.trim()}`)
+  }
+}

package/src/commands/list.ts

@@ -0,0 +1,37 @@
+import path from "path"
+import { promises as fs } from "fs"
+import { defineCommand } from "citty"
+import { pathExists } from "../utils/files"
+
+export default defineCommand({
+  meta: {
+    name: "list",
+    description: "List available Claude plugins under plugins/",
+  },
+  async run() {
+    const root = process.cwd()
+    const pluginsDir = path.join(root, "plugins")
+    if (!(await pathExists(pluginsDir))) {
+      console.log("No plugins directory found.")
+      return
+    }
+
+    const entries = await fs.readdir(pluginsDir, { withFileTypes: true })
+    const plugins: string[] = []
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+      const manifestPath = path.join(pluginsDir, entry.name, ".claude-plugin", "plugin.json")
+      if (await pathExists(manifestPath)) {
+        plugins.push(entry.name)
+      }
+    }
+
+    if (plugins.length === 0) {
+      console.log("No Claude plugins found under plugins/.")
+      return
+    }
+
+    console.log(plugins.sort().join("\n"))
+  },
+})

package/src/commands/sync.ts

@@ -0,0 +1,89 @@
+import { defineCommand } from "citty"
+import os from "os"
+import path from "path"
+import { loadClaudeHome } from "../parsers/claude-home"
+import { syncToOpenCode } from "../sync/opencode"
+import { syncToCodex } from "../sync/codex"
+import { syncToPi } from "../sync/pi"
+
+function isValidTarget(value: string): value is "opencode" | "codex" | "pi" {
+  return value === "opencode" || value === "codex" || value === "pi"
+}
+
+/** Check if any MCP servers have env vars that might contain secrets */
+function hasPotentialSecrets(mcpServers: Record<string, unknown>): boolean {
+  const sensitivePatterns = /key|token|secret|password|credential|api_key/i
+  for (const server of Object.values(mcpServers)) {
+    const env = (server as { env?: Record<string, string> }).env
+    if (env) {
+      for (const key of Object.keys(env)) {
+        if (sensitivePatterns.test(key)) return true
+      }
+    }
+  }
+  return false
+}
+
+export default defineCommand({
+  meta: {
+    name: "sync",
+    description: "Sync Claude Code config (~/.claude/) to OpenCode, Codex, or Pi",
+  },
+  args: {
+    target: {
+      type: "string",
+      required: true,
+      description: "Target: opencode | codex | pi",
+    },
+    claudeHome: {
+      type: "string",
+      alias: "claude-home",
+      description: "Path to Claude home (default: ~/.claude)",
+    },
+  },
+  async run({ args }) {
+    if (!isValidTarget(args.target)) {
+      throw new Error(`Unknown target: ${args.target}. Use 'opencode', 'codex', or 'pi'.`)
+    }
+
+    const claudeHome = expandHome(args.claudeHome ?? path.join(os.homedir(), ".claude"))
+    const config = await loadClaudeHome(claudeHome)
+
+    // Warn about potential secrets in MCP env vars
+    if (hasPotentialSecrets(config.mcpServers)) {
+      console.warn(
+        "⚠️  Warning: MCP servers contain env vars that may include secrets (API keys, tokens).\n" +
+        "   These will be copied to the target config. Review before sharing the config file.",
+      )
+    }
+
+    console.log(
+      `Syncing ${config.skills.length} skills, ${Object.keys(config.mcpServers).length} MCP servers...`,
+    )
+
+    const outputRoot =
+      args.target === "opencode"
+        ? path.join(os.homedir(), ".config", "opencode")
+        : args.target === "codex"
+          ? path.join(os.homedir(), ".codex")
+          : path.join(os.homedir(), ".pi", "agent")
+
+    if (args.target === "opencode") {
+      await syncToOpenCode(config, outputRoot)
+    } else if (args.target === "codex") {
+      await syncToCodex(config, outputRoot)
+    } else {
+      await syncToPi(config, outputRoot)
+    }
+
+    console.log(`✓ Synced to ${args.target}: ${outputRoot}`)
+  },
+})
+
+function expandHome(value: string): string {
+  if (value === "~") return os.homedir()
+  if (value.startsWith(`~${path.sep}`)) {
+    return path.join(os.homedir(), value.slice(2))
+  }
+  return value
+}