create-dwy 0.13.8 → 0.14.1

package/src/sync.js

@@ -1,9 +1,7 @@
 import fs from 'fs-extra'
 import path from 'path'
-import os from 'os'
-import inquirer from 'inquirer'
-import { ensureRepoCache, chalk } from './utils.js'
-import { groupedCheckbox } from './prompts/grouped-checkbox.js'
+import { groupMultiselect, isCancel, select } from '@clack/prompts'
+import { PACKAGE_ROOT, chalk } from './utils.js'
 
 const CATEGORIES = [
   { key: 'skills', label: 'Skills' },
@@ -53,6 +51,41 @@ export function extractDescription(content) {
   return ''
 }
 
+function extractTitleLine(content) {
+  const headingMatch = content.match(/^#\s+(.+)$/m)
+  if (headingMatch) return headingMatch[1].trim()
+
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+    if (trimmed.startsWith('# ')) return trimmed.slice(2).trim()
+    if (trimmed.startsWith('//')) return trimmed.replace(/^\/\/\s*/, '').trim()
+    if (trimmed.startsWith('#')) return trimmed.replace(/^#\s*/, '').trim()
+    return trimmed
+  }
+
+  return ''
+}
+
+async function readEntryDescription(entryPath, fallback) {
+  if (!await fs.pathExists(entryPath)) return fallback
+
+  try {
+    const stat = await fs.stat(entryPath)
+    if (stat.isDirectory()) {
+      const readmePath = path.join(entryPath, 'README.md')
+      if (!await fs.pathExists(readmePath)) return fallback
+      const readme = await fs.readFile(readmePath, 'utf-8')
+      return extractDescription(readme) || extractTitleLine(readme) || fallback
+    }
+
+    const content = await fs.readFile(entryPath, 'utf-8')
+    return extractDescription(content) || extractTitleLine(content) || fallback
+  } catch {
+    return fallback
+  }
+}
+
 export async function scanSkills(sourceDir) {
   const skillsDir = path.join(sourceDir, 'skills')
   if (!await fs.pathExists(skillsDir)) return []
@@ -108,16 +141,20 @@ export async function scanCommands(sourceDir) {
   if (!await fs.pathExists(commandsDir)) return []
 
   const entries = await fs.readdir(commandsDir, { withFileTypes: true })
-  return entries
-    .filter(e => e.name !== '.gitkeep')
-    .map(e => ({
+  const commands = await Promise.all(entries
+    .filter(e => e.name !== '.gitkeep' && e.name !== '.DS_Store')
+    .map(async e => ({
       name: e.name,
-      description: e.isDirectory() ? '命令目录' : '命令文件',
-      category: '其他',
+      description: await readEntryDescription(
+        path.join(commandsDir, e.name),
+        e.isDirectory() ? '命令目录' : '命令文件',
+      ),
+      category: e.isDirectory() ? '目录命令' : '文件命令',
       sourcePath: path.join(commandsDir, e.name),
       type: 'command',
-    }))
-    .sort((a, b) => a.name.localeCompare(b.name))
+    })))
+
+  return commands.sort((a, b) => a.name.localeCompare(b.name))
 }
 
 export async function scanHooks(sourceDir) {
@@ -130,11 +167,15 @@ export async function scanHooks(sourceDir) {
     const catDir = path.join(hooksDir, cat.name)
     for (const entry of await fs.readdir(catDir, { withFileTypes: true })) {
       if (entry.name === '.gitkeep') continue
+      const hookPath = path.join(catDir, entry.name)
       hooks.push({
         name: entry.name,
-        description: entry.isDirectory() ? '钩子目录' : '钩子脚本',
+        description: await readEntryDescription(
+          hookPath,
+          entry.isDirectory() ? '钩子目录' : '钩子脚本',
+        ),
         category: cat.name,
-        sourcePath: path.join(catDir, entry.name),
+        sourcePath: hookPath,
         type: 'hook',
       })
     }
@@ -142,6 +183,18 @@ export async function scanHooks(sourceDir) {
   return hooks.sort((a, b) => a.name.localeCompare(b.name))
 }
 
+export async function loadHookManifests(sourceDir) {
+  const manifestPath = path.join(sourceDir, 'hook-manifests', 'hooks.json')
+  if (!await fs.pathExists(manifestPath)) return []
+  return fs.readJson(manifestPath)
+}
+
+export async function readBaselineDoc(sourceDir) {
+  const baselinePath = path.join(sourceDir, 'CLAUDE.md')
+  if (!await fs.pathExists(baselinePath)) return ''
+  return fs.readFile(baselinePath, 'utf-8')
+}
+
 export async function scanExisting(projectTargetDir, typePlural) {
   const dir = path.join(projectTargetDir, typePlural)
   if (!await fs.pathExists(dir)) return new Set()
@@ -149,14 +202,48 @@ export async function scanExisting(projectTargetDir, typePlural) {
   return new Set(entries.filter(name => name !== '.gitkeep' && name !== '.DS_Store'))
 }
 
+function buildGroupedOptions(items) {
+  const groups = new Map()
+  for (const item of items) {
+    const category = item.category || '其他'
+    const options = groups.get(category) || []
+    const hint = item.description
+      ? item.description.length > 72
+        ? `${item.description.slice(0, 72)}...`
+        : item.description
+      : undefined
+
+    options.push({
+      value: item.name,
+      label: hint ? `${item.name}（${hint}）` : item.name,
+    })
+    groups.set(category, options)
+  }
+
+  return Object.fromEntries(
+    [...groups.entries()]
+      .sort(([a], [b]) => a.localeCompare(b, 'zh'))
+      .map(([category, options]) => [
+        category,
+        options.sort((a, b) => a.label.localeCompare(b.label, 'zh')),
+      ]),
+  )
+}
+
 async function promptSelection(items, label, defaultNames) {
   if (items.length === 0) return []
-  return groupedCheckbox({
+  const selectedNames = await groupMultiselect({
     message: `选择 ${label}`,
-    items,
-    defaultSelected: defaultNames,
-    pageSize: 15,
+    options: buildGroupedOptions(items),
+    initialValues: [...defaultNames],
+    maxItems: 15,
+    required: false,
+    groupSpacing: 1,
+    selectableGroups: true,
   })
+  if (isCancel(selectedNames)) return null
+  const selectedSet = new Set(selectedNames)
+  return items.filter(item => selectedSet.has(item.name))
 }
 
 /**
@@ -174,23 +261,22 @@ export async function interactiveSelect(scans, existing) {
       ? new Set(sel[key].map(x => x.name))
       : existing[key]
     sel[key] = await promptSelection(scans[key], label, defaultNames)
+    if (sel[key] === null) return null
 
     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',
+    const nav = await select({
       message: `${label} 已选 ${sel[key].length} 项。下一步：`,
-      choices: [
-        { name: `→ 继续选 ${nextLabel}`, value: 'next' },
-        ...(prevLabel ? [{ name: `← 返回重选 ${prevLabel}`, value: 'back' }] : []),
-        { name: '✗ 取消同步', value: 'cancel' },
+      options: [
+        { label: `继续选 ${nextLabel}`, value: 'next' },
+        ...(prevLabel ? [{ label: `返回重选 ${prevLabel}`, value: 'back' }] : []),
+        { label: '取消同步', value: 'cancel' },
       ],
-      default: 'next',
-    }])
-    if (nav === 'cancel') return null
+      initialValue: 'next',
+    })
+    if (isCancel(nav) || nav === 'cancel') return null
     i = nav === 'back' ? i - 1 : i + 1
   }
 
@@ -200,111 +286,138 @@ export async function interactiveSelect(scans, existing) {
     for (const { key, label } of CATEGORIES) {
       console.log(chalk.gray(`  ${label.padEnd(10)} ${sel[key].length} 项`))
     }
-    const { final } = await inquirer.prompt([{
-      type: 'list',
-      name: 'final',
+    const final = await select({
       message: '确认提交还是重选？',
-      choices: [
-        { name: '✓ 确认提交', value: 'confirm' },
-        ...CATEGORIES.map(c => ({ name: `重选 ${c.label}`, value: c.key })),
-        { name: '✗ 取消同步', value: 'cancel' },
+      options: [
+        { label: '确认提交', value: 'confirm' },
+        ...CATEGORIES.map(c => ({ label: `重选 ${c.label}`, value: c.key })),
+        { label: '取消同步', value: 'cancel' },
       ],
-      default: 'confirm',
-    }])
+      initialValue: 'confirm',
+    })
+    if (isCancel(final) || final === 'cancel') return null
     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)))
+    if (sel[final] === null) return null
   }
 }
 
-export function logAction(dryRun, label, color = 'green', prefix = '✓') {
-  console.log(chalk[color](`  ${dryRun ? '[dry-run] ' : prefix + ' '}${label}`))
+export function logAction(label, color = 'green', prefix = '✓') {
+  console.log(chalk[color](`  ${prefix} ${label}`))
 }
 
-async function copyItems(items, targetDir, dryRun) {
+async function copyItems(items, targetDir) {
   for (const item of items) {
     const dest = path.join(targetDir, item.type + 's', item.name)
-    if (!dryRun) {
-      await fs.ensureDir(path.dirname(dest))
-      await fs.copy(item.sourcePath, dest, { overwrite: true, filter: copyFilter })
-    }
-    logAction(dryRun, `${item.type}s/${item.name}`)
+    await fs.ensureDir(path.dirname(dest))
+    await fs.copy(item.sourcePath, dest, { overwrite: true, filter: copyFilter })
+    logAction(`${item.type}s/${item.name}`)
   }
   return items.length
 }
 
-async function copyHooks(items, targetDir, dryRun) {
+async function copyHooks(items, targetDir) {
   if (items.length === 0) return 0
   const hooksTargetDir = path.join(targetDir, 'hooks')
-  if (!dryRun) await fs.ensureDir(hooksTargetDir)
+  await fs.ensureDir(hooksTargetDir)
   for (const hook of items) {
     const dest = path.join(hooksTargetDir, hook.name)
-    if (!dryRun) {
-      await fs.copy(hook.sourcePath, dest, { overwrite: true, filter: copyFilter })
-      await fs.chmod(dest, 0o755)
-    }
-    logAction(dryRun, `hooks/${hook.name}`)
+    await fs.copy(hook.sourcePath, dest, { overwrite: true, filter: copyFilter })
+    await fs.chmod(dest, 0o755)
+    logAction(`hooks/${hook.name}`)
   }
   return items.length
 }
 
-async function removeUnselected(typePlural, existingNames, selectedNames, templateNames, targetDir, dryRun) {
+async function removeUnselected(typePlural, existingNames, selectedNames, templateNames, targetDir) {
   let count = 0
   for (const name of existingNames) {
     if (selectedNames.has(name)) continue
     // 项目独有(模板未提供过)的条目永不删除,保留用户自定义
     if (!templateNames.has(name)) continue
     const target = path.join(targetDir, typePlural, name)
-    if (!dryRun) await fs.remove(target)
-    logAction(dryRun, `${typePlural}/${name}`, 'red', '×')
+    await fs.remove(target)
+    logAction(`${typePlural}/${name}`, 'red', '×')
     count++
   }
   return count
 }
 
-/**
- * 过滤模板 settings.json 中未选中 hooks 的引用。
- * 识别规则：command 字段中匹配 $CLAUDE_PROJECT_DIR/.claude/hooks/<name> 的项。
- */
-function filterSettingsByHooks(newSettings, selectedHookNames) {
-  if (!newSettings.hooks) return newSettings
-  const cloned = JSON.parse(JSON.stringify(newSettings))
-  const hookPathRegex = /\.claude\/hooks\/([^\s'"]+)/
+function buildClaudeHooksSettings(manifests, selectedHookNames) {
+  const grouped = new Map()
+
+  for (const manifest of manifests) {
+    if (!selectedHookNames.has(manifest.name)) continue
+    if (manifest.platforms && !manifest.platforms.includes('claude')) 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 $CLAUDE_PROJECT_DIR/.claude/hooks/${manifest.name}`,
+    })
+    grouped.set(key, hooks)
+  }
+
+  if (grouped.size === 0) return {}
 
-  for (const event of Object.keys(cloned.hooks)) {
-    const configs = cloned.hooks[event] || []
+  const settings = { hooks: {} }
+  for (const [key, hooks] of grouped.entries()) {
+    const [event, matcher] = key.split('::')
+    settings.hooks[event] ||= []
+    settings.hooks[event].push({ matcher, hooks })
+  }
+
+  return settings
+}
+
+function isManagedClaudeHookCommand(command, managedHookNames) {
+  if (typeof command !== 'string') return false
+  const match = command.match(/\.claude\/hooks\/([^\s'"]+)/)
+  return !!(match && managedHookNames.has(match[1]))
+}
+
+function mergeClaudeHooks(existingHooks, generatedHooks, managedHookNames) {
+  const merged = {}
+  const sourceEvents = new Set([
+    ...Object.keys(existingHooks || {}),
+    ...Object.keys(generatedHooks || {}),
+  ])
+
+  for (const event of sourceEvents) {
     const kept = []
-    for (const cfg of configs) {
-      const remainingHooks = (cfg.hooks || []).filter(h => {
-        const m = h.command?.match(hookPathRegex)
-        if (!m) return true
-        return selectedHookNames.has(m[1])
-      })
+
+    for (const cfg of existingHooks?.[event] || []) {
+      const remainingHooks = (cfg.hooks || []).filter(hook => !isManagedClaudeHookCommand(hook.command, managedHookNames))
       if (remainingHooks.length > 0) kept.push({ ...cfg, hooks: remainingHooks })
     }
-    if (kept.length > 0) cloned.hooks[event] = kept
-    else delete cloned.hooks[event]
+
+    for (const cfg of generatedHooks?.[event] || []) kept.push(cfg)
+    if (kept.length > 0) merged[event] = kept
   }
 
-  if (Object.keys(cloned.hooks).length === 0) delete cloned.hooks
-  return cloned
+  return Object.keys(merged).length > 0 ? merged : undefined
 }
 
-async function syncSettings(sourceDir, targetDir, selectedHookNames, dryRun) {
-  const settingsSrc = path.join(sourceDir, 'settings.json')
-  if (!await fs.pathExists(settingsSrc)) return 0
-
+async function syncSettings(sourceDir, targetDir, selectedHookNames) {
   const settingsDest = path.join(targetDir, 'settings.json')
-  const newSettings = await fs.readJson(settingsSrc)
-  const filteredNew = filterSettingsByHooks(newSettings, selectedHookNames)
+  const manifests = await loadHookManifests(sourceDir)
+  const generatedSettings = buildClaudeHooksSettings(manifests, selectedHookNames)
+  const managedHookNames = new Set(
+    manifests
+      .filter(manifest => !manifest.platforms || manifest.platforms.includes('claude'))
+      .map(manifest => manifest.name),
+  )
 
   let merged
   let action
   if (await fs.pathExists(settingsDest)) {
     const existing = await fs.readJson(settingsDest)
     merged = { ...existing }
-    for (const [key, value] of Object.entries(filteredNew)) {
+    for (const [key, value] of Object.entries(generatedSettings)) {
       if (key === 'hooks') continue
       if (key in merged && typeof merged[key] === 'object' && !Array.isArray(merged[key])
           && typeof value === 'object' && !Array.isArray(value)) {
@@ -313,90 +426,55 @@ async function syncSettings(sourceDir, targetDir, selectedHookNames, dryRun) {
         merged[key] = value
       }
     }
-    // hooks 字段由模板独占：模板有则覆盖，模板没有则删除
-    if (filteredNew.hooks) merged.hooks = filteredNew.hooks
+    const nextHooks = mergeClaudeHooks(existing.hooks, generatedSettings.hooks, managedHookNames)
+    if (nextHooks) merged.hooks = nextHooks
     else delete merged.hooks
     action = 'merged'
   } else {
-    merged = filteredNew
+    merged = generatedSettings
     action = 'created'
   }
 
-  if (!dryRun) await fs.writeJson(settingsDest, merged, { spaces: 2 })
-  logAction(dryRun, `settings.json — ${action}`)
+  await fs.writeJson(settingsDest, merged, { spaces: 2 })
+  logAction(`settings.json — ${action}`)
   return 1
 }
 
-async function syncClaudeMd(sourceDir, targetDir, dryRun) {
-  const claudeMdSrc = path.join(sourceDir, 'CLAUDE.md')
-  if (!await fs.pathExists(claudeMdSrc)) return 0
-  if (!dryRun) await fs.copy(claudeMdSrc, path.join(targetDir, 'CLAUDE.md'), { overwrite: true })
-  logAction(dryRun, 'CLAUDE.md')
+async function syncClaudeBaselineDoc(sourceDir, targetDir) {
+  const baseline = await readBaselineDoc(sourceDir)
+  if (!baseline) return 0
+
+  const dest = path.join(targetDir, 'CLAUDE.md')
+  const current = await fs.pathExists(dest) ? await fs.readFile(dest, 'utf-8') : ''
+  if (current === baseline) return 0
+
+  await fs.writeFile(dest, baseline)
+  logAction('.claude/CLAUDE.md')
   return 1
 }
 
 export async function resolveSourceDir() {
-  const localTemplate = path.join(process.cwd(), 'claude-cli', 'templates', 'claude-global')
-  if (await fs.pathExists(localTemplate)) {
-    console.log(chalk.gray('Using local templates from current project...'))
-    return localTemplate
+  const packagedTemplate = path.join(PACKAGE_ROOT, 'templates', 'ai-tools')
+  if (!await fs.pathExists(packagedTemplate)) {
+    throw new Error(`packaged ai-tools templates not found: ${packagedTemplate}`)
   }
-  const repoDir = await ensureRepoCache()
-  return path.join(repoDir, 'claude-cli', 'templates', 'claude-global')
+  return packagedTemplate
 }
 
-/**
- * 入口：`dwy claude sync [target]`
- *   target=undefined  同步项目 .claude/（不动全局 CLAUDE.md）
- *   target='md'       仅同步 CLAUDE.md → 全局 ~/.claude/
- */
 export async function syncClaude({
-  target,
-  reselect = false,
-  dryRun = false,
   sourceDir: sourceDirOverride,
   projectDir,
-  selected: selectedOverride,
-  skipInitPrompt = false,
+  selected,
 } = {}) {
   const sourceDir = sourceDirOverride || await resolveSourceDir()
   if (!await fs.pathExists(sourceDir)) {
-    console.error(chalk.red('Error: claude-global templates not found in repo'))
-    process.exit(1)
-  }
-
-  if (target === 'md') {
-    const globalTargetDir = path.join(os.homedir(), '.claude')
-    if (!dryRun) await fs.ensureDir(globalTargetDir)
-    console.log(chalk.blue(`\nSyncing CLAUDE.md to ${globalTargetDir}...\n`))
-    const synced = await syncClaudeMd(sourceDir, globalTargetDir, dryRun)
-    if (!synced) console.log(chalk.yellow('CLAUDE.md not found in templates, nothing to sync.'))
-    else 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)
+    throw new Error('ai-tools templates not found in repo')
   }
 
   console.log(chalk.blue('\nScanning available Claude configuration...\n'))
   const projectRoot = projectDir || process.cwd()
   const projectTargetDir = path.join(projectRoot, '.claude')
 
-  if (!selectedOverride && !skipInitPrompt && !await fs.pathExists(projectTargetDir)) {
-    const { shouldCreate } = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'shouldCreate',
-      message: `当前目录 ${chalk.yellow(projectRoot)} 未找到 .claude 目录，是否在此创建？`,
-      default: false,
-    }])
-    if (!shouldCreate) {
-      console.log(chalk.yellow('\n已取消同步。'))
-      return
-    }
-  }
-
   const scans = {
     skills: await scanSkills(sourceDir),
     rules: await scanRules(sourceDir),
@@ -411,69 +489,40 @@ export async function syncClaude({
     commands: await scanExisting(projectTargetDir, 'commands'),
     hooks: await scanExisting(projectTargetDir, 'hooks'),
   }
-  const hasAnyExisting = existing.skills.size + existing.rules.size + existing.commands.size + existing.hooks.size > 0
 
-  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)),
-      commands: scans.commands.filter(item => selectedNames('commands').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)),
-      commands: scans.commands.filter(c => existing.commands.has(c.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.commands.length} commands, ${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)),
+    commands: scans.commands.filter(item => selectedNames('commands').has(item.name)),
+    hooks: scans.hooks.filter(item => selectedNames('hooks').has(item.name)),
   }
 
-  const selectedHookNames = new Set(selected.hooks.map(h => h.name))
+  const selectedHookNames = new Set(syncedSelection.hooks.map(h => h.name))
 
-  console.log(chalk.blue(`\n${dryRun ? '[dry-run] ' : ''}Syncing to ${projectTargetDir}...\n`))
-  if (!dryRun) await fs.ensureDir(projectTargetDir)
+  console.log(chalk.blue(`\nSyncing to ${projectTargetDir}...\n`))
+  await fs.ensureDir(projectTargetDir)
 
   let syncedCount = 0
   let removedCount = 0
 
-  syncedCount += await copyItems(selected.skills, projectTargetDir, dryRun)
-  syncedCount += await copyItems(selected.rules, projectTargetDir, dryRun)
-  syncedCount += await copyItems(selected.commands, projectTargetDir, dryRun)
-  syncedCount += await syncSettings(sourceDir, projectTargetDir, selectedHookNames, dryRun)
-  syncedCount += await copyHooks(selected.hooks, projectTargetDir, dryRun)
-
-  // 删除已存在但本次未勾选的(仅 reselect 模式:缓存模式默认 selected ⊇ existing 不会触发)
-  // 删除范围限定在模板提供过的条目内,项目自定义条目(scans 里没有的)始终保留
-  if (reselect) {
-    const skillTemplateNames = new Set(scans.skills.map(s => s.name))
-    const ruleTemplateNames = new Set(scans.rules.map(r => r.name))
-    const commandTemplateNames = new Set(scans.commands.map(c => c.name))
-    const hookTemplateNames = new Set(scans.hooks.map(h => h.name))
-    removedCount += await removeUnselected('skills', existing.skills, new Set(selected.skills.map(s => s.name)), skillTemplateNames, projectTargetDir, dryRun)
-    removedCount += await removeUnselected('rules', existing.rules, new Set(selected.rules.map(r => r.name)), ruleTemplateNames, projectTargetDir, dryRun)
-    removedCount += await removeUnselected('commands', existing.commands, new Set(selected.commands.map(c => c.name)), commandTemplateNames, projectTargetDir, dryRun)
-    removedCount += await removeUnselected('hooks', existing.hooks, selectedHookNames, hookTemplateNames, projectTargetDir, dryRun)
-  }
-
-  console.log(chalk.blue(`\n${dryRun ? 'Dry-run complete.' : 'Done!'} ${syncedCount} synced${removedCount > 0 ? `, ${removedCount} removed` : ''}.`))
+  syncedCount += await syncClaudeBaselineDoc(sourceDir, projectTargetDir)
+  syncedCount += await copyItems(syncedSelection.skills, projectTargetDir)
+  syncedCount += await copyItems(syncedSelection.rules, projectTargetDir)
+  syncedCount += await copyItems(syncedSelection.commands, projectTargetDir)
+  syncedCount += await syncSettings(sourceDir, projectTargetDir, selectedHookNames)
+  syncedCount += await copyHooks(syncedSelection.hooks, projectTargetDir)
+
+  const skillTemplateNames = new Set(scans.skills.map(s => s.name))
+  const ruleTemplateNames = new Set(scans.rules.map(r => r.name))
+  const commandTemplateNames = new Set(scans.commands.map(c => c.name))
+  const hookTemplateNames = new Set(scans.hooks.map(h => h.name))
+  removedCount += await removeUnselected('skills', existing.skills, new Set(syncedSelection.skills.map(s => s.name)), skillTemplateNames, projectTargetDir)
+  removedCount += await removeUnselected('rules', existing.rules, new Set(syncedSelection.rules.map(r => r.name)), ruleTemplateNames, projectTargetDir)
+  removedCount += await removeUnselected('commands', existing.commands, new Set(syncedSelection.commands.map(c => c.name)), commandTemplateNames, projectTargetDir)
+  removedCount += await removeUnselected('hooks', existing.hooks, selectedHookNames, hookTemplateNames, projectTargetDir)
+
+  console.log(chalk.blue(`\nDone! ${syncedCount} synced${removedCount > 0 ? `, ${removedCount} removed` : ''}.`))
   console.log(chalk.gray(`  Project config → ${projectTargetDir}`))
   console.log(chalk.gray(`  Hooks          → ${path.join(projectTargetDir, 'hooks')}`))
-  console.log(chalk.gray('  CLAUDE.md      → 跳过（用 `dwy claude sync md` 单独同步到 ~/.claude/）'))
 }

package/src/utils.js

@@ -1,48 +1,12 @@
 import fs from 'fs-extra'
 import path from 'path'
 import Handlebars from 'handlebars'
-import { simpleGit } from 'simple-git'
 import chalk from 'chalk'
 import { fileURLToPath } from 'url'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
 export const PACKAGE_ROOT = path.resolve(__dirname, '..')
-export const CACHE_DIR = path.join(process.env.HOME, '.dwy', 'cache')
-export const DWY_REPO_URL = 'https://github.com/danweiyuancircle/dwy-ai-experience.git'
-
-export async function needsRepoReclone(git, repoUrl) {
-  const remotes = await git.getRemotes(true)
-  const origin = remotes.find(remote => remote.name === 'origin')
-  if (!origin) return true
-
-  const fetchUrl = origin.refs?.fetch
-  const pushUrl = origin.refs?.push
-  return fetchUrl !== repoUrl || pushUrl !== repoUrl
-}
-
-export async function ensureRepoCache() {
-  await fs.ensureDir(CACHE_DIR)
-  const repoDir = path.join(CACHE_DIR, 'dwy')
-
-  if (await fs.pathExists(path.join(repoDir, '.git'))) {
-    const git = simpleGit(repoDir)
-    if (await needsRepoReclone(git, DWY_REPO_URL)) {
-      console.log(chalk.gray('Cached templates point to another repo, recreating cache...'))
-      await fs.remove(repoDir)
-      console.log(chalk.gray('Cloning template repo...'))
-      await simpleGit().clone(DWY_REPO_URL, repoDir)
-    } else {
-      console.log(chalk.gray('Pulling latest templates...'))
-      await git.pull()
-    }
-  } else {
-    console.log(chalk.gray('Cloning template repo...'))
-    await simpleGit().clone(DWY_REPO_URL, repoDir)
-  }
-
-  return repoDir
-}
 
 export async function renderTemplate(templateDir, destDir, context) {
   const entries = await fs.readdir(templateDir, { withFileTypes: true })