@agile-team/robot-cli 1.0.9 → 1.1.1

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];
   }
   
@@ -79,7 +64,7 @@ async function tryDownload(repoUrl, spinner) {
       }
       
       const response = await fetch(downloadUrl, {
-        timeout: isOriginal ? 15000 : 10000, // 官方源给更多时间
+        timeout: isOriginal ? 15000 : 10000,
         headers: {
           'User-Agent': 'Robot-CLI/1.0.0'
         }
@@ -105,90 +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)) {
-    if (spinner) {
-      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 {
     if (spinner) {
-      spinner.text = '🌐 开始下载模板...';
+      spinner.text = '🌐 开始下载最新模板...';
     }
     
     // 尝试从不同源下载
     const { response, sourceName } = await tryDownload(template.repoUrl, spinner);
 
-    // 显示下载完成，开始保存
     if (spinner) {
       spinner.text = '💾 保存下载文件...';
     }
 
-    // 保存到临时文件
-    const tempZipPath = path.join(os.tmpdir(), cacheKey + '-' + Date.now() + '.zip');
-    const tempExtractPath = path.join(os.tmpdir(), cacheKey + '-extract-' + Date.now());
+    // 创建临时目录和文件
+    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);
 
@@ -227,37 +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);
 
-    // 清理临时文件
-    if (spinner) {
-      spinner.text = '🧹 清理临时文件...';
-    }
-    
+    // 清理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) {
@@ -267,7 +194,6 @@ export async function downloadTemplate(template, options = {}) {
       // 忽略清理错误
     }
 
-    // 简单的错误处理
     let errorMessage = `模板下载失败: ${error.message}`;
     
     if (error.code === 'ENOTFOUND' || error.message.includes('网络')) {
@@ -276,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.9",
-  "description": "🤖 现代化项目脚手架工具，支持多技术栈快速创建项目",
+  "version": "1.1.1",
+  "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];
-}