@agile-team/robot-cli 1.0.8 → 1.1.0

package/README.md

@@ -9,7 +9,7 @@
 - **🎯 智能模板分类** - 推荐模板、分类浏览、关键词搜索
 - **⚡ 极速项目创建** - 一条命令创建完整项目架构
 - **📦 现代包管理器** - 优先推荐 bun/pnpm，智能检测最佳选择
-- **🌐 智能缓存机制** - 本地缓存，避免重复下载
+- **🌐 总是最新版本** - 每次创建都下载最新模板，无缓存困扰
 - **🎨 友好用户界面** - 现代化终端交互，清晰进度提示
 
 ## 🚀 快速开始
@@ -70,9 +70,6 @@ robot create my-project --template robot-admin
 
 # 跳过依赖安装
 robot create my-project --skip-install
-
-# 强制重新下载
-robot create my-project --no-cache
 ```
 
 ### 模板管理
@@ -88,15 +85,6 @@ robot search vue
 robot search admin
 ```
 
-### 缓存管理
-```bash
-# 查看缓存信息
-robot cache
-
-# 清除缓存
-robot cache --clear
-```
-
 ## 📦 包管理器优先级
 
 Robot CLI 智能选择最佳包管理器：
@@ -106,6 +94,15 @@ Robot CLI 智能选择最佳包管理器：
 3. **yarn** ⚖️ - 兼容现有项目
 4. **npm** ⚖️ - Node.js默认
 
+## 🌐 为什么选择"总是最新"
+
+Robot CLI 不使用本地缓存，每次创建项目都会下载最新版本的模板：
+
+- ✅ **确保最新**: 总是获得最新的代码和依赖
+- ✅ **避免冲突**: 无需担心缓存过期或版本不一致
+- ✅ **简化维护**: 用户无需管理缓存，开发者无需考虑缓存策略
+- ✅ **减少错误**: 避免因缓存损坏导致的创建失败
+
 ## 🛠 开发指南
 
 ### 项目结构
@@ -116,7 +113,6 @@ robot-cli/
 │   ├── templates.js      # 模板配置
 │   ├── create.js         # 创建流程
 │   ├── download.js       # 下载逻辑
-│   ├── cache.js          # 缓存管理
 │   └── utils.js          # 工具函数
 └── test/local-test.js    # 测试脚本
 ```
@@ -128,7 +124,7 @@ robot-cli/
 'robot-new-template': {
   name: 'Robot新模板',
   description: '模板描述',
-  repo: 'ChenyCHENYU/Robot_New_Template',
+  repoUrl: 'https://github.com/ChenyCHENYU/Robot_New_Template',
   features: ['特性1', '特性2'],
   version: 'full'
 }
@@ -200,7 +196,7 @@ export const TEMPLATE_CATEGORIES = {
             templates: {
               'your-admin': {
                 name: '你的后台模板',
-                repo: 'YOUR_ORG/Your_Admin_Template',
+                repoUrl: 'https://github.com/YOUR_ORG/Your_Admin_Template',
                 // ...
               }
             }
@@ -319,10 +315,7 @@ your-cli generate component MyComponent
 {
   "templateSource": "github",
   "defaultOrg": "YourOrg",
-  "cache": {
-    "enabled": true,
-    "ttl": 86400000
-  }
+  "alwaysLatest": true
 }
 ```
 
@@ -401,7 +394,7 @@ analytics.track('template_used', {
 A: 全局安装CLI：`npm install -g @agile-team/robot-cli`
 
 **Q: 模板下载失败？**  
-A: 检查网络连接，尝试清除缓存：`robot cache --clear`
+A: 检查网络连接，确保能访问GitHub
 
 **Q: 如何添加自定义模板？**  
 A: 创建模板仓库 → 添加配置 → 测试功能
@@ -409,6 +402,9 @@ A: 创建模板仓库 → 添加配置 → 测试功能
 **Q: 支持私有仓库吗？**  
 A: 目前仅支持公开GitHub仓库
 
+**Q: 为什么不使用缓存？**  
+A: 为了确保总是获得最新版本的模板，避免缓存相关的问题
+
 ## 🎉 快速体验
 
 ```bash

package/bin/index.js

@@ -14,7 +14,6 @@ const __dirname = dirname(__filename);
  */
 function getPackageVersion() {
   try {
-    // 尝试从多个位置读取 package.json
     const possiblePaths = [
       join(__dirname, '..', 'package.json'),
       join(__dirname, 'package.json'),
@@ -28,49 +27,34 @@ function getPackageVersion() {
       }
     }
     
-    return '1.0.0'; // 默认版本
+    return '1.0.0';
   } catch (error) {
-    return '1.0.0'; // 出错时返回默认版本
+    return '1.0.0';
   }
 }
 
-// 获取版本号
 const PACKAGE_VERSION = getPackageVersion();
 
 /**
- * 智能路径解析 - 兼容不同包管理器的安装路径
+ * 智能路径解析
  */
 function resolveLibPath() {
-  // 可能的 lib 目录路径
   const possiblePaths = [
-    // 1. 标准相对路径 (开发环境 + 大多数情况)
     join(__dirname, '..', 'lib'),
-    
-    // 2. 同级目录 (某些链接情况)
     join(__dirname, 'lib'),
-    
-    // 3. 向上查找 (深度嵌套情况)
     join(__dirname, '..', '..', 'lib'),
-    
-    // 4. 从 node_modules 查找 (npm/yarn)
     join(__dirname, '..', 'node_modules', '@agile-team', 'robot-cli', 'lib'),
-    
-    // 5. 全局安装的各种可能路径
     resolve(__dirname, '..', 'lib'),
     resolve(__dirname, '../../lib'),
-    
-    // 6. bun 特殊路径处理
     join(__dirname, '..', '..', '@agile-team', 'robot-cli', 'lib'),
   ];
 
-  // 查找第一个存在的路径
   for (const libPath of possiblePaths) {
     if (existsSync(libPath)) {
       return libPath;
     }
   }
 
-  // 如果都找不到，抛出详细错误
   throw new Error(`
 无法找到 lib 目录，已尝试以下路径:
 ${possiblePaths.map(p => `  - ${p}`).join('\n')}
@@ -85,25 +69,21 @@ ${possiblePaths.map(p => `  - ${p}`).join('\n')}
   `);
 }
 
-// 动态导入所需模块
+// 动态导入所需模块 - 移除缓存相关模块
 async function loadModules() {
   try {
     const libPath = resolveLibPath();
     
-    // 将路径转换为 file:// URL 格式（Windows 兼容）
     const createUrl = pathToFileURL(join(libPath, 'create.js')).href;
-    const cacheUrl = pathToFileURL(join(libPath, 'cache.js')).href;
     const templatesUrl = pathToFileURL(join(libPath, 'templates.js')).href;
     const utilsUrl = pathToFileURL(join(libPath, 'utils.js')).href;
     
-    // 动态导入所有需要的模块
     const [
       { Command },
       chalk,
       boxen,
       inquirer,
       { createProject },
-      { clearCache, getCacheInfo, formatSize },
       { getAllTemplates, searchTemplates, getRecommendedTemplates },
       { checkNetworkConnection }
     ] = await Promise.all([
@@ -112,7 +92,6 @@ async function loadModules() {
       import('boxen'),
       import('inquirer'),
       import(createUrl),
-      import(cacheUrl),
       import(templatesUrl),
       import(utilsUrl)
     ]);
@@ -123,9 +102,6 @@ async function loadModules() {
       boxen: boxen.default,
       inquirer: inquirer.default,
       createProject,
-      clearCache,
-      getCacheInfo,
-      formatSize,
       getAllTemplates,
       searchTemplates,
       getRecommendedTemplates,
@@ -160,9 +136,6 @@ async function main() {
       boxen, 
       inquirer,
       createProject,
-      clearCache,
-      getCacheInfo,
-      formatSize,
       getAllTemplates,
       searchTemplates,
       getRecommendedTemplates,
@@ -203,20 +176,18 @@ async function main() {
       console.log();
     }
 
-    // 显示主菜单
+    // 显示主菜单 - 移除缓存信息
     async function showMainMenu() {
       const title = chalk.white.bold('🚀 快速开始');
       
       console.log('  ' + title);
       console.log();
       
-      // 获取统计信息
       const allTemplates = getAllTemplates();
       const templateCount = Object.keys(allTemplates).length;
-      const cacheInfo = await getCacheInfo();
       
       console.log(chalk.dim(`  📦 可用模板: ${templateCount} 个`));
-      console.log(chalk.dim(`  💾 缓存模板: ${cacheInfo.templates.length} 个 (${formatSize(cacheInfo.size)})`));
+      console.log(chalk.dim(`  🌐 总是下载最新版本`));
       console.log();
       
       const commands = [
@@ -239,11 +210,6 @@ async function main() {
           cmd: 'robot search <keyword>',
           desc: '搜索模板',
           color: 'magenta'
-        },
-        {
-          cmd: 'robot cache',
-          desc: '缓存管理',
-          color: 'yellow'
         }
       ];
       
@@ -262,29 +228,26 @@ async function main() {
     program
       .name('robot')
       .description('🤖 Robot 项目脚手架工具 - @agile-team/robot-cli')
-      .version(PACKAGE_VERSION) // 🎯 使用动态版本号
+      .version(PACKAGE_VERSION)
       .hook('preAction', () => {
         showWelcome();
       });
 
-    // 创建项目命令
+    // 创建项目命令 - 移除缓存相关选项
     program
       .command('create [project-name]')
       .description('创建新项目')
       .option('-t, --template <template>', '指定模板类型')
-      .option('--no-cache', '强制重新下载模板')
       .option('--skip-install', '跳过依赖安装')
       .action(async (projectName, options) => {
         try {
           // 检查网络连接
-          if (!options.cache) {
-            console.log(chalk.blue('🌐 检查网络连接...'));
-            const hasNetwork = await checkNetworkConnection();
-            if (!hasNetwork) {
-              console.log(chalk.red('❌ 网络连接失败，无法下载模板'));
-              console.log(chalk.yellow('💡 请检查网络连接后重试'));
-              process.exit(1);
-            }
+          console.log(chalk.blue('🌐 检查网络连接...'));
+          const hasNetwork = await checkNetworkConnection();
+          if (!hasNetwork) {
+            console.log(chalk.red('❌ 网络连接失败，无法下载模板'));
+            console.log(chalk.yellow('💡 请检查网络连接后重试'));
+            process.exit(1);
           }
           
           await createProject(projectName, options);
@@ -292,7 +255,6 @@ async function main() {
           console.log();
           console.log(chalk.red('✗'), chalk.red.bold('创建失败'));
           
-          // 根据错误类型提供不同的建议
           if (error.message.includes('网络')) {
             console.log('  ' + chalk.dim('网络相关问题，请检查网络连接'));
           } else if (error.message.includes('权限')) {
@@ -337,7 +299,6 @@ async function main() {
           // 按分类显示
           const categories = {};
           Object.entries(templates).forEach(([key, template]) => {
-            // 简单分类逻辑，根据模板名称前缀
             const category = key.split('-')[0];
             if (!categories[category]) {
               categories[category] = [];
@@ -394,81 +355,6 @@ async function main() {
         }
       });
 
-    // 缓存管理
-    program
-      .command('cache')
-      .description('缓存管理')
-      .option('-c, --clear', '清除所有缓存')
-      .option('-i, --info', '显示缓存信息')
-      .action(async (options) => {
-        try {
-          if (options.clear) {
-            const { confirmed } = await inquirer.prompt([
-              {
-                type: 'confirm',
-                name: 'confirmed',
-                message: '确认清除所有模板缓存?',
-                default: false
-              }
-            ]);
-            
-            if (confirmed) {
-              await clearCache();
-              console.log();
-              console.log(chalk.green('✓'), chalk.green.bold('缓存清除成功'));
-            } else {
-              console.log(chalk.yellow('❌ 取消清除'));
-            }
-          } else {
-            // 显示缓存信息
-            const cacheInfo = await getCacheInfo();
-            
-            console.log();
-            console.log(chalk.blue('💾 缓存信息:'));
-            console.log();
-            
-            if (!cacheInfo.exists || cacheInfo.templates.length === 0) {
-              console.log(chalk.dim('  暂无缓存模板'));
-            } else {
-              console.log(`  缓存目录: ${chalk.dim(cacheInfo.path)}`);
-              console.log(`  模板数量: ${chalk.cyan(cacheInfo.templates.length)} 个`);
-              console.log(`  总大小: ${chalk.cyan(formatSize(cacheInfo.size))}`);
-              console.log();
-              console.log(chalk.blue('  缓存的模板:'));
-              
-              cacheInfo.templates.forEach(template => {
-                const modifiedTime = template.modifiedTime.toLocaleDateString();
-                console.log(`    ${chalk.green('●')} ${template.name}`);
-                console.log(`      大小: ${formatSize(template.size)}  更新: ${modifiedTime}`);
-              });
-            }
-            
-            console.log();
-            console.log(chalk.dim('  使用 robot cache --clear 清除缓存'));
-          }
-        } catch (error) {
-          console.log(chalk.red('❌ 缓存操作失败:'), error.message);
-        }
-      });
-
-    // 清除缓存命令 (向后兼容)
-    program
-      .command('clear-cache')
-      .description('清除模板缓存')
-      .action(async () => {
-        try {
-          await clearCache();
-          console.log();
-          console.log(chalk.green('✓'), chalk.green.bold('缓存清除成功'));
-          console.log();
-        } catch (error) {
-          console.log();
-          console.log(chalk.red('✗'), chalk.red.bold('清除缓存失败'));
-          console.log('  ' + chalk.dim(error.message));
-          console.log();
-        }
-      });
-
     // 如果没有参数，显示主菜单
     if (process.argv.length === 2) {
       showWelcome();

package/lib/create.js

@@ -1,4 +1,4 @@
-// lib/create.js - 增强版本，改进进度显示
+// lib/create.js - 简化版，移除缓存功能
 import fs from "fs-extra";
 import path from "path";
 import chalk from "chalk";
@@ -539,7 +539,7 @@ async function selectFromAll() {
 }
 
 /**
- * 项目配置选项
+ * 项目配置选项 - 移除缓存相关配置
  */
 async function configureProject(options) {
   console.log();
@@ -592,7 +592,6 @@ async function configureProject(options) {
     },
   ]);
 
-  // 如果用户不确认配置，提供重新配置或退出选项
   if (!config.confirmConfig) {
     const { action } = await inquirer.prompt([
       {
@@ -607,21 +606,18 @@ async function configureProject(options) {
     ]);
 
     if (action === "reconfigure") {
-      return await configureProject(options); // 递归重新配置
+      return await configureProject(options);
     } else {
       console.log(chalk.yellow("❌ 取消创建项目"));
       process.exit(0);
     }
   }
 
-  return {
-    ...config,
-    useCache: options.cache !== false,
-  };
+  return config;
 }
 
 /**
- * 确认创建
+ * 确认创建 - 移除缓存相关信息显示
  */
 async function confirmCreation(projectName, template, projectConfig) {
   console.log();
@@ -652,7 +648,7 @@ async function confirmCreation(projectName, template, projectConfig) {
         : chalk.dim("否")
     }`
   );
-  console.log(`  源码仓库: ${chalk.dim(template.repo)}`);
+  console.log(`  源码仓库: ${chalk.dim(template.repoUrl)}`);
   console.log();
 
   const { confirmed } = await inquirer.prompt([
@@ -671,10 +667,9 @@ async function confirmCreation(projectName, template, projectConfig) {
 }
 
 /**
- * 执行创建流程 - 增强版本，改进进度显示
+ * 执行创建流程 - 简化版本，总是下载最新模板
  */
 async function executeCreation(projectName, template, projectConfig) {
-  // 调试信息 - 确保参数正确
   if (!projectName || typeof projectName !== "string") {
     throw new Error(`项目名称无效: ${projectName}`);
   }
@@ -683,13 +678,14 @@ async function executeCreation(projectName, template, projectConfig) {
     throw new Error(`模板数据无效: ${JSON.stringify(template)}`);
   }
 
-  // 使用更详细的 spinner 配置
   const spinner = ora({
     text: "🚀 准备创建项目...",
     spinner: 'dots',
     color: 'cyan'
   }).start();
 
+  let tempTemplatePath; // 用于清理临时文件
+
   try {
     // 1. 检查目录是否存在
     spinner.text = "📁 检查项目目录...";
@@ -717,23 +713,13 @@ async function executeCreation(projectName, template, projectConfig) {
       spinner.text = "📁 准备创建新目录...";
     }
 
-    // 2. 下载模板 - download.js 会自动更新 spinner 状态
-    spinner.text = "🌐 开始下载模板...";
-    let templatePath;
-
+    // 2. 下载最新模板
+    spinner.text = "🌐 下载最新模板...";
     try {
-      templatePath = await downloadTemplate(template, {
-        useCache: projectConfig.useCache,
-        spinner, // 传递 spinner，让 download 函数更新进度
-      });
-
-      // 验证模板路径
-      if (!templatePath || typeof templatePath !== "string") {
-        throw new Error(`模板路径无效: ${templatePath}`);
-      }
+      tempTemplatePath = await downloadTemplate(template, { spinner });
 
-      if (!fs.existsSync(templatePath)) {
-        throw new Error(`模板路径不存在: ${templatePath}`);
+      if (!tempTemplatePath || !fs.existsSync(tempTemplatePath)) {
+        throw new Error(`模板路径无效: ${tempTemplatePath}`);
       }
     } catch (error) {
       spinner.fail("模板下载失败");
@@ -743,16 +729,14 @@ async function executeCreation(projectName, template, projectConfig) {
       console.log();
       console.log(chalk.blue("💡 可能的解决方案:"));
       console.log(chalk.dim("   1. 检查网络连接"));
-      console.log(chalk.dim("   2. 使用 robot cache --clear 清除缓存"));
-      console.log(chalk.dim("   3. 重试: robot create --no-cache"));
-      console.log(chalk.dim("   4. 检查仓库地址是否正确"));
+      console.log(chalk.dim("   2. 重试命令"));
+      console.log(chalk.dim("   3. 检查仓库地址是否正确"));
       console.log();
       throw error;
     }
 
-    // 3. 复制模板文件
-    spinner.text = "📋 复制项目文件...";
-    await copyTemplate(templatePath, projectPath);
+    // 3. 复制模板文件 - 带详细进度
+    await copyTemplate(tempTemplatePath, projectPath, spinner);
 
     // 4. 处理项目配置
     spinner.text = "⚙️  处理项目配置...";
@@ -779,7 +763,13 @@ async function executeCreation(projectName, template, projectConfig) {
       );
     }
 
-    // 7. 创建成功
+    // 7. 清理临时文件
+    if (tempTemplatePath) {
+      spinner.text = "🧹 清理临时文件...";
+      await fs.remove(tempTemplatePath).catch(() => {});
+    }
+
+    // 8. 创建成功
     spinner.succeed(chalk.green("🎉 项目创建成功!"));
 
     console.log();
@@ -809,7 +799,6 @@ async function executeCreation(projectName, template, projectConfig) {
       );
     }
 
-    // 根据模板类型提供启动命令
     const startCommand = getStartCommand(template);
     if (startCommand) {
       console.log(chalk.cyan(`   ${startCommand}`));
@@ -826,6 +815,11 @@ async function executeCreation(projectName, template, projectConfig) {
       console.log();
     }
   } catch (error) {
+    // 清理临时文件
+    if (tempTemplatePath) {
+      await fs.remove(tempTemplatePath).catch(() => {});
+    }
+    
     spinner.fail("创建项目失败");
     throw error;
   }

package/lib/download.js

@@ -1,17 +1,9 @@
-// lib/download.js - 真正简化版，解决实际问题
+// lib/download.js - 简化版，移除缓存功能
 import fs from 'fs-extra';
 import path from 'path';
 import os from 'os';
 import fetch from 'node-fetch';
 import extract from 'extract-zip';
-import chalk from 'chalk';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// 缓存目录
-const CACHE_DIR = path.join(os.homedir(), '.robot-cli', 'cache');
 
 /**
  * 解析仓库URL，构建下载链接
@@ -20,30 +12,24 @@ function buildDownloadUrl(repoUrl) {
   try {
     const url = new URL(repoUrl);
     const hostname = url.hostname;
-    const pathname = url.pathname;
     
     if (hostname === 'github.com') {
-      // GitHub: https://github.com/user/repo -> /user/repo/archive/refs/heads/main.zip
       return `${repoUrl}/archive/refs/heads/main.zip`;
     } else if (hostname === 'gitee.com') {
-      // Gitee: https://gitee.com/user/repo -> /user/repo/repository/archive/master.zip
       return `${repoUrl}/repository/archive/master.zip`;
     } else if (hostname === 'gitlab.com') {
-      // GitLab: https://gitlab.com/user/repo -> /user/repo/-/archive/main/repo-main.zip
-      const repoName = pathname.split('/').pop();
+      const repoName = repoUrl.split('/').pop();
       return `${repoUrl}/-/archive/main/${repoName}-main.zip`;
     } else {
-      // 其他平台，默认使用 GitHub 格式
       return `${repoUrl}/archive/refs/heads/main.zip`;
     }
   } catch (error) {
-    // URL 解析失败，返回原始URL + 默认后缀
     return `${repoUrl}/archive/refs/heads/main.zip`;
   }
 }
 
 /**
- * 尝试下载 - 支持多平台
+ * 尝试从多个源下载
  */
 async function tryDownload(repoUrl, spinner) {
   const url = new URL(repoUrl);
@@ -58,7 +44,6 @@ async function tryDownload(repoUrl, spinner) {
       `https://ghproxy.com/${repoUrl}`      // GitHub 代理
     ];
   } else {
-    // 其他平台直接使用原始URL
     mirrors = [repoUrl];
   }
   
@@ -69,13 +54,17 @@ async function tryDownload(repoUrl, spinner) {
     
     try {
       if (spinner) {
-        spinner.text = `📦 尝试从 ${sourceName} 下载...`;
+        spinner.text = `🔍 连接到 ${sourceName}...`;
       }
       
       const downloadUrl = buildDownloadUrl(currentUrl);
       
+      if (spinner) {
+        spinner.text = `📦 从 ${sourceName} 下载模板...`;
+      }
+      
       const response = await fetch(downloadUrl, {
-        timeout: isOriginal ? 15000 : 10000, // 官方源给更多时间
+        timeout: isOriginal ? 15000 : 10000,
         headers: {
           'User-Agent': 'Robot-CLI/1.0.0'
         }
@@ -101,81 +90,48 @@ async function tryDownload(repoUrl, spinner) {
       return { response, sourceName };
       
     } catch (error) {
-      // 如果是最后一个源，抛出错误
       if (i === mirrors.length - 1) {
         throw error;
       }
       
-      // 否则继续尝试下一个源
       if (spinner) {
         spinner.text = `⚠️  ${sourceName} 访问失败，尝试其他源...`;
       }
       
-      // 等待1秒再试下一个
       await new Promise(resolve => setTimeout(resolve, 1000));
     }
   }
 }
 
 /**
- * 下载模板 - 简化版
+ * 下载模板 - 简化版，总是下载最新版本
  */
 export async function downloadTemplate(template, options = {}) {
-  const { useCache = true, spinner } = options;
+  const { spinner } = options;
   
   // 验证模板参数
-  if (!template) {
-    throw new Error('模板参数不能为空');
-  }
-  
-  if (!template.key && !template.repoUrl) {
+  if (!template || !template.repoUrl) {
     throw new Error(`模板配置无效: ${JSON.stringify(template)}`);
   }
-  
-  // 获取缓存键值
-  const cacheKey = template.key || template.repoUrl?.split('/').pop() || 'unknown-template';
-  const cachePath = path.join(CACHE_DIR, cacheKey);
 
-  // 检查缓存
-  if (useCache && fs.existsSync(cachePath)) {
+  try {
     if (spinner) {
-      spinner.text = '📂 使用缓存模板...';
+      spinner.text = '🌐 开始下载最新模板...';
     }
     
-    // 验证缓存完整性
-    const packageJsonPath = path.join(cachePath, 'package.json');
-    if (fs.existsSync(packageJsonPath)) {
-      if (spinner) {
-        spinner.text = '✅ 缓存模板验证通过';
-      }
-      return cachePath;
-    } else {
-      // 缓存损坏，删除重新下载
-      if (spinner) {
-        spinner.text = '🔄 缓存损坏，重新下载...';
-      }
-      await fs.remove(cachePath);
-    }
-  }
-
-  // 如果是本地测试模板
-  if (template.localTest || !template.repoUrl) {
-    if (fs.existsSync(cachePath)) {
-      return cachePath;
-    } else {
-      throw new Error(`本地测试模板不存在: ${cachePath}`);
-    }
-  }
-
-  // 下载远程模板
-  try {
     // 尝试从不同源下载
     const { response, sourceName } = await tryDownload(template.repoUrl, spinner);
 
-    // 保存到临时文件
-    const tempZipPath = path.join(os.tmpdir(), cacheKey + '-' + Date.now() + '.zip');
-    const tempExtractPath = path.join(os.tmpdir(), cacheKey + '-extract-' + Date.now());
+    if (spinner) {
+      spinner.text = '💾 保存下载文件...';
+    }
 
+    // 创建临时目录和文件
+    const timestamp = Date.now();
+    const tempZipPath = path.join(os.tmpdir(), `robot-template-${timestamp}.zip`);
+    const tempExtractPath = path.join(os.tmpdir(), `robot-extract-${timestamp}`);
+
+    // 保存下载的文件
     const buffer = await response.buffer();
     await fs.writeFile(tempZipPath, buffer);
 
@@ -186,6 +142,10 @@ export async function downloadTemplate(template, options = {}) {
     // 解压文件
     await extract(tempZipPath, { dir: tempExtractPath });
 
+    if (spinner) {
+      spinner.text = '🔍 查找项目结构...';
+    }
+
     // 查找项目目录
     const extractedItems = await fs.readdir(tempExtractPath);
     const projectDir = extractedItems.find(item => 
@@ -210,33 +170,21 @@ export async function downloadTemplate(template, options = {}) {
       throw new Error(`模板缺少 package.json 文件`);
     }
 
-    // 保存到缓存
     if (spinner) {
-      spinner.text = '💾 保存到缓存...';
-    }
-
-    await fs.ensureDir(CACHE_DIR);
-    if (fs.existsSync(cachePath)) {
-      await fs.remove(cachePath);
+      spinner.text = `🎉 模板下载完成 (via ${sourceName})`;
     }
-    await fs.move(sourcePath, cachePath);
 
-    // 清理临时文件
+    // 清理zip文件，但保留解压的源码目录供后续使用
     await fs.remove(tempZipPath).catch(() => {});
-    await fs.remove(tempExtractPath).catch(() => {});
-
-    if (spinner) {
-      spinner.text = `🎉 模板下载完成 (via ${sourceName})`;
-    }
 
-    return cachePath;
+    return sourcePath;
 
   } catch (error) {
     // 清理临时文件
     try {
       const tempFiles = await fs.readdir(os.tmpdir());
       const robotTempFiles = tempFiles.filter(file => 
-        file.includes(cacheKey) && (file.endsWith('.zip') || file.includes('extract'))
+        file.includes('robot-template-') || file.includes('robot-extract-')
       );
       
       for (const file of robotTempFiles) {
@@ -246,7 +194,6 @@ export async function downloadTemplate(template, options = {}) {
       // 忽略清理错误
     }
 
-    // 简单的错误处理
     let errorMessage = `模板下载失败: ${error.message}`;
     
     if (error.code === 'ENOTFOUND' || error.message.includes('网络')) {
@@ -255,14 +202,4 @@ export async function downloadTemplate(template, options = {}) {
     
     throw new Error(errorMessage);
   }
-}
-
-/**
- * 清除所有缓存
- */
-export async function clearCache() {
-  if (fs.existsSync(CACHE_DIR)) {
-    await fs.remove(CACHE_DIR);
-  }
-  await fs.ensureDir(CACHE_DIR);
 }

package/lib/utils.js

@@ -1,4 +1,4 @@
-// lib/utils.js - 增强版本
+// lib/utils.js - 增强版本，添加详细进度展示
 import fs from 'fs-extra';
 import path from 'path';
 import chalk from 'chalk';
@@ -10,28 +10,23 @@ import fetch from 'node-fetch';
  */
 export function detectPackageManager() {
   try {
-    // 检查各种包管理器的可用性
     const managers = [];
     
-    // 检查 bun
     try {
       execSync('bun --version', { stdio: 'ignore' });
       managers.push('bun');
     } catch {}
     
-    // 检查 pnpm
     try {
       execSync('pnpm --version', { stdio: 'ignore' });
       managers.push('pnpm');
     } catch {}
     
-    // 检查 yarn
     try {
       execSync('yarn --version', { stdio: 'ignore' });
       managers.push('yarn');
     } catch {}
     
-    // npm 通常总是可用的
     try {
       execSync('npm --version', { stdio: 'ignore' });
       managers.push('npm');
@@ -39,75 +34,10 @@ export function detectPackageManager() {
     
     return managers;
   } catch (error) {
-    return ['npm']; // 默认返回 npm
+    return ['npm'];
   }
 }
 
-/**
- * 获取当前CLI的安装信息
- */
-export function getInstallationInfo() {
-  try {
-    const packagePath = process.env.npm_config_global 
-      ? path.join(process.env.npm_config_global, 'node_modules', '@agile-team', 'robot-cli')
-      : null;
-      
-    return {
-      binPath: process.argv[1],
-      packagePath,
-      nodeVersion: process.version,
-      platform: process.platform,
-      arch: process.arch
-    };
-  } catch (error) {
-    return {
-      binPath: process.argv[1],
-      packagePath: null,
-      nodeVersion: process.version,
-      platform: process.platform,
-      arch: process.arch
-    };
-  }
-}
-
-/**
- * 诊断安装问题
- */
-export function diagnoseInstallation() {
-  const info = getInstallationInfo();
-  const managers = detectPackageManager();
-  
-  console.log(chalk.blue('🔍 安装诊断信息:'));
-  console.log();
-  console.log(`  执行文件: ${chalk.cyan(info.binPath)}`);
-  console.log(`  Node版本: ${chalk.cyan(info.nodeVersion)}`);
-  console.log(`  系统平台: ${chalk.cyan(info.platform)} (${info.arch})`);
-  console.log(`  可用包管理器: ${chalk.cyan(managers.join(', '))}`);
-  
-  if (info.packagePath) {
-    console.log(`  包路径: ${chalk.cyan(info.packagePath)}`);
-  }
-  
-  console.log();
-  console.log(chalk.blue('💡 推荐的安装方式:'));
-  
-  if (managers.includes('bun')) {
-    console.log(chalk.green('  bun install -g @agile-team/robot-cli'));
-  }
-  if (managers.includes('pnpm')) {
-    console.log(chalk.green('  pnpm install -g @agile-team/robot-cli'));
-  }
-  if (managers.includes('yarn')) {
-    console.log(chalk.green('  yarn global add @agile-team/robot-cli'));
-  }
-  if (managers.includes('npm')) {
-    console.log(chalk.green('  npm install -g @agile-team/robot-cli'));
-  }
-  
-  console.log();
-  console.log(chalk.yellow('⚠️  建议只使用一种包管理器来避免冲突'));
-}
-
 /**
  * 验证项目名称
  */
@@ -157,28 +87,92 @@ export function validateProjectName(name) {
 }
 
 /**
- * 复制模板文件
+ * 统计目录中的文件数量
  */
-export async function copyTemplate(sourcePath, targetPath) {
+async function countFiles(dirPath) {
+  let count = 0;
+  
+  async function walkDir(currentPath) {
+    const items = await fs.readdir(currentPath);
+    
+    for (const item of items) {
+      const itemPath = path.join(currentPath, item);
+      const stat = await fs.stat(itemPath);
+      
+      if (stat.isDirectory()) {
+        // 跳过不需要的目录
+        if (!['node_modules', '.git', '.DS_Store'].includes(item)) {
+          await walkDir(itemPath);
+        }
+      } else {
+        count++;
+      }
+    }
+  }
+  
+  await walkDir(dirPath);
+  return count;
+}
+
+/**
+ * 复制模板文件 - 带详细进度展示
+ */
+export async function copyTemplate(sourcePath, targetPath, spinner) {
   if (!fs.existsSync(sourcePath)) {
     throw new Error(`源路径不存在: ${sourcePath}`);
   }
 
   await fs.ensureDir(targetPath);
-  await fs.copy(sourcePath, targetPath, {
-    filter: (src) => {
-      const basename = path.basename(src);
-      // 排除不需要的文件
-      return ![
-        '.git',
-        'node_modules',
-        '.DS_Store',
-        'Thumbs.db',
-        '.vscode',
-        '.idea'
-      ].includes(basename);
+  
+  // 1. 统计文件数量
+  if (spinner) {
+    spinner.text = '📊 统计文件数量...';
+  }
+  
+  const totalFiles = await countFiles(sourcePath);
+  
+  if (spinner) {
+    spinner.text = `📋 开始复制 ${totalFiles} 个文件...`;
+  }
+  
+  let copiedFiles = 0;
+  
+  // 2. 递归复制文件，带进度更新
+  async function copyWithProgress(srcDir, destDir) {
+    const items = await fs.readdir(srcDir);
+    
+    for (const item of items) {
+      const srcPath = path.join(srcDir, item);
+      const destPath = path.join(destDir, item);
+      const stat = await fs.stat(srcPath);
+      
+      if (stat.isDirectory()) {
+        // 排除不需要的文件夹
+        if (['node_modules', '.git', '.DS_Store', '.vscode', '.idea'].includes(item)) {
+          continue;
+        }
+        
+        await fs.ensureDir(destPath);
+        await copyWithProgress(srcPath, destPath);
+      } else {
+        // 复制文件
+        await fs.copy(srcPath, destPath);
+        copiedFiles++;
+        
+        // 更新进度 (每10个文件或重要节点更新一次)
+        if (spinner && (copiedFiles % 10 === 0 || copiedFiles === totalFiles)) {
+          const percentage = Math.round((copiedFiles / totalFiles) * 100);
+          spinner.text = `📋 复制中... ${copiedFiles}/${totalFiles} (${percentage}%)`;
+        }
+      }
     }
-  });
+  }
+  
+  await copyWithProgress(sourcePath, targetPath);
+  
+  if (spinner) {
+    spinner.text = `✅ 文件复制完成 (${copiedFiles} 个文件)`;
+  }
 }
 
 /**
@@ -190,7 +184,6 @@ export async function installDependencies(projectPath, spinner, packageManager =
   try {
     process.chdir(projectPath);
 
-    // 检查 package.json 是否存在
     const packageJsonPath = path.join(projectPath, 'package.json');
     if (!fs.existsSync(packageJsonPath)) {
       if (spinner) {
@@ -199,7 +192,6 @@ export async function installDependencies(projectPath, spinner, packageManager =
       return;
     }
 
-    // 根据包管理器选择安装命令
     const installCommands = {
       bun: 'bun install',
       pnpm: 'pnpm install',
@@ -215,9 +207,13 @@ export async function installDependencies(projectPath, spinner, packageManager =
 
     execSync(command, { 
       stdio: 'ignore',
-      timeout: 300000 // 5分钟超时
+      timeout: 300000
     });
 
+    if (spinner) {
+      spinner.text = `✅ 依赖安装完成 (${packageManager})`;
+    }
+
   } catch (error) {
     if (spinner) {
       spinner.text = `⚠️  依赖安装失败，请手动安装`;
@@ -246,7 +242,6 @@ export async function checkNetworkConnection() {
     });
     return response.ok;
   } catch (error) {
-    // 尝试备用检查
     try {
       const response = await fetch('https://www.npmjs.com', {
         method: 'HEAD',
@@ -279,7 +274,6 @@ export async function generateProjectStats(projectPath) {
         const stat = await fs.stat(itemPath);
 
         if (stat.isDirectory()) {
-          // 跳过 node_modules 等目录
           if (!['node_modules', '.git', '.DS_Store'].includes(item)) {
             stats.directories++;
             await walkDir(itemPath);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agile-team/robot-cli",
-  "version": "1.0.8",
-  "description": "🤖 现代化项目脚手架工具，支持多技术栈快速创建项目",
+  "version": "1.1.0",
+  "description": "🤖 现代化项目脚手架工具，支持多技术栈快速创建项目 - 总是下载最新版本",
   "type": "module",
   "bin": {
     "robot": "bin/index.js"
@@ -11,8 +11,6 @@
     "robot:create": "node bin/index.js create",
     "robot:list": "node bin/index.js list",
     "robot:search": "node bin/index.js search",
-    "robot:cache": "node bin/index.js cache --info",
-    "robot:cache:clear": "node bin/index.js cache --clear",
     "test": "node test/local-test.js",
     "test:setup": "node test/local-test.js --setup",
     "test:clean": "node test/local-test.js --clean",
@@ -20,8 +18,6 @@
     "dev:create": "node bin/index.js create",
     "dev:list": "node bin/index.js list",
     "dev:search": "node bin/index.js search",
-    "dev:cache": "node bin/index.js cache --info",
-    "dev:cache:clear": "node bin/index.js cache --clear",
     "install:deps": "bun install || npm install",
     "clean:modules": "rm -rf node_modules",
     "reinstall": "npm run clean:modules && npm run install:deps",
@@ -61,6 +57,8 @@
     "electron",
     "project-generator",
     "boilerplate",
+    "always-latest",
+    "no-cache",
     "cheny"
   ],
   "engines": {

package/lib/cache.js

@@ -1,120 +0,0 @@
-// lib/cache.js 
-import fs from 'fs-extra';
-import path from 'path';
-import os from 'os';
-import chalk from 'chalk';
-
-const CACHE_DIR = path.join(os.homedir(), '.robot-cli', 'cache');
-
-/**
- * 清除缓存
- */
-export async function clearCache() {
-  try {
-    if (fs.existsSync(CACHE_DIR)) {
-      const cacheItems = await fs.readdir(CACHE_DIR);
-      
-      if (cacheItems.length === 0) {
-        console.log(chalk.yellow('📭 缓存目录为空'));
-        return;
-      }
-
-      await fs.remove(CACHE_DIR);
-      await fs.ensureDir(CACHE_DIR);
-      
-      console.log(chalk.green(`🗑️  已清除 ${cacheItems.length} 个缓存模板:`));
-      cacheItems.forEach(item => {
-        console.log(chalk.gray(`   - ${item}`));
-      });
-    } else {
-      console.log(chalk.yellow('📭 缓存目录不存在'));
-    }
-  } catch (error) {
-    throw new Error(`清除缓存失败: ${error.message}`);
-  }
-}
-
-/**
- * 获取缓存信息
- */
-export async function getCacheInfo() {
-  try {
-    if (!fs.existsSync(CACHE_DIR)) {
-      return {
-        exists: false,
-        templates: [],
-        size: 0,
-        path: CACHE_DIR
-      };
-    }
-
-    const templates = await fs.readdir(CACHE_DIR);
-    let totalSize = 0;
-
-    const templateInfos = await Promise.all(
-      templates.map(async (template) => {
-        const templatePath = path.join(CACHE_DIR, template);
-        const stats = await fs.stat(templatePath);
-        const size = await getFolderSize(templatePath);
-        totalSize += size;
-
-        return {
-          name: template,
-          modifiedTime: stats.mtime,
-          size: size
-        };
-      })
-    );
-
-    return {
-      exists: true,
-      templates: templateInfos,
-      size: totalSize,
-      path: CACHE_DIR
-    };
-  } catch (error) {
-    throw new Error(`获取缓存信息失败: ${error.message}`);
-  }
-}
-
-/**
- * 计算文件夹大小
- */
-async function getFolderSize(folderPath) {
-  let size = 0;
-
-  async function calculateSize(currentPath) {
-    try {
-      const items = await fs.readdir(currentPath);
-      
-      for (const item of items) {
-        const itemPath = path.join(currentPath, item);
-        const stats = await fs.stat(itemPath);
-        
-        if (stats.isDirectory()) {
-          await calculateSize(itemPath);
-        } else {
-          size += stats.size;
-        }
-      }
-    } catch (error) {
-      // 忽略权限错误等
-    }
-  }
-
-  await calculateSize(folderPath);
-  return size;
-}
-
-/**
- * 格式化文件大小
- */
-export function formatSize(bytes) {
-  if (bytes === 0) return '0 B';
-  
-  const k = 1024;
-  const sizes = ['B', 'KB', 'MB', 'GB'];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  
-  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
-}