@every-env/compound-plugin 0.8.0 → 0.12.0

package/src/commands/sync.ts

@@ -7,30 +7,19 @@ import { syncToCodex } from "../sync/codex"
 import { syncToPi } from "../sync/pi"
 import { syncToDroid } from "../sync/droid"
 import { syncToCopilot } from "../sync/copilot"
+import { syncToGemini } from "../sync/gemini"
 import { expandHome } from "../utils/resolve-home"
+import { hasPotentialSecrets } from "../utils/secrets"
+import { detectInstalledTools } from "../utils/detect-tools"
 
-const validTargets = ["opencode", "codex", "pi", "droid", "copilot"] as const
+const validTargets = ["opencode", "codex", "pi", "droid", "copilot", "gemini", "all"] as const
 type SyncTarget = (typeof validTargets)[number]
 
 function isValidTarget(value: string): value is SyncTarget {
   return (validTargets as readonly string[]).includes(value)
 }
 
-/** Check if any MCP servers have env vars that might contain secrets */
-function hasPotentialSecrets(mcpServers: Record<string, unknown>): boolean {
-  const sensitivePatterns = /key|token|secret|password|credential|api_key/i
-  for (const server of Object.values(mcpServers)) {
-    const env = (server as { env?: Record<string, string> }).env
-    if (env) {
-      for (const key of Object.keys(env)) {
-        if (sensitivePatterns.test(key)) return true
-      }
-    }
-  }
-  return false
-}
-
-function resolveOutputRoot(target: SyncTarget): string {
+function resolveOutputRoot(target: string): string {
   switch (target) {
     case "opencode":
       return path.join(os.homedir(), ".config", "opencode")
@@ -42,19 +31,46 @@ function resolveOutputRoot(target: SyncTarget): string {
       return path.join(os.homedir(), ".factory")
     case "copilot":
       return path.join(process.cwd(), ".github")
+    case "gemini":
+      return path.join(process.cwd(), ".gemini")
+    default:
+      throw new Error(`No output root for target: ${target}`)
+  }
+}
+
+async function syncTarget(target: string, config: Awaited<ReturnType<typeof loadClaudeHome>>, outputRoot: string): Promise<void> {
+  switch (target) {
+    case "opencode":
+      await syncToOpenCode(config, outputRoot)
+      break
+    case "codex":
+      await syncToCodex(config, outputRoot)
+      break
+    case "pi":
+      await syncToPi(config, outputRoot)
+      break
+    case "droid":
+      await syncToDroid(config, outputRoot)
+      break
+    case "copilot":
+      await syncToCopilot(config, outputRoot)
+      break
+    case "gemini":
+      await syncToGemini(config, outputRoot)
+      break
   }
 }
 
 export default defineCommand({
   meta: {
     name: "sync",
-    description: "Sync Claude Code config (~/.claude/) to OpenCode, Codex, Pi, Droid, or Copilot",
+    description: "Sync Claude Code config (~/.claude/) to OpenCode, Codex, Pi, Droid, Copilot, or Gemini",
   },
   args: {
     target: {
       type: "string",
-      required: true,
-      description: "Target: opencode | codex | pi | droid | copilot",
+      default: "all",
+      description: "Target: opencode | codex | pi | droid | copilot | gemini | all (default: all)",
     },
     claudeHome: {
       type: "string",
@@ -78,30 +94,34 @@ export default defineCommand({
       )
     }
 
+    if (args.target === "all") {
+      const detected = await detectInstalledTools()
+      const activeTargets = detected.filter((t) => t.detected).map((t) => t.name)
+
+      if (activeTargets.length === 0) {
+        console.log("No AI coding tools detected.")
+        return
+      }
+
+      console.log(`Syncing to ${activeTargets.length} detected tool(s)...`)
+      for (const tool of detected) {
+        console.log(`  ${tool.detected ? "✓" : "✗"} ${tool.name} — ${tool.reason}`)
+      }
+
+      for (const name of activeTargets) {
+        const outputRoot = resolveOutputRoot(name)
+        await syncTarget(name, config, outputRoot)
+        console.log(`✓ Synced to ${name}: ${outputRoot}`)
+      }
+      return
+    }
+
     console.log(
       `Syncing ${config.skills.length} skills, ${Object.keys(config.mcpServers).length} MCP servers...`,
     )
 
     const outputRoot = resolveOutputRoot(args.target)
-
-    switch (args.target) {
-      case "opencode":
-        await syncToOpenCode(config, outputRoot)
-        break
-      case "codex":
-        await syncToCodex(config, outputRoot)
-        break
-      case "pi":
-        await syncToPi(config, outputRoot)
-        break
-      case "droid":
-        await syncToDroid(config, outputRoot)
-        break
-      case "copilot":
-        await syncToCopilot(config, outputRoot)
-        break
-    }
-
+    await syncTarget(args.target, config, outputRoot)
     console.log(`✓ Synced to ${args.target}: ${outputRoot}`)
   },
 })

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

@@ -0,0 +1,262 @@
+import { readFileSync, existsSync } from "fs"
+import path from "path"
+import { formatFrontmatter } from "../utils/frontmatter"
+import type { ClaudeAgent, ClaudeCommand, ClaudeMcpServer, ClaudePlugin } from "../types/claude"
+import type {
+  KiroAgent,
+  KiroAgentConfig,
+  KiroBundle,
+  KiroMcpServer,
+  KiroSkill,
+  KiroSteeringFile,
+} from "../types/kiro"
+import type { ClaudeToOpenCodeOptions } from "./claude-to-opencode"
+
+export type ClaudeToKiroOptions = ClaudeToOpenCodeOptions
+
+const KIRO_SKILL_NAME_MAX_LENGTH = 64
+const KIRO_SKILL_NAME_PATTERN = /^[a-z][a-z0-9-]*$/
+const KIRO_DESCRIPTION_MAX_LENGTH = 1024
+
+const CLAUDE_TO_KIRO_TOOLS: Record<string, string> = {
+  Bash: "shell",
+  Write: "write",
+  Read: "read",
+  Edit: "write", // NOTE: Kiro write is full-file, not surgical edit. Lossy mapping.
+  Glob: "glob",
+  Grep: "grep",
+  WebFetch: "web_fetch",
+  Task: "use_subagent",
+}
+
+export function convertClaudeToKiro(
+  plugin: ClaudePlugin,
+  _options: ClaudeToKiroOptions,
+): KiroBundle {
+  const usedSkillNames = new Set<string>()
+
+  // Pass-through skills are processed first — they're the source of truth
+  const skillDirs = plugin.skills.map((skill) => ({
+    name: skill.name,
+    sourceDir: skill.sourceDir,
+  }))
+  for (const skill of skillDirs) {
+    usedSkillNames.add(normalizeName(skill.name))
+  }
+
+  // Convert agents to Kiro custom agents
+  const agentNames = plugin.agents.map((a) => normalizeName(a.name))
+  const agents = plugin.agents.map((agent) => convertAgentToKiroAgent(agent, agentNames))
+
+  // Convert commands to skills (generated)
+  const generatedSkills = plugin.commands.map((command) =>
+    convertCommandToSkill(command, usedSkillNames, agentNames),
+  )
+
+  // Convert MCP servers (stdio only)
+  const mcpServers = convertMcpServers(plugin.mcpServers)
+
+  // Build steering files from CLAUDE.md
+  const steeringFiles = buildSteeringFiles(plugin, agentNames)
+
+  // Warn about hooks
+  if (plugin.hooks && Object.keys(plugin.hooks.hooks).length > 0) {
+    console.warn(
+      "Warning: Kiro CLI hooks use a different format (preToolUse/postToolUse inside agent configs). Hooks were skipped during conversion.",
+    )
+  }
+
+  return { agents, generatedSkills, skillDirs, steeringFiles, mcpServers }
+}
+
+function convertAgentToKiroAgent(agent: ClaudeAgent, knownAgentNames: string[]): KiroAgent {
+  const name = normalizeName(agent.name)
+  const description = sanitizeDescription(
+    agent.description ?? `Use this agent for ${agent.name} tasks`,
+  )
+
+  const config: KiroAgentConfig = {
+    name,
+    description,
+    prompt: `file://./prompts/${name}.md`,
+    tools: ["*"],
+    resources: [
+      "file://.kiro/steering/**/*.md",
+      "skill://.kiro/skills/**/SKILL.md",
+    ],
+    includeMcpJson: true,
+    welcomeMessage: `Switching to the ${name} agent. ${description}`,
+  }
+
+  let body = transformContentForKiro(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.`
+  }
+
+  return { name, config, promptContent: body }
+}
+
+function convertCommandToSkill(
+  command: ClaudeCommand,
+  usedNames: Set<string>,
+  knownAgentNames: string[],
+): KiroSkill {
+  const rawName = normalizeName(command.name)
+  const name = uniqueName(rawName, usedNames)
+
+  const description = sanitizeDescription(
+    command.description ?? `Converted from Claude command ${command.name}`,
+  )
+
+  const frontmatter: Record<string, unknown> = { name, description }
+
+  let body = transformContentForKiro(command.body.trim(), knownAgentNames)
+  if (body.length === 0) {
+    body = `Instructions converted from the ${command.name} command.`
+  }
+
+  const content = formatFrontmatter(frontmatter, body)
+  return { name, content }
+}
+
+/**
+ * Transform Claude Code content to Kiro-compatible content.
+ *
+ * 1. Task agent calls: Task agent-name(args) -> Use the use_subagent tool ...
+ * 2. Path rewriting: .claude/ -> .kiro/, ~/.claude/ -> ~/.kiro/
+ * 3. Slash command refs: /workflows:plan -> use the workflows-plan skill
+ * 4. Claude tool names: Bash -> shell, Read -> read, etc.
+ * 5. Agent refs: @agent-name -> the agent-name agent (only for known agent names)
+ */
+export function transformContentForKiro(body: string, knownAgentNames: string[] = []): string {
+  let result = body
+
+  // 1. Transform Task agent calls
+  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 use_subagent tool to delegate to the ${normalizeName(agentName)} agent: ${args.trim()}`
+  })
+
+  // 2. Rewrite .claude/ paths to .kiro/ (with word-boundary-like lookbehind)
+  result = result.replace(/(?<=^|\s|["'`])~\/\.claude\//gm, "~/.kiro/")
+  result = result.replace(/(?<=^|\s|["'`])\.claude\//gm, ".kiro/")
+
+  // 3. Slash command refs: /command-name -> skill activation language
+  result = result.replace(/(?<=^|\s)`?\/([a-zA-Z][a-zA-Z0-9_:-]*)`?/gm, (_match, cmdName: string) => {
+    const skillName = normalizeName(cmdName)
+    return `the ${skillName} skill`
+  })
+
+  // 4. Claude tool names -> Kiro tool names
+  for (const [claudeTool, kiroTool] of Object.entries(CLAUDE_TO_KIRO_TOOLS)) {
+    // Match tool name references: "the X tool", "using X", "use X to"
+    const toolPattern = new RegExp(`\\b${claudeTool}\\b(?=\\s+tool|\\s+to\\s)`, "g")
+    result = result.replace(toolPattern, kiroTool)
+  }
+
+  // 5. Transform @agent-name references (only for known agent names)
+  if (knownAgentNames.length > 0) {
+    const escapedNames = knownAgentNames.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+    const agentRefPattern = new RegExp(`@(${escapedNames.join("|")})\\b`, "g")
+    result = result.replace(agentRefPattern, (_match, agentName: string) => {
+      return `the ${normalizeName(agentName)} agent`
+    })
+  }
+
+  return result
+}
+
+function convertMcpServers(
+  servers?: Record<string, ClaudeMcpServer>,
+): Record<string, KiroMcpServer> {
+  if (!servers || Object.keys(servers).length === 0) return {}
+
+  const result: Record<string, KiroMcpServer> = {}
+  for (const [name, server] of Object.entries(servers)) {
+    if (!server.command) {
+      console.warn(
+        `Warning: MCP server "${name}" has no command (HTTP/SSE transport). Kiro only supports stdio. Skipping.`,
+      )
+      continue
+    }
+
+    const entry: KiroMcpServer = { 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
+
+    console.log(`MCP server "${name}" will execute: ${server.command}${server.args ? " " + server.args.join(" ") : ""}`)
+    result[name] = entry
+  }
+  return result
+}
+
+function buildSteeringFiles(plugin: ClaudePlugin, knownAgentNames: string[]): KiroSteeringFile[] {
+  const claudeMdPath = path.join(plugin.root, "CLAUDE.md")
+  if (!existsSync(claudeMdPath)) return []
+
+  let content: string
+  try {
+    content = readFileSync(claudeMdPath, "utf8")
+  } catch {
+    return []
+  }
+
+  if (!content || content.trim().length === 0) return []
+
+  const transformed = transformContentForKiro(content, knownAgentNames)
+  return [{ name: "compound-engineering", content: transformed }]
+}
+
+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, "-") // Collapse consecutive hyphens (Agent Skills standard)
+    .replace(/^-+|-+$/g, "")
+
+  // Enforce max length (truncate at last hyphen boundary)
+  if (normalized.length > KIRO_SKILL_NAME_MAX_LENGTH) {
+    normalized = normalized.slice(0, KIRO_SKILL_NAME_MAX_LENGTH)
+    const lastHyphen = normalized.lastIndexOf("-")
+    if (lastHyphen > 0) {
+      normalized = normalized.slice(0, lastHyphen)
+    }
+    normalized = normalized.replace(/-+$/g, "")
+  }
+
+  // Ensure name starts with a letter
+  if (normalized.length === 0 || !/^[a-z]/.test(normalized)) {
+    return "item"
+  }
+
+  return normalized
+}
+
+function sanitizeDescription(value: string, maxLength = KIRO_DESCRIPTION_MAX_LENGTH): string {
+  const normalized = value.replace(/\s+/g, " ").trim()
+  if (normalized.length <= maxLength) return normalized
+  const ellipsis = "..."
+  return normalized.slice(0, Math.max(0, maxLength - ellipsis.length)).trimEnd() + ellipsis
+}
+
+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/converters/claude-to-openclaw.ts

@@ -0,0 +1,240 @@
+import { formatFrontmatter } from "../utils/frontmatter"
+import type {
+  ClaudeAgent,
+  ClaudeCommand,
+  ClaudePlugin,
+  ClaudeMcpServer,
+} from "../types/claude"
+import type {
+  OpenClawBundle,
+  OpenClawCommandRegistration,
+  OpenClawPluginManifest,
+  OpenClawSkillFile,
+} from "../types/openclaw"
+import type { ClaudeToOpenCodeOptions } from "./claude-to-opencode"
+
+export type ClaudeToOpenClawOptions = ClaudeToOpenCodeOptions
+
+export function convertClaudeToOpenClaw(
+  plugin: ClaudePlugin,
+  _options: ClaudeToOpenClawOptions,
+): OpenClawBundle {
+  const enabledCommands = plugin.commands.filter((cmd) => !cmd.disableModelInvocation)
+
+  const agentSkills = plugin.agents.map(convertAgentToSkill)
+  const commandSkills = enabledCommands.map(convertCommandToSkill)
+  const commands = enabledCommands.map(convertCommand)
+
+  const skills: OpenClawSkillFile[] = [...agentSkills, ...commandSkills]
+
+  const skillDirCopies = plugin.skills.map((skill) => ({
+    sourceDir: skill.sourceDir,
+    name: skill.name,
+  }))
+
+  const allSkillDirs = [
+    ...agentSkills.map((s) => s.dir),
+    ...commandSkills.map((s) => s.dir),
+    ...plugin.skills.map((s) => s.name),
+  ]
+
+  const manifest = buildManifest(plugin, allSkillDirs)
+
+  const packageJson = buildPackageJson(plugin)
+
+  const openclawConfig = plugin.mcpServers
+    ? buildOpenClawConfig(plugin.mcpServers)
+    : undefined
+
+  const entryPoint = generateEntryPoint(commands)
+
+  return {
+    manifest,
+    packageJson,
+    entryPoint,
+    skills,
+    skillDirCopies,
+    commands,
+    openclawConfig,
+  }
+}
+
+function buildManifest(plugin: ClaudePlugin, skillDirs: string[]): OpenClawPluginManifest {
+  return {
+    id: plugin.manifest.name,
+    name: formatDisplayName(plugin.manifest.name),
+    kind: "tool",
+    skills: skillDirs.map((dir) => `skills/${dir}`),
+  }
+}
+
+function buildPackageJson(plugin: ClaudePlugin): Record<string, unknown> {
+  return {
+    name: `openclaw-${plugin.manifest.name}`,
+    version: plugin.manifest.version,
+    type: "module",
+    private: true,
+    description: plugin.manifest.description,
+    main: "index.ts",
+    openclaw: {
+      extensions: [
+        {
+          id: plugin.manifest.name,
+          entry: "./index.ts",
+        },
+      ],
+    },
+    keywords: [
+      "openclaw",
+      "openclaw-plugin",
+      ...(plugin.manifest.keywords ?? []),
+    ],
+  }
+}
+
+function convertAgentToSkill(agent: ClaudeAgent): OpenClawSkillFile {
+  const frontmatter: Record<string, unknown> = {
+    name: agent.name,
+    description: agent.description,
+  }
+
+  if (agent.model && agent.model !== "inherit") {
+    frontmatter.model = agent.model
+  }
+
+  const body = rewritePaths(agent.body)
+  const content = formatFrontmatter(frontmatter, body)
+
+  return {
+    name: agent.name,
+    content,
+    dir: `agent-${agent.name}`,
+  }
+}
+
+function convertCommandToSkill(command: ClaudeCommand): OpenClawSkillFile {
+  const frontmatter: Record<string, unknown> = {
+    name: `cmd-${command.name}`,
+    description: command.description,
+  }
+
+  if (command.model && command.model !== "inherit") {
+    frontmatter.model = command.model
+  }
+
+  const body = rewritePaths(command.body)
+  const content = formatFrontmatter(frontmatter, body)
+
+  return {
+    name: command.name,
+    content,
+    dir: `cmd-${command.name}`,
+  }
+}
+
+function convertCommand(command: ClaudeCommand): OpenClawCommandRegistration {
+  return {
+    name: command.name.replace(/:/g, "-"),
+    description: command.description ?? `Run ${command.name}`,
+    acceptsArgs: Boolean(command.argumentHint),
+    body: rewritePaths(command.body),
+  }
+}
+
+function buildOpenClawConfig(
+  servers: Record<string, ClaudeMcpServer>,
+): Record<string, unknown> {
+  const mcpServers: Record<string, unknown> = {}
+
+  for (const [name, server] of Object.entries(servers)) {
+    if (server.command) {
+      mcpServers[name] = {
+        type: "stdio",
+        command: server.command,
+        args: server.args ?? [],
+        env: server.env,
+      }
+    } else if (server.url) {
+      mcpServers[name] = {
+        type: "http",
+        url: server.url,
+        headers: server.headers,
+      }
+    }
+  }
+
+  return { mcpServers }
+}
+
+function generateEntryPoint(commands: OpenClawCommandRegistration[]): string {
+  const commandRegistrations = commands
+    .map((cmd) => {
+      // JSON.stringify produces a fully-escaped string literal safe for JS/TS source embedding
+      const safeName = JSON.stringify(cmd.name)
+      const safeDesc = JSON.stringify(cmd.description ?? "")
+      const safeNotFound = JSON.stringify(`Command ${cmd.name} not found. Check skills directory.`)
+      return `  api.registerCommand({
+    name: ${safeName},
+    description: ${safeDesc},
+    acceptsArgs: ${cmd.acceptsArgs},
+    requireAuth: false,
+    handler: (ctx) => ({
+      text: skills[${safeName}] ?? ${safeNotFound},
+    }),
+  });`
+    })
+    .join("\n\n")
+
+  return `// Auto-generated OpenClaw plugin entry point
+// Converted from Claude Code plugin format by compound-plugin CLI
+import { promises as fs } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Pre-load skill bodies for command responses
+const skills: Record<string, string> = {};
+
+async function loadSkills() {
+  const skillsDir = path.join(__dirname, "skills");
+  try {
+    const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillPath = path.join(skillsDir, entry.name, "SKILL.md");
+      try {
+        const content = await fs.readFile(skillPath, "utf8");
+        // Strip frontmatter
+        const body = content.replace(/^---[\\s\\S]*?---\\n*/, "");
+        skills[entry.name.replace(/^cmd-/, "")] = body.trim();
+      } catch {
+        // Skill file not found, skip
+      }
+    }
+  } catch {
+    // Skills directory not found
+  }
+}
+
+export default async function register(api) {
+  await loadSkills();
+
+${commandRegistrations}
+}
+`
+}
+
+function rewritePaths(body: string): string {
+  return body
+    .replace(/(?<=^|\s|["'`])~\/\.claude\//gm, "~/.openclaw/")
+    .replace(/(?<=^|\s|["'`])\.claude\//gm, ".openclaw/")
+    .replace(/\.claude-plugin\//g, "openclaw-plugin/")
+}
+
+function formatDisplayName(name: string): string {
+  return name
+    .split("-")
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(" ")
+}

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

@@ -8,7 +8,7 @@ import type {
 } from "../types/claude"
 import type {
   OpenCodeBundle,
-  OpenCodeCommandConfig,
+  OpenCodeCommandFile,
   OpenCodeConfig,
   OpenCodeMcpServer,
 } from "../types/opencode"
@@ -66,13 +66,12 @@ export function convertClaudeToOpenCode(
   options: ClaudeToOpenCodeOptions,
 ): OpenCodeBundle {
   const agentFiles = plugin.agents.map((agent) => convertAgent(agent, options))
-  const commandMap = convertCommands(plugin.commands)
+  const cmdFiles = convertCommands(plugin.commands)
   const mcp = plugin.mcpServers ? convertMcp(plugin.mcpServers) : undefined
   const plugins = plugin.hooks ? [convertHooks(plugin.hooks)] : []
 
   const config: OpenCodeConfig = {
     $schema: "https://opencode.ai/config.json",
-    command: Object.keys(commandMap).length > 0 ? commandMap : undefined,
     mcp: mcp && Object.keys(mcp).length > 0 ? mcp : undefined,
   }
 
@@ -81,6 +80,7 @@ export function convertClaudeToOpenCode(
   return {
     config,
     agents: agentFiles,
+    commandFiles: cmdFiles,
     plugins,
     skillDirs: plugin.skills.map((skill) => ({ sourceDir: skill.sourceDir, name: skill.name })),
   }
@@ -111,20 +111,22 @@ function convertAgent(agent: ClaudeAgent, options: ClaudeToOpenCodeOptions) {
   }
 }
 
-function convertCommands(commands: ClaudeCommand[]): Record<string, OpenCodeCommandConfig> {
-  const result: Record<string, OpenCodeCommandConfig> = {}
+// Commands are written as individual .md files rather than entries in opencode.json.
+// Chosen over JSON map because opencode resolves commands by filename at runtime (ADR-001).
+function convertCommands(commands: ClaudeCommand[]): OpenCodeCommandFile[] {
+  const files: OpenCodeCommandFile[] = []
   for (const command of commands) {
     if (command.disableModelInvocation) continue
-    const entry: OpenCodeCommandConfig = {
+    const frontmatter: Record<string, unknown> = {
       description: command.description,
-      template: rewriteClaudePaths(command.body),
     }
     if (command.model && command.model !== "inherit") {
-      entry.model = normalizeModel(command.model)
+      frontmatter.model = normalizeModel(command.model)
     }
-    result[command.name] = entry
+    const content = formatFrontmatter(frontmatter, rewriteClaudePaths(command.body))
+    files.push({ name: command.name, content })
   }
-  return result
+  return files
 }
 
 function convertMcp(servers: Record<string, ClaudeMcpServer>): Record<string, OpenCodeMcpServer> {