create-dwy 0.13.7 → 0.14.0

package/src/sync-codex.js

@@ -1,11 +1,10 @@
 import fs from 'fs-extra'
 import path from 'path'
-import os from 'os'
-import inquirer from 'inquirer'
 import { chalk } from './utils.js'
-import { groupedCheckbox } from './prompts/grouped-checkbox.js'
 import {
   extractDescription,
+  loadHookManifests,
+  readBaselineDoc,
   scanSkills,
   scanRules,
   scanHooks,
@@ -14,13 +13,10 @@ import {
   logAction,
 } from './sync.js'
 
-const CATEGORIES = [
-  { key: 'skills', label: 'Skills' },
-  { key: 'rules', label: 'Rules' },
-  { key: 'hooks', label: 'Hooks' },
-]
-
-const BLOCK_START = '<!-- DWY-RULES:START 由 dwy codex sync 生成，请勿手动编辑此区块 -->'
+const BASELINE_START = '<!-- DWY-BASELINE:START 由 dwy 交互式同步生成，请勿手动编辑此区块 -->'
+const BASELINE_END = '<!-- DWY-BASELINE:END -->'
+const BASELINE_RE = /<!-- DWY-BASELINE:START[\s\S]*?DWY-BASELINE:END -->/
+const BLOCK_START = '<!-- DWY-RULES:START 由 dwy 交互式同步生成，请勿手动编辑此区块 -->'
 const BLOCK_END = '<!-- DWY-RULES:END -->'
 const BLOCK_RE = /<!-- DWY-RULES:START[\s\S]*?DWY-RULES:END -->/
 
@@ -76,19 +72,56 @@ function upsertManagedBlock(content, blockBody) {
   return base ? `${base}\n\n${block}\n` : `${block}\n`
 }
 
-async function syncRulesToAgentsMd(selectedRules, proj, dryRun) {
-  const dest = path.join(proj, 'AGENTS.md')
-  const current = await fs.pathExists(dest) ? await fs.readFile(dest, 'utf-8') : ''
+function upsertBaselineBlock(content, baselineBody) {
+  if (!baselineBody.trim()) {
+    if (!BASELINE_RE.test(content)) return content
+    const next = content.replace(BASELINE_RE, '').replace(/\n{3,}/g, '\n\n').trimEnd()
+    return next ? `${next}\n` : ''
+  }
+
+  const block = `${BASELINE_START}\n\n${baselineBody.trim()}\n\n${BASELINE_END}`
+  if (BASELINE_RE.test(content)) return content.replace(BASELINE_RE, block)
 
+  const base = content.trimStart()
+  return base ? `${block}\n\n${base}` : `${block}\n`
+}
+
+export async function syncProjectAgentsMd(sourceDir, projectDir, selectedRules) {
+  const dest = path.join(projectDir, 'AGENTS.md')
+  const current = await fs.pathExists(dest) ? await fs.readFile(dest, 'utf-8') : ''
+  const baselineBody = await readBaselineDoc(sourceDir)
   const sections = []
-  for (const r of selectedRules) sections.push(await ruleToSection(r))
+  for (const rule of selectedRules) sections.push(await ruleToSection(rule))
   const blockBody = sections.join('\n\n---\n\n')
 
-  const next = upsertManagedBlock(current, blockBody)
+  const withBaseline = upsertBaselineBlock(current, baselineBody)
+  const next = upsertManagedBlock(withBaseline, blockBody)
   if (next === current) return 0
-  if (!dryRun) await fs.writeFile(dest, next)
-  const filled = blockBody.trim()
-  logAction(dryRun, `AGENTS.md — ${filled ? selectedRules.length + ' rules' : 'block removed'}`, filled ? 'green' : 'red', filled ? '✓' : '×')
+  await fs.writeFile(dest, next)
+  const parts = []
+  if (baselineBody.trim()) parts.push('baseline')
+  parts.push(blockBody.trim() ? `${selectedRules.length} rules` : 'rules removed')
+  logAction(`AGENTS.md — ${parts.join(', ')}`)
+  return 1
+}
+
+export async function clearProjectAgentsMd(projectDir) {
+  const dest = path.join(projectDir, 'AGENTS.md')
+  if (!await fs.pathExists(dest)) return 0
+
+  const current = await fs.readFile(dest, 'utf-8')
+  const withoutBaseline = upsertBaselineBlock(current, '')
+  const next = upsertManagedBlock(withoutBaseline, '')
+  if (next === current) return 0
+
+  if (!next.trim()) {
+    await fs.remove(dest)
+    logAction('AGENTS.md', 'red', '×')
+    return 1
+  }
+
+  await fs.writeFile(dest, next)
+  logAction('AGENTS.md — cleared', 'red', '×')
   return 1
 }
 
@@ -101,27 +134,25 @@ export async function scanExistingCodexSkills(proj) {
   return new Set(entries.filter(e => e.isDirectory()).map(e => e.name))
 }
 
-async function copySkillsFlat(skills, proj, dryRun) {
+async function copySkillsFlat(skills, proj) {
   const root = path.join(proj, '.agents', 'skills')
   for (const s of skills) {
     const dest = path.join(root, s.name)
-    if (!dryRun) {
-      await fs.ensureDir(path.dirname(dest))
-      await fs.copy(s.sourcePath, dest, { overwrite: true, filter: copyFilter })
-    }
-    logAction(dryRun, `.agents/skills/${s.name}`)
+    await fs.ensureDir(path.dirname(dest))
+    await fs.copy(s.sourcePath, dest, { overwrite: true, filter: copyFilter })
+    logAction(`.agents/skills/${s.name}`)
   }
   return skills.length
 }
 
-async function removeUnselectedFlat(subdir, existingNames, selectedNames, templateNames, proj, dryRun) {
+async function removeUnselectedFlat(subdir, existingNames, selectedNames, templateNames, proj) {
   let count = 0
   for (const name of existingNames) {
     if (selectedNames.has(name)) continue
     // 项目独有(模板未提供过)的条目永不删除,保留用户自定义
     if (!templateNames.has(name)) continue
-    if (!dryRun) await fs.remove(path.join(proj, ...subdir, name))
-    logAction(dryRun, `${subdir.join('/')}/${name}`, 'red', '×')
+    await fs.remove(path.join(proj, ...subdir, name))
+    logAction(`${subdir.join('/')}/${name}`, 'red', '×')
     count++
   }
   return count
@@ -136,175 +167,131 @@ export async function scanExistingCodexHooks(proj) {
   return new Set(entries.filter(n => n !== '.gitkeep' && n !== '.DS_Store'))
 }
 
-async function copyCodexHooks(hooks, proj, dryRun) {
+async function copyCodexHooks(hooks, proj) {
   if (hooks.length === 0) return 0
   const dir = path.join(proj, '.codex', 'hooks')
-  if (!dryRun) await fs.ensureDir(dir)
+  await fs.ensureDir(dir)
   for (const h of hooks) {
     const dest = path.join(dir, h.name)
-    if (!dryRun) {
-      await fs.copy(h.sourcePath, dest, { overwrite: true, filter: copyFilter })
-      await fs.chmod(dest, 0o755)
-    }
-    logAction(dryRun, `.codex/hooks/${h.name}`)
+    await fs.copy(h.sourcePath, dest, { overwrite: true, filter: copyFilter })
+    await fs.chmod(dest, 0o755)
+    logAction(`.codex/hooks/${h.name}`)
   }
   return hooks.length
 }
 
-function filterCodexHooksByNames(hooksJson, selectedNames) {
-  if (!hooksJson.hooks) return hooksJson
-  const cloned = JSON.parse(JSON.stringify(hooksJson))
-  const re = /\.codex\/hooks\/([^\s"']+)/
-
-  for (const event of Object.keys(cloned.hooks)) {
-    const kept = []
-    for (const cfg of cloned.hooks[event] || []) {
-      const remaining = (cfg.hooks || []).filter(h => {
-        const m = h.command?.match(re)
-        if (!m) return true
-        return selectedNames.has(m[1])
-      })
-      if (remaining.length > 0) kept.push({ ...cfg, hooks: remaining })
-    }
-    if (kept.length > 0) cloned.hooks[event] = kept
-    else delete cloned.hooks[event]
+function buildCodexHooksJson(manifests, selectedHookNames) {
+  const hooksJson = { hooks: {} }
+  const grouped = new Map()
+
+  for (const manifest of manifests) {
+    if (!selectedHookNames.has(manifest.name)) continue
+    if (manifest.platforms && !manifest.platforms.includes('codex')) continue
+
+    const event = manifest.event || 'PreToolUse'
+    const matcher = manifest.matcher || 'Bash'
+    const key = `${event}::${matcher}`
+    const hooks = grouped.get(key) || []
+    hooks.push({
+      type: 'command',
+      command: `bash \"$(git rev-parse --show-toplevel)\"/.codex/hooks/${manifest.name}`,
+      ...(manifest.timeout ? { timeout: manifest.timeout } : {}),
+    })
+    grouped.set(key, hooks)
   }
-  if (Object.keys(cloned.hooks).length === 0) delete cloned.hooks
-  return cloned
-}
-
-async function syncCodexHooksJson(hooksJsonSrc, proj, selectedHookNames, dryRun) {
-  if (!await fs.pathExists(hooksJsonSrc)) return 0
-  const dest = path.join(proj, '.codex', 'hooks.json')
-  const filtered = filterCodexHooksByNames(await fs.readJson(hooksJsonSrc), selectedHookNames)
 
-  if (!filtered.hooks) {
-    if (!await fs.pathExists(dest)) return 0
-    if (!dryRun) await fs.remove(dest)
-    logAction(dryRun, '.codex/hooks.json — removed', 'red', '×')
-    return 1
+  for (const [key, hooks] of grouped.entries()) {
+    const [event, matcher] = key.split('::')
+    hooksJson.hooks[event] ||= []
+    hooksJson.hooks[event].push({ matcher, hooks })
   }
 
-  if (!dryRun) {
-    await fs.ensureDir(path.dirname(dest))
-    await fs.writeJson(dest, filtered, { spaces: 2 })
-  }
-  logAction(dryRun, '.codex/hooks.json')
-  return 1
+  return Object.keys(hooksJson.hooks).length > 0 ? hooksJson : {}
 }
 
-// ---------- 交互选择 ----------
-
-async function promptSelection(items, label, defaultNames) {
-  if (items.length === 0) return []
-  return groupedCheckbox({ message: `选择 ${label}`, items, defaultSelected: defaultNames, pageSize: 15 })
+function isManagedCodexHookCommand(command, managedHookNames) {
+  if (typeof command !== 'string') return false
+  const match = command.match(/\.codex\/hooks\/([^\s'"]+)/)
+  return !!(match && managedHookNames.has(match[1]))
 }
 
-async function interactiveSelect(scans, existing) {
-  const sel = {}
-
-  let i = 0
-  while (i < CATEGORIES.length) {
-    const { key, label } = CATEGORIES[i]
-    const defaultNames = sel[key] ? new Set(sel[key].map(x => x.name)) : existing[key]
-    sel[key] = await promptSelection(scans[key], label, defaultNames)
-
-    if (i === CATEGORIES.length - 1) break
-
-    const nextLabel = CATEGORIES[i + 1].label
-    const prevLabel = i > 0 ? CATEGORIES[i - 1].label : null
-    const { nav } = await inquirer.prompt([{
-      type: 'list',
-      name: 'nav',
-      message: `${label} 已选 ${sel[key].length} 项。下一步：`,
-      choices: [
-        { name: `→ 继续选 ${nextLabel}`, value: 'next' },
-        ...(prevLabel ? [{ name: `← 返回重选 ${prevLabel}`, value: 'back' }] : []),
-        { name: '✗ 取消同步', value: 'cancel' },
-      ],
-      default: 'next',
-    }])
-    if (nav === 'cancel') return null
-    i = nav === 'back' ? i - 1 : i + 1
-  }
+function mergeCodexHooks(existingHooks, generatedHooks, managedHookNames) {
+  const merged = {}
+  const sourceEvents = new Set([
+    ...Object.keys(existingHooks || {}),
+    ...Object.keys(generatedHooks || {}),
+  ])
+
+  for (const event of sourceEvents) {
+    const kept = []
 
-  while (true) {
-    console.log(chalk.gray('\n选择汇总：'))
-    for (const { key, label } of CATEGORIES) {
-      console.log(chalk.gray(`  ${label.padEnd(10)} ${sel[key].length} 项`))
+    for (const cfg of existingHooks?.[event] || []) {
+      const remainingHooks = (cfg.hooks || []).filter(hook => !isManagedCodexHookCommand(hook.command, managedHookNames))
+      if (remainingHooks.length > 0) kept.push({ ...cfg, hooks: remainingHooks })
     }
-    const { final } = await inquirer.prompt([{
-      type: 'list',
-      name: 'final',
-      message: '确认提交还是重选？',
-      choices: [
-        { name: '✓ 确认提交', value: 'confirm' },
-        ...CATEGORIES.map(c => ({ name: `重选 ${c.label}`, value: c.key })),
-        { name: '✗ 取消同步', value: 'cancel' },
-      ],
-      default: 'confirm',
-    }])
-    if (final === 'confirm') return sel
-    if (final === 'cancel') return null
-    const cat = CATEGORIES.find(c => c.key === final)
-    sel[final] = await promptSelection(scans[final], cat.label, new Set(sel[final].map(x => x.name)))
+
+    for (const cfg of generatedHooks?.[event] || []) kept.push(cfg)
+    if (kept.length > 0) merged[event] = kept
   }
+
+  return Object.keys(merged).length > 0 ? merged : undefined
 }
 
-// ---------- 入口 ----------
+async function syncCodexHooksJson(sourceDir, proj, selectedHookNames) {
+  const dest = path.join(proj, '.codex', 'hooks.json')
+  const manifests = await loadHookManifests(sourceDir)
+  const generated = buildCodexHooksJson(manifests, selectedHookNames)
+  const managedHookNames = new Set(
+    manifests
+      .filter(manifest => !manifest.platforms || manifest.platforms.includes('codex'))
+      .map(manifest => manifest.name),
+  )
+
+  let nextJson
+  if (await fs.pathExists(dest)) {
+    const existing = await fs.readJson(dest)
+    const nextHooks = mergeCodexHooks(existing.hooks, generated.hooks, managedHookNames)
+    if (!nextHooks) {
+      if (!existing.hooks) return 0
+      const { hooks, ...rest } = existing
+      if (Object.keys(rest).length === 0) {
+        await fs.remove(dest)
+        logAction('.codex/hooks.json — removed', 'red', '×')
+        return 1
+      }
+      nextJson = rest
+    } else {
+      nextJson = { ...existing, hooks: nextHooks }
+    }
+  } else {
+    if (!generated.hooks) return 0
+    nextJson = generated
+  }
+
+  await fs.ensureDir(path.dirname(dest))
+  await fs.writeJson(dest, nextJson, { spaces: 2 })
+  logAction('.codex/hooks.json')
+  return 1
+}
 
-/**
- * 入口：`dwy codex sync [target]`
- *   target=undefined  同步到项目：rules→AGENTS.md / skills→.agents/skills / hooks→.codex
- *   target='md'       仅同步 CLAUDE.md → 全局 ~/.codex/AGENTS.md
- */
 export async function syncCodex({
-  target,
-  reselect = false,
-  dryRun = false,
   sourceDir: sourceDirOverride,
   projectDir,
-  selected: selectedOverride,
-  skipInitPrompt = false,
+  selected,
 } = {}) {
-  const claudeGlobal = sourceDirOverride || await resolveSourceDir()
-  if (!await fs.pathExists(claudeGlobal)) {
-    console.error(chalk.red('Error: claude-global templates not found in repo'))
-    process.exit(1)
+  const sourceDir = sourceDirOverride || await resolveSourceDir()
+  if (!await fs.pathExists(sourceDir)) {
+    throw new Error('ai-tools templates not found in repo')
   }
 
-  if (target === 'md') {
-    const src = path.join(claudeGlobal, 'CLAUDE.md')
-    if (!await fs.pathExists(src)) {
-      console.log(chalk.yellow('CLAUDE.md not found in templates, nothing to sync.'))
-      return
-    }
-    const dest = path.join(os.homedir(), '.codex', 'AGENTS.md')
-    console.log(chalk.blue(`\nSyncing CLAUDE.md → ${dest}...\n`))
-    if (!dryRun) {
-      await fs.ensureDir(path.dirname(dest))
-      await fs.copy(src, dest, { overwrite: true })
-    }
-    logAction(dryRun, dest)
-    console.log(chalk.blue(`\n${dryRun ? 'Dry-run complete.' : 'Done.'}`))
-    return
-  }
-
-  if (target !== undefined) {
-    console.error(chalk.red(`Error: unknown sync target "${target}". Supported: (none) | md`))
-    process.exit(2)
-  }
-
-  const codexGlobal = path.join(claudeGlobal, '..', 'codex-global')
-  const hooksJsonSrc = path.join(codexGlobal, 'hooks.json')
   const proj = projectDir || process.cwd()
 
   console.log(chalk.blue('\nScanning available config for Codex...\n'))
 
   const scans = {
-    skills: await scanSkills(claudeGlobal),
-    rules: await scanRules(claudeGlobal),
-    hooks: await scanHooks(codexGlobal),
+    skills: await scanSkills(sourceDir),
+    rules: await scanRules(sourceDir),
+    hooks: await scanHooks(sourceDir),
   }
   console.log(chalk.yellow(`Found ${scans.skills.length} skills, ${scans.rules.length} rules, ${scans.hooks.length} hooks\n`))
 
@@ -315,72 +302,30 @@ export async function syncCodex({
     rules: parseManagedRuleNames(agentsMdContent),
     hooks: await scanExistingCodexHooks(proj),
   }
-  const hasAnyExisting = existing.skills.size + existing.rules.size + existing.hooks.size > 0
-
-  if (!selectedOverride
-      && !skipInitPrompt
-      && !hasAnyExisting
-      && !await fs.pathExists(path.join(proj, '.codex'))
-      && !await fs.pathExists(path.join(proj, '.agents'))) {
-    const { ok } = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'ok',
-      message: `当前目录 ${chalk.yellow(proj)} 尚无 Codex 配置，是否在此初始化？`,
-      default: false,
-    }])
-    if (!ok) {
-      console.log(chalk.yellow('\n已取消同步。'))
-      return
-    }
-  }
-
-  let selected
-  if (selectedOverride) {
-    const selectedNames = key => new Set((selectedOverride[key] || []).map(item => item.name))
-    selected = {
-      skills: scans.skills.filter(item => selectedNames('skills').has(item.name)),
-      rules: scans.rules.filter(item => selectedNames('rules').has(item.name)),
-      hooks: scans.hooks.filter(item => selectedNames('hooks').has(item.name)),
-    }
-  } else if (!reselect && hasAnyExisting) {
-    selected = {
-      skills: scans.skills.filter(s => existing.skills.has(s.name)),
-      rules: scans.rules.filter(r => existing.rules.has(r.name)),
-      hooks: existing.hooks.size > 0 ? scans.hooks.filter(h => existing.hooks.has(h.name)) : scans.hooks,
-    }
-    console.log(chalk.gray('使用已选覆盖同步（如需调整请加 -i / --reselect）：'))
-    console.log(chalk.gray(`  ${selected.skills.length} skills, ${selected.rules.length} rules, ${selected.hooks.length} hooks\n`))
-  } else {
-    if (!reselect && !hasAnyExisting) console.log(chalk.gray('首次同步，进入交互式选择...\n'))
-    const result = await interactiveSelect(scans, existing)
-    if (result === null) {
-      console.log(chalk.yellow('\n已取消同步。'))
-      return
-    }
-    selected = result
+  const selectedNames = key => new Set((selected[key] || []).map(item => item.name))
+  const syncedSelection = {
+    skills: scans.skills.filter(item => selectedNames('skills').has(item.name)),
+    rules: scans.rules.filter(item => selectedNames('rules').has(item.name)),
+    hooks: scans.hooks.filter(item => selectedNames('hooks').has(item.name)),
   }
+  const selectedHookNames = new Set(syncedSelection.hooks.map(h => h.name))
 
-  const selectedHookNames = new Set(selected.hooks.map(h => h.name))
-
-  console.log(chalk.blue(`\n${dryRun ? '[dry-run] ' : ''}Syncing to ${proj}...\n`))
+  console.log(chalk.blue(`\nSyncing to ${proj}...\n`))
 
   let syncedCount = 0
   let removedCount = 0
 
-  syncedCount += await copySkillsFlat(selected.skills, proj, dryRun)
-  syncedCount += await syncRulesToAgentsMd(selected.rules, proj, dryRun)
-  syncedCount += await copyCodexHooks(selected.hooks, proj, dryRun)
-  syncedCount += await syncCodexHooksJson(hooksJsonSrc, proj, selectedHookNames, dryRun)
-
-  // 删除已存在但本次未勾选的（仅 reselect 模式；rules 删除已由托管块重生成体现）
-  if (reselect) {
-    const skillTemplateNames = new Set(scans.skills.map(s => s.name))
-    const hookTemplateNames = new Set(scans.hooks.map(h => h.name))
-    removedCount += await removeUnselectedFlat(['.agents', 'skills'], existing.skills, new Set(selected.skills.map(s => s.name)), skillTemplateNames, proj, dryRun)
-    removedCount += await removeUnselectedFlat(['.codex', 'hooks'], existing.hooks, selectedHookNames, hookTemplateNames, proj, dryRun)
-  }
+  syncedCount += await copySkillsFlat(syncedSelection.skills, proj)
+  syncedCount += await syncProjectAgentsMd(sourceDir, proj, syncedSelection.rules)
+  syncedCount += await copyCodexHooks(syncedSelection.hooks, proj)
+  syncedCount += await syncCodexHooksJson(sourceDir, proj, selectedHookNames)
+
+  const skillTemplateNames = new Set(scans.skills.map(s => s.name))
+  const hookTemplateNames = new Set(scans.hooks.map(h => h.name))
+  removedCount += await removeUnselectedFlat(['.agents', 'skills'], existing.skills, new Set(syncedSelection.skills.map(s => s.name)), skillTemplateNames, proj)
+  removedCount += await removeUnselectedFlat(['.codex', 'hooks'], existing.hooks, selectedHookNames, hookTemplateNames, proj)
 
-  console.log(chalk.blue(`\n${dryRun ? 'Dry-run complete.' : 'Done!'} ${syncedCount} synced${removedCount > 0 ? `, ${removedCount} removed` : ''}.`))
+  console.log(chalk.blue(`\nDone! ${syncedCount} synced${removedCount > 0 ? `, ${removedCount} removed` : ''}.`))
   console.log(chalk.gray(`  Rules  → ${agentsMdPath}`))
   console.log(chalk.gray(`  Skills → ${path.join(proj, '.agents', 'skills')}`))
   console.log(chalk.gray(`  Hooks  → ${path.join(proj, '.codex')}`))

package/src/sync-cursor.js

@@ -0,0 +1,163 @@
+import fs from 'fs-extra'
+import path from 'path'
+import { chalk } from './utils.js'
+import {
+  extractDescription,
+  logAction,
+  readBaselineDoc,
+  scanRules,
+  resolveSourceDir,
+} from './sync.js'
+
+const BASELINE_RULE_NAME = '00-dwy-global.mdc'
+
+function stripFrontmatter(content) {
+  const match = content.match(/^---\s*\n[\s\S]*?\n---\s*\n?/)
+  return match ? content.slice(match[0].length).trim() : content.trim()
+}
+
+function extractFrontmatter(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n?/)
+  return match ? match[1] : ''
+}
+
+function parseRulePaths(frontmatter) {
+  const match = frontmatter.match(/^paths:\s*\n((?:\s*-\s*.*\n?)+)/m)
+  if (!match) return []
+  return match[1]
+    .split('\n')
+    .map(line => line.trim())
+    .filter(line => line.startsWith('-'))
+    .map(line => line.replace(/^-\s*/, '').replace(/^["']|["']$/g, '').trim())
+    .filter(Boolean)
+}
+
+function toCursorRuleName(ruleName) {
+  return `dwy-${ruleName.replace(/\.md$/i, '')}.mdc`
+}
+
+async function buildCursorRule(ruleItem) {
+  const raw = await fs.readFile(ruleItem.sourcePath, 'utf-8')
+  const description = extractDescription(raw) || ruleItem.name.replace(/\.md$/i, '')
+  const frontmatter = extractFrontmatter(raw)
+  const paths = parseRulePaths(frontmatter)
+  const body = stripFrontmatter(raw)
+
+  const lines = [
+    '---',
+    `description: ${JSON.stringify(`[dwy] ${description}`)}`,
+  ]
+
+  if (paths.length > 0) {
+    lines.push('alwaysApply: false')
+    lines.push('globs:')
+    for (const rulePath of paths) {
+      lines.push(`  - ${JSON.stringify(rulePath)}`)
+    }
+  } else {
+    lines.push('alwaysApply: true')
+  }
+
+  lines.push('---', '', body, '')
+  return lines.join('\n')
+}
+
+async function syncCursorRules(selectedRules, projectDir) {
+  const rulesDir = path.join(projectDir, '.cursor', 'rules')
+  await fs.ensureDir(rulesDir)
+
+  let syncedCount = 0
+  for (const rule of selectedRules) {
+    const destName = toCursorRuleName(rule.name)
+    const destPath = path.join(rulesDir, destName)
+    const content = await buildCursorRule(rule)
+    await fs.writeFile(destPath, content)
+    logAction(`.cursor/rules/${destName}`)
+    syncedCount++
+  }
+
+  return syncedCount
+}
+
+async function syncCursorBaselineRule(sourceDir, projectDir) {
+  const baseline = await readBaselineDoc(sourceDir)
+  if (!baseline) return 0
+
+  const rulesDir = path.join(projectDir, '.cursor', 'rules')
+  const destPath = path.join(rulesDir, BASELINE_RULE_NAME)
+  const content = [
+    '---',
+    `description: ${JSON.stringify('[dwy] Global baseline')}`,
+    'alwaysApply: true',
+    '---',
+    '',
+    baseline.trim(),
+    '',
+  ].join('\n')
+
+  await fs.ensureDir(rulesDir)
+  await fs.writeFile(destPath, content)
+  logAction(`.cursor/rules/${BASELINE_RULE_NAME}`)
+  return 1
+}
+
+async function removeUnselectedCursorRules(existingNames, selectedNames, projectDir) {
+  const rulesDir = path.join(projectDir, '.cursor', 'rules')
+  let removedCount = 0
+
+  for (const name of existingNames) {
+    if (selectedNames.has(name)) continue
+    await fs.remove(path.join(rulesDir, name))
+    logAction(`.cursor/rules/${name}`, 'red', '×')
+    removedCount++
+  }
+
+  return removedCount
+}
+
+async function scanExistingCursorRules(projectDir) {
+  const rulesDir = path.join(projectDir, '.cursor', 'rules')
+  if (!await fs.pathExists(rulesDir)) return new Set()
+  const entries = await fs.readdir(rulesDir, { withFileTypes: true })
+  return new Set(
+    entries
+      .filter(entry => entry.isFile()
+        && ((entry.name.startsWith('dwy-') && entry.name.endsWith('.mdc')) || entry.name === BASELINE_RULE_NAME))
+      .map(entry => entry.name),
+  )
+}
+
+export async function syncCursor({
+  sourceDir: sourceDirOverride,
+  projectDir,
+  selected,
+} = {}) {
+  const sourceDir = sourceDirOverride || await resolveSourceDir()
+  if (!await fs.pathExists(sourceDir)) {
+    throw new Error('ai-tools templates not found in repo')
+  }
+
+  const proj = projectDir || process.cwd()
+
+  console.log(chalk.blue('\nSyncing Cursor configuration...\n'))
+
+  const scans = {
+    rules: await scanRules(sourceDir),
+  }
+  const selectedRuleNames = new Set((selected.rules || []).map(item => item.name))
+  const syncedSelection = scans.rules.filter(rule => selectedRuleNames.has(rule.name))
+  const existingRules = await scanExistingCursorRules(proj)
+  const nextRuleNames = new Set(syncedSelection.map(rule => toCursorRuleName(rule.name)))
+
+  let syncedCount = 0
+  let removedCount = 0
+
+  syncedCount += await syncCursorBaselineRule(sourceDir, proj)
+  syncedCount += await syncCursorRules(syncedSelection, proj)
+  nextRuleNames.add(BASELINE_RULE_NAME)
+  removedCount += await removeUnselectedCursorRules(existingRules, nextRuleNames, proj)
+
+  console.log(chalk.blue(`\nDone! ${syncedCount} synced${removedCount > 0 ? `, ${removedCount} removed` : ''}.`))
+  console.log(chalk.gray(`  Rules → ${path.join(proj, '.cursor', 'rules')}`))
+  console.log(chalk.gray('  Skills / Commands / Hooks → 当前适配未支持'))
+}