@every-env/compound-plugin 0.8.0 → 0.12.0

package/src/converters/claude-to-qwen.ts

@@ -0,0 +1,238 @@
+import { formatFrontmatter } from "../utils/frontmatter"
+import type { ClaudeAgent, ClaudeCommand, ClaudeMcpServer, ClaudePlugin } from "../types/claude"
+import type {
+  QwenAgentFile,
+  QwenBundle,
+  QwenCommandFile,
+  QwenExtensionConfig,
+  QwenMcpServer,
+  QwenSetting,
+} from "../types/qwen"
+
+export type ClaudeToQwenOptions = {
+  agentMode: "primary" | "subagent"
+  inferTemperature: boolean
+}
+
+export function convertClaudeToQwen(plugin: ClaudePlugin, options: ClaudeToQwenOptions): QwenBundle {
+  const agentFiles = plugin.agents.map((agent) => convertAgent(agent, options))
+  const cmdFiles = convertCommands(plugin.commands)
+  const mcp = plugin.mcpServers ? convertMcp(plugin.mcpServers) : undefined
+  const settings = extractSettings(plugin.mcpServers)
+
+  const config: QwenExtensionConfig = {
+    name: plugin.manifest.name,
+    version: plugin.manifest.version || "1.0.0",
+    commands: "commands",
+    skills: "skills",
+    agents: "agents",
+  }
+
+  if (mcp && Object.keys(mcp).length > 0) {
+    config.mcpServers = mcp
+  }
+
+  if (settings && settings.length > 0) {
+    config.settings = settings
+  }
+
+  const contextFile = generateContextFile(plugin)
+
+  return {
+    config,
+    agents: agentFiles,
+    commandFiles: cmdFiles,
+    skillDirs: plugin.skills.map((skill) => ({ sourceDir: skill.sourceDir, name: skill.name })),
+    contextFile,
+  }
+}
+
+function convertAgent(agent: ClaudeAgent, options: ClaudeToQwenOptions): QwenAgentFile {
+  const frontmatter: Record<string, unknown> = {
+    name: agent.name,
+    description: agent.description,
+  }
+
+  if (agent.model && agent.model !== "inherit") {
+    frontmatter.model = normalizeModel(agent.model)
+  }
+
+  if (options.inferTemperature) {
+    const temperature = inferTemperature(agent)
+    if (temperature !== undefined) {
+      frontmatter.temperature = temperature
+    }
+  }
+
+  // Qwen supports both YAML and Markdown for agents
+  // Using YAML format for structured config
+  const content = formatFrontmatter(frontmatter, rewriteQwenPaths(agent.body))
+
+  return {
+    name: agent.name,
+    content,
+    format: "yaml",
+  }
+}
+
+function convertCommands(commands: ClaudeCommand[]): QwenCommandFile[] {
+  const files: QwenCommandFile[] = []
+  for (const command of commands) {
+    if (command.disableModelInvocation) continue
+    const frontmatter: Record<string, unknown> = {
+      description: command.description,
+    }
+    if (command.model && command.model !== "inherit") {
+      frontmatter.model = normalizeModel(command.model)
+    }
+    if (command.allowedTools && command.allowedTools.length > 0) {
+      frontmatter.allowedTools = command.allowedTools
+    }
+    const content = formatFrontmatter(frontmatter, rewriteQwenPaths(command.body))
+    files.push({ name: command.name, content })
+  }
+  return files
+}
+
+function convertMcp(servers: Record<string, ClaudeMcpServer>): Record<string, QwenMcpServer> {
+  const result: Record<string, QwenMcpServer> = {}
+  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) {
+      // Qwen only supports stdio (command-based) MCP servers — skip remote servers
+      console.warn(
+        `Warning: Remote MCP server '${name}' (URL: ${server.url}) is not supported in Qwen format. Qwen only supports stdio MCP servers. Skipping.`,
+      )
+    }
+  }
+  return result
+}
+
+function extractSettings(mcpServers?: Record<string, ClaudeMcpServer>): QwenSetting[] {
+  const settings: QwenSetting[] = []
+  if (!mcpServers) return settings
+
+  for (const [name, server] of Object.entries(mcpServers)) {
+    if (server.env) {
+      for (const [envVar, value] of Object.entries(server.env)) {
+        // Only add settings for environment variables that look like placeholders
+        if (value.startsWith("${") || value.includes("YOUR_") || value.includes("XXX")) {
+          settings.push({
+            name: formatSettingName(envVar),
+            description: `Environment variable for ${name} MCP server`,
+            envVar,
+            sensitive: envVar.toLowerCase().includes("key") || envVar.toLowerCase().includes("token") || envVar.toLowerCase().includes("secret"),
+          })
+        }
+      }
+    }
+  }
+
+  return settings
+}
+
+function formatSettingName(envVar: string): string {
+  return envVar
+    .replace(/_/g, " ")
+    .toLowerCase()
+    .replace(/\b\w/g, (c) => c.toUpperCase())
+}
+
+function generateContextFile(plugin: ClaudePlugin): string {
+  const sections: string[] = []
+
+  // Plugin description
+  sections.push(`# ${plugin.manifest.name}`)
+  sections.push("")
+  if (plugin.manifest.description) {
+    sections.push(plugin.manifest.description)
+    sections.push("")
+  }
+
+  // Agents section
+  if (plugin.agents.length > 0) {
+    sections.push("## Agents")
+    sections.push("")
+    for (const agent of plugin.agents) {
+      sections.push(`- **${agent.name}**: ${agent.description || "No description"}`)
+    }
+    sections.push("")
+  }
+
+  // Commands section
+  if (plugin.commands.length > 0) {
+    sections.push("## Commands")
+    sections.push("")
+    for (const command of plugin.commands) {
+      if (!command.disableModelInvocation) {
+        sections.push(`- **/${command.name}**: ${command.description || "No description"}`)
+      }
+    }
+    sections.push("")
+  }
+
+  // Skills section
+  if (plugin.skills.length > 0) {
+    sections.push("## Skills")
+    sections.push("")
+    for (const skill of plugin.skills) {
+      sections.push(`- ${skill.name}`)
+    }
+    sections.push("")
+  }
+
+  return sections.join("\n")
+}
+
+function rewriteQwenPaths(body: string): string {
+  return body
+    .replace(/(?<=^|\s|["'`])~\/\.claude\//gm, "~/.qwen/")
+    .replace(/(?<=^|\s|["'`])\.claude\//gm, ".qwen/")
+}
+
+const CLAUDE_FAMILY_ALIASES: Record<string, string> = {
+  haiku: "claude-haiku",
+  sonnet: "claude-sonnet",
+  opus: "claude-opus",
+}
+
+function normalizeModel(model: string): string {
+  if (model.includes("/")) return model
+  if (CLAUDE_FAMILY_ALIASES[model]) {
+    const resolved = `anthropic/${CLAUDE_FAMILY_ALIASES[model]}`
+    console.warn(
+      `Warning: bare model alias "${model}" mapped to "${resolved}".`,
+    )
+    return resolved
+  }
+  if (/^claude-/.test(model)) return `anthropic/${model}`
+  if (/^(gpt-|o1-|o3-)/.test(model)) return `openai/${model}`
+  if (/^gemini-/.test(model)) return `google/${model}`
+  if (/^qwen-/.test(model)) return `qwen/${model}`
+  return `anthropic/${model}`
+}
+
+function inferTemperature(agent: ClaudeAgent): number | undefined {
+  const sample = `${agent.name} ${agent.description ?? ""}`.toLowerCase()
+  if (/(review|audit|security|sentinel|oracle|lint|verification|guardian)/.test(sample)) {
+    return 0.1
+  }
+  if (/(plan|planning|architecture|strategist|analysis|research)/.test(sample)) {
+    return 0.2
+  }
+  if (/(doc|readme|changelog|editor|writer)/.test(sample)) {
+    return 0.3
+  }
+  if (/(brainstorm|creative|ideate|design|concept)/.test(sample)) {
+    return 0.6
+  }
+  return undefined
+}

package/src/converters/claude-to-windsurf.ts

@@ -0,0 +1,205 @@
+import { formatFrontmatter } from "../utils/frontmatter"
+import { findServersWithPotentialSecrets } from "../utils/secrets"
+import type { ClaudeAgent, ClaudeCommand, ClaudeMcpServer, ClaudePlugin } from "../types/claude"
+import type { WindsurfBundle, WindsurfGeneratedSkill, WindsurfMcpConfig, WindsurfMcpServerEntry, WindsurfWorkflow } from "../types/windsurf"
+import type { ClaudeToOpenCodeOptions } from "./claude-to-opencode"
+
+export type ClaudeToWindsurfOptions = ClaudeToOpenCodeOptions
+
+const WINDSURF_WORKFLOW_CHAR_LIMIT = 12_000
+
+export function convertClaudeToWindsurf(
+  plugin: ClaudePlugin,
+  _options: ClaudeToWindsurfOptions,
+): WindsurfBundle {
+  const knownAgentNames = plugin.agents.map((a) => normalizeName(a.name))
+
+  // Pass-through skills (collected first so agent skill names can deduplicate against them)
+  const skillDirs = plugin.skills.map((skill) => ({
+    name: skill.name,
+    sourceDir: skill.sourceDir,
+  }))
+
+  // Convert agents to skills (seed usedNames with pass-through skill names)
+  const usedSkillNames = new Set<string>(skillDirs.map((s) => s.name))
+  const agentSkills = plugin.agents.map((agent) =>
+    convertAgentToSkill(agent, knownAgentNames, usedSkillNames),
+  )
+
+  // Convert commands to workflows
+  const usedCommandNames = new Set<string>()
+  const commandWorkflows = plugin.commands.map((command) =>
+    convertCommandToWorkflow(command, knownAgentNames, usedCommandNames),
+  )
+
+  // Build MCP config
+  const mcpConfig = buildMcpConfig(plugin.mcpServers)
+
+  // Warn about hooks
+  if (plugin.hooks && Object.keys(plugin.hooks.hooks).length > 0) {
+    console.warn(
+      "Warning: Windsurf has no hooks equivalent. Hooks were skipped during conversion.",
+    )
+  }
+
+  return { agentSkills, commandWorkflows, skillDirs, mcpConfig }
+}
+
+function convertAgentToSkill(
+  agent: ClaudeAgent,
+  knownAgentNames: string[],
+  usedNames: Set<string>,
+): WindsurfGeneratedSkill {
+  const name = uniqueName(normalizeName(agent.name), usedNames)
+  const description = sanitizeDescription(
+    agent.description ?? `Converted from Claude agent ${agent.name}`,
+  )
+
+  let body = transformContentForWindsurf(agent.body.trim(), knownAgentNames)
+  if (agent.capabilities && agent.capabilities.length > 0) {
+    const capabilities = agent.capabilities.map((c) => `- ${c}`).join("\n")
+    body = `## Capabilities\n${capabilities}\n\n${body}`.trim()
+  }
+  if (body.length === 0) {
+    body = `Instructions converted from the ${agent.name} agent.`
+  }
+
+  const content = formatFrontmatter({ name, description }, `# ${name}\n\n${body}`) + "\n"
+  return { name, content }
+}
+
+function convertCommandToWorkflow(
+  command: ClaudeCommand,
+  knownAgentNames: string[],
+  usedNames: Set<string>,
+): WindsurfWorkflow {
+  const name = uniqueName(normalizeName(command.name), usedNames)
+  const description = sanitizeDescription(
+    command.description ?? `Converted from Claude command ${command.name}`,
+  )
+
+  let body = transformContentForWindsurf(command.body.trim(), knownAgentNames)
+  if (command.argumentHint) {
+    body = `> Arguments: ${command.argumentHint}\n\n${body}`
+  }
+  if (body.length === 0) {
+    body = `Instructions converted from the ${command.name} command.`
+  }
+
+  const frontmatter: Record<string, unknown> = { description }
+  const fullContent = formatFrontmatter(frontmatter, `# ${name}\n\n${body}`)
+  if (fullContent.length > WINDSURF_WORKFLOW_CHAR_LIMIT) {
+    console.warn(
+      `Warning: Workflow "${name}" is ${fullContent.length} characters (limit: ${WINDSURF_WORKFLOW_CHAR_LIMIT}). It may be truncated by Windsurf.`,
+    )
+  }
+
+  return { name, description, body }
+}
+
+/**
+ * Transform Claude Code content to Windsurf-compatible content.
+ *
+ * 1. Path rewriting: .claude/ -> .windsurf/, ~/.claude/ -> ~/.codeium/windsurf/
+ * 2. Slash command refs: /workflows:plan -> /workflows-plan (Windsurf invokes workflows as /{name})
+ * 3. @agent-name refs: kept as @agent-name (already Windsurf skill invocation syntax)
+ * 4. Task agent calls: Task agent-name(args) -> Use the @agent-name skill: args
+ */
+export function transformContentForWindsurf(body: string, knownAgentNames: string[] = []): string {
+  let result = body
+
+  // 1. Rewrite paths
+  result = result.replace(/(?<=^|\s|["'`])~\/\.claude\//gm, "~/.codeium/windsurf/")
+  result = result.replace(/(?<=^|\s|["'`])\.claude\//gm, ".windsurf/")
+
+  // 2. Slash command refs: /workflows:plan -> /workflows-plan (Windsurf invokes as /{name})
+  result = result.replace(/(?<=^|\s)`?\/([a-zA-Z][a-zA-Z0-9_:-]*)`?/gm, (_match, cmdName: string) => {
+    const workflowName = normalizeName(cmdName)
+    return `/${workflowName}`
+  })
+
+  // 3. @agent-name references: no transformation needed.
+  // In Windsurf, @skill-name is the native invocation syntax for skills.
+  // Since agents are now mapped to skills, @agent-name already works correctly.
+
+  // 4. Transform Task agent calls to skill references
+  const taskPattern = /^(\s*-?\s*)Task\s+([a-z][a-z0-9-]*)\(([^)]+)\)/gm
+  result = result.replace(taskPattern, (_match, prefix: string, agentName: string, args: string) => {
+    return `${prefix}Use the @${normalizeName(agentName)} skill: ${args.trim()}`
+  })
+
+  return result
+}
+
+function buildMcpConfig(servers?: Record<string, ClaudeMcpServer>): WindsurfMcpConfig | null {
+  if (!servers || Object.keys(servers).length === 0) return null
+
+  const result: Record<string, WindsurfMcpServerEntry> = {}
+  for (const [name, server] of Object.entries(servers)) {
+    if (server.command) {
+      // stdio transport
+      const entry: WindsurfMcpServerEntry = { command: server.command }
+      if (server.args?.length) entry.args = server.args
+      if (server.env && Object.keys(server.env).length > 0) entry.env = server.env
+      result[name] = entry
+    } else if (server.url) {
+      // HTTP/SSE transport
+      const entry: WindsurfMcpServerEntry = { serverUrl: 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 = server.env
+      result[name] = entry
+    } else {
+      console.warn(`Warning: MCP server "${name}" has no command or URL. Skipping.`)
+      continue
+    }
+  }
+
+  if (Object.keys(result).length === 0) return null
+
+  // Warn about secrets (don't redact — they're needed for the config to work)
+  const flagged = findServersWithPotentialSecrets(result)
+  if (flagged.length > 0) {
+    console.warn(
+      `Warning: MCP servers contain env vars that may include secrets: ${flagged.join(", ")}.\n` +
+      "   These will be written to mcp_config.json. Review before sharing the config file.",
+    )
+  }
+
+  return { mcpServers: result }
+}
+
+export function normalizeName(value: string): string {
+  const trimmed = value.trim()
+  if (!trimmed) return "item"
+  let normalized = trimmed
+    .toLowerCase()
+    .replace(/[\\/]+/g, "-")
+    .replace(/[:\s]+/g, "-")
+    .replace(/[^a-z0-9_-]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-+|-+$/g, "")
+
+  if (normalized.length === 0 || !/^[a-z]/.test(normalized)) {
+    return "item"
+  }
+
+  return normalized
+}
+
+function sanitizeDescription(value: string): string {
+  return value.replace(/\s+/g, " ").trim()
+}
+
+function uniqueName(base: string, used: Set<string>): string {
+  if (!used.has(base)) {
+    used.add(base)
+    return base
+  }
+  let index = 2
+  while (used.has(`${base}-${index}`)) {
+    index += 1
+  }
+  const name = `${base}-${index}`
+  used.add(name)
+  return name
+}

package/src/sync/gemini.ts

@@ -0,0 +1,76 @@
+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 GeminiMcpServer = {
+  command?: string
+  args?: string[]
+  url?: string
+  env?: Record<string, string>
+  headers?: Record<string, string>
+}
+
+export async function syncToGemini(
+  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 settingsPath = path.join(outputRoot, "settings.json")
+    const existing = await readJsonSafe(settingsPath)
+    const converted = convertMcpForGemini(config.mcpServers)
+    const existingMcp =
+      existing.mcpServers && typeof existing.mcpServers === "object"
+        ? (existing.mcpServers as Record<string, unknown>)
+        : {}
+    const merged = {
+      ...existing,
+      mcpServers: { ...existingMcp, ...converted },
+    }
+    await fs.writeFile(settingsPath, JSON.stringify(merged, 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 convertMcpForGemini(
+  servers: Record<string, ClaudeMcpServer>,
+): Record<string, GeminiMcpServer> {
+  const result: Record<string, GeminiMcpServer> = {}
+  for (const [name, server] of Object.entries(servers)) {
+    const entry: GeminiMcpServer = {}
+    if (server.command) {
+      entry.command = server.command
+      if (server.args && server.args.length > 0) entry.args = server.args
+      if (server.env && Object.keys(server.env).length > 0) entry.env = server.env
+    } else if (server.url) {
+      entry.url = server.url
+      if (server.headers && Object.keys(server.headers).length > 0) entry.headers = server.headers
+    }
+    result[name] = entry
+  }
+  return result
+}

package/src/targets/index.ts

@@ -5,24 +5,66 @@ import type { DroidBundle } from "../types/droid"
 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"
 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"
 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> = {
@@ -62,4 +104,30 @@ export const targets: Record<string, TargetHandler> = {
     convert: convertClaudeToGemini as TargetHandler<GeminiBundle>["convert"],
     write: writeGeminiBundle as TargetHandler<GeminiBundle>["write"],
   },
+  kiro: {
+    name: "kiro",
+    implemented: true,
+    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"],
+  },
 }