feat: Add Qwen Code support

- Add Qwen Code target for converting Claude Code plugins - Implement claude-to-qwen converter with agent/command/skill mapping - Write qwen-extension.json config with MCP servers and settings - Generate QWEN.md context file with plugin documentation - Support nested commands with colon separator (workflows:plan) - Extract MCP environment placeholders as settings - Add --to qwen and --qwen-home CLI options - Document Qwen installation in README Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
2026-02-28 11:51:28 -05:00
parent 9196ed8ad8
commit e1d5bdedb3
6 changed files with 417 additions and 3 deletions
--- a/README.md
+++ b/README.md
@@ -18,9 +18,9 @@ A Claude Code plugin marketplace featuring the **Compound Engineering Plugin**
 /add-plugin compound-engineering
 ```

-## OpenCode, Codex, Droid, Pi, Gemini, Copilot & Kiro (experimental) Install
+## OpenCode, Codex, Droid, Pi, Gemini, Copilot, Kiro & Qwen (experimental) Install

-This repo includes a Bun/TypeScript CLI that converts Claude Code plugins to OpenCode, Codex, Factory Droid, Pi, Gemini CLI, GitHub Copilot, and Kiro CLI.
+This repo includes a Bun/TypeScript CLI that converts Claude Code plugins to OpenCode, Codex, Factory Droid, Pi, Gemini CLI, GitHub Copilot, Kiro CLI, and Qwen Code.

 ```bash
 # convert the compound-engineering plugin into OpenCode format
@@ -43,6 +43,9 @@ bunx @every-env/compound-plugin install compound-engineering --to copilot

 # convert to Kiro CLI format
 bunx @every-env/compound-plugin install compound-engineering --to kiro
+
+# convert to Qwen Code format
+bunx @every-env/compound-plugin install compound-engineering --to qwen
 ```

 Local dev:
@@ -58,6 +61,7 @@ Pi output is written to `~/.pi/agent/` by default with prompts, skills, extensio
 Gemini output is written to `.gemini/` with skills (from agents), commands (`.toml`), and `settings.json` (MCP servers). Namespaced commands create directory structure (`workflows:plan` → `commands/workflows/plan.toml`). Skills use the identical SKILL.md standard and pass through unchanged.
 Copilot output is written to `.github/` with agents (`.agent.md`), skills (`SKILL.md`), and `copilot-mcp-config.json`. Agents get Copilot frontmatter (`description`, `tools: ["*"]`, `infer: true`), commands are converted to agent skills, and MCP server env vars are prefixed with `COPILOT_MCP_`.
 Kiro output is written to `.kiro/` with custom agents (`.json` configs + prompt `.md` files), skills (from commands), pass-through skills, steering files (from CLAUDE.md), and `mcp.json`. Agents get `includeMcpJson: true` for MCP server access. Only stdio MCP servers are supported (HTTP servers are skipped with a warning).
+Qwen output is written to `~/.qwen/extensions/compound-engineering/` by default with `qwen-extension.json` (MCP servers), `QWEN.md` (context), agents (`.yaml`), commands (`.md`), and skills. Claude tool names are passed through unchanged. MCP server environment variables with placeholder values are extracted as settings in `qwen-extension.json`. Nested commands use colon separator (`workflows:plan` → `commands/workflows/plan.md`).

 All provider targets are experimental and may change as the formats evolve.

--- a/src/commands/install.ts
+++ b/src/commands/install.ts
@@ -25,7 +25,7 @@ export default defineCommand({
    to: {
      type: "string",
      default: "opencode",
-      description: "Target format (opencode | codex | droid | cursor | pi | copilot | gemini | kiro)",
+      description: "Target format (opencode | codex | droid | cursor | pi | copilot | gemini | kiro | qwen)",
    },
    output: {
      type: "string",
@@ -42,6 +42,11 @@ export default defineCommand({
      alias: "pi-home",
      description: "Write Pi output to this Pi root (ex: ~/.pi/agent or ./.pi)",
    },
+    qwenHome: {
+      type: "string",
+      alias: "qwen-home",
+      description: "Write Qwen output to this Qwen extensions root (ex: ~/.qwen/extensions/compound-engineering)",
+    },
    also: {
      type: "string",
      description: "Comma-separated extra targets to generate (ex: codex)",
@@ -84,6 +89,7 @@ export default defineCommand({
      const outputRoot = resolveOutputRoot(args.output)
      const codexHome = resolveTargetHome(args.codexHome, path.join(os.homedir(), ".codex"))
      const piHome = resolveTargetHome(args.piHome, path.join(os.homedir(), ".pi", "agent"))
+      const qwenHome = resolveTargetHome(args.qwenHome, path.join(os.homedir(), ".qwen", "extensions", "compound-engineering"))

      const options = {
        agentMode: String(args.agentMode) === "primary" ? "primary" : "subagent",
@@ -178,6 +184,10 @@ function resolveTargetOutputRoot(
 ): string {
  if (targetName === "codex") return codexHome
  if (targetName === "pi") return piHome
+  if (targetName === "qwen") {
+    const base = hasExplicitOutput ? outputRoot : path.join(os.homedir(), ".qwen", "extensions")
+    return path.join(base, "compound-engineering")
+  }
  if (targetName === "droid") return path.join(os.homedir(), ".factory")
  if (targetName === "cursor") {
    const base = hasExplicitOutput ? outputRoot : process.cwd()
--- a/src/converters/claude-to-qwen.ts
+++ b/src/converters/claude-to-qwen.ts
@@ -0,0 +1,262 @@
+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
+}
+
+const TOOL_MAP: Record<string, string> = {
+  bash: "bash",
+  read: "read",
+  write: "write",
+  edit: "edit",
+  grep: "grep",
+  glob: "glob",
+  list: "list",
+  webfetch: "webfetch",
+  skill: "skill",
+  patch: "patch",
+  task: "task",
+  question: "question",
+  todowrite: "todowrite",
+  todoread: "todoread",
+}
+
+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,
+        cwd: "${extensionPath}${/}",
+      }
+      continue
+    }
+
+    if (server.url) {
+      // Qwen doesn't support remote MCP servers in the same way
+      // Convert to local with proxy or skip
+      console.warn(`Warning: Remote MCP server '${name}' with URL ${server.url} is not fully supported in Qwen format`)
+      result[name] = {
+        command: "curl",
+        args: [server.url],
+        env: server.headers,
+      }
+    }
+  }
+  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.name}`)
+  sections.push("")
+  if (plugin.description) {
+    sections.push(plugin.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(/~\/\.claude\//g, "~/.qwen/")
+    .replace(/\.claude\//g, ".qwen/")
+    .replace(/~\/\.config\/opencode\//g, "~/.qwen/")
+    .replace(/\.opencode\//g, ".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 0.3
+}
--- a/src/targets/index.ts
+++ b/src/targets/index.ts
@@ -6,6 +6,7 @@ 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 { 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 +14,7 @@ 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 { convertClaudeToQwen, type ClaudeToQwenOptions } from "../converters/claude-to-qwen"
 import { writeOpenCodeBundle } from "./opencode"
 import { writeCodexBundle } from "./codex"
 import { writeDroidBundle } from "./droid"
@@ -20,6 +22,7 @@ import { writePiBundle } from "./pi"
 import { writeCopilotBundle } from "./copilot"
 import { writeGeminiBundle } from "./gemini"
 import { writeKiroBundle } from "./kiro"
+import { writeQwenBundle } from "./qwen"

 export type TargetHandler<TBundle = unknown> = {
  name: string
@@ -71,4 +74,10 @@ export const targets: Record<string, TargetHandler> = {
    convert: convertClaudeToKiro as TargetHandler<KiroBundle>["convert"],
    write: writeKiroBundle as TargetHandler<KiroBundle>["write"],
  },
+  qwen: {
+    name: "qwen",
+    implemented: true,
+    convert: convertClaudeToQwen as TargetHandler<QwenBundle>["convert"],
+    write: writeQwenBundle as TargetHandler<QwenBundle>["write"],
+  },
 }
--- a/src/targets/qwen.ts
+++ b/src/targets/qwen.ts
@@ -0,0 +1,81 @@
+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) {
+  const base = path.basename(outputRoot)
+  // Global install: ~/.qwen/extensions/<extension-name>
+  // Project install: .qwen/extensions/<extension-name> or <extension-name> at root
+  // If the output root already ends with "extensions" or contains ".qwen/extensions", write directly
+  if (base === "extensions" || outputRoot.includes(".qwen/extensions")) {
+    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"),
+    }
+  }
+
+  // Custom output directory - write directly to the output root (not nested)
+  // This is for project-level installs like ./my-extension
+  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"),
+  }
+}
--- a/src/types/qwen.ts
+++ b/src/types/qwen.ts
@@ -0,0 +1,48 @@
+export type QwenExtensionConfig = {
+  name: string
+  version: string
+  mcpServers?: Record<string, QwenMcpServer>
+  contextFileName?: string
+  commands?: string
+  skills?: string
+  agents?: string
+  settings?: QwenSetting[]
+}
+
+export type QwenMcpServer = {
+  command?: string
+  args?: string[]
+  env?: Record<string, string>
+  cwd?: string
+}
+
+export type QwenSetting = {
+  name: string
+  description: string
+  envVar: string
+  sensitive?: boolean
+}
+
+export type QwenAgentFile = {
+  name: string
+  content: string
+  format: "yaml" | "markdown"
+}
+
+export type QwenSkillDir = {
+  sourceDir: string
+  name: string
+}
+
+export type QwenCommandFile = {
+  name: string
+  content: string
+}
+
+export type QwenBundle = {
+  config: QwenExtensionConfig
+  agents: QwenAgentFile[]
+  commandFiles: QwenCommandFile[]
+  skillDirs: QwenSkillDir[]
+  contextFile?: string
+}