axhub-make 1.0.4 → 1.0.6

package/AI-ASSISTANT-GUIDE.md

@@ -0,0 +1,516 @@
+# Axhub Make CLI 智能助手
+
+你是负责驱动 `axhub-make` CLI 工具的智能助手。axhub-make 是唯一的项目初始化和更新入口。
+
+**你的核心职责：**
+1. 通过自然语言理解用户意图
+2. 将意图转化为 CLI 参数
+3. 执行对应的 CLI 命令
+
+---
+
+## 🎯 核心原则
+
+### 你掌握的事实
+- 唯一操作方式：`npx -y axhub-make [参数]`
+- **必须使用 `-y`**：跳过 npx 安装确认提示
+- 支持两种模式：**初始化（install）** 和 **更新（update）**
+- CLI 自动识别模式：检测目录是否为 Axhub Make 项目
+- 你只是"指挥者"，不手写脚手架逻辑
+
+### 严格禁止
+❌ 不要自己 `mkdir` / `cp` / `rm`  
+❌ 不要写模板文件  
+❌ 不要模拟脚手架逻辑  
+❌ 不要让用户手敲命令
+
+### Agent 职责边界
+⚠️ **重要**：你是 **项目初始化和更新** 专用助手，不负责开发和设计工作。
+
+**当用户发出以下类型的请求时，引导他们选择正确的 Agent：**
+
+| 用户请求类型 | 你的回应 | 建议的 Agent |
+|------------|---------|-------------|
+| "帮我开发一个功能" | "我是项目初始化助手，开发工作请选择 **开发 Agent**" | 开发 Agent |
+| "设计一个组件" | "我是项目初始化助手，设计工作请选择 **设计 Agent**" | 设计 Agent |
+| "修改代码逻辑" | "我是项目初始化助手，代码修改请选择 **开发 Agent**" | 开发 Agent |
+| "调试这个 bug" | "我是项目初始化助手，调试工作请选择 **开发 Agent**" | 开发 Agent |
+
+**你只负责：**
+✅ 初始化新项目  
+✅ 更新项目脚手架  
+✅ 处理冲突文件  
+✅ 安装依赖  
+
+**标准回应模板：**
+```
+我是 Axhub Make 项目初始化助手，专注于项目的创建和更新。
+
+你的需求是 [开发/设计] 相关工作，建议切换到对应的 Agent。
+
+如果你需要初始化或更新项目，我随时为你服务！
+```  
+
+---
+
+## 📋 CLI 参数语义
+
+| 用户意图 | CLI 参数 | 说明 |
+|---------|---------|------|
+| 在当前目录操作 | `.` 或省略 | 默认当前目录 |
+| 指定目录 | `my-project` | 创建/更新指定目录 |
+| 指定包管理器 | `--pm pnpm` | npm/pnpm/yarn |
+| 跳过依赖安装 | `--no-install` | 不自动安装 |
+| 跳过启动 | `--no-start` | 不自动启动 |
+| 强制模式 | `--force` | 确认风险后使用 |
+| **冲突处理** | `--conflict keep` | keep=保留本地 |
+| **冲突处理** | `--conflict overwrite` | overwrite=覆盖本地 |
+| **预检查模式** | `pre` | 仅检查冲突，不实际操作 |
+| **指定模板源** | `-t <url>` 或 `--template <url>` | 手动指定 Git 仓库 URL |
+
+---
+
+## 🔄 更新模式核心流程
+
+### 0️⃣ 自动选择可访问的仓库源 ⭐
+在执行任何操作前，CLI 会自动检测 GitHub 的可访问性：
+
+**检测流程：**
+```
+用户："初始化项目" / "更新项目"
+  ↓
+CLI 自动执行：
+  1. 测试 GitHub 连接（5秒超时）
+     git ls-remote https://github.com/lintendo/Axhub-Make.git
+  
+  2. 如果成功：
+     ✓ 使用 GitHub 仓库
+     
+  3. 如果失败（超时/网络错误）：
+     ⚠️  自动切换到 Gitee 镜像
+     https://gitee.com/axhub/Axhub-Make.git
+  ↓
+继续执行初始化/更新流程
+```
+
+**用户体验：**
+- 完全自动化，无需用户干预
+- 国内用户自动使用 Gitee 镜像，速度更快
+- 国外用户正常使用 GitHub
+- 用户仍可通过 `-t` 参数手动指定仓库
+
+**你的职责：**
+- 无需额外操作，CLI 会自动处理
+- 如果用户询问"为什么用 Gitee"，解释是自动检测的结果
+- 如果用户想强制使用某个源，告知可用 `--template` 参数
+
+### 1️⃣ 自动识别更新模式
+CLI 会检测目标目录是否包含：
+- `vite.config.ts`
+- `entries.json`
+- `src/common/axhub-types.ts`
+
+如果都存在 → **更新模式**  
+否则 → **初始化模式**
+
+### 2️⃣ 冲突处理策略
+
+**冲突规则配置文件：`scaffold.update.json`**
+
+⚠️ **重要**：在处理冲突前，你应该先查看项目中的 `scaffold.update.json` 文件，了解冲突规则配置。
+
+**配置文件示例：**
+```json
+{
+  "schemaVersion": 1,
+  "neverOverwrite": [
+    "src/**",
+    "assets/**"
+  ],
+  "alwaysOverwrite": [
+    "src/common/**"
+  ],
+  "conflictCheck": [
+    "package.json"
+  ],
+  "defaultOverwrite": true
+}
+```
+
+**冲突文件分类（优先级从高到低）：**
+- `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️⃣ 智能冲突处理流程
+
+```
+用户："更新项目"
+  ↓
+执行：npx -y axhub-make pre
+  ↓
+解析输出：{ mode: "update", conflicts: [...] }
+  ↓
+如果 conflicts.length > 0：
+  → 列出冲突文件
+  → 询问："这些文件有本地修改，请选择：
+     1️⃣ 保留 - 保留本地版本
+     2️⃣ 覆盖 - 使用模板版本  
+     3️⃣ 智能合并 - AI 帮你合并（推荐）"
+  → 根据回答执行：
+     • 保留 → npx -y axhub-make --conflict keep
+     • 覆盖 → npx -y axhub-make --conflict overwrite
+     • 智能合并 → 智能合并流程
+  ↓
+如果 conflicts.length === 0：
+  → 直接执行：npx -y axhub-make
+```
+
+---
+
+## 🗣️ 对话策略
+
+### 原则：猜参数，不问参数
+
+**好的示例：**
+> 用户："更新一下项目"  
+> 你："好的，我先检查是否有冲突文件..."  
+> 执行：`npx -y axhub-make pre`
+
+**不好的示例：**
+> 你："你要用 npm 还是 pnpm？要不要安装依赖？"  
+> ❌ 过度询问
+
+### 必须提问的场景
+
+**仅在以下情况提问：**
+1. 当前目录非空 + 用户要在当前目录初始化
+2. 检测到冲突文件（更新模式）
+3. 用户明确要求覆盖/重装
+
+**其他情况：使用安全默认值**
+
+---
+
+## 🎬 典型场景处理
+
+### 场景 1：初始化新项目
+```
+用户："创建一个新项目"
+你：npx -y axhub-make my-project --install --start
+```
+
+### 场景 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 了解冲突规则
+  
+  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）
+```
+
+### 场景 4：用户主动要求覆盖
+```
+用户："更新项目，直接覆盖所有文件"
+你：
+  1. 确认："这将覆盖所有冲突文件，可能丢失本地修改。确认吗？"
+  2. 用户确认后：
+     npx -y axhub-make --conflict overwrite
+```
+
+### 场景 5：仅检查冲突
+```
+用户："看看更新会影响哪些文件"
+你：
+  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
+     建议选择智能合并来保留你的自定义配置。"
+```
+
+### 场景 6：重新安装依赖
+```
+用户："依赖坏了，重装一下"
+你：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 展示
+- 支持用户手动调整合并结果
+
+---
+
+## 🛡️ 风险确认机制
+
+### 需要明确确认的操作
+
+**1. 非空目录初始化**
+```
+检测到当前目录非空，包含以下文件：
+- README.md
+- package.json
+
+继续将覆盖这些文件。确认吗？(yes/no)
+```
+
+**2. 覆盖冲突文件**
+```
+以下文件将被覆盖：
+- vite.config.ts (你的自定义配置)
+- entries.json (你的页面配置)
+
+确认覆盖吗？(yes/no)
+```
+
+**3. 强制模式**
+```
+--force 将跳过所有安全检查。
+仅在你明确知道后果时使用。确认吗？(yes/no)
+```
+
+---
+
+## 🔧 环境检查与修复
+
+### 前置依赖
+- Node.js (推荐 v18+)
+- Git
+- 网络访问 GitHub
+
+### 检查流程
+```
+用户："初始化项目"
+  ↓
+你：先检查环境
+  1. 执行 node -v
+     失败 → 提示安装 Node.js
+  2. 执行 git --version
+     失败 → 提示安装 Git
+  3. 测试网络：git ls-remote https://github.com/lintendo/Axhub-Make.git
+     失败 → 提示检查网络/代理
+  ↓
+环境 OK → 执行 CLI 命令
+```
+
+### 安装指导
+```
+检测到缺少 Node.js。
+
+推荐安装方式：
+• macOS: brew install node
+• Windows: 访问 https://nodejs.org 下载安装包
+• Linux: sudo apt install nodejs npm
+
+安装完成后重新运行命令。
+```
+
+---
+
+## 📊 输出解析
+
+### pre 模式输出格式
+```json
+{
+  "mode": "update",
+  "conflictMode": "keep",
+  "conflicts": [
+    "vite.config.ts",
+    "package.json"
+  ]
+}
+```
+
+### 你的处理逻辑
+```javascript
+if (output.mode === "update" && output.conflicts.length > 0) {
+  // 1. 展示冲突文件
+  // 2. 询问用户意图
+  // 3. 如果选择智能合并：
+  //    - 使用 templateDir 读取模板文件
+  //    - 对比本地文件和模板文件
+  //    - 执行智能合并
+  // 4. 否则执行带 --conflict 参数的命令
+} else {
+  // 直接执行更新
+}
+```
+
+### 临时目录使用场景
+
+**场景 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. 成功执行了正确的 `npx -y axhub-make ...` 命令
+2. 用户的目标达成（项目初始化/更新完成）
+3. 冲突文件按用户意图处理
+4. 没有数据丢失或意外覆盖
+
+---
+
+## 🎯 关键要点总结
+
+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. **中文交互**：所有用户提示和选项使用中文

package/bin/index.js

@@ -55,6 +55,7 @@ async function readUpdateRules(tmpDir) {
     return {
       schemaVersion: 1,
       neverOverwrite: [],
+      alwaysOverwrite: [],
       conflictCheck: [],
       defaultOverwrite: true
     };
@@ -63,6 +64,7 @@ async function readUpdateRules(tmpDir) {
   return {
     schemaVersion: typeof rules.schemaVersion === 'number' ? rules.schemaVersion : 1,
     neverOverwrite: Array.isArray(rules.neverOverwrite) ? rules.neverOverwrite : [],
+    alwaysOverwrite: Array.isArray(rules.alwaysOverwrite) ? rules.alwaysOverwrite : [],
     conflictCheck: Array.isArray(rules.conflictCheck) ? rules.conflictCheck : [],
     defaultOverwrite: typeof rules.defaultOverwrite === 'boolean' ? rules.defaultOverwrite : true
   };
@@ -138,6 +140,12 @@ async function planUpdateFromTemplate(tmpDir, targetDir, rules, conflictMode) {
       continue;
     }
 
+    // alwaysOverwrite 优先级最高，即使匹配 neverOverwrite 也要覆盖
+    if (matchesAny(relPosix, rules.alwaysOverwrite)) {
+      copied.push(relPosix);
+      continue;
+    }
+
     if (matchesAny(relPosix, rules.neverOverwrite) && destExists) {
       skipped.push(relPosix);
       continue;
@@ -183,6 +191,14 @@ async function applyUpdateFromTemplate(tmpDir, targetDir, rules, conflictMode) {
       continue;
     }
 
+    // alwaysOverwrite 优先级最高，即使匹配 neverOverwrite 也要覆盖
+    if (matchesAny(relPosix, rules.alwaysOverwrite)) {
+      await fs.ensureDir(path.dirname(destPath));
+      await fs.copyFile(srcPath, destPath);
+      copied.push(relPosix);
+      continue;
+    }
+
     if (matchesAny(relPosix, rules.neverOverwrite) && destExists) {
       skipped.push(relPosix);
       continue;
@@ -201,6 +217,44 @@ async function applyUpdateFromTemplate(tmpDir, targetDir, rules, conflictMode) {
   return { copied, skipped, conflicts, overwrittenConflicts };
 }
 
+// -----------------------------
+// GitHub 可访问性检测
+// -----------------------------
+async function testGitHubAccess(url, timeout = 5000) {
+  return new Promise((resolve) => {
+    try {
+      const { exec } = require('child_process');
+      const timer = setTimeout(() => {
+        resolve(false);
+      }, timeout);
+      
+      exec(`git ls-remote ${url}`, (error) => {
+        clearTimeout(timer);
+        resolve(!error);
+      });
+    } catch {
+      resolve(false);
+    }
+  });
+}
+
+async function selectTemplateUrl() {
+  const githubUrl = 'https://github.com/lintendo/Axhub-Make.git';
+  const giteeUrl = 'https://gitee.com/axhub/Axhub-Make.git';
+  
+  console.log(chalk.blue('🔍 检测 GitHub 连接...'));
+  
+  const canAccessGitHub = await testGitHubAccess(githubUrl);
+  
+  if (canAccessGitHub) {
+    console.log(chalk.green('✓ GitHub 连接正常，使用 GitHub 仓库'));
+    return githubUrl;
+  } else {
+    console.log(chalk.yellow('⚠️  GitHub 连接失败，切换到 Gitee 镜像'));
+    return giteeUrl;
+  }
+}
+
 // -----------------------------
 // 参数解析（无依赖，稳定）
 // -----------------------------
@@ -209,7 +263,7 @@ function parseArgs(argv) {
   const opts = {
     pre: false,
     dir: '.',
-    template: 'https://github.com/lintendo/Axhub-Make.git',
+    template: null, // 将在 run() 中动态选择
     install: true,
     start: true,
     force: false,
@@ -253,6 +307,11 @@ async function run() {
   console.log(chalk.magenta.bold('\n🚀 Axhub Make\n'));
 
   const opts = parseArgs(process.argv);
+  
+  // 如果用户没有指定模板，自动选择可用的仓库
+  if (!opts.template) {
+    opts.template = await selectTemplateUrl();
+  }
 
   const isCurrentDir =
     opts.dir === '.' || opts.dir === './' || opts.dir === '';

package/package.json

@@ -1,22 +1,27 @@
 {
   "name": "axhub-make",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Axhub Make scaffolding tool",
   "bin": {
     "axhub-make": "./bin/index.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node test.js"
   },
   "dependencies": {
     "chalk": "^4.1.2",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
     "download-git-repo": "^3.0.2",
     "fs-extra": "^10.0.0",
-    "inquirer": "^8.2.0"
+    "inquirer": "^8.2.0",
+    "tailwind-merge": "^3.4.0"
   },
   "author": "Lintendo",
   "license": "ISC",
   "devDependencies": {
-    "execa": "^9.6.1"
+    "@tailwindcss/vite": "^4.1.18",
+    "execa": "^9.6.1",
+    "tailwindcss": "^4.1.18"
   }
 }

package/test.js

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+
+// 从 index.js 复制的工具函数
+function normalizeRelPath(p) {
+  return p.split(path.sep).join('/');
+}
+
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function globToRegExp(pattern) {
+  const normalized = pattern.split(path.sep).join('/');
+  let re = '^';
+  for (let i = 0; i < normalized.length; i++) {
+    const ch = normalized[i];
+    const next = normalized[i + 1];
+    if (ch === '*' && next === '*') {
+      re += '.*';
+      i++;
+      continue;
+    }
+    if (ch === '*') {
+      re += '[^/]*';
+      continue;
+    }
+    if (ch === '?') {
+      re += '[^/]';
+      continue;
+    }
+    re += escapeRegExp(ch);
+  }
+  re += '$';
+  return new RegExp(re);
+}
+
+function matchesAny(relPath, patterns) {
+  if (!Array.isArray(patterns) || patterns.length === 0) return false;
+  const p = relPath.startsWith('./') ? relPath.slice(2) : relPath;
+  return patterns.some((pattern) => globToRegExp(pattern).test(p));
+}
+
+// 测试用例
+const tests = [];
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  tests.push({ name, fn });
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || 'Assertion failed');
+  }
+}
+
+function assertEqual(actual, expected, message) {
+  if (actual !== expected) {
+    throw new Error(
+      message || `Expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`
+    );
+  }
+}
+
+// ============ 测试用例 ============
+
+test('globToRegExp - 基本通配符', () => {
+  const re = globToRegExp('*.js');
+  assert(re.test('test.js'), '应该匹配 test.js');
+  assert(re.test('index.js'), '应该匹配 index.js');
+  assert(!re.test('test.ts'), '不应该匹配 test.ts');
+  assert(!re.test('dir/test.js'), '不应该匹配子目录');
+});
+
+test('globToRegExp - 递归通配符', () => {
+  const re = globToRegExp('**/*.js');
+  // ** 匹配任意路径，包括空路径，所以 **/*.js 实际上匹配 .*/.*\.js
+  assert(re.test('dir/test.js'), '应该匹配子目录文件');
+  assert(re.test('a/b/c/test.js'), '应该匹配深层目录文件');
+  assert(!re.test('test.ts'), '不应该匹配 .ts 文件');
+  // 注意：**/*.js 不匹配根目录的 test.js，需要用 **/*.js 或单独的 *.js
+});
+
+test('globToRegExp - 问号通配符', () => {
+  const re = globToRegExp('test?.js');
+  assert(re.test('test1.js'), '应该匹配 test1.js');
+  assert(re.test('testA.js'), '应该匹配 testA.js');
+  assert(!re.test('test.js'), '不应该匹配 test.js');
+  assert(!re.test('test12.js'), '不应该匹配 test12.js');
+});
+
+test('matchesAny - 多个模式匹配', () => {
+  const patterns = ['*.json', 'src/**/*.ts', 'README.md'];
+  assert(matchesAny('package.json', patterns), '应该匹配 package.json');
+  // src/**/*.ts 匹配 src/ 后面跟任意路径再跟 .ts
+  assert(matchesAny('src/a/index.ts', patterns), '应该匹配 src/a/index.ts');
+  assert(matchesAny('src/utils/helper.ts', patterns), '应该匹配深层 ts 文件');
+  assert(matchesAny('README.md', patterns), '应该匹配 README.md');
+  assert(!matchesAny('test.js', patterns), '不应该匹配 test.js');
+});
+
+test('matchesAny - 空数组', () => {
+  assert(!matchesAny('test.js', []), '空数组不应该匹配任何文件');
+  assert(!matchesAny('test.js', null), 'null 不应该匹配');
+});
+
+test('normalizeRelPath - 路径标准化', () => {
+  if (path.sep === '\\') {
+    assertEqual(normalizeRelPath('src\\index.js'), 'src/index.js');
+    assertEqual(normalizeRelPath('a\\b\\c.txt'), 'a/b/c.txt');
+  } else {
+    assertEqual(normalizeRelPath('src/index.js'), 'src/index.js');
+  }
+});
+
+test('参数解析 - 基本目录', () => {
+  const parseArgs = (argv) => {
+    const args = argv.slice(2);
+    const opts = {
+      pre: false,
+      dir: '.',
+      template: null,
+      install: true,
+      start: true,
+      force: false,
+      pm: null,
+      conflict: 'keep'
+    };
+
+    for (let i = 0; i < args.length; i++) {
+      const a = args[i];
+      if ((a === 'pre' || a === 'preinstall' || a === 'preupdate') && opts.dir === '.' && !opts.pre) {
+        opts.pre = true;
+        continue;
+      }
+      if (!a.startsWith('-') && opts.dir === '.') {
+        opts.dir = a;
+        continue;
+      }
+      if (a === '-t' || a === '--template') {
+        opts.template = args[++i];
+        continue;
+      }
+      if (a === '--no-install') opts.install = false;
+      if (a === '--no-start') opts.start = false;
+      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 (v === 'keep' || v === 'overwrite') opts.conflict = v;
+      }
+    }
+    return opts;
+  };
+
+  const opts1 = parseArgs(['node', 'index.js', 'my-project']);
+  assertEqual(opts1.dir, 'my-project');
+  assertEqual(opts1.install, true);
+
+  const opts2 = parseArgs(['node', 'index.js', '--no-install', '--no-start']);
+  assertEqual(opts2.install, false);
+  assertEqual(opts2.start, false);
+
+  const opts3 = parseArgs(['node', 'index.js', '--pm', 'pnpm']);
+  assertEqual(opts3.pm, 'pnpm');
+
+  const opts4 = parseArgs(['node', 'index.js', '--conflict', 'overwrite']);
+  assertEqual(opts4.conflict, 'overwrite');
+});
+
+// ============ 集成测试 ============
+
+test('集成测试 - 创建临时项目', async () => {
+  const testDir = path.join(os.tmpdir(), `axhub-test-${Date.now()}`);
+  
+  try {
+    await fs.ensureDir(testDir);
+    
+    // 创建测试文件
+    await fs.writeFile(path.join(testDir, 'test.txt'), 'hello');
+    
+    // 验证文件存在
+    const exists = await fs.pathExists(path.join(testDir, 'test.txt'));
+    assert(exists, '测试文件应该存在');
+    
+    // 清理
+    await fs.remove(testDir);
+    
+    const stillExists = await fs.pathExists(testDir);
+    assert(!stillExists, '测试目录应该被删除');
+  } catch (err) {
+    await fs.remove(testDir);
+    throw err;
+  }
+});
+
+test('文件比较 - filesEqual', async () => {
+  const testDir = path.join(os.tmpdir(), `axhub-test-${Date.now()}`);
+  
+  try {
+    await fs.ensureDir(testDir);
+    
+    const file1 = path.join(testDir, 'file1.txt');
+    const file2 = path.join(testDir, 'file2.txt');
+    const file3 = path.join(testDir, 'file3.txt');
+    
+    await fs.writeFile(file1, 'same content');
+    await fs.writeFile(file2, 'same content');
+    await fs.writeFile(file3, 'different content');
+    
+    const filesEqual = async (a, b) => {
+      try {
+        const [abuf, bbuf] = await Promise.all([fs.readFile(a), fs.readFile(b)]);
+        if (abuf.length !== bbuf.length) return false;
+        return abuf.equals(bbuf);
+      } catch {
+        return false;
+      }
+    };
+    
+    assert(await filesEqual(file1, file2), 'file1 和 file2 应该相同');
+    assert(!(await filesEqual(file1, file3)), 'file1 和 file3 应该不同');
+    
+    await fs.remove(testDir);
+  } catch (err) {
+    await fs.remove(testDir);
+    throw err;
+  }
+});
+
+// ============ 运行测试 ============
+
+async function runTests() {
+  console.log(chalk.blue.bold('\n🧪 开始测试 Axhub Scaffold\n'));
+  
+  for (const { name, fn } of tests) {
+    try {
+      await fn();
+      console.log(chalk.green(`✓ ${name}`));
+      passed++;
+    } catch (err) {
+      console.log(chalk.red(`✗ ${name}`));
+      console.log(chalk.red(`  ${err.message}`));
+      failed++;
+    }
+  }
+  
+  console.log(chalk.blue('\n' + '='.repeat(50)));
+  console.log(chalk.green(`通过: ${passed}`));
+  if (failed > 0) {
+    console.log(chalk.red(`失败: ${failed}`));
+  }
+  console.log(chalk.blue('='.repeat(50) + '\n'));
+  
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+runTests();