create-dwy 0.14.4 → 0.14.6

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # create-dwy
 
+## 0.14.6
+
+### Patch Changes
+
+- `dwy` 交互同步时，默认勾选优先读取项目目录下 `/.dwy/sync-state.json` 的上次托管选择结果，减少每次重新勾选 `rules`、`skills`、`commands`、`hooks`。
+- 新增 iOS 适配开发规则 `dwy-ios-layout-adaptation.md`，统一原型基准为 `393×852 pt`，补充 `375 / 393 / 430 pt` 验证矩阵与 Safe Area 约束。
+- 补充 iOS 与 Android 应用图标安全边距规则：iOS 图标源稿使用 `1024x1024` PNG，Android 启动图标源稿使用 `mipmap-xxxhdpi` `192x192`，主体默认预留 `10%` 安全边距。
+
+## 0.14.5
+
+### Patch Changes
+
+- `dwy` 同步模板改回运行时从仓库缓存拉取，默认更新 `~/.dwy/cache/dwy` 后再读取模板，不再依赖 CLI 包内静态模板。
+- 新增项目级同步状态文件 `/.dwy/sync-state.json`，记录各平台上次由 `dwy` 托管的 skills / rules / commands / hooks。
+- 当模板仓库移除已同步项时，再次执行 `dwy` 会罗列缺失项并让用户选择是否删除；未确认删除的旧项会继续保留。
+
 ## 0.14.4
 
 ### Patch Changes
@@ -7,6 +23,7 @@
 - 将 iOS 规则 `dwy-swift-style.md` 重命名为 `dwy-swift-core.md`，并重构为精简版规范。
 - 新增规则级配置收口约束，要求可配置项统一在 `AppConfig` 管理。
 - 加强国际化规则：默认要求中文/英文支持，统一 `localizationBundle + loc() + LocalizationManager + AppLanguage` 实施要点。
+- 模板同步改为仅使用 CLI 内置 `dwy-cli/templates/ai-tools`，不再读取外部缓存目录或按 `origin` 拉取远端模板仓库。
 
 ## 0.14.3
 
@@ -35,9 +52,9 @@
 ### Minor Changes
 
 - CLI 重构为单一交互式入口，移除旧的命令式 `create` / `sync` / `claude` / `codex` 流程。
-- 模板源统一收敛到 `/Users/chances/WebstormProjects/dwy-shared/claude-cli/templates/ai-tools`，随 CLI 包一起发布，不再运行时拉取远端模板仓库。
+- 模板源统一收敛到 `/Users/chances/WebstormProjects/dwy-shared/dwy-cli/templates/ai-tools`，随 CLI 包一起发布，不再运行时拉取远端模板仓库。
 - 新增多平台适配层：支持 `Claude Code`、`Codex`、`Cursor`、`OpenCode` 的 rules / skills / commands / hooks 同步。
-- 基准规范文件 `/Users/chances/WebstormProjects/dwy-shared/claude-cli/templates/ai-tools/CLAUDE.md` 现在会按平台分别同步到 `.claude/CLAUDE.md`、根 `AGENTS.md`、`.cursor/rules/00-dwy-global.mdc`。
+- 基准规范文件 `/Users/chances/WebstormProjects/dwy-shared/dwy-cli/templates/ai-tools/CLAUDE.md` 现在会按平台分别同步到 `.claude/CLAUDE.md`、根 `AGENTS.md`、`.cursor/rules/00-dwy-global.mdc`。
 - 平台未选中时会清理 dwy 托管内容，同时保留用户自定义文件、用户自定义 hook 配置和 `AGENTS.md` 非托管内容。
 
 ## 0.13.8

package/bin/index.js

@@ -7,6 +7,32 @@ import { syncAll } from '../src/sync-all.js'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const pkg = JSON.parse(readFileSync(resolve(__dirname, '..', 'package.json'), 'utf-8'))
+const argv = process.argv.slice(2)
 
-console.log(`dwy ${pkg.version}`)
-await syncAll()
+function printHelp() {
+  const lines = [
+    `dwy ${pkg.version}`,
+    '',
+    'Usage:',
+    '  dwy               运行交互式同步',
+    '  dwy sync          运行交互式同步',
+    '  dwy --help        显示本说明',
+    '  dwy -h            显示本说明',
+    '  dwy --version     显示当前版本',
+    '  dwy -V            显示当前版本',
+    '',
+  ]
+  console.log(lines.join('\n'))
+}
+
+if (argv.includes('--help') || argv.includes('-h') || argv[0] === 'help') {
+  printHelp()
+} else if (argv.includes('--version') || argv.includes('-V')) {
+  console.log(pkg.version)
+} else if (argv.length === 0 || argv[0] === 'sync') {
+  await syncAll()
+} else {
+  console.error(`未知命令: ${argv.join(' ')}`)
+  printHelp()
+  process.exitCode = 1
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-dwy",
-  "version": "0.14.4",
+  "version": "0.14.6",
   "description": "项目脚手架与多平台 AI 配置同步工具",
   "type": "module",
   "bin": {

package/src/sync-all.js

@@ -22,7 +22,7 @@ import {
   scanExistingCodexSkills,
   syncCodex,
 } from './sync-codex.js'
-import { syncCursor } from './sync-cursor.js'
+import { scanExistingCursorRules, syncCursor } from './sync-cursor.js'
 import { syncOpenCode } from './sync-opencode.js'
 
 const PLATFORM_OPTIONS = [
@@ -33,11 +33,53 @@ const PLATFORM_OPTIONS = [
 ]
 
 const CURSOR_BASELINE_RULE_NAME = '00-dwy-global.mdc'
+const SYNC_STATE_PATH = ['.dwy', 'sync-state.json']
+const PLATFORM_SYNC_TYPES = {
+  claude: ['skills', 'rules', 'commands', 'hooks'],
+  codex: ['skills', 'rules', 'hooks'],
+  cursor: ['rules'],
+  opencode: ['skills', 'rules', 'commands'],
+}
+const PLATFORM_LABELS = {
+  claude: 'Claude Code',
+  codex: 'Codex',
+  cursor: 'Cursor',
+  opencode: 'OpenCode',
+}
+const TYPE_LABELS = {
+  skills: 'skills',
+  rules: 'rules',
+  commands: 'commands',
+  hooks: 'hooks',
+}
 
 function unionSets(...sets) {
   return new Set(sets.flatMap(set => [...set]))
 }
 
+function hasSetItems(setsByType) {
+  return setsByType.skills.size + setsByType.rules.size + setsByType.commands.size + setsByType.hooks.size > 0
+}
+
+export function buildSelectionDefaultsFromSyncState(existing, syncState) {
+  const stateDefaults = {
+    skills: new Set(),
+    rules: new Set(),
+    commands: new Set(),
+    hooks: new Set(),
+  }
+
+  for (const platformState of Object.values(syncState?.platforms || {})) {
+    for (const type of ['skills', 'rules', 'commands', 'hooks']) {
+      for (const name of platformState?.[type] || []) {
+        stateDefaults[type].add(name)
+      }
+    }
+  }
+
+  return hasSetItems(stateDefaults) ? stateDefaults : existing
+}
+
 async function scanCombinedExisting(projectDir) {
   const claudeDir = path.join(projectDir, '.claude')
   const agentsMdPath = path.join(projectDir, 'AGENTS.md')
@@ -61,7 +103,7 @@ async function scanCombinedExisting(projectDir) {
 }
 
 async function shouldInitialize(projectDir, existing) {
-  const hasAnyExisting = existing.skills.size + existing.rules.size + existing.commands.size + existing.hooks.size > 0
+  const hasAnyExisting = hasSetItems(existing)
   if (hasAnyExisting) return true
 
   const hasConfigDir = await fs.pathExists(path.join(projectDir, '.claude'))
@@ -111,6 +153,172 @@ function buildCursorBaselineContent(baseline) {
   ].join('\n')
 }
 
+function createEmptyPlatformState() {
+  return {
+    skills: [],
+    rules: [],
+    commands: [],
+    hooks: [],
+  }
+}
+
+async function loadSyncState(projectDir) {
+  const statePath = path.join(projectDir, ...SYNC_STATE_PATH)
+  if (!await fs.pathExists(statePath)) {
+    return {
+      version: 1,
+      platforms: {},
+    }
+  }
+
+  const state = await fs.readJson(statePath)
+  return {
+    version: 1,
+    platforms: state.platforms || {},
+  }
+}
+
+async function saveSyncState(projectDir, state) {
+  const statePath = path.join(projectDir, ...SYNC_STATE_PATH)
+  await fs.ensureDir(path.dirname(statePath))
+  await fs.writeJson(statePath, state, { spaces: 2 })
+}
+
+function getCurrentTemplateNames(scans) {
+  return {
+    skills: new Set(scans.skills.map(item => item.name)),
+    rules: new Set(scans.rules.map(item => item.name)),
+    commands: new Set(scans.commands.map(item => item.name)),
+    hooks: new Set(scans.hooks.map(item => item.name)),
+  }
+}
+
+async function collectCurrentManagedNames(projectDir) {
+  const claudeDir = path.join(projectDir, '.claude')
+  const openCodeDir = path.join(projectDir, '.opencode')
+  const agentsMdPath = path.join(projectDir, 'AGENTS.md')
+  const agentsMdContent = await fs.pathExists(agentsMdPath) ? await fs.readFile(agentsMdPath, 'utf-8') : ''
+
+  return {
+    claude: {
+      skills: await scanExisting(claudeDir, 'skills'),
+      rules: await scanExisting(claudeDir, 'rules'),
+      commands: await scanExisting(claudeDir, 'commands'),
+      hooks: await scanExisting(claudeDir, 'hooks'),
+    },
+    codex: {
+      skills: await scanExistingCodexSkills(projectDir),
+      rules: parseManagedRuleNames(agentsMdContent),
+      hooks: await scanExistingCodexHooks(projectDir),
+    },
+    cursor: {
+      rules: await scanExistingCursorRules(projectDir),
+    },
+    opencode: {
+      skills: await scanExisting(openCodeDir, 'skills'),
+      rules: parseManagedRuleNames(agentsMdContent),
+      commands: await scanExisting(openCodeDir, 'commands'),
+    },
+  }
+}
+
+function normalizeRemovalInput(removals = {}) {
+  const normalized = {}
+  for (const [platform, types] of Object.entries(removals)) {
+    normalized[platform] = {}
+    for (const [type, names] of Object.entries(types || {})) {
+      normalized[platform][type] = new Set(Array.isArray(names) ? names : [...names])
+    }
+  }
+  return normalized
+}
+
+function createEmptyRemovalState() {
+  return Object.fromEntries(
+    Object.keys(PLATFORM_SYNC_TYPES).map(platform => [platform, {}]),
+  )
+}
+
+async function collectStaleEntries(projectDir, scans, syncState, selectedPlatforms) {
+  const currentTemplateNames = getCurrentTemplateNames(scans)
+  const currentManaged = await collectCurrentManagedNames(projectDir)
+  const staleEntries = createEmptyRemovalState()
+
+  for (const platform of selectedPlatforms) {
+    const previous = syncState.platforms?.[platform] || {}
+    const platformManaged = currentManaged[platform] || {}
+
+    for (const type of PLATFORM_SYNC_TYPES[platform] || []) {
+      const previousNames = previous[type] || []
+      const currentNames = currentTemplateNames[type] || new Set()
+      const managedNames = platformManaged[type] || new Set()
+      const staleNames = []
+
+      for (const name of previousNames) {
+        if (currentNames.has(name)) continue
+        if (type === 'rules' && platform === 'cursor') {
+          if (!managedNames.has(buildCursorRuleName(name))) continue
+        } else if (!managedNames.has(name)) {
+          continue
+        }
+        staleNames.push(name)
+      }
+
+      if (staleNames.length > 0) staleEntries[platform][type] = staleNames.sort((a, b) => a.localeCompare(b, 'zh'))
+    }
+  }
+
+  return staleEntries
+}
+
+async function promptStaleRemovals(staleEntries) {
+  const approvals = createEmptyRemovalState()
+
+  for (const platform of Object.keys(PLATFORM_SYNC_TYPES)) {
+    for (const type of PLATFORM_SYNC_TYPES[platform]) {
+      const names = staleEntries[platform]?.[type] || []
+      if (names.length === 0) continue
+
+      console.log(chalk.yellow(`\n检测到 ${PLATFORM_LABELS[platform]} 已同步但模板仓库已移除的 ${TYPE_LABELS[type]}：`))
+      for (const name of names) {
+        console.log(chalk.gray(`  - ${name}`))
+      }
+
+      const selected = await multiselect({
+        message: `选择要删除的 ${PLATFORM_LABELS[platform]} ${TYPE_LABELS[type]}`,
+        options: names.map(name => ({ value: name, label: name })),
+        initialValues: names,
+        required: false,
+      })
+      if (isCancel(selected)) return null
+      approvals[platform][type] = new Set(selected)
+    }
+  }
+
+  return approvals
+}
+
+function getPreservedStaleNames(staleEntries, approvedRemovals, platform, type) {
+  const staleNames = staleEntries[platform]?.[type] || []
+  const approvedNames = approvedRemovals[platform]?.[type] || new Set()
+  return new Set(staleNames.filter(name => !approvedNames.has(name)))
+}
+
+function buildNextPlatformState(selected, staleEntries, approvedRemovals, platform) {
+  const state = createEmptyPlatformState()
+
+  for (const type of PLATFORM_SYNC_TYPES[platform] || []) {
+    const selectedNames = new Set((selected[type] || []).map(item => item.name))
+    for (const name of staleEntries[platform]?.[type] || []) {
+      const approvedNames = approvedRemovals[platform]?.[type] || new Set()
+      if (!approvedNames.has(name)) selectedNames.add(name)
+    }
+    state[type] = [...selectedNames].sort((a, b) => a.localeCompare(b, 'zh'))
+  }
+
+  return state
+}
+
 async function removeManagedItems(targetDir, existingNames, managedNames, labelPrefix) {
   let removedCount = 0
 
@@ -267,7 +475,6 @@ async function cleanupCursorPlatform(projectDir, scans, baseline) {
   )
 
   let removedCount = 0
-  const managedRuleNames = new Set(scans.rules.map(rule => buildCursorRuleName(rule.name)))
   for (const name of existingManagedNames) {
     if (name === CURSOR_BASELINE_RULE_NAME) continue
     await fs.remove(path.join(rulesDir, name))
@@ -316,6 +523,9 @@ async function cleanupOpenCodePlatform(projectDir, scans) {
 export async function syncAll({
   sourceDir: sourceDirOverride,
   projectDir: projectDirOverride,
+  selected: selectedOverride,
+  selectedPlatforms: selectedPlatformsOverride,
+  staleRemovals: staleRemovalsOverride,
 } = {}) {
   const sourceDir = sourceDirOverride || await resolveSourceDir()
   if (!await fs.pathExists(sourceDir)) {
@@ -346,28 +556,40 @@ export async function syncAll({
   console.log(chalk.yellow(`Found ${scans.skills.length} skills, ${scans.rules.length} rules, ${scans.commands.length} commands, ${scans.hooks.length} hooks\n`))
 
   const existing = await scanCombinedExisting(projectDir)
-  if (!await shouldInitialize(projectDir, existing)) {
+  const syncState = await loadSyncState(projectDir)
+  const selectionDefaults = buildSelectionDefaultsFromSyncState(existing, syncState)
+  const skipInitPrompt = !!(selectedOverride || selectedPlatformsOverride)
+  if (!skipInitPrompt && !await shouldInitialize(projectDir, existing)) {
     console.log(chalk.yellow('\n已取消同步。'))
     return
   }
 
-  const hasAnyExisting = existing.skills.size + existing.rules.size + existing.commands.size + existing.hooks.size > 0
-  if (!hasAnyExisting) {
+  const hasAnyExisting = hasSetItems(existing)
+  if (!hasAnyExisting && !selectedOverride) {
     console.log(chalk.gray('首次同步，进入交互式选择...\n'))
   }
 
-  const selected = await interactiveSelect(scans, existing)
+  const selected = selectedOverride || await interactiveSelect(scans, selectionDefaults)
   if (selected === null) {
     console.log(chalk.yellow('\n已取消同步。'))
     return
   }
 
-  const selectedPlatforms = await selectPlatforms()
+  const selectedPlatforms = selectedPlatformsOverride || await selectPlatforms()
   if (selectedPlatforms === null) {
     console.log(chalk.yellow('\n已取消同步。'))
     return
   }
 
+  const staleEntries = await collectStaleEntries(projectDir, scans, syncState, selectedPlatforms)
+  const approvedStaleRemovals = staleRemovalsOverride
+    ? normalizeRemovalInput(staleRemovalsOverride)
+    : await promptStaleRemovals(staleEntries)
+  if (approvedStaleRemovals === null) {
+    console.log(chalk.yellow('\n已取消同步。'))
+    return
+  }
+
   let syncedAnySupportedPlatform = false
 
   if (selectedPlatforms.includes('claude')) {
@@ -377,6 +599,7 @@ export async function syncAll({
       sourceDir,
       projectDir,
       selected,
+      staleRemovals: approvedStaleRemovals.claude,
     })
   }
 
@@ -387,6 +610,8 @@ export async function syncAll({
       sourceDir,
       projectDir,
       selected,
+      staleRemovals: approvedStaleRemovals.codex,
+      preserveMissingRules: getPreservedStaleNames(staleEntries, approvedStaleRemovals, 'codex', 'rules'),
     })
   }
 
@@ -396,6 +621,7 @@ export async function syncAll({
       sourceDir,
       projectDir,
       selected,
+      staleRemovals: approvedStaleRemovals.cursor,
     })
   }
 
@@ -405,6 +631,8 @@ export async function syncAll({
       sourceDir,
       projectDir,
       selected,
+      staleRemovals: approvedStaleRemovals.opencode,
+      preserveMissingRules: getPreservedStaleNames(staleEntries, approvedStaleRemovals, 'opencode', 'rules'),
     })
   }
 
@@ -428,6 +656,15 @@ export async function syncAll({
     await cleanupOpenCodePlatform(projectDir, scans)
   }
 
+  for (const platform of Object.keys(PLATFORM_SYNC_TYPES)) {
+    if (selectedPlatforms.includes(platform)) {
+      syncState.platforms[platform] = buildNextPlatformState(selected, staleEntries, approvedStaleRemovals, platform)
+    } else {
+      syncState.platforms[platform] = createEmptyPlatformState()
+    }
+  }
+  await saveSyncState(projectDir, syncState)
+
   if (!syncedAnySupportedPlatform) {
     console.log(chalk.yellow('未选择已接入平台，本次未执行同步。'))
   }

package/src/sync-codex.js

@@ -60,6 +60,32 @@ export function parseManagedRuleNames(content) {
   return names
 }
 
+export function parseManagedRuleSections(content) {
+  const block = content.match(BLOCK_RE)
+  if (!block) return new Map()
+
+  const sections = new Map()
+  const blockContent = block[0]
+  const markerRe = /<!-- dwy-rule:\s*(.+?)\s*-->/g
+  const markers = []
+  let match
+  while ((match = markerRe.exec(blockContent))) {
+    markers.push({
+      name: match[1],
+      index: match.index,
+    })
+  }
+
+  const blockEndIndex = blockContent.lastIndexOf(BLOCK_END)
+  for (let i = 0; i < markers.length; i++) {
+    const start = markers[i].index
+    const end = i + 1 < markers.length ? markers[i + 1].index : blockEndIndex
+    sections.set(markers[i].name, blockContent.slice(start, end).trim())
+  }
+
+  return sections
+}
+
 function upsertManagedBlock(content, blockBody) {
   if (!blockBody.trim()) {
     if (!BLOCK_RE.test(content)) return content
@@ -86,12 +112,21 @@ function upsertBaselineBlock(content, baselineBody) {
   return base ? `${block}\n\n${base}` : `${block}\n`
 }
 
-export async function syncProjectAgentsMd(sourceDir, projectDir, selectedRules) {
+export async function syncProjectAgentsMd(sourceDir, projectDir, selectedRules, {
+  preservedRuleNames = new Set(),
+} = {}) {
   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 selectedRuleNames = new Set(selectedRules.map(rule => rule.name))
+  const existingSections = parseManagedRuleSections(current)
   const sections = []
   for (const rule of selectedRules) sections.push(await ruleToSection(rule))
+  for (const ruleName of preservedRuleNames) {
+    if (selectedRuleNames.has(ruleName)) continue
+    const existingSection = existingSections.get(ruleName)
+    if (existingSection) sections.push(existingSection)
+  }
   const blockBody = sections.join('\n\n---\n\n')
 
   const withBaseline = upsertBaselineBlock(current, baselineBody)
@@ -172,8 +207,16 @@ async function copyCodexHooks(hooks, proj) {
   const dir = path.join(proj, '.codex', 'hooks')
   await fs.ensureDir(dir)
   for (const h of hooks) {
+    if (!await fs.pathExists(h.sourcePath)) {
+      logAction(`.codex/hooks/${h.name}`, 'yellow', '!')
+      continue
+    }
     const dest = path.join(dir, h.name)
     await fs.copy(h.sourcePath, dest, { overwrite: true, filter: copyFilter })
+    if (!await fs.pathExists(dest)) {
+      logAction(`.codex/hooks/${h.name}`, 'yellow', '!')
+      continue
+    }
     await fs.chmod(dest, 0o755)
     logAction(`.codex/hooks/${h.name}`)
   }
@@ -278,6 +321,8 @@ export async function syncCodex({
   sourceDir: sourceDirOverride,
   projectDir,
   selected,
+  staleRemovals = {},
+  preserveMissingRules = new Set(),
 } = {}) {
   const sourceDir = sourceDirOverride || await resolveSourceDir()
   if (!await fs.pathExists(sourceDir)) {
@@ -316,12 +361,20 @@ export async function syncCodex({
   let removedCount = 0
 
   syncedCount += await copySkillsFlat(syncedSelection.skills, proj)
-  syncedCount += await syncProjectAgentsMd(sourceDir, proj, syncedSelection.rules)
+  syncedCount += await syncProjectAgentsMd(sourceDir, proj, syncedSelection.rules, {
+    preservedRuleNames: preserveMissingRules,
+  })
   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))
+  const skillTemplateNames = new Set([
+    ...scans.skills.map(s => s.name),
+    ...(staleRemovals.skills || new Set()),
+  ])
+  const hookTemplateNames = new Set([
+    ...scans.hooks.map(h => h.name),
+    ...(staleRemovals.hooks || new Set()),
+  ])
   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)
 

package/src/sync-cursor.js

@@ -101,12 +101,13 @@ async function syncCursorBaselineRule(sourceDir, projectDir) {
   return 1
 }
 
-async function removeUnselectedCursorRules(existingNames, selectedNames, projectDir) {
+async function removeUnselectedCursorRules(existingNames, selectedNames, managedNames, projectDir) {
   const rulesDir = path.join(projectDir, '.cursor', 'rules')
   let removedCount = 0
 
   for (const name of existingNames) {
     if (selectedNames.has(name)) continue
+    if (!managedNames.has(name)) continue
     await fs.remove(path.join(rulesDir, name))
     logAction(`.cursor/rules/${name}`, 'red', '×')
     removedCount++
@@ -115,7 +116,7 @@ async function removeUnselectedCursorRules(existingNames, selectedNames, project
   return removedCount
 }
 
-async function scanExistingCursorRules(projectDir) {
+export 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 })
@@ -131,6 +132,7 @@ export async function syncCursor({
   sourceDir: sourceDirOverride,
   projectDir,
   selected,
+  staleRemovals = {},
 } = {}) {
   const sourceDir = sourceDirOverride || await resolveSourceDir()
   if (!await fs.pathExists(sourceDir)) {
@@ -148,6 +150,11 @@ export async function syncCursor({
   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)))
+  const managedRuleNames = new Set([
+    ...scans.rules.map(rule => toCursorRuleName(rule.name)),
+    ...[...(staleRemovals.rules || new Set())].map(ruleName => toCursorRuleName(ruleName)),
+    BASELINE_RULE_NAME,
+  ])
 
   let syncedCount = 0
   let removedCount = 0
@@ -155,7 +162,7 @@ export async function syncCursor({
   syncedCount += await syncCursorBaselineRule(sourceDir, proj)
   syncedCount += await syncCursorRules(syncedSelection, proj)
   nextRuleNames.add(BASELINE_RULE_NAME)
-  removedCount += await removeUnselectedCursorRules(existingRules, nextRuleNames, proj)
+  removedCount += await removeUnselectedCursorRules(existingRules, nextRuleNames, managedRuleNames, proj)
 
   console.log(chalk.blue(`\nDone! ${syncedCount} synced${removedCount > 0 ? `, ${removedCount} removed` : ''}.`))
   console.log(chalk.gray(`  Rules → ${path.join(proj, '.cursor', 'rules')}`))

package/src/sync-opencode.js

@@ -46,6 +46,8 @@ export async function syncOpenCode({
   sourceDir: sourceDirOverride,
   projectDir,
   selected,
+  staleRemovals = {},
+  preserveMissingRules = new Set(),
 } = {}) {
   const sourceDir = sourceDirOverride || await resolveSourceDir()
   if (!await fs.pathExists(sourceDir)) {
@@ -80,7 +82,9 @@ export async function syncOpenCode({
   let removedCount = 0
 
   const agentsPath = path.join(proj, 'AGENTS.md')
-  syncedCount += await syncProjectAgentsMd(sourceDir, proj, syncedSelection.rules)
+  syncedCount += await syncProjectAgentsMd(sourceDir, proj, syncedSelection.rules, {
+    preservedRuleNames: preserveMissingRules,
+  })
 
   syncedCount += await copyItemsTo(openCodeDir, 'skills', syncedSelection.skills)
   syncedCount += await copyItemsTo(openCodeDir, 'commands', syncedSelection.commands)
@@ -89,14 +93,20 @@ export async function syncOpenCode({
     'skills',
     existing.skills,
     new Set(syncedSelection.skills.map(item => item.name)),
-    new Set(scans.skills.map(item => item.name)),
+    new Set([
+      ...scans.skills.map(item => item.name),
+      ...(staleRemovals.skills || new Set()),
+    ]),
     proj,
   )
   removedCount += await removeUnselected(
     'commands',
     existing.commands,
     new Set(syncedSelection.commands.map(item => item.name)),
-    new Set(scans.commands.map(item => item.name)),
+    new Set([
+      ...scans.commands.map(item => item.name),
+      ...(staleRemovals.commands || new Set()),
+    ]),
     proj,
   )
 

package/src/sync.js

@@ -1,7 +1,7 @@
 import fs from 'fs-extra'
 import path from 'path'
 import { groupMultiselect, isCancel, select } from '@clack/prompts'
-import { PACKAGE_ROOT, chalk } from './utils.js'
+import { chalk, DEFAULT_TEMPLATE_REPO_URL, getDwyHomeDir, runGit } from './utils.js'
 
 const CATEGORIES = [
   { key: 'skills', label: 'Skills' },
@@ -21,6 +21,12 @@ const COPY_EXCLUDE_PATTERNS = [
   /\.pyc$/,
 ]
 
+const TEMPLATE_SOURCE_CANDIDATES = [
+  ['dwy-cli', 'templates', 'ai-tools'],
+  ['claude-cli', 'templates', 'ai-tools'],
+  ['templates', 'ai-tools'],
+]
+
 export function copyFilter(src) {
   return !COPY_EXCLUDE_PATTERNS.some(re => re.test(src))
 }
@@ -307,6 +313,55 @@ export function logAction(label, color = 'green', prefix = '✓') {
   console.log(chalk[color](`  ${prefix} ${label}`))
 }
 
+function getTemplateRepoCacheDir() {
+  return path.join(getDwyHomeDir(), 'cache', 'dwy')
+}
+
+async function resolveTemplateDirFromRepo(repoDir) {
+  for (const segments of TEMPLATE_SOURCE_CANDIDATES) {
+    const candidate = path.join(repoDir, ...segments)
+    if (await fs.pathExists(candidate)) return candidate
+  }
+
+  throw new Error(`ai-tools templates not found in repo: ${repoDir}`)
+}
+
+async function readGitOriginUrl(repoDir) {
+  try {
+    return await runGit(['-C', repoDir, 'remote', 'get-url', 'origin'])
+  } catch {
+    return ''
+  }
+}
+
+async function ensureTemplateRepoCache() {
+  const repoDir = getTemplateRepoCacheDir()
+  const repoRoot = path.dirname(repoDir)
+  await fs.ensureDir(repoRoot)
+
+  const hasGitDir = await fs.pathExists(path.join(repoDir, '.git'))
+  if (hasGitDir) {
+    const originUrl = await readGitOriginUrl(repoDir)
+    if (!originUrl || originUrl !== DEFAULT_TEMPLATE_REPO_URL) {
+      console.log(chalk.gray('缓存模板仓库 origin 已变更，重建缓存...'))
+      await fs.remove(repoDir)
+    }
+  } else if (await fs.pathExists(repoDir)) {
+    console.log(chalk.gray('缓存目录不是 git 仓库，重建缓存...'))
+    await fs.remove(repoDir)
+  }
+
+  if (!await fs.pathExists(path.join(repoDir, '.git'))) {
+    console.log(chalk.gray('拉取模板仓库...'))
+    await runGit(['clone', DEFAULT_TEMPLATE_REPO_URL, repoDir])
+    return repoDir
+  }
+
+  console.log(chalk.gray('更新模板仓库...'))
+  await runGit(['-C', repoDir, 'pull', '--ff-only'])
+  return repoDir
+}
+
 async function copyItems(items, targetDir) {
   for (const item of items) {
     const dest = path.join(targetDir, item.type + 's', item.name)
@@ -322,8 +377,16 @@ async function copyHooks(items, targetDir) {
   const hooksTargetDir = path.join(targetDir, 'hooks')
   await fs.ensureDir(hooksTargetDir)
   for (const hook of items) {
+    if (!await fs.pathExists(hook.sourcePath)) {
+      logAction(`hooks/${hook.name}`, 'yellow', '!')
+      continue
+    }
     const dest = path.join(hooksTargetDir, hook.name)
     await fs.copy(hook.sourcePath, dest, { overwrite: true, filter: copyFilter })
+    if (!await fs.pathExists(dest)) {
+      logAction(`hooks/${hook.name}`, 'yellow', '!')
+      continue
+    }
     await fs.chmod(dest, 0o755)
     logAction(`hooks/${hook.name}`)
   }
@@ -454,17 +517,23 @@ async function syncClaudeBaselineDoc(sourceDir, targetDir) {
 }
 
 export async function resolveSourceDir() {
-  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 explicitSourceDir = process.env.DWY_TEMPLATE_SOURCE_DIR
+  if (explicitSourceDir) {
+    if (!await fs.pathExists(explicitSourceDir)) {
+      throw new Error(`DWY_TEMPLATE_SOURCE_DIR not found: ${explicitSourceDir}`)
+    }
+    return explicitSourceDir
   }
-  return packagedTemplate
+
+  const repoDir = await ensureTemplateRepoCache()
+  return resolveTemplateDirFromRepo(repoDir)
 }
 
 export async function syncClaude({
   sourceDir: sourceDirOverride,
   projectDir,
   selected,
+  staleRemovals = {},
 } = {}) {
   const sourceDir = sourceDirOverride || await resolveSourceDir()
   if (!await fs.pathExists(sourceDir)) {
@@ -481,6 +550,20 @@ export async function syncClaude({
     commands: await scanCommands(sourceDir),
     hooks: await scanHooks(sourceDir),
   }
+  const availableHooks = []
+  for (const hook of scans.hooks) {
+    if (await fs.pathExists(hook.sourcePath)) {
+      availableHooks.push(hook)
+    }
+  }
+  if (availableHooks.length < scans.hooks.length) {
+    const missing = scans.hooks
+      .filter(h => !availableHooks.includes(h))
+      .map(h => h.name)
+      .join('、')
+    logAction(`hooks skipped: ${missing}`, 'yellow', '!')
+  }
+  scans.hooks = availableHooks
   console.log(chalk.yellow(`Found ${scans.skills.length} skills, ${scans.rules.length} rules, ${scans.commands.length} commands, ${scans.hooks.length} hooks\n`))
 
   const existing = {
@@ -499,6 +582,10 @@ export async function syncClaude({
   }
 
   const selectedHookNames = new Set(syncedSelection.hooks.map(h => h.name))
+  const approvedStaleSkills = staleRemovals.skills || new Set()
+  const approvedStaleRules = staleRemovals.rules || new Set()
+  const approvedStaleCommands = staleRemovals.commands || new Set()
+  const approvedStaleHooks = staleRemovals.hooks || new Set()
 
   console.log(chalk.blue(`\nSyncing to ${projectTargetDir}...\n`))
   await fs.ensureDir(projectTargetDir)
@@ -513,10 +600,10 @@ export async function syncClaude({
   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))
+  const skillTemplateNames = new Set([...scans.skills.map(s => s.name), ...approvedStaleSkills])
+  const ruleTemplateNames = new Set([...scans.rules.map(r => r.name), ...approvedStaleRules])
+  const commandTemplateNames = new Set([...scans.commands.map(c => c.name), ...approvedStaleCommands])
+  const hookTemplateNames = new Set([...scans.hooks.map(h => h.name), ...approvedStaleHooks])
   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)

package/src/utils.js

@@ -1,12 +1,32 @@
 import fs from 'fs-extra'
+import os from 'node:os'
 import path from 'path'
 import Handlebars from 'handlebars'
 import chalk from 'chalk'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
 import { fileURLToPath } from 'url'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const execFileAsync = promisify(execFile)
 
 export const PACKAGE_ROOT = path.resolve(__dirname, '..')
+export const DEFAULT_TEMPLATE_REPO_URL = process.env.DWY_REPO_URL || 'https://github.com/danweiyuancircle/dwy-ai-experience.git'
+
+export function getDwyHomeDir() {
+  return process.env.DWY_HOME || path.join(os.homedir(), '.dwy')
+}
+
+export async function runGit(args, options = {}) {
+  try {
+    const { stdout } = await execFileAsync('git', args, options)
+    return stdout.trim()
+  } catch (error) {
+    const stderr = error.stderr?.trim()
+    const details = stderr ? `: ${stderr}` : ''
+    throw new Error(`git ${args.join(' ')} failed${details}`)
+  }
+}
 
 export async function renderTemplate(templateDir, destDir, context) {
   const entries = await fs.readdir(templateDir, { withFileTypes: true })

package/templates/ai-tools/rules/Android/dwy-android-core.md

@@ -97,6 +97,8 @@ res/drawable/
 #### mipmap / 9-patch / 模块前缀
 
 - **mipmap 只放启动图标**(`ic_launcher` 系列),其余图片一律放 `drawable` —— mipmap 会跨密度保留资源,普通图放 mipmap 白白增大包体
+- 应用图标设计稿只提供 `mipmap-xxxhdpi` 目录下的 `192x192` 启动图标源图,其余密度版本交给系统或构建流程派生。
+- 图标主体必须预留至少 `10%` 安全边距,避免启动器缩放、遮罩或厂商裁切时贴边缺角。
 - **9-patch 图保留 `.9` 后缀**:`bg_chat_bubble.9.png`
 - **模块前缀(可选)**:多模块 / 大型项目推荐资源加业务模块前缀,便于检索、避免跨模块重名 —— `user_activity_login.xml`、id `user_tv_name`;单模块 / 老项目可省略,保持本规范其余示例的无前缀写法
 
@@ -783,4 +785,4 @@ val result = calculate(x)
 | 21  | Gradle 脚本(Groovy / kts):锁版本 / `exclude` / 自定义 task / 变体 / 关键魔法值有 why 注释,无复述式、无注释掉的配置块                                                                                                                                     | ✓        |
 
 
-**不执行自检就提交代码 = 违规。**
+**不执行自检就提交代码 = 违规。**

package/templates/ai-tools/rules/iOS/dwy-ios-layout-adaptation.md

@@ -0,0 +1,47 @@
+---
+description: iOS 适配开发与原型基准规范（393pt 主基准、安全区、自适应布局）
+paths:
+  - "**/*.swift"
+---
+
+## iOS 适配基线
+
+- iOS 布局统一使用 `pt`，不要按 `px` 做分辨率换算。
+- iOS 适配依赖 SwiftUI 自适应布局 + Safe Area，不为每个机型单独写一套尺寸。
+- 原型图与开发都以同一套布局意图为准，原型不是按像素缩放给不同机型。
+
+## 原型基准尺寸
+
+- 做 iOS 原型图时，统一基于 `393×852 pt` 制作，对齐 `iPhone 15 / iPhone 16` 主流尺寸。
+- `393×852 pt` 是视觉基准，不是要求开发写死页面宽高。
+- 切图资源按系统倍率处理，布局本身仍按 `pt` 思考。
+
+## 适配验证矩阵
+
+- 小屏下限按 `375pt` 宽验证，不允许关键内容挤压、截断、横向溢出。
+- 主基准按 `393pt` 宽设计与开发。
+- 大屏上限按 `430pt` 宽验证，要求布局自然放宽，不靠写死间距撑版。
+
+## 布局规则
+
+- 页面容器、列表、卡片宽度优先 `maxWidth: .infinity` 或等价自适应写法。
+- 间距优先用 `Spacer`、stack、grid、`safeAreaInset` 等布局系统能力，不用绝对 `offset` 拼版。
+- 禁止用 `UIScreen.main.bounds` 为页面主布局做硬编码换算，优先 `GeometryReader` 或容器相对布局。
+- 具有固定视觉比例的实体控件可以使用固定 `pt` 尺寸，但外层容器必须自适应。
+
+## 安全区
+
+- 前景内容默认在安全区内布局，不进入刘海、灵动岛、Home 指示条区域。
+- 全屏背景、遮罩可用 `ignoresSafeArea()`，但不能让主要交互内容越过安全区。
+- 禁止写死状态栏、刘海、底部 Home 条高度，统一依赖系统安全区。
+
+## 字体与可访问性
+
+- 字号优先语义化管理，避免页面散落裸值。
+- 关键文案默认兼容 Dynamic Type，系统字体放大后不能破版。
+
+## 开发验证
+
+- 至少验证三档宽度：`375pt`、`393pt`、`430pt`。
+- 检查内容是否被刘海、灵动岛、Home 指示条遮挡。
+- 检查滚动页、底部固定栏、弹层在小屏和大屏下都无错位或裁切。

package/templates/ai-tools/rules/iOS/dwy-swift-core.md

@@ -53,6 +53,8 @@ private let motionSpring = Animation.spring(response: 0.5, dampingFraction: 0.75
 ## 图标与文案
 
 - 图标优先 `Image(systemName:)`，无符号则用成熟 SVG。
+- iOS 应用图标设计稿只提供一张 `1024x1024` 的 PNG 源图，由系统生成各尺寸适配版本。
+- 图标主体必须预留至少 `10%` 安全边距，避免系统缩放、圆角遮罩或视觉放大时被切边。
 - 文案禁止 emoji，禁止硬编码，统一 `loc("key")`。
 - 禁止使用 emoji 作为功能说明、状态、提示。
 

package/templates/ai-tools/skills//345/205/203/345/267/245/345/205/267/dwy-shared/SKILL.md

@@ -40,7 +40,7 @@ skill 与 dwy-shared 仓库深度绑定但**不硬编码路径**。每次执行
 CONFIG="$HOME/.config/dwy-shared/repo.json"
 if [ -f "$CONFIG" ]; then
   REPO_PATH=$(jq -r .repo_path "$CONFIG" 2>/dev/null)
-  if [ -n "$REPO_PATH" ] && [ -d "$REPO_PATH/.git" ] && [ -d "$REPO_PATH/claude-cli/templates/ai-tools" ]; then
+  if [ -n "$REPO_PATH" ] && [ -d "$REPO_PATH/.git" ] && [ -d "$REPO_PATH/dwy-cli/templates/ai-tools" ]; then
     echo "OK: $REPO_PATH"
   else
     echo "INVALID"
@@ -69,7 +69,7 @@ fi
    - `test -d "$PATH"` 路径存在
    - `test -d "$PATH/.git"` 是 git 仓库
    - `git -C "$PATH" remote -v | grep -q dwy-shared` remote 指向 dwy-shared
-   - `test -d "$PATH/claude-cli/templates/ai-tools"` 含特征目录
+   - `test -d "$PATH/dwy-cli/templates/ai-tools"` 含特征目录
 4. 全部通过 → 写缓存：
 
    ```bash
@@ -114,7 +114,7 @@ fi
 ### 步骤 3：读现有分类 + 准备推荐上下文
 
 ```bash
-TYPE_DIR="$REPO_PATH/claude-cli/templates/ai-tools/<type>"
+TYPE_DIR="$REPO_PATH/dwy-cli/templates/ai-tools/<type>"
 for cat in "$TYPE_DIR"/*/; do
   echo "=== $(basename "$cat") ==="
   # 读分类下第一个样例的 description 行（前 100 字）
@@ -141,7 +141,7 @@ done
 ### 步骤 6：执行文件操作
 
 ```bash
-TARGET_DIR="$REPO_PATH/claude-cli/templates/ai-tools/<type>/<category>"
+TARGET_DIR="$REPO_PATH/dwy-cli/templates/ai-tools/<type>/<category>"
 mkdir -p "$TARGET_DIR"
 
 # 源在仓库外：cp

package/templates/ai-tools/skills//350/204/232/346/211/213/346/236/266/dwy-fullstack-scaffold/SKILL.md

@@ -183,7 +183,7 @@ description: "调用 dwy create CLI 生成全栈 Vue 3 + FastAPI monorepo 骨架
 | 症状 | 原因 | 解决 |
 |------|------|------|
 | `dwy create` 命令找不到 | create-dwy 未安装或不在 PATH | `pnpm i -g create-dwy` 或在 dwy-shared 仓库 `pnpm link --global` |
-| `dwy create` 报模板找不到 | Gitee 缓存过期或 dwy-shared 未推送最新版 | 删 `~/.dwy/cache/` 重试，确认 Gitee 上 dwy-shared 含 `fullstack-monorepo` 模板 |
+| `dwy create` 报模板找不到 | 当前版本 CLI 未包含对应模板，或用户本机 install 的版本落后 | 升级 `create-dwy` 到最新版本；确认 `dwy --version` 与线上版本一致后重试 |
 | `uv sync` 报 dwyeapi 找不到 | aliyun 镜像未同步 | pyproject 已声明 pypi-org 备 index，确保 uv >=0.4 |
 | `pnpm install` 报 catalog 找不到 | pnpm <10 不支持 catalog | 升级: `npm i -g pnpm@latest` |
 | backend health check 失败 | DATABASE_URL/SECRET_KEY 用了占位值导致启动报错 | 检查 .env 是否已 cp 自 .env.example；查 uvicorn stderr 输出 |