compound-engineering-pi 0.2.3

package/src/sync/opencode.ts

@@ -0,0 +1,75 @@
+import fs from "fs/promises"
+import path from "path"
+import type { ClaudeHomeConfig } from "../parsers/claude-home"
+import type { ClaudeMcpServer } from "../types/claude"
+import type { OpenCodeMcpServer } from "../types/opencode"
+import { forceSymlink, isValidSkillName } from "../utils/symlink"
+
+export async function syncToOpenCode(
+  config: ClaudeHomeConfig,
+  outputRoot: string,
+): Promise<void> {
+  // Ensure output directories exist
+  const skillsDir = path.join(outputRoot, "skills")
+  await fs.mkdir(skillsDir, { recursive: true })
+
+  // Symlink skills (with validation)
+  for (const skill of config.skills) {
+    if (!isValidSkillName(skill.name)) {
+      console.warn(`Skipping skill with invalid name: ${skill.name}`)
+      continue
+    }
+    const target = path.join(skillsDir, skill.name)
+    await forceSymlink(skill.sourceDir, target)
+  }
+
+  // Merge MCP servers into opencode.json
+  if (Object.keys(config.mcpServers).length > 0) {
+    const configPath = path.join(outputRoot, "opencode.json")
+    const existing = await readJsonSafe(configPath)
+    const mcpConfig = convertMcpForOpenCode(config.mcpServers)
+    existing.mcp = { ...(existing.mcp ?? {}), ...mcpConfig }
+    await fs.writeFile(configPath, JSON.stringify(existing, null, 2), { mode: 0o600 })
+  }
+}
+
+async function readJsonSafe(filePath: string): Promise<Record<string, unknown>> {
+  try {
+    const content = await fs.readFile(filePath, "utf-8")
+    return JSON.parse(content) as Record<string, unknown>
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+      return {}
+    }
+    throw err
+  }
+}
+
+function convertMcpForOpenCode(
+  servers: Record<string, ClaudeMcpServer>,
+): Record<string, OpenCodeMcpServer> {
+  const result: Record<string, OpenCodeMcpServer> = {}
+
+  for (const [name, server] of Object.entries(servers)) {
+    if (server.command) {
+      result[name] = {
+        type: "local",
+        command: [server.command, ...(server.args ?? [])],
+        environment: server.env,
+        enabled: true,
+      }
+      continue
+    }
+
+    if (server.url) {
+      result[name] = {
+        type: "remote",
+        url: server.url,
+        headers: server.headers,
+        enabled: true,
+      }
+    }
+  }
+
+  return result
+}

package/src/sync/pi.ts

@@ -0,0 +1,88 @@
+import fs from "fs/promises"
+import path from "path"
+import type { ClaudeHomeConfig } from "../parsers/claude-home"
+import type { ClaudeMcpServer } from "../types/claude"
+import { forceSymlink, isValidSkillName } from "../utils/symlink"
+
+type McporterServer = {
+  baseUrl?: string
+  command?: string
+  args?: string[]
+  env?: Record<string, string>
+  headers?: Record<string, string>
+}
+
+type McporterConfig = {
+  mcpServers: Record<string, McporterServer>
+}
+
+export async function syncToPi(
+  config: ClaudeHomeConfig,
+  outputRoot: string,
+): Promise<void> {
+  const skillsDir = path.join(outputRoot, "skills")
+  const mcporterPath = path.join(outputRoot, "compound-engineering", "mcporter.json")
+
+  await fs.mkdir(skillsDir, { recursive: true })
+
+  for (const skill of config.skills) {
+    if (!isValidSkillName(skill.name)) {
+      console.warn(`Skipping skill with invalid name: ${skill.name}`)
+      continue
+    }
+    const target = path.join(skillsDir, skill.name)
+    await forceSymlink(skill.sourceDir, target)
+  }
+
+  if (Object.keys(config.mcpServers).length > 0) {
+    await fs.mkdir(path.dirname(mcporterPath), { recursive: true })
+
+    const existing = await readJsonSafe(mcporterPath)
+    const converted = convertMcpToMcporter(config.mcpServers)
+    const merged: McporterConfig = {
+      mcpServers: {
+        ...(existing.mcpServers ?? {}),
+        ...converted.mcpServers,
+      },
+    }
+
+    await fs.writeFile(mcporterPath, JSON.stringify(merged, null, 2), { mode: 0o600 })
+  }
+}
+
+async function readJsonSafe(filePath: string): Promise<Partial<McporterConfig>> {
+  try {
+    const content = await fs.readFile(filePath, "utf-8")
+    return JSON.parse(content) as Partial<McporterConfig>
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+      return {}
+    }
+    throw err
+  }
+}
+
+function convertMcpToMcporter(servers: Record<string, ClaudeMcpServer>): McporterConfig {
+  const mcpServers: Record<string, McporterServer> = {}
+
+  for (const [name, server] of Object.entries(servers)) {
+    if (server.command) {
+      mcpServers[name] = {
+        command: server.command,
+        args: server.args,
+        env: server.env,
+        headers: server.headers,
+      }
+      continue
+    }
+
+    if (server.url) {
+      mcpServers[name] = {
+        baseUrl: server.url,
+        headers: server.headers,
+      }
+    }
+  }
+
+  return { mcpServers }
+}

package/src/targets/codex.ts

@@ -0,0 +1,96 @@
+import path from "path"
+import { backupFile, copyDir, ensureDir, writeText } from "../utils/files"
+import type { CodexBundle } from "../types/codex"
+import type { ClaudeMcpServer } from "../types/claude"
+
+export async function writeCodexBundle(outputRoot: string, bundle: CodexBundle): Promise<void> {
+  const codexRoot = resolveCodexRoot(outputRoot)
+  await ensureDir(codexRoot)
+
+  if (bundle.prompts.length > 0) {
+    const promptsDir = path.join(codexRoot, "prompts")
+    for (const prompt of bundle.prompts) {
+      await writeText(path.join(promptsDir, `${prompt.name}.md`), prompt.content + "\n")
+    }
+  }
+
+  if (bundle.skillDirs.length > 0) {
+    const skillsRoot = path.join(codexRoot, "skills")
+    for (const skill of bundle.skillDirs) {
+      await copyDir(skill.sourceDir, path.join(skillsRoot, skill.name))
+    }
+  }
+
+  if (bundle.generatedSkills.length > 0) {
+    const skillsRoot = path.join(codexRoot, "skills")
+    for (const skill of bundle.generatedSkills) {
+      await writeText(path.join(skillsRoot, skill.name, "SKILL.md"), skill.content + "\n")
+    }
+  }
+
+  const config = renderCodexConfig(bundle.mcpServers)
+  if (config) {
+    const configPath = path.join(codexRoot, "config.toml")
+    const backupPath = await backupFile(configPath)
+    if (backupPath) {
+      console.log(`Backed up existing config to ${backupPath}`)
+    }
+    await writeText(configPath, config)
+  }
+}
+
+function resolveCodexRoot(outputRoot: string): string {
+  return path.basename(outputRoot) === ".codex" ? outputRoot : path.join(outputRoot, ".codex")
+}
+
+export function renderCodexConfig(mcpServers?: Record<string, ClaudeMcpServer>): string | null {
+  if (!mcpServers || Object.keys(mcpServers).length === 0) return null
+
+  const lines: string[] = ["# Generated by compound-plugin", ""]
+
+  for (const [name, server] of Object.entries(mcpServers)) {
+    const key = formatTomlKey(name)
+    lines.push(`[mcp_servers.${key}]`)
+
+    if (server.command) {
+      lines.push(`command = ${formatTomlString(server.command)}`)
+      if (server.args && server.args.length > 0) {
+        const args = server.args.map((arg) => formatTomlString(arg)).join(", ")
+        lines.push(`args = [${args}]`)
+      }
+
+      if (server.env && Object.keys(server.env).length > 0) {
+        lines.push("")
+        lines.push(`[mcp_servers.${key}.env]`)
+        for (const [envKey, value] of Object.entries(server.env)) {
+          lines.push(`${formatTomlKey(envKey)} = ${formatTomlString(value)}`)
+        }
+      }
+    } else if (server.url) {
+      lines.push(`url = ${formatTomlString(server.url)}`)
+      if (server.headers && Object.keys(server.headers).length > 0) {
+        lines.push(`http_headers = ${formatTomlInlineTable(server.headers)}`)
+      }
+    }
+
+    lines.push("")
+  }
+
+  return lines.join("\n")
+}
+
+function formatTomlString(value: string): string {
+  return JSON.stringify(value)
+}
+
+function formatTomlKey(value: string): string {
+  if (/^[A-Za-z0-9_-]+$/.test(value)) return value
+  return JSON.stringify(value)
+}
+
+function formatTomlInlineTable(entries: Record<string, string>): string {
+  const parts = Object.entries(entries).map(
+    ([key, value]) => `${formatTomlKey(key)} = ${formatTomlString(value)}`,
+  )
+  return `{ ${parts.join(", ")} }`
+}

package/src/targets/index.ts

@@ -0,0 +1,38 @@
+import type { ClaudePlugin } from "../types/claude"
+import type { OpenCodeBundle } from "../types/opencode"
+import type { CodexBundle } from "../types/codex"
+import type { PiBundle } from "../types/pi"
+import { convertClaudeToOpenCode, type ClaudeToOpenCodeOptions } from "../converters/claude-to-opencode"
+import { convertClaudeToCodex } from "../converters/claude-to-codex"
+import { convertClaudeToPi } from "../converters/claude-to-pi"
+import { writeOpenCodeBundle } from "./opencode"
+import { writeCodexBundle } from "./codex"
+import { writePiBundle } from "./pi"
+
+export type TargetHandler<TBundle = any> = {
+  name: string
+  implemented: boolean
+  convert: (plugin: ClaudePlugin, options: ClaudeToOpenCodeOptions) => TBundle | null
+  write: (outputRoot: string, bundle: TBundle) => Promise<void>
+}
+
+export const targets: Record<string, TargetHandler> = {
+  opencode: {
+    name: "opencode",
+    implemented: true,
+    convert: convertClaudeToOpenCode,
+    write: writeOpenCodeBundle,
+  },
+  codex: {
+    name: "codex",
+    implemented: true,
+    convert: convertClaudeToCodex as TargetHandler<CodexBundle>["convert"],
+    write: writeCodexBundle as TargetHandler<CodexBundle>["write"],
+  },
+  pi: {
+    name: "pi",
+    implemented: true,
+    convert: convertClaudeToPi as TargetHandler<PiBundle>["convert"],
+    write: writePiBundle as TargetHandler<PiBundle>["write"],
+  },
+}

package/src/targets/opencode.ts

@@ -0,0 +1,57 @@
+import path from "path"
+import { backupFile, copyDir, ensureDir, writeJson, writeText } from "../utils/files"
+import type { OpenCodeBundle } from "../types/opencode"
+
+export async function writeOpenCodeBundle(outputRoot: string, bundle: OpenCodeBundle): Promise<void> {
+  const paths = resolveOpenCodePaths(outputRoot)
+  await ensureDir(paths.root)
+
+  const backupPath = await backupFile(paths.configPath)
+  if (backupPath) {
+    console.log(`Backed up existing config to ${backupPath}`)
+  }
+  await writeJson(paths.configPath, bundle.config)
+
+  const agentsDir = paths.agentsDir
+  for (const agent of bundle.agents) {
+    await writeText(path.join(agentsDir, `${agent.name}.md`), agent.content + "\n")
+  }
+
+  if (bundle.plugins.length > 0) {
+    const pluginsDir = paths.pluginsDir
+    for (const plugin of bundle.plugins) {
+      await writeText(path.join(pluginsDir, plugin.name), plugin.content + "\n")
+    }
+  }
+
+  if (bundle.skillDirs.length > 0) {
+    const skillsRoot = paths.skillsDir
+    for (const skill of bundle.skillDirs) {
+      await copyDir(skill.sourceDir, path.join(skillsRoot, skill.name))
+    }
+  }
+}
+
+function resolveOpenCodePaths(outputRoot: string) {
+  const base = path.basename(outputRoot)
+  // Global install: ~/.config/opencode (basename is "opencode")
+  // Project install: .opencode (basename is ".opencode")
+  if (base === "opencode" || base === ".opencode") {
+    return {
+      root: outputRoot,
+      configPath: path.join(outputRoot, "opencode.json"),
+      agentsDir: path.join(outputRoot, "agents"),
+      pluginsDir: path.join(outputRoot, "plugins"),
+      skillsDir: path.join(outputRoot, "skills"),
+    }
+  }
+
+  // Custom output directory - nest under .opencode subdirectory
+  return {
+    root: outputRoot,
+    configPath: path.join(outputRoot, "opencode.json"),
+    agentsDir: path.join(outputRoot, ".opencode", "agents"),
+    pluginsDir: path.join(outputRoot, ".opencode", "plugins"),
+    skillsDir: path.join(outputRoot, ".opencode", "skills"),
+  }
+}

package/src/targets/pi.ts

@@ -0,0 +1,131 @@
+import path from "path"
+import {
+  backupFile,
+  copyDir,
+  ensureDir,
+  pathExists,
+  readText,
+  writeJson,
+  writeText,
+} from "../utils/files"
+import type { PiBundle } from "../types/pi"
+
+const PI_AGENTS_BLOCK_START = "<!-- BEGIN COMPOUND PI TOOL MAP -->"
+const PI_AGENTS_BLOCK_END = "<!-- END COMPOUND PI TOOL MAP -->"
+
+const PI_AGENTS_BLOCK_BODY = `## Compound Engineering (Pi compatibility)
+
+This block is managed by compound-plugin.
+
+Compatibility notes:
+- Claude Task(agent, args) maps to the subagent extension tool
+- For parallel agent runs, batch multiple subagent calls with multi_tool_use.parallel
+- AskUserQuestion maps to the ask_user_question extension tool
+- MCP access uses MCPorter via mcporter_list and mcporter_call extension tools
+- MCPorter config path: .pi/compound-engineering/mcporter.json (project) or ~/.pi/agent/compound-engineering/mcporter.json (global)
+`
+
+export async function writePiBundle(outputRoot: string, bundle: PiBundle): Promise<void> {
+  const paths = resolvePiPaths(outputRoot)
+
+  await ensureDir(paths.skillsDir)
+  await ensureDir(paths.promptsDir)
+  await ensureDir(paths.extensionsDir)
+
+  for (const prompt of bundle.prompts) {
+    await writeText(path.join(paths.promptsDir, `${prompt.name}.md`), prompt.content + "\n")
+  }
+
+  for (const skill of bundle.skillDirs) {
+    await copyDir(skill.sourceDir, path.join(paths.skillsDir, skill.name))
+  }
+
+  for (const skill of bundle.generatedSkills) {
+    await writeText(path.join(paths.skillsDir, skill.name, "SKILL.md"), skill.content + "\n")
+  }
+
+  for (const extension of bundle.extensions) {
+    await writeText(path.join(paths.extensionsDir, extension.name), extension.content + "\n")
+  }
+
+  if (bundle.mcporterConfig) {
+    const backupPath = await backupFile(paths.mcporterConfigPath)
+    if (backupPath) {
+      console.log(`Backed up existing MCPorter config to ${backupPath}`)
+    }
+    await writeJson(paths.mcporterConfigPath, bundle.mcporterConfig)
+  }
+
+  await ensurePiAgentsBlock(paths.agentsPath)
+}
+
+function resolvePiPaths(outputRoot: string) {
+  const base = path.basename(outputRoot)
+
+  // Global install root: ~/.pi/agent
+  if (base === "agent") {
+    return {
+      skillsDir: path.join(outputRoot, "skills"),
+      promptsDir: path.join(outputRoot, "prompts"),
+      extensionsDir: path.join(outputRoot, "extensions"),
+      mcporterConfigPath: path.join(outputRoot, "compound-engineering", "mcporter.json"),
+      agentsPath: path.join(outputRoot, "AGENTS.md"),
+    }
+  }
+
+  // Project local .pi directory
+  if (base === ".pi") {
+    return {
+      skillsDir: path.join(outputRoot, "skills"),
+      promptsDir: path.join(outputRoot, "prompts"),
+      extensionsDir: path.join(outputRoot, "extensions"),
+      mcporterConfigPath: path.join(outputRoot, "compound-engineering", "mcporter.json"),
+      agentsPath: path.join(outputRoot, "AGENTS.md"),
+    }
+  }
+
+  // Custom output root -> nest under .pi
+  return {
+    skillsDir: path.join(outputRoot, ".pi", "skills"),
+    promptsDir: path.join(outputRoot, ".pi", "prompts"),
+    extensionsDir: path.join(outputRoot, ".pi", "extensions"),
+    mcporterConfigPath: path.join(outputRoot, ".pi", "compound-engineering", "mcporter.json"),
+    agentsPath: path.join(outputRoot, "AGENTS.md"),
+  }
+}
+
+async function ensurePiAgentsBlock(filePath: string): Promise<void> {
+  const block = buildPiAgentsBlock()
+
+  if (!(await pathExists(filePath))) {
+    await writeText(filePath, block + "\n")
+    return
+  }
+
+  const existing = await readText(filePath)
+  const updated = upsertBlock(existing, block)
+  if (updated !== existing) {
+    await writeText(filePath, updated)
+  }
+}
+
+function buildPiAgentsBlock(): string {
+  return [PI_AGENTS_BLOCK_START, PI_AGENTS_BLOCK_BODY.trim(), PI_AGENTS_BLOCK_END].join("\n")
+}
+
+function upsertBlock(existing: string, block: string): string {
+  const startIndex = existing.indexOf(PI_AGENTS_BLOCK_START)
+  const endIndex = existing.indexOf(PI_AGENTS_BLOCK_END)
+
+  if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+    const before = existing.slice(0, startIndex).trimEnd()
+    const after = existing.slice(endIndex + PI_AGENTS_BLOCK_END.length).trimStart()
+    return [before, block, after].filter(Boolean).join("\n\n") + "\n"
+  }
+
+  if (existing.trim().length === 0) {
+    return block + "\n"
+  }
+
+  return existing.trimEnd() + "\n\n" + block + "\n"
+}