@every-env/compound-plugin 0.9.0 → 2.34.2

package/src/sync/registry.ts

@@ -0,0 +1,141 @@
+import os from "os"
+import path from "path"
+import type { ClaudeHomeConfig } from "../parsers/claude-home"
+import { syncToCodex } from "./codex"
+import { syncToCopilot } from "./copilot"
+import { syncToDroid } from "./droid"
+import { syncToGemini } from "./gemini"
+import { syncToKiro } from "./kiro"
+import { syncToOpenClaw } from "./openclaw"
+import { syncToOpenCode } from "./opencode"
+import { syncToPi } from "./pi"
+import { syncToQwen } from "./qwen"
+import { syncToWindsurf } from "./windsurf"
+
+function getCopilotHomeRoot(home: string): string {
+  return path.join(home, ".copilot")
+}
+
+function getGeminiHomeRoot(home: string): string {
+  return path.join(home, ".gemini")
+}
+
+export type SyncTargetName =
+  | "opencode"
+  | "codex"
+  | "pi"
+  | "droid"
+  | "copilot"
+  | "gemini"
+  | "windsurf"
+  | "kiro"
+  | "qwen"
+  | "openclaw"
+
+export type SyncTargetDefinition = {
+  name: SyncTargetName
+  detectPaths: (home: string, cwd: string) => string[]
+  resolveOutputRoot: (home: string, cwd: string) => string
+  sync: (config: ClaudeHomeConfig, outputRoot: string) => Promise<void>
+}
+
+export const syncTargets: SyncTargetDefinition[] = [
+  {
+    name: "opencode",
+    detectPaths: (home, cwd) => [
+      path.join(home, ".config", "opencode"),
+      path.join(cwd, ".opencode"),
+    ],
+    resolveOutputRoot: (home) => path.join(home, ".config", "opencode"),
+    sync: syncToOpenCode,
+  },
+  {
+    name: "codex",
+    detectPaths: (home) => [path.join(home, ".codex")],
+    resolveOutputRoot: (home) => path.join(home, ".codex"),
+    sync: syncToCodex,
+  },
+  {
+    name: "pi",
+    detectPaths: (home) => [path.join(home, ".pi")],
+    resolveOutputRoot: (home) => path.join(home, ".pi", "agent"),
+    sync: syncToPi,
+  },
+  {
+    name: "droid",
+    detectPaths: (home) => [path.join(home, ".factory")],
+    resolveOutputRoot: (home) => path.join(home, ".factory"),
+    sync: syncToDroid,
+  },
+  {
+    name: "copilot",
+    detectPaths: (home, cwd) => [
+      getCopilotHomeRoot(home),
+      path.join(cwd, ".github", "skills"),
+      path.join(cwd, ".github", "agents"),
+      path.join(cwd, ".github", "copilot-instructions.md"),
+    ],
+    resolveOutputRoot: (home) => getCopilotHomeRoot(home),
+    sync: syncToCopilot,
+  },
+  {
+    name: "gemini",
+    detectPaths: (home, cwd) => [
+      path.join(cwd, ".gemini"),
+      getGeminiHomeRoot(home),
+    ],
+    resolveOutputRoot: (home) => getGeminiHomeRoot(home),
+    sync: syncToGemini,
+  },
+  {
+    name: "windsurf",
+    detectPaths: (home, cwd) => [
+      path.join(home, ".codeium", "windsurf"),
+      path.join(cwd, ".windsurf"),
+    ],
+    resolveOutputRoot: (home) => path.join(home, ".codeium", "windsurf"),
+    sync: syncToWindsurf,
+  },
+  {
+    name: "kiro",
+    detectPaths: (home, cwd) => [
+      path.join(home, ".kiro"),
+      path.join(cwd, ".kiro"),
+    ],
+    resolveOutputRoot: (home) => path.join(home, ".kiro"),
+    sync: syncToKiro,
+  },
+  {
+    name: "qwen",
+    detectPaths: (home, cwd) => [
+      path.join(home, ".qwen"),
+      path.join(cwd, ".qwen"),
+    ],
+    resolveOutputRoot: (home) => path.join(home, ".qwen"),
+    sync: syncToQwen,
+  },
+  {
+    name: "openclaw",
+    detectPaths: (home) => [path.join(home, ".openclaw")],
+    resolveOutputRoot: (home) => path.join(home, ".openclaw"),
+    sync: syncToOpenClaw,
+  },
+]
+
+export const syncTargetNames = syncTargets.map((target) => target.name)
+
+export function isSyncTargetName(value: string): value is SyncTargetName {
+  return syncTargetNames.includes(value as SyncTargetName)
+}
+
+export function getSyncTarget(name: SyncTargetName): SyncTargetDefinition {
+  const target = syncTargets.find((entry) => entry.name === name)
+  if (!target) {
+    throw new Error(`Unknown sync target: ${name}`)
+  }
+  return target
+}
+
+export function getDefaultSyncRegistryContext(): { home: string; cwd: string } {
+  return { home: os.homedir(), cwd: process.cwd() }
+}

package/src/sync/skills.ts

@@ -0,0 +1,21 @@
+import path from "path"
+import type { ClaudeSkill } from "../types/claude"
+import { ensureDir } from "../utils/files"
+import { forceSymlink, isValidSkillName } from "../utils/symlink"
+
+export async function syncSkills(
+  skills: ClaudeSkill[],
+  skillsDir: string,
+): Promise<void> {
+  await ensureDir(skillsDir)
+
+  for (const skill of 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/windsurf.ts

@@ -0,0 +1,59 @@
+import path from "path"
+import type { ClaudeHomeConfig } from "../parsers/claude-home"
+import type { ClaudeMcpServer } from "../types/claude"
+import type { WindsurfMcpServerEntry } from "../types/windsurf"
+import { syncWindsurfCommands } from "./commands"
+import { mergeJsonConfigAtKey } from "./json-config"
+import { hasExplicitSseTransport } from "./mcp-transports"
+import { syncSkills } from "./skills"
+
+export async function syncToWindsurf(
+  config: ClaudeHomeConfig,
+  outputRoot: string,
+): Promise<void> {
+  await syncSkills(config.skills, path.join(outputRoot, "skills"))
+  await syncWindsurfCommands(config, outputRoot, "global")
+
+  if (Object.keys(config.mcpServers).length > 0) {
+    await mergeJsonConfigAtKey({
+      configPath: path.join(outputRoot, "mcp_config.json"),
+      key: "mcpServers",
+      incoming: convertMcpForWindsurf(config.mcpServers),
+    })
+  }
+}
+
+function convertMcpForWindsurf(
+  servers: Record<string, ClaudeMcpServer>,
+): Record<string, WindsurfMcpServerEntry> {
+  const result: Record<string, WindsurfMcpServerEntry> = {}
+
+  for (const [name, server] of Object.entries(servers)) {
+    if (server.command) {
+      result[name] = {
+        command: server.command,
+        args: server.args,
+        env: server.env,
+      }
+      continue
+    }
+
+    if (!server.url) {
+      continue
+    }
+
+    const entry: WindsurfMcpServerEntry = {
+      headers: server.headers,
+    }
+
+    if (hasExplicitSseTransport(server)) {
+      entry.url = server.url
+    } else {
+      entry.serverUrl = server.url
+    }
+
+    result[name] = entry
+  }
+
+  return result
+}

package/src/targets/index.ts

@@ -6,6 +6,9 @@ import type { PiBundle } from "../types/pi"
 import type { CopilotBundle } from "../types/copilot"
 import type { GeminiBundle } from "../types/gemini"
 import type { KiroBundle } from "../types/kiro"
+import type { WindsurfBundle } from "../types/windsurf"
+import type { OpenClawBundle } from "../types/openclaw"
+import type { QwenBundle } from "../types/qwen"
 import { convertClaudeToOpenCode, type ClaudeToOpenCodeOptions } from "../converters/claude-to-opencode"
 import { convertClaudeToCodex } from "../converters/claude-to-codex"
 import { convertClaudeToDroid } from "../converters/claude-to-droid"
@@ -13,6 +16,9 @@ import { convertClaudeToPi } from "../converters/claude-to-pi"
 import { convertClaudeToCopilot } from "../converters/claude-to-copilot"
 import { convertClaudeToGemini } from "../converters/claude-to-gemini"
 import { convertClaudeToKiro } from "../converters/claude-to-kiro"
+import { convertClaudeToWindsurf } from "../converters/claude-to-windsurf"
+import { convertClaudeToOpenClaw } from "../converters/claude-to-openclaw"
+import { convertClaudeToQwen } from "../converters/claude-to-qwen"
 import { writeOpenCodeBundle } from "./opencode"
 import { writeCodexBundle } from "./codex"
 import { writeDroidBundle } from "./droid"
@@ -20,12 +26,45 @@ import { writePiBundle } from "./pi"
 import { writeCopilotBundle } from "./copilot"
 import { writeGeminiBundle } from "./gemini"
 import { writeKiroBundle } from "./kiro"
+import { writeWindsurfBundle } from "./windsurf"
+import { writeOpenClawBundle } from "./openclaw"
+import { writeQwenBundle } from "./qwen"
+
+export type TargetScope = "global" | "workspace"
+
+export function isTargetScope(value: string): value is TargetScope {
+  return value === "global" || value === "workspace"
+}
+
+/**
+ * Validate a --scope flag against a target's supported scopes.
+ * Returns the resolved scope (explicit or default) or throws on invalid input.
+ */
+export function validateScope(
+  targetName: string,
+  target: TargetHandler,
+  scopeArg: string | undefined,
+): TargetScope | undefined {
+  if (scopeArg === undefined) return target.defaultScope
+
+  if (!target.supportedScopes) {
+    throw new Error(`Target "${targetName}" does not support the --scope flag.`)
+  }
+  if (!isTargetScope(scopeArg) || !target.supportedScopes.includes(scopeArg)) {
+    throw new Error(`Target "${targetName}" does not support --scope ${scopeArg}. Supported: ${target.supportedScopes.join(", ")}`)
+  }
+  return scopeArg
+}
 
 export type TargetHandler<TBundle = unknown> = {
   name: string
   implemented: boolean
+  /** Default scope when --scope is not provided. Only meaningful when supportedScopes is defined. */
+  defaultScope?: TargetScope
+  /** Valid scope values. If absent, the --scope flag is rejected for this target. */
+  supportedScopes?: TargetScope[]
   convert: (plugin: ClaudePlugin, options: ClaudeToOpenCodeOptions) => TBundle | null
-  write: (outputRoot: string, bundle: TBundle) => Promise<void>
+  write: (outputRoot: string, bundle: TBundle, scope?: TargetScope) => Promise<void>
 }
 
 export const targets: Record<string, TargetHandler> = {
@@ -71,4 +110,24 @@ export const targets: Record<string, TargetHandler> = {
     convert: convertClaudeToKiro as TargetHandler<KiroBundle>["convert"],
     write: writeKiroBundle as TargetHandler<KiroBundle>["write"],
   },
+  windsurf: {
+    name: "windsurf",
+    implemented: true,
+    defaultScope: "global",
+    supportedScopes: ["global", "workspace"],
+    convert: convertClaudeToWindsurf as TargetHandler<WindsurfBundle>["convert"],
+    write: writeWindsurfBundle as TargetHandler<WindsurfBundle>["write"],
+  },
+  openclaw: {
+    name: "openclaw",
+    implemented: true,
+    convert: convertClaudeToOpenClaw as TargetHandler<OpenClawBundle>["convert"],
+    write: writeOpenClawBundle as TargetHandler<OpenClawBundle>["write"],
+  },
+  qwen: {
+    name: "qwen",
+    implemented: true,
+    convert: convertClaudeToQwen as TargetHandler<QwenBundle>["convert"],
+    write: writeQwenBundle as TargetHandler<QwenBundle>["write"],
+  },
 }

package/src/targets/openclaw.ts

@@ -0,0 +1,96 @@
+import path from "path"
+import { promises as fs } from "fs"
+import { backupFile, copyDir, ensureDir, pathExists, readJson, walkFiles, writeJson, writeText } from "../utils/files"
+import type { OpenClawBundle } from "../types/openclaw"
+
+export async function writeOpenClawBundle(outputRoot: string, bundle: OpenClawBundle): Promise<void> {
+  const paths = resolveOpenClawPaths(outputRoot)
+  await ensureDir(paths.root)
+
+  // Write openclaw.plugin.json
+  await writeJson(paths.manifestPath, bundle.manifest)
+
+  // Write package.json
+  await writeJson(paths.packageJsonPath, bundle.packageJson)
+
+  // Write index.ts entry point
+  await writeText(paths.entryPointPath, bundle.entryPoint)
+
+  // Write generated skills (agents + commands converted to SKILL.md)
+  for (const skill of bundle.skills) {
+    const skillDir = path.join(paths.skillsDir, skill.dir)
+    await ensureDir(skillDir)
+    await writeText(path.join(skillDir, "SKILL.md"), skill.content + "\n")
+  }
+
+  // Copy original skill directories (preserving references/, assets/, scripts/)
+  // and rewrite .claude/ paths to .openclaw/ in markdown files
+  for (const skill of bundle.skillDirCopies) {
+    const destDir = path.join(paths.skillsDir, skill.name)
+    await copyDir(skill.sourceDir, destDir)
+    await rewritePathsInDir(destDir)
+  }
+
+  // Write openclaw.json config fragment if MCP servers exist
+  if (bundle.openclawConfig) {
+    const configPath = path.join(paths.root, "openclaw.json")
+    const backupPath = await backupFile(configPath)
+    if (backupPath) {
+      console.log(`Backed up existing config to ${backupPath}`)
+    }
+    const merged = await mergeOpenClawConfig(configPath, bundle.openclawConfig)
+    await writeJson(configPath, merged)
+  }
+}
+
+function resolveOpenClawPaths(outputRoot: string) {
+  return {
+    root: outputRoot,
+    manifestPath: path.join(outputRoot, "openclaw.plugin.json"),
+    packageJsonPath: path.join(outputRoot, "package.json"),
+    entryPointPath: path.join(outputRoot, "index.ts"),
+    skillsDir: path.join(outputRoot, "skills"),
+  }
+}
+
+async function rewritePathsInDir(dir: string): Promise<void> {
+  const files = await walkFiles(dir)
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue
+    const content = await fs.readFile(file, "utf8")
+    const rewritten = content
+      .replace(/~\/\.claude\//g, "~/.openclaw/")
+      .replace(/\.claude\//g, ".openclaw/")
+      .replace(/\.claude-plugin\//g, "openclaw-plugin/")
+    if (rewritten !== content) {
+      await fs.writeFile(file, rewritten, "utf8")
+    }
+  }
+}
+
+async function mergeOpenClawConfig(
+  configPath: string,
+  incoming: Record<string, unknown>,
+): Promise<Record<string, unknown>> {
+  if (!(await pathExists(configPath))) return incoming
+
+  let existing: Record<string, unknown>
+  try {
+    existing = await readJson<Record<string, unknown>>(configPath)
+  } catch {
+    console.warn(
+      `Warning: existing ${configPath} is not valid JSON. Writing plugin config without merging.`,
+    )
+    return incoming
+  }
+
+  // Merge MCP servers: existing takes precedence on conflict
+  const incomingMcp = (incoming.mcpServers ?? {}) as Record<string, unknown>
+  const existingMcp = (existing.mcpServers ?? {}) as Record<string, unknown>
+  const mergedMcp = { ...incomingMcp, ...existingMcp }
+
+  return {
+    ...existing,
+    mcpServers: Object.keys(mergedMcp).length > 0 ? mergedMcp : undefined,
+  }
+}

package/src/targets/opencode.ts

@@ -1,31 +1,93 @@
 import path from "path"
-import { backupFile, copyDir, ensureDir, writeJson, writeText } from "../utils/files"
-import type { OpenCodeBundle } from "../types/opencode"
+import { backupFile, copyDir, ensureDir, pathExists, readJson, writeJson, writeText } from "../utils/files"
+import type { OpenCodeBundle, OpenCodeConfig } from "../types/opencode"
+
+// Merges plugin config into existing opencode.json. User keys win on conflict. See ADR-002.
+async function mergeOpenCodeConfig(
+  configPath: string,
+  incoming: OpenCodeConfig,
+): Promise<OpenCodeConfig> {
+  // If no existing config, write plugin config as-is
+  if (!(await pathExists(configPath))) return incoming
+
+  let existing: OpenCodeConfig
+  try {
+    existing = await readJson<OpenCodeConfig>(configPath)
+  } catch {
+    // Safety first per AGENTS.md -- do not destroy user data even if their config is malformed.
+    // Warn and fall back to plugin-only config rather than crashing.
+    console.warn(
+      `Warning: existing ${configPath} is not valid JSON. Writing plugin config without merging.`
+    )
+    return incoming
+  }
+
+  // User config wins on conflict -- see ADR-002
+  // MCP servers: add plugin entry, skip keys already in user config.
+  const mergedMcp = {
+    ...(incoming.mcp ?? {}),
+    ...(existing.mcp ?? {}), // existing takes precedence (overwrites same-named plugin entry)
+  }
+
+  // Permission: add plugin entry, skip keys already in user config.
+  const mergedPermission = incoming.permission
+    ? {
+        ...(incoming.permission),
+        ...(existing.permission ?? {}), // existing takes precedence
+      }
+    : existing.permission
+
+  // Tools: same pattern
+  const mergedTools = incoming.tools
+    ? {
+        ...(incoming.tools),
+        ...(existing.tools ?? {}),
+      }
+    : existing.tools
+
+  return {
+    ...existing,                    // all user keys preserved
+    $schema: incoming.$schema ?? existing.$schema,
+    mcp: Object.keys(mergedMcp).length > 0 ? mergedMcp : undefined,
+    permission: mergedPermission,
+    tools: mergedTools,
+  }
+}
 
 export async function writeOpenCodeBundle(outputRoot: string, bundle: OpenCodeBundle): Promise<void> {
-  const paths = resolveOpenCodePaths(outputRoot)
-  await ensureDir(paths.root)
+  const openCodePaths = resolveOpenCodePaths(outputRoot)
+  await ensureDir(openCodePaths.root)
 
-  const backupPath = await backupFile(paths.configPath)
+  const backupPath = await backupFile(openCodePaths.configPath)
   if (backupPath) {
     console.log(`Backed up existing config to ${backupPath}`)
   }
-  await writeJson(paths.configPath, bundle.config)
+  const merged = await mergeOpenCodeConfig(openCodePaths.configPath, bundle.config)
+  await writeJson(openCodePaths.configPath, merged)
 
-  const agentsDir = paths.agentsDir
+  const agentsDir = openCodePaths.agentsDir
   for (const agent of bundle.agents) {
     await writeText(path.join(agentsDir, `${agent.name}.md`), agent.content + "\n")
   }
 
+  for (const commandFile of bundle.commandFiles) {
+    const dest = path.join(openCodePaths.commandDir, `${commandFile.name}.md`)
+    const cmdBackupPath = await backupFile(dest)
+    if (cmdBackupPath) {
+      console.log(`Backed up existing command file to ${cmdBackupPath}`)
+    }
+    await writeText(dest, commandFile.content + "\n")
+  }
+
   if (bundle.plugins.length > 0) {
-    const pluginsDir = paths.pluginsDir
+    const pluginsDir = openCodePaths.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
+    const skillsRoot = openCodePaths.skillsDir
     for (const skill of bundle.skillDirs) {
       await copyDir(skill.sourceDir, path.join(skillsRoot, skill.name))
     }
@@ -43,6 +105,8 @@ function resolveOpenCodePaths(outputRoot: string) {
       agentsDir: path.join(outputRoot, "agents"),
       pluginsDir: path.join(outputRoot, "plugins"),
       skillsDir: path.join(outputRoot, "skills"),
+      // .md command files; alternative to the command key in opencode.json
+      commandDir: path.join(outputRoot, "commands"),
     }
   }
 
@@ -53,5 +117,7 @@ function resolveOpenCodePaths(outputRoot: string) {
     agentsDir: path.join(outputRoot, ".opencode", "agents"),
     pluginsDir: path.join(outputRoot, ".opencode", "plugins"),
     skillsDir: path.join(outputRoot, ".opencode", "skills"),
+    // .md command files; alternative to the command key in opencode.json
+    commandDir: path.join(outputRoot, ".opencode", "commands"),
   }
-}
+}

package/src/targets/qwen.ts

@@ -0,0 +1,64 @@
+import path from "path"
+import { backupFile, copyDir, ensureDir, writeJson, writeText } from "../utils/files"
+import type { QwenBundle, QwenExtensionConfig } from "../types/qwen"
+
+export async function writeQwenBundle(outputRoot: string, bundle: QwenBundle): Promise<void> {
+  const qwenPaths = resolveQwenPaths(outputRoot)
+  await ensureDir(qwenPaths.root)
+
+  // Write qwen-extension.json config
+  const configPath = qwenPaths.configPath
+  const backupPath = await backupFile(configPath)
+  if (backupPath) {
+    console.log(`Backed up existing config to ${backupPath}`)
+  }
+  await writeJson(configPath, bundle.config)
+
+  // Write context file (QWEN.md)
+  if (bundle.contextFile) {
+    await writeText(qwenPaths.contextPath, bundle.contextFile + "\n")
+  }
+
+  // Write agents
+  const agentsDir = qwenPaths.agentsDir
+  await ensureDir(agentsDir)
+  for (const agent of bundle.agents) {
+    const ext = agent.format === "yaml" ? "yaml" : "md"
+    await writeText(path.join(agentsDir, `${agent.name}.${ext}`), agent.content + "\n")
+  }
+
+  // Write commands
+  const commandsDir = qwenPaths.commandsDir
+  await ensureDir(commandsDir)
+  for (const commandFile of bundle.commandFiles) {
+    // Support nested commands with colon separator
+    const parts = commandFile.name.split(":")
+    if (parts.length > 1) {
+      const nestedDir = path.join(commandsDir, ...parts.slice(0, -1))
+      await ensureDir(nestedDir)
+      await writeText(path.join(nestedDir, `${parts[parts.length - 1]}.md`), commandFile.content + "\n")
+    } else {
+      await writeText(path.join(commandsDir, `${commandFile.name}.md`), commandFile.content + "\n")
+    }
+  }
+
+  // Copy skills
+  if (bundle.skillDirs.length > 0) {
+    const skillsRoot = qwenPaths.skillsDir
+    await ensureDir(skillsRoot)
+    for (const skill of bundle.skillDirs) {
+      await copyDir(skill.sourceDir, path.join(skillsRoot, skill.name))
+    }
+  }
+}
+
+function resolveQwenPaths(outputRoot: string) {
+  return {
+    root: outputRoot,
+    configPath: path.join(outputRoot, "qwen-extension.json"),
+    contextPath: path.join(outputRoot, "QWEN.md"),
+    agentsDir: path.join(outputRoot, "agents"),
+    commandsDir: path.join(outputRoot, "commands"),
+    skillsDir: path.join(outputRoot, "skills"),
+  }
+}