opencastle 0.1.0

package/src/cli/adapters/claude-code.ts

@@ -0,0 +1,287 @@
+import { resolve, basename } from 'node:path'
+import { mkdir, writeFile, readdir, readFile, unlink, rm } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { copyDir, getOrchestratorRoot } from '../copy.js'
+import { scaffoldMcpConfig } from '../mcp.js'
+import { getExcludedSkills, getExcludedAgents, getCustomizationsTransform } from '../stack-config.js'
+import type { CopyResults, ManagedPaths, StackConfig } from '../types.js'
+
+/**
+ * Claude Code adapter.
+ *
+ * Generates CLAUDE.md (root instructions) and .claude/ structure.
+ *
+ *   copilot-instructions.md    → CLAUDE.md  (combined with instructions/)
+ *   skills/\*\/SKILL.md         → .claude/skills/<name>.md
+ *   agent-workflows/*.md       → .claude/commands/workflow-<name>.md
+ *   prompts/*.prompt.md        → .claude/commands/<name>.md
+ *   customizations/            → .claude/customizations/  (scaffolded once)
+ *
+ * Note: Claude Code has no "agents" concept. Agent definitions are embedded
+ *       as reference sections within CLAUDE.md so Claude can adopt personas
+ *       when asked.
+ */
+
+export const IDE_ID = 'claude-code'
+export const IDE_LABEL = 'Claude Code'
+
+// ─── Helpers ──────────────────────────────────────────────────────
+
+function stripFrontmatter(content: string): string {
+  const m = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
+  return m ? m[2].trim() : content.trim()
+}
+
+function parseFrontmatterMeta(content: string): Record<string, string> {
+  const m = content.match(/^---\n([\s\S]*?)\n---/)
+  if (!m) return {}
+  const meta: Record<string, string> = {}
+  for (const line of m[1].split('\n')) {
+    const kv = line.match(/^(\w[\w-]*):\s*['"]?(.+?)['"]?\s*$/)
+    if (kv) meta[kv[1]] = kv[2]
+  }
+  return meta
+}
+
+// ─── Install ──────────────────────────────────────────────────────
+
+export async function install(
+  pkgRoot: string,
+  projectRoot: string,
+  stack?: StackConfig
+): Promise<CopyResults> {
+  const srcRoot = getOrchestratorRoot(pkgRoot)
+  const results: CopyResults = { copied: [], skipped: [], created: [] }
+
+  const excludedSkills = stack ? getExcludedSkills(stack) : new Set<string>()
+  const excludedAgents = stack ? getExcludedAgents(stack) : new Set<string>()
+
+  // 1. Build CLAUDE.md ← copilot-instructions + instructions/* + agent index + skill index
+  const claudeMd = resolve(projectRoot, 'CLAUDE.md')
+  if (!existsSync(claudeMd)) {
+    const sections: string[] = []
+
+    // Main instructions
+    const main = await readFile(
+      resolve(srcRoot, 'copilot-instructions.md'),
+      'utf8'
+    )
+    sections.push(stripFrontmatter(main))
+
+    // Always-loaded instruction files
+    const instDir = resolve(srcRoot, 'instructions')
+    if (existsSync(instDir)) {
+      for (const file of (await readdir(instDir)).sort()) {
+        if (!file.endsWith('.md')) continue
+        const content = await readFile(resolve(instDir, file), 'utf8')
+        sections.push(
+          `\n---\n\n<!-- Source: instructions/${file} -->\n\n${stripFrontmatter(content)}`
+        )
+      }
+    }
+
+    // Agent reference (so Claude can adopt personas)
+    const agentsDir = resolve(srcRoot, 'agents')
+    if (existsSync(agentsDir)) {
+      const agentLines: string[] = ['\n---\n\n## Agent Definitions\n']
+      agentLines.push(
+        'The following agent personas are available. Adopt the appropriate persona when asked.\n'
+      )
+      for (const file of (await readdir(agentsDir)).sort()) {
+        if (!file.endsWith('.md')) continue
+        if (excludedAgents.has(file)) continue
+        const meta = parseFrontmatterMeta(
+          await readFile(resolve(agentsDir, file), 'utf8')
+        )
+        const name = meta['name'] ?? basename(file, '.agent.md')
+        const desc = meta['description'] ?? ''
+        agentLines.push(`- **${name}**: ${desc}`)
+      }
+      agentLines.push(
+        '\nFull agent definitions are in `.claude/agents/`. Read the relevant file when adopting a persona.'
+      )
+      sections.push(agentLines.join('\n'))
+    }
+
+    // Skill index
+    const skillsDir = resolve(srcRoot, 'skills')
+    if (existsSync(skillsDir)) {
+      const skillLines: string[] = ['\n---\n\n## Available Skills\n']
+      skillLines.push(
+        'Skills are on-demand knowledge files. Read the file when the task matches.\n'
+      )
+      const subdirs = (
+        await readdir(skillsDir, { withFileTypes: true })
+      ).filter((e) => e.isDirectory())
+      for (const entry of subdirs.sort((a, b) =>
+        a.name.localeCompare(b.name)
+      )) {
+        if (excludedSkills.has(entry.name)) continue
+        const skillFile = resolve(skillsDir, entry.name, 'SKILL.md')
+        if (!existsSync(skillFile)) continue
+        const meta = parseFrontmatterMeta(await readFile(skillFile, 'utf8'))
+        const desc = meta['description'] ?? ''
+        skillLines.push(
+          `- **${entry.name}** (\`.claude/skills/${entry.name}.md\`): ${desc}`
+        )
+      }
+      sections.push(skillLines.join('\n'))
+    }
+
+    await writeFile(claudeMd, sections.join('\n') + '\n')
+    results.created.push(claudeMd)
+  } else {
+    results.skipped.push(claudeMd)
+  }
+
+  const claudeDir = resolve(projectRoot, '.claude')
+
+  // 2. Agent definitions → .claude/agents/
+  const agentsDir = resolve(srcRoot, 'agents')
+  if (existsSync(agentsDir)) {
+    const destAgents = resolve(claudeDir, 'agents')
+    await mkdir(destAgents, { recursive: true })
+    for (const file of await readdir(agentsDir)) {
+      if (!file.endsWith('.md')) continue
+      if (excludedAgents.has(file)) continue
+      const destPath = resolve(destAgents, file)
+      if (existsSync(destPath)) {
+        results.skipped.push(destPath)
+        continue
+      }
+      const content = await readFile(resolve(agentsDir, file), 'utf8')
+      await writeFile(destPath, stripFrontmatter(content) + '\n')
+      results.created.push(destPath)
+    }
+  }
+
+  // 3. Skills → .claude/skills/<name>.md
+  const skillsDir = resolve(srcRoot, 'skills')
+  if (existsSync(skillsDir)) {
+    const destSkills = resolve(claudeDir, 'skills')
+    await mkdir(destSkills, { recursive: true })
+    const subdirs = (
+      await readdir(skillsDir, { withFileTypes: true })
+    ).filter((e) => e.isDirectory())
+    for (const entry of subdirs) {
+      if (excludedSkills.has(entry.name)) continue
+      const skillFile = resolve(skillsDir, entry.name, 'SKILL.md')
+      if (!existsSync(skillFile)) continue
+      const destPath = resolve(destSkills, `${entry.name}.md`)
+      if (existsSync(destPath)) {
+        results.skipped.push(destPath)
+        continue
+      }
+      const content = await readFile(skillFile, 'utf8')
+      await writeFile(destPath, stripFrontmatter(content) + '\n')
+      results.created.push(destPath)
+    }
+  }
+
+  // 4. Prompts → .claude/commands/<name>.md
+  const promptDir = resolve(srcRoot, 'prompts')
+  if (existsSync(promptDir)) {
+    const destCmds = resolve(claudeDir, 'commands')
+    await mkdir(destCmds, { recursive: true })
+    for (const file of await readdir(promptDir)) {
+      if (!file.endsWith('.md')) continue
+      const name = basename(file, '.prompt.md') || basename(file, '.md')
+      const destPath = resolve(destCmds, `${name}.md`)
+      if (existsSync(destPath)) {
+        results.skipped.push(destPath)
+        continue
+      }
+      const content = await readFile(resolve(promptDir, file), 'utf8')
+      await writeFile(destPath, stripFrontmatter(content) + '\n')
+      results.created.push(destPath)
+    }
+  }
+
+  // 5. Agent Workflows → .claude/commands/workflow-<name>.md
+  const wfDir = resolve(srcRoot, 'agent-workflows')
+  if (existsSync(wfDir)) {
+    const destCmds = resolve(claudeDir, 'commands')
+    await mkdir(destCmds, { recursive: true })
+    for (const file of await readdir(wfDir)) {
+      if (!file.endsWith('.md')) continue
+      const name = basename(file, '.md')
+      const destPath = resolve(destCmds, `workflow-${name}.md`)
+      if (existsSync(destPath)) {
+        results.skipped.push(destPath)
+        continue
+      }
+      const content = await readFile(resolve(wfDir, file), 'utf8')
+      await writeFile(destPath, stripFrontmatter(content) + '\n')
+      results.created.push(destPath)
+    }
+  }
+
+  // 6. Customizations (scaffold once, pre-populated with stack choices)
+  const custDir = resolve(srcRoot, 'customizations')
+  if (existsSync(custDir)) {
+    const destCust = resolve(claudeDir, 'customizations')
+    const custTransform = stack ? getCustomizationsTransform(stack) : undefined
+    const sub = await copyDir(custDir, destCust, { transform: custTransform })
+    results.created.push(...sub.created)
+    results.skipped.push(...sub.skipped)
+  }
+
+  // 7. MCP server config → .claude/mcp.json (scaffold once)
+  const mcpResult = await scaffoldMcpConfig(
+    pkgRoot,
+    projectRoot,
+    '.claude/mcp.json',
+    stack
+  )
+  results[mcpResult.action].push(mcpResult.path)
+
+  return results
+}
+
+// ─── Update ───────────────────────────────────────────────────────
+
+export async function update(
+  pkgRoot: string,
+  projectRoot: string,
+  stack?: StackConfig
+): Promise<CopyResults> {
+  const results: CopyResults = { copied: [], skipped: [], created: [] }
+  const claudeDir = resolve(projectRoot, '.claude')
+
+  // 1. Regenerate CLAUDE.md (overwrite)
+  const claudeMd = resolve(projectRoot, 'CLAUDE.md')
+  if (existsSync(claudeMd)) {
+    await unlink(claudeMd)
+  }
+
+  // 2. Remove existing framework files so install() recreates them
+  const frameworkDirs = ['agents', 'skills', 'commands']
+  for (const dir of frameworkDirs) {
+    const dirPath = resolve(claudeDir, dir)
+    if (existsSync(dirPath)) {
+      await rm(dirPath, { recursive: true })
+    }
+  }
+
+  // 3. Re-run full install (CLAUDE.md + agents + skills + commands)
+  const installResult = await install(pkgRoot, projectRoot, stack)
+  // Everything install created is an "update" copy
+  results.copied.push(...installResult.created)
+  results.skipped.push(...installResult.skipped)
+
+  return results
+}
+
+// ─── Managed paths ────────────────────────────────────────────────
+
+export function getManagedPaths(): ManagedPaths {
+  return {
+    framework: [
+      'CLAUDE.md',
+      '.claude/agents/',
+      '.claude/skills/',
+      '.claude/commands/',
+    ],
+    customizable: ['.claude/customizations/', '.claude/mcp.json'],
+  }
+}

package/src/cli/adapters/cursor.ts

@@ -0,0 +1,377 @@
+import { resolve, basename } from 'node:path'
+import { mkdir, writeFile, readdir, readFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { copyDir, getOrchestratorRoot, removeDirIfExists } from '../copy.js'
+import { scaffoldMcpConfig } from '../mcp.js'
+import { getExcludedSkills, getExcludedAgents, getCustomizationsTransform } from '../stack-config.js'
+import type { CopyResults, ManagedPaths, StackConfig } from '../types.js'
+
+/**
+ * Cursor adapter.
+ *
+ * Transforms Copilot-format orchestrator files into Cursor's .mdc rule format.
+ *
+ *   copilot-instructions.md    → .cursorrules
+ *   instructions/*.md          → .cursor/rules/*.mdc            (alwaysApply: true)
+ *   agents/*.agent.md          → .cursor/rules/agents/*.mdc     (description-triggered)
+ *   skills/\*\/SKILL.md         → .cursor/rules/skills/*.mdc     (alwaysApply: false)
+ *   agent-workflows/*.md       → .cursor/rules/agent-workflows/*.mdc
+ *   prompts/*.prompt.md        → .cursor/rules/prompts/*.mdc
+ *   customizations/            → .cursor/rules/customizations/  (scaffolded once)
+ */
+
+export const IDE_ID = 'cursor'
+export const IDE_LABEL = 'Cursor'
+
+// ─── Helpers ──────────────────────────────────────────────────────
+
+interface FrontmatterResult {
+  frontmatter: string
+  body: string
+}
+
+function stripFrontmatter(content: string): FrontmatterResult {
+  const m = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
+  return m
+    ? { frontmatter: m[1], body: m[2] }
+    : { frontmatter: '', body: content }
+}
+
+function parseFrontmatter(fm: string): Record<string, string> {
+  const result: Record<string, string> = {}
+  for (const line of fm.split('\n')) {
+    const m = line.match(/^(\w[\w-]*):\s*['"]?(.+?)['"]?\s*$/)
+    if (m) result[m[1]] = m[2]
+  }
+  return result
+}
+
+interface MdcOptions {
+  description?: string
+  globs?: string[]
+  alwaysApply: boolean
+  body: string
+}
+
+function toMdc({ description, globs, alwaysApply, body }: MdcOptions): string {
+  const lines = ['---']
+  if (description) lines.push(`description: "${description}"`)
+  if (globs) lines.push(`globs: ${JSON.stringify(globs)}`)
+  lines.push(`alwaysApply: ${alwaysApply ? 'true' : 'false'}`)
+  lines.push('---', '', body.trim(), '')
+  return lines.join('\n')
+}
+
+/** Convert a source filename to .mdc, stripping intermediate extensions. */
+function mdcName(name: string): string {
+  // Handle compound extensions like .agent.md, .instructions.md, .prompt.md
+  const compound = name.replace(/\.(agent|instructions|prompt)\.md$/, '.mdc')
+  if (compound !== name) return compound
+  // Handle plain .md files
+  return name.replace(/\.md$/, '.mdc')
+}
+
+interface ConvertFileOptions {
+  alwaysApply?: boolean
+  descriptionFallback?: string
+}
+
+/** Read a source .md and produce an .mdc string. */
+async function convertFile(
+  srcPath: string,
+  { alwaysApply = false, descriptionFallback = '' }: ConvertFileOptions = {}
+): Promise<string> {
+  const content = await readFile(srcPath, 'utf8')
+  const { frontmatter, body } = stripFrontmatter(content)
+  const meta = parseFrontmatter(frontmatter)
+
+  // Description: frontmatter > fallback > first heading
+  let description = meta['description'] ?? descriptionFallback
+  if (!description) {
+    const heading = body.match(/^#\s+(.+)/m)
+    if (heading) description = heading[1]
+  }
+
+  // If applyTo is '**' the rule should always apply
+  const globs = meta['applyTo'] ? [meta['applyTo']] : undefined
+  const apply = meta['applyTo'] === '**' ? true : alwaysApply
+
+  return toMdc({ description, globs, alwaysApply: apply, body: body.trim() })
+}
+
+/** Write a converted file; skip if it already exists (unless overwrite). */
+async function writeConverted(
+  srcPath: string,
+  destPath: string,
+  opts: ConvertFileOptions,
+  results: CopyResults,
+  overwrite = false
+): Promise<void> {
+  if (!overwrite && existsSync(destPath)) {
+    results.skipped.push(destPath)
+    return
+  }
+  const existed = existsSync(destPath)
+  const mdc = await convertFile(srcPath, opts)
+  await writeFile(destPath, mdc)
+  results[existed ? 'copied' : 'created'].push(destPath)
+}
+
+// ─── Install ──────────────────────────────────────────────────────
+
+export async function install(
+  pkgRoot: string,
+  projectRoot: string,
+  stack?: StackConfig
+): Promise<CopyResults> {
+  const srcRoot = getOrchestratorRoot(pkgRoot)
+  const results: CopyResults = { copied: [], skipped: [], created: [] }
+
+  const excludedSkills = stack ? getExcludedSkills(stack) : new Set<string>()
+  const excludedAgents = stack ? getExcludedAgents(stack) : new Set<string>()
+
+  // 1. .cursorrules  ← copilot-instructions.md (body only)
+  const cursorrules = resolve(projectRoot, '.cursorrules')
+  if (!existsSync(cursorrules)) {
+    const { body } = stripFrontmatter(
+      await readFile(resolve(srcRoot, 'copilot-instructions.md'), 'utf8')
+    )
+    await writeFile(cursorrules, body.trim() + '\n')
+    results.created.push(cursorrules)
+  } else {
+    results.skipped.push(cursorrules)
+  }
+
+  const rulesRoot = resolve(projectRoot, '.cursor', 'rules')
+  await mkdir(rulesRoot, { recursive: true })
+
+  // 2. Instructions → .cursor/rules/*.mdc  (alwaysApply: true)
+  await convertDir(srcRoot, 'instructions', rulesRoot, results, {
+    alwaysApply: true,
+  })
+
+  // 3. Agents → .cursor/rules/agents/*.mdc
+  await convertDir(srcRoot, 'agents', resolve(rulesRoot, 'agents'), results, {
+    descriptionPrefix: 'Agent: ',
+    removeExt: '.agent.md',
+    excludeFiles: excludedAgents,
+  })
+
+  // 4. Skills → .cursor/rules/skills/*.mdc
+  await convertSkills(srcRoot, resolve(rulesRoot, 'skills'), results, false, excludedSkills)
+
+  // 5. Agent Workflows → .cursor/rules/agent-workflows/*.mdc
+  await convertDir(
+    srcRoot,
+    'agent-workflows',
+    resolve(rulesRoot, 'agent-workflows'),
+    results,
+    { descriptionPrefix: 'Workflow: ' }
+  )
+
+  // 6. Prompts → .cursor/rules/prompts/*.mdc
+  await convertDir(srcRoot, 'prompts', resolve(rulesRoot, 'prompts'), results, {
+    descriptionPrefix: 'Prompt: ',
+    removeExt: '.prompt.md',
+  })
+
+  // 7. Customizations (scaffold once, pre-populated with stack choices)
+  const custSrc = resolve(srcRoot, 'customizations')
+  if (existsSync(custSrc)) {
+    const custDest = resolve(rulesRoot, 'customizations')
+    const custTransform = stack ? getCustomizationsTransform(stack) : undefined
+    const sub = await copyDir(custSrc, custDest, { transform: custTransform })
+    results.created.push(...sub.created)
+    results.skipped.push(...sub.skipped)
+  }
+
+  // 8. MCP server config → .cursor/mcp.json (scaffold once)
+  const mcpResult = await scaffoldMcpConfig(
+    pkgRoot,
+    projectRoot,
+    '.cursor/mcp.json',
+    stack
+  )
+  results[mcpResult.action].push(mcpResult.path)
+
+  return results
+}
+
+// ─── Update ───────────────────────────────────────────────────────
+
+export async function update(
+  pkgRoot: string,
+  projectRoot: string,
+  stack?: StackConfig
+): Promise<CopyResults> {
+  const srcRoot = getOrchestratorRoot(pkgRoot)
+  const results: CopyResults = { copied: [], skipped: [], created: [] }
+
+  const excludedSkills = stack ? getExcludedSkills(stack) : new Set<string>()
+  const excludedAgents = stack ? getExcludedAgents(stack) : new Set<string>()
+
+  // Overwrite .cursorrules
+  const { body } = stripFrontmatter(
+    await readFile(resolve(srcRoot, 'copilot-instructions.md'), 'utf8')
+  )
+  await writeFile(resolve(projectRoot, '.cursorrules'), body.trim() + '\n')
+  results.copied.push('.cursorrules')
+
+  const rulesRoot = resolve(projectRoot, '.cursor', 'rules')
+
+  // Remove existing framework rule directories to clear stale files
+  const FRAMEWORK_RULE_DIRS = ['agents', 'skills', 'agent-workflows', 'prompts']
+  for (const dir of FRAMEWORK_RULE_DIRS) {
+    await removeDirIfExists(resolve(rulesRoot, dir))
+  }
+
+  // Overwrite framework rules
+  await convertDir(srcRoot, 'instructions', rulesRoot, results, {
+    alwaysApply: true,
+    overwrite: true,
+  })
+  await convertDir(
+    srcRoot,
+    'agents',
+    resolve(rulesRoot, 'agents'),
+    results,
+    { descriptionPrefix: 'Agent: ', removeExt: '.agent.md', overwrite: true, excludeFiles: excludedAgents }
+  )
+  await convertSkills(srcRoot, resolve(rulesRoot, 'skills'), results, true, excludedSkills)
+  await convertDir(
+    srcRoot,
+    'agent-workflows',
+    resolve(rulesRoot, 'agent-workflows'),
+    results,
+    { descriptionPrefix: 'Workflow: ', overwrite: true }
+  )
+  await convertDir(
+    srcRoot,
+    'prompts',
+    resolve(rulesRoot, 'prompts'),
+    results,
+    { descriptionPrefix: 'Prompt: ', removeExt: '.prompt.md', overwrite: true }
+  )
+
+  // Customizations are NEVER overwritten.
+
+  // All re-installed framework files count as "updated" (copied), not "created"
+  results.copied.push(...results.created)
+  results.created = []
+
+  return results
+}
+
+// ─── Managed paths ────────────────────────────────────────────────
+
+export function getManagedPaths(): ManagedPaths {
+  return {
+    framework: [
+      '.cursorrules',
+      '.cursor/rules/agents/',
+      '.cursor/rules/skills/',
+      '.cursor/rules/agent-workflows/',
+      '.cursor/rules/prompts/',
+      '.cursor/rules/general.mdc',
+      '.cursor/rules/ai-optimization.mdc',
+    ],
+    customizable: [
+      '.cursor/rules/customizations/',
+      '.cursor/mcp.json',
+    ],
+  }
+}
+
+// ─── Internal helpers ─────────────────────────────────────────────
+
+interface ConvertDirOptions {
+  alwaysApply?: boolean
+  descriptionPrefix?: string
+  removeExt?: string
+  overwrite?: boolean
+  excludeFiles?: Set<string>
+}
+
+async function convertDir(
+  srcRoot: string,
+  dirName: string,
+  destDir: string,
+  results: CopyResults,
+  {
+    alwaysApply,
+    descriptionPrefix,
+    removeExt,
+    overwrite,
+    excludeFiles,
+  }: ConvertDirOptions = {}
+): Promise<void> {
+  const srcDir = resolve(srcRoot, dirName)
+  if (!existsSync(srcDir)) return
+
+  await mkdir(destDir, { recursive: true })
+
+  for (const file of await readdir(srcDir)) {
+    if (!file.endsWith('.md')) continue
+    if (excludeFiles?.has(file)) continue
+    const fallback = descriptionPrefix
+      ? `${descriptionPrefix}${basename(file, removeExt ?? '.md')}`
+      : ''
+    const destPath = resolve(destDir, mdcName(file))
+    await writeConverted(
+      resolve(srcDir, file),
+      destPath,
+      { alwaysApply: alwaysApply ?? false, descriptionFallback: fallback },
+      results,
+      overwrite
+    )
+  }
+}
+
+async function convertSkills(
+  srcRoot: string,
+  destDir: string,
+  results: CopyResults,
+  overwrite = false,
+  excludedSkills?: Set<string>
+): Promise<void> {
+  const skillsDir = resolve(srcRoot, 'skills')
+  if (!existsSync(skillsDir)) return
+
+  await mkdir(destDir, { recursive: true })
+
+  const subdirs = await readdir(skillsDir, { withFileTypes: true })
+  for (const entry of subdirs) {
+    if (!entry.isDirectory()) continue
+    if (excludedSkills?.has(entry.name)) continue
+    const skillFile = resolve(skillsDir, entry.name, 'SKILL.md')
+    if (!existsSync(skillFile)) continue
+
+    // Main skill → skills/<name>.mdc
+    const destPath = resolve(destDir, `${entry.name}.mdc`)
+    await writeConverted(
+      skillFile,
+      destPath,
+      { descriptionFallback: `Skill: ${entry.name}` },
+      results,
+      overwrite
+    )
+
+    // Extra files in the skill directory (e.g. templates)
+    const files = await readdir(resolve(skillsDir, entry.name))
+    const extras = files.filter((f) => f !== 'SKILL.md' && f.endsWith('.md'))
+    if (extras.length > 0) {
+      const subDest = resolve(destDir, entry.name)
+      await mkdir(subDest, { recursive: true })
+      for (const file of extras) {
+        const extraDest = resolve(subDest, mdcName(file))
+        await writeConverted(
+          resolve(skillsDir, entry.name, file),
+          extraDest,
+          { descriptionFallback: `${entry.name}: ${basename(file, '.md')}` },
+          results,
+          overwrite
+        )
+      }
+    }
+  }
+}