axhub-make 1.0.6 → 1.0.7

package/AI-ASSISTANT-GUIDE.md

@@ -63,11 +63,10 @@
 | 跳过依赖安装 | `--no-install` | 不自动安装 |
 | 跳过启动 | `--no-start` | 不自动启动 |
 | 强制模式 | `--force` | 确认风险后使用 |
-| **冲突处理** | `--conflict keep` | keep=保留本地 |
-| **冲突处理** | `--conflict overwrite` | overwrite=覆盖本地 |
-| **预检查模式** | `pre` | 仅检查冲突，不实际操作 |
 | **指定模板源** | `-t <url>` 或 `--template <url>` | 手动指定 Git 仓库 URL |
 
+**注意**：`--conflict` 参数已内部化，默认使用 `overwrite` 模式，不对外暴露。
+
 ---
 
 ## 🔄 更新模式核心流程
@@ -113,108 +112,77 @@ CLI 会检测目标目录是否包含：
 如果都存在 → **更新模式**  
 否则 → **初始化模式**
 
-### 2️⃣ 冲突处理策略
-
-**冲突规则配置文件：`scaffold.update.json`**
-
-⚠️ **重要**：在处理冲突前，你应该先查看项目中的 `scaffold.update.json` 文件，了解冲突规则配置。
-
-**配置文件示例：**
-```json
-{
-  "schemaVersion": 1,
-  "neverOverwrite": [
-    "src/**",
-    "assets/**"
-  ],
-  "alwaysOverwrite": [
-    "src/common/**"
-  ],
-  "conflictCheck": [
-    "package.json"
-  ],
-  "defaultOverwrite": true
-}
-```
+### 2️⃣ 默认覆盖策略（简化流程）⭐
+
+**核心原则：默认直接覆盖，无需用户选择**
+
+CLI 现在默认使用 `overwrite` 模式，会自动：
+- 覆盖所有需要更新的文件
+- **自动备份配置文件**（如 package.json）
+- 自动合并旧配置中的自定义内容
+- 保护用户的业务文件（src/**、assets/**）
 
-**冲突文件分类（优先级从高到低）：**
-- `alwaysOverwrite`：**最高优先级**，强制覆盖的文件
-  - 即使文件匹配 `neverOverwrite` 规则，也会被覆盖
-  - 当前配置：`src/common/**`（脚手架公共代码，需要保持同步）
-  - 使用场景：框架核心文件、类型定义等需要随模板更新的文件
-- `conflictCheck`：需要检查的文件（如配置文件）
-  - 当前配置：`package.json`
-  - 未来可能添加：`vite.config.ts`、`tsconfig.json` 等
-- `neverOverwrite`：永不覆盖的文件（如用户数据）
-  - 当前配置：`src/**`、`assets/**`（用户业务代码和资源）
-  - 注意：会被 `alwaysOverwrite` 规则覆盖
-- `defaultOverwrite`：默认行为（true = 其他文件默认覆盖）
-
-**你的工作流程：**
-1. 执行 `npx -y axhub-make pre` 检查冲突
-2. 如果有冲突，读取 `scaffold.update.json` 了解规则
-3. 向用户解释哪些文件会冲突以及原因
-4. 根据用户选择执行对应操作
-
-**用户场景映射：**
-
-| 用户说 | 你的行为 |
-|-------|---------|
-| "更新项目" | 先执行 `npx -y axhub-make pre` 检查冲突 |
-| "有冲突吗？" | 执行 `pre` 模式，解析 JSON 输出 |
-| "保留我的修改" / "保留" | 使用 `--conflict keep`（默认） |
-| "用新版本覆盖" / "覆盖" | 使用 `--conflict overwrite` + 确认 |
-| "智能合并" / "帮我合并" | 进入智能合并流程 |
-| "我想看看冲突文件" | 执行 `pre`，列出 `conflicts` 数组 |
-| "为什么这个文件会冲突？" | 查看 `scaffold.update.json`，解释规则 |
-
-### 3️⃣ 智能冲突处理流程
+**文件处理规则：**
+- 脚手架文件：自动更新
+- 配置文件：备份后更新，保留自定义内容
+- 用户业务文件：永不覆盖
+
+### 3️⃣ 简化的更新流程
 
 ```
 用户："更新项目"
   ↓
-执行：npx -y axhub-make pre
-  ↓
-解析输出：{ mode: "update", conflicts: [...] }
+你：直接执行更新
+  npx -y axhub-make
   ↓
-如果 conflicts.length > 0：
-  → 列出冲突文件
-  → 询问："这些文件有本地修改，请选择：
-     1️⃣ 保留 - 保留本地版本
-     2️⃣ 覆盖 - 使用模板版本  
-     3️⃣ 智能合并 - AI 帮你合并（推荐）"
-  → 根据回答执行：
-     • 保留 → npx -y axhub-make --conflict keep
-     • 覆盖 → npx -y axhub-make --conflict overwrite
-     • 智能合并 → 智能合并流程
+CLI 自动完成：
+  1. 下载最新模板
+  2. 备份配置文件
+  3. 更新项目文件
+  4. 安装依赖
   ↓
-如果 conflicts.length === 0：
-  → 直接执行：npx -y axhub-make
+更新完成后，提示用户：
+  "✅ 更新完成！已自动备份配置文件。
+  
+  请测试项目功能，有问题随时告诉我。"
+```
+
+### 4️⃣ 问题处理流程
+
+**当用户反馈问题时：**
+
+```
+用户："更新后启动报错了"
+你：
+  1. 查看错误信息
+  2. 检查备份文件，对比差异
+  3. 分析问题原因
+  4. 提供解决方案或恢复备份
 ```
 
 ---
 
 ## 🗣️ 对话策略
 
-### 原则：猜参数，不问参数
+### 原则：直接执行，减少询问
 
 **好的示例：**
 > 用户："更新一下项目"  
-> 你："好的，我先检查是否有冲突文件..."  
-> 执行：`npx -y axhub-make pre`
+> 你："好的，开始更新项目..."  
+> 执行：`npx -y axhub-make`
+> 完成后："✅ 更新完成！package.json 已自动备份。请测试项目功能，有问题随时告诉我。"
 
 **不好的示例：**
-> 你："你要用 npm 还是 pnpm？要不要安装依赖？"  
+> 你："你要保留本地文件还是覆盖？要用 npm 还是 pnpm？"  
 > ❌ 过度询问
 
 ### 必须提问的场景
 
 **仅在以下情况提问：**
 1. 当前目录非空 + 用户要在当前目录初始化
-2. 检测到冲突文件（更新模式）
-3. 用户明确要求覆盖/重装
+2. 用户明确要求覆盖/重装时需要确认风险
 
-**其他情况：使用安全默认值**
+**其他情况：直接执行，使用默认值**
 
 ---
 
@@ -223,140 +191,45 @@ CLI 会检测目标目录是否包含：
 ### 场景 1：初始化新项目
 ```
 用户："创建一个新项目"
-你：npx -y axhub-make my-project --install --start
+你：npx -y axhub-make my-project
 ```
 
-### 场景 2：更新现有项目（无冲突）
+### 场景 2：更新现有项目
 ```
 用户："更新项目"
 你：
-  1. npx -y axhub-make pre
-  2. 解析输出 → conflicts: []
-  3. npx -y axhub-make --install
-```
-
-### 场景 3：更新项目（有冲突）
-```
-用户："更新项目"
-你：
-  1. npx -y axhub-make pre
-  
-  2. 解析输出 → conflicts: ["package.json"], templateDir: "/tmp/axhub-make-xxx"
-  
-  3. 读取 scaffold.update.json 了解冲突规则
+  1. npx -y axhub-make
   
-  4. 提示："检测到 1 个冲突文件：
-     
-     📦 package.json
-        原因：此文件在 conflictCheck 列表中，可能包含你的自定义依赖
-     
-     ℹ️  以下文件会被保护，不会覆盖：
-     • src/** - 你的业务代码（除了 src/common/**）
-     • assets/** - 你的资源文件
-     
-     ℹ️  以下文件会强制更新（保持与模板同步）：
-     • src/common/** - 脚手架公共代码和类型定义
-     
-     请选择处理方式：
-     
-     1️⃣ 保留 - 保留你的本地版本（推荐，安全）
-     2️⃣ 覆盖 - 使用模板的新版本（会丢失本地修改）
-     3️⃣ 智能合并 - 让我帮你合并两个版本的内容（推荐）
-     
-     请回复：保留 / 覆盖 / 智能合并"
-     
-  5. 根据回答执行：
-     • 保留 → npx -y axhub-make --conflict keep
-     • 覆盖 → npx -y axhub-make --conflict overwrite
-     • 智能合并 → 进入智能合并流程（见场景 7）
+  2. 更新完成后提示：
+     "✅ 更新完成！已自动备份配置文件。
+     请测试项目功能，有问题随时告诉我。"
 ```
 
-### 场景 4：用户主动要求覆盖
+### 场景 3：更新后出现问题
 ```
-用户："更新项目，直接覆盖所有文件"
+用户："更新后启动报错了"
 你：
-  1. 确认："这将覆盖所有冲突文件，可能丢失本地修改。确认吗？"
-  2. 用户确认后：
-     npx -y axhub-make --conflict overwrite
+  1. "让我看看错误信息..."
+  2. 检查备份文件，对比差异
+  3. 分析问题并提供解决方案
+  4. 如需要可以恢复备份
 ```
 
-### 场景 5：仅检查冲突
+### 场景 4：恢复备份
 ```
-用户："看看更新会影响哪些文件"
+用户："还是用回旧版本的配置吧"
 你：
-  1. npx -y axhub-make pre
-  
-  2. 读取 scaffold.update.json 了解规则
-  
-  3. 友好展示结果：
-     "📋 更新影响分析：
-     
-     ✅ 会自动更新的文件：
-     • vite.config.ts
-     • tsconfig.json
-     • src/common/** - 脚手架公共代码（强制更新）
-     • 其他脚手架文件
-     
-     ⚠️  需要确认的冲突文件：
-     • package.json（在 conflictCheck 列表中）
-     
-     🔒 永不覆盖的文件：
-     • src/** - 你的业务代码（除了 src/common/**）
-     • assets/** - 你的资源文件
-     
-     当前冲突文件：package.json
-     建议选择智能合并来保留你的自定义配置。"
+  1. 找到备份文件（.backup.{timestamp}）
+  2. 恢复备份并重新安装依赖
+  3. "已恢复旧版本配置。现在试试看？"
 ```
 
-### 场景 6：重新安装依赖
+### 场景 5：重新安装依赖
 ```
 用户："依赖坏了，重装一下"
 你：npx -y axhub-make --no-start
-（更新模式会重新复制文件并安装依赖）
-```
-
-### 场景 7：智能合并冲突文件 ⭐
-```
-用户选择："智能合并"
-你：
-  1. 先执行 keep 模式保护用户数据：
-     npx -y axhub-make --conflict keep
-     
-  2. 对每个冲突文件执行智能合并：
-     a. 读取本地文件内容（用户版本）
-     b. 从模板仓库获取新版本内容
-     c. 分析两个版本的差异
-     d. 智能合并：
-        - 保留用户的自定义配置
-        - 合并模板的新功能和修复
-        - 处理冲突部分（优先保留用户修改）
-     e. 展示合并结果，询问确认
-     f. 用户确认后写入文件
-     
-  3. 示例对话：
-     "正在合并 vite.config.ts...
-     
-     发现以下差异：
-     • 你添加了自定义插件：customPlugin()
-     • 模板更新了构建配置：build.target
-     
-     合并策略：
-     ✓ 保留你的 customPlugin
-     ✓ 应用模板的 build.target 更新
-     
-     合并后的内容：
-     [显示合并后的代码]
-     
-     确认应用这个合并吗？（是/否/手动编辑）"
 ```
 
-**智能合并的核心原则：**
-- 用户的业务逻辑 > 模板的默认配置
-- 模板的新功能和修复 > 旧版本代码
-- 有疑问时询问用户，不要擅自决定
-- 提供清晰的 diff 展示
-- 支持用户手动调整合并结果
-
 ---
 
 ## 🛡️ 风险确认机制
@@ -365,27 +238,19 @@ CLI 会检测目标目录是否包含：
 
 **1. 非空目录初始化**
 ```
-检测到当前目录非空，包含以下文件：
-- README.md
-- package.json
-
-继续将覆盖这些文件。确认吗？(yes/no)
+检测到当前目录非空，继续将覆盖现有文件。确认吗？(yes/no)
 ```
 
-**2. 覆盖冲突文件**
+**2. 强制模式**
 ```
-以下文件将被覆盖：
-- vite.config.ts (你的自定义配置)
-- entries.json (你的页面配置)
-
-确认覆盖吗？(yes/no)
+--force 将跳过所有安全检查。确认吗？(yes/no)
 ```
 
-**3. 强制模式**
-```
---force 将跳过所有安全检查。
-仅在你明确知道后果时使用。确认吗？(yes/no)
-```
+**注意**：更新模式不再需要确认，因为：
+- 默认自动覆盖，提升效率
+- 配置文件自动备份，保证安全
+- 用户业务文件受保护，不会被覆盖
+- 出现问题时可以通过备份恢复
 
 ---
 
@@ -427,65 +292,26 @@ CLI 会检测目标目录是否包含：
 
 ## 📊 输出解析
 
-### pre 模式输出格式
-```json
-{
-  "mode": "update",
-  "conflictMode": "keep",
-  "conflicts": [
-    "vite.config.ts",
-    "package.json"
-  ]
-}
-```
+### 更新完成后的输出
+CLI 会输出更新摘要，包括：
+- 已更新文件数量
+- 已覆盖文件列表
+- 跳过文件列表（受保护的用户文件）
+- 备份文件路径
 
 ### 你的处理逻辑
-```javascript
-if (output.mode === "update" && output.conflicts.length > 0) {
-  // 1. 展示冲突文件
-  // 2. 询问用户意图
-  // 3. 如果选择智能合并：
-  //    - 使用 templateDir 读取模板文件
-  //    - 对比本地文件和模板文件
-  //    - 执行智能合并
-  // 4. 否则执行带 --conflict 参数的命令
-} else {
-  // 直接执行更新
-}
 ```
+更新完成后：
+  1. 确认备份文件已创建
+  2. 提示用户测试项目
+  3. 告知如有问题可协助处理
+  4. 等待用户反馈
 
-### 临时目录使用场景
-
-**场景 1：pre 命令执行失败**
-```
-用户："更新项目"
-你：执行 npx -y axhub-make pre
-  ↓
-命令失败或输出解析失败
-  ↓
-你：尝试手动读取临时目录
-  1. 查找最新的 /tmp/axhub-make-* 目录
-  2. 读取 scaffold.update.json 获取冲突规则
-  3. 手动对比文件差异
-  4. 继续智能合并流程
-```
-
-**场景 2：智能合并时读取模板文件**
-```
-用户选择："智能合并"
-你：
-  1. 从 pre 输出获取 templateDir
-  
-  2. 读取 scaffold.update.json 了解冲突规则
-  
-  3. 对每个冲突文件（当前只有 package.json）：
-     - 读取本地文件：{projectDir}/package.json
-     - 读取模板文件：{templateDir}/package.json
-     - 对比差异并智能合并
-     
-  4. 合并完成后，临时目录会在下次更新时自动清理
-  
-  5. 如果未来 conflictCheck 添加了新文件，重复步骤 3
+如果用户报告问题：
+  1. 读取备份文件
+  2. 对比新旧版本
+  3. 分析问题原因
+  4. 提供解决方案或恢复备份
 ```
 
 ---
@@ -493,24 +319,23 @@ if (output.mode === "update" && output.conflicts.length > 0) {
 ## ✅ 成功标准
 
 **你的任务完成标志：**
-1. 成功执行了正确的 `npx -y axhub-make ...` 命令
-2. 用户的目标达成（项目初始化/更新完成）
-3. 冲突文件按用户意图处理
-4. 没有数据丢失或意外覆盖
+1. 成功执行 CLI 命令
+2. 项目初始化/更新完成
+3. 提示用户测试功能
+4. 告知备份位置，以便出现问题时恢复
+5. 准备好协助处理更新后的问题
 
 ---
 
 ## 🎯 关键要点总结
 
-1. **自动源选择**：CLI 自动检测并选择可访问的仓库（GitHub/Gitee）
-2. **更新前先检查**：使用 `pre` 模式预检查冲突
-3. **查看冲突规则**：读取 `scaffold.update.json` 了解配置
-4. **默认安全策略**：`--conflict keep` 保护用户数据
-5. **明确风险提示**：覆盖操作必须确认
-6. **一条命令原则**：所有操作最终落到一条 CLI 命令
-7. **环境优先检查**：Node/Git 缺失时先协助安装
-8. **智能猜测意图**：减少不必要的询问
-9. **友好展示结果**：解析 JSON 输出为人类可读格式
-10. **智能合并优先**：有冲突时推荐用户选择智能合并
-11. **利用临时目录**：pre 模式保留 templateDir，方便智能对比
-12. **中文交互**：所有用户提示和选项使用中文
+1. **自动源选择**：CLI 自动选择可访问的仓库（GitHub/Gitee）
+2. **默认覆盖**：直接覆盖更新，无需用户选择
+3. **自动备份**：配置文件自动备份
+4. **内容合并**：自动合并用户的自定义配置
+5. **用户文件保护**：业务文件永不覆盖
+6. **测试提示**：更新后提示用户测试
+7. **问题协助**：利用备份文件协助解决问题
+8. **一条命令**：所有操作落到一条 CLI 命令
+9. **减少询问**：直接执行，只在必要时确认
+10. **简单语言**：用非技术人员能理解的语言交流

package/bin/index.js

@@ -45,9 +45,7 @@ function matchesAny(relPath, patterns) {
   return patterns.some((pattern) => globToRegExp(pattern).test(p));
 }
 
-function isValidConflictMode(v) {
-  return v === 'keep' || v === 'overwrite';
-}
+// 移除 conflict mode 验证函数，业务上强制使用 overwrite
 
 async function readUpdateRules(tmpDir) {
   const rulesPath = path.join(tmpDir, 'scaffold.update.json');
@@ -162,6 +160,42 @@ async function planUpdateFromTemplate(tmpDir, targetDir, rules, conflictMode) {
   return { copied, skipped, conflicts, wouldOverwriteConflicts };
 }
 
+async function mergePackageJson(oldPkgPath, newPkgPath, targetDir) {
+  const oldPkg = await fs.readJson(oldPkgPath);
+  const newPkg = await fs.readJson(newPkgPath);
+  
+  // 备份旧版本
+  const backupPath = path.join(targetDir, `package.json.backup.${Date.now()}`);
+  await fs.copyFile(oldPkgPath, backupPath);
+  console.log(chalk.yellow(`📦 已备份旧版本 package.json 到: ${path.basename(backupPath)}`));
+  
+  // 合并依赖：将旧版本独有的依赖添加到新版本
+  const depTypes = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+  let addedCount = 0;
+  
+  for (const depType of depTypes) {
+    if (oldPkg[depType]) {
+      if (!newPkg[depType]) {
+        newPkg[depType] = {};
+      }
+      
+      for (const [pkg, version] of Object.entries(oldPkg[depType])) {
+        if (!newPkg[depType][pkg]) {
+          newPkg[depType][pkg] = version;
+          addedCount++;
+          console.log(chalk.green(`  ✓ 添加依赖: ${pkg}@${version} (${depType})`));
+        }
+      }
+    }
+  }
+  
+  if (addedCount > 0) {
+    console.log(chalk.green(`📦 已从旧版本合并 ${addedCount} 个依赖到新版本`));
+  }
+  
+  return newPkg;
+}
+
 async function applyUpdateFromTemplate(tmpDir, targetDir, rules, conflictMode) {
   const templateFiles = await listFilesRecursive(tmpDir);
   const copied = [];
@@ -177,21 +211,44 @@ async function applyUpdateFromTemplate(tmpDir, targetDir, rules, conflictMode) {
     const destPath = path.join(targetDir, relPath);
     const destExists = await fs.pathExists(destPath);
 
-    if (matchesAny(relPosix, rules.conflictCheck) && destExists) {
+    // 特殊处理 package.json：备份 + 合并依赖
+    if (relPosix === 'package.json' && destExists) {
       const same = await filesEqual(destPath, srcPath);
       if (!same) {
         conflicts.push(relPosix);
-        if (conflictMode !== 'overwrite') continue;
-        await fs.ensureDir(path.dirname(destPath));
-        await fs.copyFile(srcPath, destPath);
+        // package.json 始终使用新版本，但合并旧版本的依赖
+        const mergedPkg = await mergePackageJson(destPath, srcPath, targetDir);
+        await fs.writeJson(destPath, mergedPkg, { spaces: 2 });
         overwrittenConflicts.push(relPosix);
         copied.push(relPosix);
         continue;
       }
+      // 文件内容相同，无需操作
       continue;
     }
 
-    // alwaysOverwrite 优先级最高，即使匹配 neverOverwrite 也要覆盖
+    // 优先级 1: conflictCheck - 检测冲突文件
+    if (matchesAny(relPosix, rules.conflictCheck) && destExists) {
+      const same = await filesEqual(destPath, srcPath);
+      if (!same) {
+        conflicts.push(relPosix);
+        // 只有在 overwrite 模式下才覆盖冲突文件
+        if (conflictMode === 'overwrite') {
+          await fs.ensureDir(path.dirname(destPath));
+          await fs.copyFile(srcPath, destPath);
+          overwrittenConflicts.push(relPosix);
+          copied.push(relPosix);
+        } else {
+          // keep 模式：跳过冲突文件，保留本地版本
+          skipped.push(relPosix);
+        }
+        continue;
+      }
+      // 文件内容相同，无需操作
+      continue;
+    }
+
+    // 优先级 2: alwaysOverwrite - 强制覆盖（最高优先级）
     if (matchesAny(relPosix, rules.alwaysOverwrite)) {
       await fs.ensureDir(path.dirname(destPath));
       await fs.copyFile(srcPath, destPath);
@@ -199,16 +256,19 @@ async function applyUpdateFromTemplate(tmpDir, targetDir, rules, conflictMode) {
       continue;
     }
 
+    // 优先级 3: neverOverwrite - 永不覆盖
     if (matchesAny(relPosix, rules.neverOverwrite) && destExists) {
       skipped.push(relPosix);
       continue;
     }
 
+    // 优先级 4: defaultOverwrite 规则
     if (destExists && rules.defaultOverwrite === false) {
       skipped.push(relPosix);
       continue;
     }
 
+    // 默认行为：复制文件（新文件或允许覆盖的文件）
     await fs.ensureDir(path.dirname(destPath));
     await fs.copyFile(srcPath, destPath);
     copied.push(relPosix);
@@ -268,7 +328,7 @@ function parseArgs(argv) {
     start: true,
     force: false,
     pm: null,
-    conflict: 'keep'
+    conflict: 'overwrite' // 默认强制覆盖，用户可通过 --conflict keep 改为保留模式（不对外文档化）
   };
 
   for (let i = 0; i < args.length; i++) {
@@ -294,10 +354,7 @@ function parseArgs(argv) {
     if (a === '--pre') opts.pre = true;
     if (a === '--force') opts.force = true;
     if (a === '--pm') opts.pm = args[++i];
-    if (a === '--conflict') {
-      const v = args[++i];
-      if (isValidConflictMode(v)) opts.conflict = v;
-    }
+    // 移除 --conflict 参数，不对外暴露
   }
 
   return opts;
@@ -360,7 +417,7 @@ async function run() {
   await fs.remove(path.join(tmpDir, '.git'));
 
   const rules = await readUpdateRules(tmpDir);
-  const conflictMode = isValidConflictMode(opts.conflict) ? opts.conflict : 'keep';
+  const conflictMode = isValidConflictMode(opts.conflict) ? opts.conflict : 'overwrite';
 
   if (opts.pre) {
     const plan = await planUpdateFromTemplate(tmpDir, targetDir, rules, conflictMode);
@@ -376,19 +433,29 @@ async function run() {
   const result = await applyUpdateFromTemplate(tmpDir, targetDir, rules, conflictMode);
   await fs.remove(tmpDir);
 
-  if (result.conflicts.length > 0 && conflictMode !== 'overwrite') {
-    console.log(chalk.yellow('\n⚠️ 发现冲突文件（已保留本地文件）：'));
-    result.conflicts.forEach((p) => console.log(chalk.yellow(`- ${p}`)));
-  }
-  if (result.overwrittenConflicts.length > 0 && conflictMode === 'overwrite') {
-    console.log(chalk.yellow('\n⚠️ 发现冲突文件（已按配置覆盖）：'));
-    result.overwrittenConflicts.forEach((p) => console.log(chalk.yellow(`- ${p}`)));
+  // 输出更新结果摘要
+  console.log(chalk.cyan('\n📊 更新摘要：'));
+  console.log(chalk.green(`✓ 已更新文件：${result.copied.length} 个`));
+  
+  if (result.conflicts.length > 0) {
+    if (conflictMode === 'keep') {
+      console.log(chalk.yellow(`⚠ 冲突文件（已保留本地）：${result.conflicts.length} 个`));
+      result.conflicts.forEach((p) => console.log(chalk.yellow(`  - ${p}`)));
+    } else {
+      console.log(chalk.red(`⚠ 冲突文件（已覆盖）：${result.overwrittenConflicts.length} 个`));
+      result.overwrittenConflicts.forEach((p) => console.log(chalk.red(`  - ${p}`)));
+    }
   }
+  
   if (result.skipped.length > 0) {
-    console.log(chalk.gray('\n⏭️  跳过覆盖（已保留本地文件）：'));
-    result.skipped.forEach((p) => console.log(chalk.gray(`- ${p}`)));
+    console.log(chalk.gray(`⏭ 跳过文件（保留本地）：${result.skipped.length} 个`));
+    if (result.skipped.length <= 10) {
+      result.skipped.forEach((p) => console.log(chalk.gray(`  - ${p}`)));
+    } else {
+      result.skipped.slice(0, 5).forEach((p) => console.log(chalk.gray(`  - ${p}`)));
+      console.log(chalk.gray(`  ... 还有 ${result.skipped.length - 5} 个文件`));
+    }
   }
-  console.log(chalk.green(`\n✅ 已写入/更新文件：${result.copied.length} 个`));
 
   // -----------------------------
   // package.json 处理

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "axhub-make",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Axhub Make scaffolding tool",
   "bin": {
     "axhub-make": "./bin/index.js"