@every-env/compound-plugin 0.9.0 → 0.12.0

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

@@ -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"),
+  }
+}