@every-env/compound-plugin 0.5.2 → 0.8.0

package/src/sync/copilot.ts

@@ -0,0 +1,100 @@
+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 CopilotMcpServer = {
+  type: string
+  command?: string
+  args?: string[]
+  url?: string
+  tools: string[]
+  env?: Record<string, string>
+  headers?: Record<string, string>
+}
+
+type CopilotMcpConfig = {
+  mcpServers: Record<string, CopilotMcpServer>
+}
+
+export async function syncToCopilot(
+  config: ClaudeHomeConfig,
+  outputRoot: string,
+): Promise<void> {
+  const skillsDir = path.join(outputRoot, "skills")
+  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) {
+    const mcpPath = path.join(outputRoot, "copilot-mcp-config.json")
+    const existing = await readJsonSafe(mcpPath)
+    const converted = convertMcpForCopilot(config.mcpServers)
+    const merged: CopilotMcpConfig = {
+      mcpServers: {
+        ...(existing.mcpServers ?? {}),
+        ...converted,
+      },
+    }
+    await fs.writeFile(mcpPath, JSON.stringify(merged, null, 2), { mode: 0o600 })
+  }
+}
+
+async function readJsonSafe(filePath: string): Promise<Partial<CopilotMcpConfig>> {
+  try {
+    const content = await fs.readFile(filePath, "utf-8")
+    return JSON.parse(content) as Partial<CopilotMcpConfig>
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+      return {}
+    }
+    throw err
+  }
+}
+
+function convertMcpForCopilot(
+  servers: Record<string, ClaudeMcpServer>,
+): Record<string, CopilotMcpServer> {
+  const result: Record<string, CopilotMcpServer> = {}
+  for (const [name, server] of Object.entries(servers)) {
+    const entry: CopilotMcpServer = {
+      type: server.command ? "local" : "sse",
+      tools: ["*"],
+    }
+
+    if (server.command) {
+      entry.command = server.command
+      if (server.args && server.args.length > 0) entry.args = server.args
+    } else if (server.url) {
+      entry.url = server.url
+      if (server.headers && Object.keys(server.headers).length > 0) entry.headers = server.headers
+    }
+
+    if (server.env && Object.keys(server.env).length > 0) {
+      entry.env = prefixEnvVars(server.env)
+    }
+
+    result[name] = entry
+  }
+  return result
+}
+
+function prefixEnvVars(env: Record<string, string>): Record<string, string> {
+  const result: Record<string, string> = {}
+  for (const [key, value] of Object.entries(env)) {
+    if (key.startsWith("COPILOT_MCP_")) {
+      result[key] = value
+    } else {
+      result[`COPILOT_MCP_${key}`] = value
+    }
+  }
+  return result
+}

package/src/sync/droid.ts

@@ -0,0 +1,21 @@
+import fs from "fs/promises"
+import path from "path"
+import type { ClaudeHomeConfig } from "../parsers/claude-home"
+import { forceSymlink, isValidSkillName } from "../utils/symlink"
+
+export async function syncToDroid(
+  config: ClaudeHomeConfig,
+  outputRoot: string,
+): Promise<void> {
+  const skillsDir = path.join(outputRoot, "skills")
+  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)
+  }
+}

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/copilot.ts

@@ -0,0 +1,48 @@
+import path from "path"
+import { backupFile, copyDir, ensureDir, writeJson, writeText } from "../utils/files"
+import type { CopilotBundle } from "../types/copilot"
+
+export async function writeCopilotBundle(outputRoot: string, bundle: CopilotBundle): Promise<void> {
+  const paths = resolveCopilotPaths(outputRoot)
+  await ensureDir(paths.githubDir)
+
+  if (bundle.agents.length > 0) {
+    const agentsDir = path.join(paths.githubDir, "agents")
+    for (const agent of bundle.agents) {
+      await writeText(path.join(agentsDir, `${agent.name}.agent.md`), agent.content + "\n")
+    }
+  }
+
+  if (bundle.generatedSkills.length > 0) {
+    const skillsDir = path.join(paths.githubDir, "skills")
+    for (const skill of bundle.generatedSkills) {
+      await writeText(path.join(skillsDir, skill.name, "SKILL.md"), skill.content + "\n")
+    }
+  }
+
+  if (bundle.skillDirs.length > 0) {
+    const skillsDir = path.join(paths.githubDir, "skills")
+    for (const skill of bundle.skillDirs) {
+      await copyDir(skill.sourceDir, path.join(skillsDir, skill.name))
+    }
+  }
+
+  if (bundle.mcpConfig && Object.keys(bundle.mcpConfig).length > 0) {
+    const mcpPath = path.join(paths.githubDir, "copilot-mcp-config.json")
+    const backupPath = await backupFile(mcpPath)
+    if (backupPath) {
+      console.log(`Backed up existing copilot-mcp-config.json to ${backupPath}`)
+    }
+    await writeJson(mcpPath, { mcpServers: bundle.mcpConfig })
+  }
+}
+
+function resolveCopilotPaths(outputRoot: string) {
+  const base = path.basename(outputRoot)
+  // If already pointing at .github, write directly into it
+  if (base === ".github") {
+    return { githubDir: outputRoot }
+  }
+  // Otherwise nest under .github
+  return { githubDir: path.join(outputRoot, ".github") }
+}

package/src/targets/gemini.ts

@@ -0,0 +1,68 @@
+import path from "path"
+import { backupFile, copyDir, ensureDir, pathExists, readJson, writeJson, writeText } from "../utils/files"
+import type { GeminiBundle } from "../types/gemini"
+
+export async function writeGeminiBundle(outputRoot: string, bundle: GeminiBundle): Promise<void> {
+  const paths = resolveGeminiPaths(outputRoot)
+  await ensureDir(paths.geminiDir)
+
+  if (bundle.generatedSkills.length > 0) {
+    for (const skill of bundle.generatedSkills) {
+      await writeText(path.join(paths.skillsDir, skill.name, "SKILL.md"), skill.content + "\n")
+    }
+  }
+
+  if (bundle.skillDirs.length > 0) {
+    for (const skill of bundle.skillDirs) {
+      await copyDir(skill.sourceDir, path.join(paths.skillsDir, skill.name))
+    }
+  }
+
+  if (bundle.commands.length > 0) {
+    for (const command of bundle.commands) {
+      await writeText(path.join(paths.commandsDir, `${command.name}.toml`), command.content + "\n")
+    }
+  }
+
+  if (bundle.mcpServers && Object.keys(bundle.mcpServers).length > 0) {
+    const settingsPath = path.join(paths.geminiDir, "settings.json")
+    const backupPath = await backupFile(settingsPath)
+    if (backupPath) {
+      console.log(`Backed up existing settings.json to ${backupPath}`)
+    }
+
+    // Merge mcpServers into existing settings if present
+    let existingSettings: Record<string, unknown> = {}
+    if (await pathExists(settingsPath)) {
+      try {
+        existingSettings = await readJson<Record<string, unknown>>(settingsPath)
+      } catch {
+        console.warn("Warning: existing settings.json could not be parsed and will be replaced.")
+      }
+    }
+
+    const existingMcp = (existingSettings.mcpServers && typeof existingSettings.mcpServers === "object")
+      ? existingSettings.mcpServers as Record<string, unknown>
+      : {}
+    const merged = { ...existingSettings, mcpServers: { ...existingMcp, ...bundle.mcpServers } }
+    await writeJson(settingsPath, merged)
+  }
+}
+
+function resolveGeminiPaths(outputRoot: string) {
+  const base = path.basename(outputRoot)
+  // If already pointing at .gemini, write directly into it
+  if (base === ".gemini") {
+    return {
+      geminiDir: outputRoot,
+      skillsDir: path.join(outputRoot, "skills"),
+      commandsDir: path.join(outputRoot, "commands"),
+    }
+  }
+  // Otherwise nest under .gemini
+  return {
+    geminiDir: path.join(outputRoot, ".gemini"),
+    skillsDir: path.join(outputRoot, ".gemini", "skills"),
+    commandsDir: path.join(outputRoot, ".gemini", "commands"),
+  }
+}

package/src/targets/index.ts

@@ -2,15 +2,21 @@ import type { ClaudePlugin } from "../types/claude"
 import type { OpenCodeBundle } from "../types/opencode"
 import type { CodexBundle } from "../types/codex"
 import type { DroidBundle } from "../types/droid"
-import type { CursorBundle } from "../types/cursor"
+import type { PiBundle } from "../types/pi"
+import type { CopilotBundle } from "../types/copilot"
+import type { GeminiBundle } from "../types/gemini"
 import { convertClaudeToOpenCode, type ClaudeToOpenCodeOptions } from "../converters/claude-to-opencode"
 import { convertClaudeToCodex } from "../converters/claude-to-codex"
 import { convertClaudeToDroid } from "../converters/claude-to-droid"
-import { convertClaudeToCursor } from "../converters/claude-to-cursor"
+import { convertClaudeToPi } from "../converters/claude-to-pi"
+import { convertClaudeToCopilot } from "../converters/claude-to-copilot"
+import { convertClaudeToGemini } from "../converters/claude-to-gemini"
 import { writeOpenCodeBundle } from "./opencode"
 import { writeCodexBundle } from "./codex"
 import { writeDroidBundle } from "./droid"
-import { writeCursorBundle } from "./cursor"
+import { writePiBundle } from "./pi"
+import { writeCopilotBundle } from "./copilot"
+import { writeGeminiBundle } from "./gemini"
 
 export type TargetHandler<TBundle = unknown> = {
   name: string
@@ -38,10 +44,22 @@ export const targets: Record<string, TargetHandler> = {
     convert: convertClaudeToDroid as TargetHandler<DroidBundle>["convert"],
     write: writeDroidBundle as TargetHandler<DroidBundle>["write"],
   },
-  cursor: {
-    name: "cursor",
+  pi: {
+    name: "pi",
     implemented: true,
-    convert: convertClaudeToCursor as TargetHandler<CursorBundle>["convert"],
-    write: writeCursorBundle as TargetHandler<CursorBundle>["write"],
+    convert: convertClaudeToPi as TargetHandler<PiBundle>["convert"],
+    write: writePiBundle as TargetHandler<PiBundle>["write"],
+  },
+  copilot: {
+    name: "copilot",
+    implemented: true,
+    convert: convertClaudeToCopilot as TargetHandler<CopilotBundle>["convert"],
+    write: writeCopilotBundle as TargetHandler<CopilotBundle>["write"],
+  },
+  gemini: {
+    name: "gemini",
+    implemented: true,
+    convert: convertClaudeToGemini as TargetHandler<GeminiBundle>["convert"],
+    write: writeGeminiBundle as TargetHandler<GeminiBundle>["write"],
   },
 }

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"
+}