@coze-arch/cli 0.0.1-alpha.89faa2 → 0.0.1-alpha.8b5326

package/lib/cli.js

@@ -4,13 +4,15 @@
 var commander = require('commander');
 var path = require('path');
 var fs = require('fs');
+var node_path = require('node:path');
+var node_fs = require('node:fs');
 var shelljs = require('shelljs');
 var perf_hooks = require('perf_hooks');
 var fs$1 = require('fs/promises');
-var toml = require('@iarna/toml');
+var os = require('os');
 var jsYaml = require('js-yaml');
+var toml = require('@iarna/toml');
 var child_process = require('child_process');
-var os = require('os');
 var addFormats = require('ajv-formats');
 var Ajv = require('ajv');
 var minimist = require('minimist');
@@ -481,6 +483,14 @@ const warmupTemplate = (templatePath, templateName) => {
   logger.info(`\nWarming up template: ${templateName}`);
   logger.info(`  Path: ${templatePath}`);
 
+  // 检查是否存在 package.json
+  const packageJsonPath = node_path.join(templatePath, 'package.json');
+  // eslint-disable-next-line security/detect-non-literal-fs-filename
+  if (!node_fs.existsSync(packageJsonPath)) {
+    logger.info(`  ⊘ Skipping ${templateName} (no package.json found)`);
+    return;
+  }
+
   const result = shelljs.exec('pnpm install', {
     cwd: templatePath,
     silent: true,
@@ -514,13 +524,7 @@ const warmupTemplate = (templatePath, templateName) => {
 /**
  * 执行 warmup 命令的内部实现
  */
-const executeWarmup = async (
-  options
-
-,
-
-  command,
-) => {
+const executeWarmup = async (options) => {
   const timer = new TimeTracker();
 
   try {
@@ -585,12 +589,12 @@ const executeWarmup = async (
 /**
  * 注册 warmup 命令到 program
  */
-const registerCommand$2 = program => {
+const registerCommand$4 = program => {
   program
     .command('warmup')
     .description('Pre-install dependencies for templates to speed up init')
     .option('-t, --template <name>', 'Warmup a specific template only')
-    .action(async (options, command) => {
+    .action(async options => {
       await executeWarmup(options);
     });
 };
@@ -727,7 +731,7 @@ const parseConfigContent = (content) => {
     return config ;
   } catch (error) {
     // TOML 解析失败，继续尝试其他格式
-    // eslint-disable-next-line no-console
+
     console.debug('TOML parse failed:', error);
   }
 
@@ -739,7 +743,7 @@ const parseConfigContent = (content) => {
     }
   } catch (error) {
     // YAML 解析失败，继续尝试其他格式
-    // eslint-disable-next-line no-console
+
     console.debug('YAML parse failed:', error);
   }
 
@@ -823,27 +827,276 @@ const getCommandConfig = (
   return commandConfig;
 };
 
-function _nullishCoalesce$1(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+// ABOUTME: Fix rule to comment out problematic outputFileTracingRoot config in Next.js projects
+// ABOUTME: This config can cause issues in monorepo environments and should be removed
+
+
+
+
+/**
+ * 检查是否为 Next.js 项目
+ */
+const isNextProject = (projectFolder) => {
+  const packageJsonPath = path.join(projectFolder, 'package.json');
+
+  if (!fs.existsSync(packageJsonPath)) {
+    return false;
+  }
+
+  try {
+    // eslint-disable-next-line no-restricted-syntax
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    const deps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies,
+    };
+
+    return 'next' in deps;
+  } catch (e) {
+    return false;
+  }
+};
 
 /**
- * 创建日志管理器
+ * 查找 Next.js 配置文件
  */
-const createLogManager = (logDir = '.coze-logs') => {
-  const ensureLogDir = () => {
-    if (!fs.existsSync(logDir)) {
-      fs.mkdirSync(logDir, { recursive: true });
+const findNextConfigFile = (projectFolder) => {
+  const possibleConfigs = [
+    'next.config.ts',
+    'next.config.js',
+    'next.config.mjs',
+  ];
+
+  for (const configFile of possibleConfigs) {
+    const configPath = path.join(projectFolder, configFile);
+    if (fs.existsSync(configPath)) {
+      return configPath;
     }
-  };
+  }
+
+  return null;
+};
+
+/**
+ * 注释掉 outputFileTracingRoot 配置
+ */
+const commentOutOutputTracingRoot = (
+  configPath,
+) => {
+  let content = fs.readFileSync(configPath, 'utf-8');
+  let modified = false;
+  let originalLine = null;
+
+  // 匹配包含 outputFileTracingRoot 的行（尚未被注释的）
+  // 支持 path.resolve(...) 后面有空格，然后可选逗号
+  // 只匹配单行配置，不匹配跨多行的配置
+  const pattern =
+    /^(\s*)(outputFileTracingRoot:\s*path\.resolve\([^\n\r)]+\)\s*,?)\s*$/gm;
+
+  const matches = content.match(pattern);
+
+  if (matches && matches.length > 0) {
+    originalLine = matches[0].trim();
+
+    // 在匹配的行前添加 // 注释
+    content = content.replace(pattern, '$1// $2');
+    modified = true;
+
+    fs.writeFileSync(configPath, content, 'utf-8');
+  }
+
+  return { modified, originalLine };
+};
+
+// start_aigc
+/**
+ * Fix 规则：注释掉 Next.js 项目中的 outputFileTracingRoot 配置
+ * 这个配置在 monorepo 环境中可能会导致问题
+ */
+const fixNextOutputTracingRoot = context => {
+  const ruleName = 'next-output-tracing-root';
+
+  // 1. 检查是否为 Next.js 项目
+  if (!isNextProject(context.projectFolder)) {
+    return {
+      ruleName,
+      applied: false,
+      message: 'Not a Next.js project, skipping',
+    };
+  }
+
+  // 2. 查找 Next.js 配置文件
+  const configPath = findNextConfigFile(context.projectFolder);
+
+  if (!configPath) {
+    return {
+      ruleName,
+      applied: false,
+      message: 'Next.js config file not found, skipping',
+    };
+  }
+
+  // 3. 注释掉 outputFileTracingRoot 配置
+  const { modified, originalLine } = commentOutOutputTracingRoot(configPath);
+
+  if (modified && originalLine) {
+    logger.success(
+      `Commented out outputFileTracingRoot in ${configPath.split('/').pop()}`,
+    );
+    logger.info(`  Original: ${originalLine}`);
 
-  const getLogPath = (logFile) => path.join(logDir, logFile);
+    return {
+      ruleName,
+      applied: true,
+      message: `Successfully commented out: ${originalLine}`,
+    };
+  }
 
   return {
-    createWriteStream: (logFile) => {
-      ensureLogDir();
-      return fs.createWriteStream(getLogPath(logFile), { flags: 'a' });
-    },
+    ruleName,
+    applied: false,
+    message: 'No outputFileTracingRoot config found, skipping',
   };
 };
+// end_aigc
+
+/**
+ * 所有修复规则的数组
+ * 按顺序执行，新增规则直接添加到数组中
+ */
+const rules = [
+  // Next.js related fixes
+  fixNextOutputTracingRoot,
+
+  // Add more rules here
+] ;
+
+// ABOUTME: Fix command for resolving legacy issues from previous project versions
+// ABOUTME: Applies a series of fix rules defined in the fix-rules directory
+
+
+// start_aigc
+/**
+ * 执行 fix 命令的内部实现
+ */
+const executeFix = async (options = {}) => {
+  try {
+    const cwd = process.cwd();
+    const projectFolder = options.directory
+      ? path.resolve(cwd, options.directory)
+      : cwd;
+
+    logger.info(`Running fix command on: ${projectFolder}`);
+    logger.info(`Found ${rules.length} fix rule(s) to apply\n`);
+
+    const context = {
+      cwd,
+      projectFolder,
+    };
+
+    let appliedCount = 0;
+    let skippedCount = 0;
+
+    // 依次执行所有修复规则
+    for (const rule of rules) {
+      try {
+        const result = await Promise.resolve(rule(context));
+
+        if (result.applied) {
+          appliedCount++;
+          logger.success(`✓ ${result.ruleName}: ${result.message}`);
+        } else {
+          skippedCount++;
+          logger.info(`○ ${result.ruleName}: ${result.message}`);
+        }
+      } catch (error) {
+        logger.error(
+          `✗ Rule execution failed: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+    }
+
+    // 输出汇总信息
+    logger.info(
+      `\nSummary: ${appliedCount} fixed, ${skippedCount} skipped, ${rules.length} total`,
+    );
+
+    if (appliedCount > 0) {
+      logger.success('\nFixes applied successfully!');
+    } else {
+      logger.info('\nNo fixes needed');
+    }
+  } catch (error) {
+    logger.error('Failed to run fix command:');
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+};
+// end_aigc
+
+/**
+ * 注册 fix 命令到 program
+ */
+const registerCommand$3 = program => {
+  program
+    .command('fix')
+    .description(
+      'Fix legacy issues from previous versions (e.g., problematic configs)',
+    )
+    .argument(
+      '[directory]',
+      'Target directory to fix (defaults to current directory)',
+    )
+    .action(async (directory) => {
+      await executeFix({ directory });
+    });
+};
+
+function _nullishCoalesce$1(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+/**
+ * 日志文件名常量
+ */
+const LOG_FILE_NAME$1 = 'dev.log';
+
+/**
+ * 获取日志目录
+ * 优先使用环境变量 COZE_LOG_DIR，否则使用 ~/.coze-logs
+ */
+const getLogDir$1 = () =>
+  process.env.COZE_LOG_DIR || path.join(os.homedir(), '.coze-logs');
+
+/**
+ * 解析日志文件路径
+ * - 如果是绝对路径，直接使用
+ * - 如果是相对路径，基于 getLogDir() + 相对路径
+ * - 如果为空，使用 getLogDir() + LOG_FILE_NAME
+ */
+const resolveLogFilePath$1 = (logFile) => {
+  if (!logFile) {
+    return path.join(getLogDir$1(), LOG_FILE_NAME$1);
+  }
+
+  if (path.isAbsolute(logFile)) {
+    return logFile;
+  }
+
+  return path.join(getLogDir$1(), logFile);
+};
+
+/**
+ * 创建日志写入流
+ */
+const createLogStream$1 = (logFilePath) => {
+  const logDir = path.dirname(logFilePath);
+
+  // 确保日志目录存在
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+
+  // 使用 'w' 标志覆盖之前的日志
+  return fs.createWriteStream(logFilePath, { flags: 'w' });
+};
 
 /**
  * 执行命令的内部实现
@@ -855,21 +1108,32 @@ const executeRun = async (
   try {
     logger.info(`Running ${commandName} command...`);
 
-    // 1. 加载 .coze 配置
+    // 1. 对于 build 命令，先执行 fix 以确保项目配置正确
+    if (['dev', 'build'].includes(commandName)) {
+      logger.info('\n🔧 Running fix command before build...\n');
+      try {
+        await executeFix();
+        // eslint-disable-next-line @coze-arch/no-empty-catch
+      } catch (e) {
+        // just ignore
+      }
+      logger.info('');
+    }
+
+    // 2. 加载 .coze 配置
     const config = await loadCozeConfig();
     const commandArgs = getCommandConfig(config, commandName);
 
-    // 2. 准备日志
-    const logManager = createLogManager();
-    const logFile = options.logFile || `${commandName}.log`;
-    const logStream = logManager.createWriteStream(logFile);
+    // 3. 准备日志
+    const logFilePath = resolveLogFilePath$1(options.logFile);
+    const logStream = createLogStream$1(logFilePath);
 
-    // 3. 执行命令
+    // 4. 执行命令
     const commandString = commandArgs.join(' ');
 
     logger.info(`Executing: ${commandString}`);
     logger.info(`Working directory: ${process.cwd()}`);
-    logger.info(`Log file: ${logFile}`);
+    logger.info(`Log file: ${logFilePath}`);
 
     const childProcess = shelljs.exec(commandString, {
       async: true,
@@ -898,11 +1162,11 @@ const executeRun = async (
         logger.error(
           `Command exited with code ${_nullishCoalesce$1(code, () => ( 'unknown'))}${signal ? ` and signal ${signal}` : ''}`,
         );
-        logger.error(`Check log file for details: ${logFile}`);
+        logger.error(`Check log file for details: ${logFilePath}`);
         process.exit(code || 1);
       } else {
         logger.success('Command completed successfully');
-        logger.info(`Log file: ${logFile}`);
+        logger.info(`Log file: ${logFilePath}`);
       }
     });
 
@@ -925,7 +1189,7 @@ const executeRun = async (
 /**
  * 注册 dev/build/start 命令到 program
  */
-const registerCommand$1 = program => {
+const registerCommand$2 = program => {
   // dev 命令
   program
     .command('dev')
@@ -1177,6 +1441,11 @@ const shouldIgnoreFile = (filePath) => {
   return directoryPatterns.some(dir => pathParts.includes(dir));
 };
 
+// ABOUTME: File system utilities for template file processing
+// ABOUTME: Provides directory scanning, file path conversion, and node_modules copying
+
+
+// start_aigc
 /**
  * 递归获取目录中的所有文件
  *
@@ -1246,7 +1515,19 @@ const convertDotfileName = (filePath) => {
 
   return filePath;
 };
+// end_aigc
+
+// ABOUTME: File rendering utilities for template processing
+// ABOUTME: Handles file content rendering, hook execution, and file writing
+
 
+
+
+
+
+
+
+// start_aigc
 /**
  * 执行文件渲染钩子
  *
@@ -1292,22 +1573,25 @@ const executeFileRenderHook = async (
 };
 
 /**
- * 处理单个文件
+ * 准备单个文件的渲染信息（不实际写入）
+ * 用于 dry-run 阶段，收集所有将要写入的文件信息
+ *
+ * @param options - 准备选项
+ * @returns 文件渲染信息，或 null 表示该文件被跳过
  */
-const processSingleFile = async (options
-
+const prepareFileInfo = async (options
 
 
 
 
 ) => {
-  const { file, templatePath, outputPath, context, templateConfig } = options;
+  const { file, templatePath, context, templateConfig } = options;
 
   const srcPath = path.join(templatePath, file);
   const destFile = convertDotfileName(file);
 
   logger.verbose(
-    `  - Processing: ${file}${destFile !== file ? ` -> ${destFile}` : ''}`,
+    `  - Preparing: ${file}${destFile !== file ? ` -> ${destFile}` : ''}`,
   );
 
   // 判断是否为二进制文件
@@ -1341,51 +1625,177 @@ const processSingleFile = async (options
     context,
   );
 
-  // 如果返回 null，跳过该文件
+  // 如果返回 null，表示该文件被 hook 跳过
   if (processedFileInfo === null) {
     logger.verbose('    ⊘ Skipped by onFileRender hook');
-    return;
+    return null;
   }
 
-  // 使用处理后的目标路径
-  const finalDestPath = path.join(outputPath, processedFileInfo.destPath);
+  return processedFileInfo;
+};
+
+/**
+ * 写入渲染后的文件到目标路径
+ *
+ * @param options - 写入选项
+ */
+const writeRenderedFile = async (options
+
+
+
+) => {
+  const { fileInfo, srcPath, destPath } = options;
+
+  logger.verbose(`  - Writing: ${fileInfo.destPath}`);
 
   // 确保目标目录存在
-  await ensureDir(path.dirname(finalDestPath));
+  await ensureDir(path.dirname(destPath));
 
   // 写入文件
-  if (processedFileInfo.isBinary) {
-    // 二进制文件：如果内容没变，直接复制；否则从 base64 解码写入
-    if (processedFileInfo.content === content) {
-      await fs$1.copyFile(srcPath, finalDestPath);
+  if (fileInfo.isBinary) {
+    // 二进制文件：如果内容是原始 base64（未被 hook 修改），直接复制；否则从 base64 解码写入
+    const buffer = await fs$1.readFile(srcPath);
+    const originalContent = buffer.toString('base64');
+
+    if (fileInfo.content === originalContent) {
+      await fs$1.copyFile(srcPath, destPath);
       logger.verbose('    ✓ Copied (binary)');
     } else {
-      const buffer = Buffer.from(processedFileInfo.content, 'base64');
-      await fs$1.writeFile(finalDestPath, buffer);
+      const modifiedBuffer = Buffer.from(fileInfo.content, 'base64');
+      await fs$1.writeFile(destPath, modifiedBuffer);
       logger.verbose('    ✓ Written (binary, modified by hook)');
     }
   } else {
     // 文本文件
-    await fs$1.writeFile(finalDestPath, processedFileInfo.content, 'utf-8');
+    await fs$1.writeFile(destPath, fileInfo.content, 'utf-8');
     logger.verbose('    ✓ Rendered and written');
   }
 };
+// end_aigc
+
+// ABOUTME: File conflict detection utilities for template processing
+// ABOUTME: Provides dry-run file collection and conflict checking
+
+
+
+
+
+
+
+// start_aigc
+/**
+ * 收集所有将要写入的文件路径（dry-run 阶段）
+ *
+ * @param options - 收集选项
+ * @returns 将要写入的文件路径列表
+ */
+const collectFilesToRender = async (options
+
+
+
+
+) => {
+  const { files, templatePath, context, templateConfig } = options;
+
+  logger.verbose('\nDry-run: Collecting files to render...');
+
+  const fileInfos = await Promise.all(
+    files.map(file =>
+      prepareFileInfo({
+        file,
+        templatePath,
+        context,
+        templateConfig,
+      }),
+    ),
+  );
+
+  // 过滤掉被 hook 跳过的文件，收集 destPath
+  const filesToWrite = fileInfos
+    .filter((info) => info !== null)
+    .map(info => info.destPath);
+
+  logger.verbose(`  - ${filesToWrite.length} files will be written`);
+  logger.verbose(
+    `  - ${fileInfos.length - filesToWrite.length} files skipped by hooks`,
+  );
+
+  return filesToWrite;
+};
+// end_aigc
+
+// ABOUTME: Main file processing orchestration for template rendering
+// ABOUTME: Coordinates file system, rendering, and conflict detection layers
+
+
+
+// start_aigc
+/**
+ * 处理单个文件（准备 + 写入）
+ *
+ * @param options - 处理选项
+ */
+const processSingleFile = async (options
+
+
+
+
+
+) => {
+  const { file, templatePath, outputPath, context, templateConfig } = options;
+
+  const srcPath = path.join(templatePath, file);
+
+  // 准备文件信息
+  const processedFileInfo = await prepareFileInfo({
+    file,
+    templatePath,
+    context,
+    templateConfig,
+  });
+
+  // 如果返回 null，跳过该文件
+  if (processedFileInfo === null) {
+    return;
+  }
+
+  // 使用处理后的目标路径
+  const finalDestPath = path.join(outputPath, processedFileInfo.destPath);
+
+  // 写入文件
+  await writeRenderedFile({
+    fileInfo: processedFileInfo,
+    srcPath,
+    destPath: finalDestPath,
+  });
+};
 
 /**
  * 复制并处理模板文件到目标目录
+ *
+ * 流程：
+ * 1. 验证模板目录
+ * 2. 扫描所有模板文件
+ * 3. Dry-run：收集将要写入的文件列表（考虑 hooks 影响）
+ * 4. 冲突检测：检查是否有文件会被覆盖（可通过 force 跳过）
+ * 5. 实际写入：渲染并写入所有文件
+ * 6. 复制 node_modules（如果存在）
+ *
+ * @param options - 处理选项
  */
 const processTemplateFiles = async (options
 
 
 
 
+
 ) => {
-  const { templatePath, outputPath, context, templateConfig } = options;
+  const { templatePath, outputPath, context, templateConfig} = options;
   logger.verbose('Processing template files:');
   logger.verbose(`  - Template path: ${templatePath}`);
   logger.verbose(`  - Output path: ${outputPath}`);
 
-  // 验证模板目录是否存在
+  // 阶段 0: 验证模板目录是否存在
   try {
     const stat = await fs$1.stat(templatePath);
     logger.verbose(
@@ -1401,6 +1811,7 @@ const processTemplateFiles = async (options
     throw error;
   }
 
+  // 阶段 1: 扫描所有模板文件
   const files = await getAllFiles(templatePath);
 
   logger.verbose(`  - Found ${files.length} files to process`);
@@ -1410,6 +1821,23 @@ const processTemplateFiles = async (options
     return;
   }
 
+  // 阶段 2: Dry-run - 收集所有将要写入的文件
+  await collectFilesToRender({
+    files,
+    templatePath,
+    context,
+    templateConfig,
+  });
+
+  // 阶段 3: 冲突检测（force 为 true 时跳过）
+  {
+    logger.verbose(
+      '  - Force mode enabled, skipping conflict detection. Existing files will be overwritten.',
+    );
+  }
+
+  // 阶段 4: 实际写入文件
+  logger.verbose('\nWriting files...');
   await Promise.all(
     files.map(file =>
       processSingleFile({
@@ -1424,78 +1852,14 @@ const processTemplateFiles = async (options
 
   logger.verbose('✓ All files processed successfully');
 
-  // 单独处理 node_modules 目录（如果存在）
-  const sourceNodeModules = path.join(templatePath, 'node_modules');
-  const targetNodeModules = path.join(outputPath, 'node_modules');
+  // node_modules 将由 pnpm install 处理（利用缓存和硬链接机制）
+};
+// end_aigc
 
-  if (fs.existsSync(sourceNodeModules)) {
-    logger.info('\nCopying node_modules from pre-warmed template...');
-    logger.verbose(`  From: ${sourceNodeModules}`);
-    logger.verbose(`  To: ${targetNodeModules}`);
+/**
+ * 模板引擎执行选项
+ */
 
-    const result = shelljs.exec(`cp -R "${sourceNodeModules}" "${targetNodeModules}"`, {
-      silent: true,
-    });
-
-    if (result.stdout) {
-      process.stdout.write(result.stdout);
-    }
-
-    if (result.stderr) {
-      process.stderr.write(result.stderr);
-    }
-
-    if (result.code === 0) {
-      logger.success('✓ node_modules copied successfully');
-    } else {
-      logger.warn(
-        `Failed to copy node_modules: ${result.stderr || 'unknown error'}`,
-      );
-      logger.info('Will need to run pnpm install manually');
-    }
-  }
-};
-
-/**
- * 检查输出目录是否为空
- * 注意:.git 目录会被忽略,允许在已初始化 git 的目录中创建项目
- *
- * @param outputPath - 输出目录路径
- * @returns 是否为空
- */
-const isOutputDirEmpty = async (
-  outputPath,
-) => {
-  try {
-    const entries = await fs$1.readdir(outputPath);
-    // 过滤掉 .git 目录,允许在已初始化 git 的目录中创建项目
-    const filteredEntries = entries.filter(entry => entry !== '.git');
-    return filteredEntries.length === 0;
-  } catch (e) {
-    // 目录不存在，视为空
-    return true;
-  }
-};
-
-/**
- * 验证输出目录
- *
- * @param outputPath - 输出目录路径
- * @throws 如果目录不为空则抛出错误
- */
-const validateOutputDir = async (outputPath) => {
-  const isEmpty = await isOutputDirEmpty(outputPath);
-  if (!isEmpty) {
-    throw new Error(
-      `Output directory is not empty: ${outputPath}\n` +
-        'Please use an empty directory or remove existing files.',
-    );
-  }
-};
-
-/**
- * 模板引擎执行选项
- */
 
 
 
@@ -1571,22 +1935,47 @@ const executeAfterRenderHook = async (
   }
 };
 
+/**
+ * 执行完成钩子
+ */
+const executeCompleteHook = async (
+  templateConfig,
+  context,
+  outputPath,
+) => {
+  if (templateConfig.onComplete) {
+    await templateConfig.onComplete(context, outputPath);
+  }
+};
+
 /**
  * 准备输出目录
  */
-const prepareOutputDirectory = async (outputPath) => {
+const prepareOutputDirectory = (outputPath) => {
   const absolutePath = path.resolve(process.cwd(), outputPath);
-  await validateOutputDir(absolutePath);
+  // 不再在这里验证目录是否为空，冲突检测已移至 processTemplateFiles 中
   return absolutePath;
 };
 
+/**
+ * 模板引擎执行结果
+ */
+
+
+
+
+
+
+
+
+
 /**
  * 执行完整的模板渲染流程
  */
 const execute = async (
   options,
 ) => {
-  const { templateName, outputPath, command } = options;
+  const { templateName, outputPath, command} = options;
 
   // 1. 加载模板
   const { templatePath } = await loadTemplateMetadata(templateName);
@@ -1603,20 +1992,23 @@ const execute = async (
   });
 
   // 5. 准备输出目录
-  const absoluteOutputPath = await prepareOutputDirectory(outputPath);
+  const absoluteOutputPath = prepareOutputDirectory(outputPath);
 
   // 6. 处理模板文件
   await processTemplateFiles({
     templatePath,
     outputPath: absoluteOutputPath,
     context,
-    templateConfig,
-  });
+    templateConfig});
 
   // 7. 执行 onAfterRender 钩子
   await executeAfterRenderHook(templateConfig, context, absoluteOutputPath);
 
-  return absoluteOutputPath;
+  return {
+    outputPath: absoluteOutputPath,
+    templateConfig,
+    context,
+  };
 };
 
 function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
@@ -1658,7 +2050,40 @@ const runPnpmInstall = (projectPath) => {
 };
 
 /**
- * 初始化 git 仓库并创建初始提交
+ * 运行 git 命令的辅助函数
+ */
+const runGitCommand = (command, projectPath) => {
+  logger.info(`Executing: ${command}`);
+
+  const result = shelljs.exec(command, {
+    cwd: projectPath,
+    silent: true,
+  });
+
+  // 输出命令的结果
+  if (result.stdout) {
+    process.stdout.write(result.stdout);
+  }
+
+  if (result.stderr) {
+    process.stderr.write(result.stderr);
+  }
+
+  if (result.code !== 0) {
+    const errorMessage = [
+      `${command} failed with exit code ${result.code}`,
+      result.stderr ? `\nStderr:\n${result.stderr}` : '',
+      result.stdout ? `\nStdout:\n${result.stdout}` : '',
+    ]
+      .filter(Boolean)
+      .join('');
+
+    throw new Error(errorMessage);
+  }
+};
+
+/**
+ * 初始化 git 仓库
  * 如果目录中已存在 .git,则跳过初始化
  */
 const runGitInit = (projectPath) => {
@@ -1671,46 +2096,9 @@ const runGitInit = (projectPath) => {
     return;
   }
 
-  const runGitCommand = (command) => {
-    logger.info(`Executing: ${command}`);
-
-    const result = shelljs.exec(command, {
-      cwd: projectPath,
-      silent: true,
-    });
-
-    // 输出命令的结果
-    if (result.stdout) {
-      process.stdout.write(result.stdout);
-    }
-
-    if (result.stderr) {
-      process.stderr.write(result.stderr);
-    }
-
-    if (result.code !== 0) {
-      const errorMessage = [
-        `${command} failed with exit code ${result.code}`,
-        result.stderr ? `\nStderr:\n${result.stderr}` : '',
-        result.stdout ? `\nStdout:\n${result.stdout}` : '',
-      ]
-        .filter(Boolean)
-        .join('');
-
-      throw new Error(errorMessage);
-    }
-  };
-
   try {
     logger.info('\nInitializing git repository...');
-    runGitCommand('git init');
-
-    logger.info('Adding files to git...');
-    runGitCommand('git add .');
-
-    logger.info('Creating initial commit...');
-    runGitCommand('git commit -m "chore: initial commit"');
-
+    runGitCommand('git init', projectPath);
     logger.success('Git repository initialized successfully!');
   } catch (error) {
     // Git 初始化失败不应该导致整个流程失败
@@ -1721,16 +2109,52 @@ const runGitInit = (projectPath) => {
   }
 };
 
+/**
+ * 提交初始化生成的所有文件
+ */
+const commitChanges = (projectPath) => {
+  // 检查是否存在 .git 目录
+  const gitDir = path.join(projectPath, '.git');
+  if (!fs.existsSync(gitDir)) {
+    logger.warn(
+      '\n⚠️  Git repository does not exist, skipping commit. Run git init first.',
+    );
+    return;
+  }
+
+  try {
+    logger.info('\nCommitting initialized files...');
+    runGitCommand('git add --all', projectPath);
+    runGitCommand('git commit -m "chore: init env"', projectPath);
+    logger.success('Changes committed successfully!');
+  } catch (error) {
+    // Commit 失败不应该导致整个流程失败
+    logger.warn(
+      `Git commit failed: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    logger.info(
+      'You can manually commit later with: git add --all && git commit -m "chore: init env"',
+    );
+  }
+};
+
 /**
  * 运行开发服务器(后台模式)
  * 启动后台子进程运行开发服务器，父进程可以直接退出
+ * 使用 CLI 自己的 dev 命令(定义在 run.ts)而不是直接运行 npm run dev
  */
-const runNpmDev = (projectPath) => {
+const runDev = (projectPath) => {
   logger.info('\nStarting development server in background...');
-  logger.info(`Executing: npm run dev in ${projectPath}`);
+
+  // 获取当前 CLI 的可执行文件路径
+  // process.argv[0] 是 node，process.argv[1] 是 CLI 入口文件
+  const cliPath = process.argv[1];
+
+  logger.info(`Executing: ${cliPath} dev in ${projectPath}`);
 
   // 使用通用的后台执行函数启动开发服务器
-  const pid = spawnDetached('npm', ['run', 'dev'], {
+  // 调用 CLI 自己的 dev 命令
+  const pid = spawnDetached(process.argv[0], [cliPath, 'dev'], {
     cwd: projectPath,
     verbose: false, // 不输出额外的进程信息，由 logger 统一处理
   });
@@ -1755,6 +2179,8 @@ const executeInit = async (
 
 
 
+
+
 ,
   command,
 ) => {
@@ -1766,61 +2192,76 @@ const executeInit = async (
       output: outputPath,
       skipInstall,
       skipGit,
+      skipCommit,
       skipDev,
+      force,
     } = options;
 
     logger.info(`Initializing project with template: ${templateName}`);
     timer.logPhase('Initialization');
 
-    // 执行模板引擎，返回绝对路径
-    const absoluteOutputPath = await execute({
+    // 执行模板引擎，返回结果对象
+    const result = await execute({
       templateName,
       outputPath,
       command,
+      force,
     });
+    const { outputPath: absoluteOutputPath, templateConfig, context } = result;
 
     timer.logPhase('Template engine execution');
     logger.success('Project created successfully!');
 
-    // 如果没有跳过安装，检查是否需要运行 pnpm install
-    if (!skipInstall) {
-      const nodeModulesPath = path.join(absoluteOutputPath, 'node_modules');
-      const hasNodeModules = fs.existsSync(nodeModulesPath);
+    // 检查是否存在 package.json
+    const packageJsonPath = path.join(absoluteOutputPath, 'package.json');
+    const hasPackageJson = fs.existsSync(packageJsonPath);
 
-      if (hasNodeModules) {
-        logger.info(
-          '\n💡 Using pre-warmed node_modules, skipping pnpm install',
-        );
-        timer.logPhase('Node modules (pre-warmed)');
-      } else {
+    // 安装依赖（始终使用 pnpm install，利用缓存机制）
+    if (!skipInstall) {
+      if (hasPackageJson) {
         runPnpmInstall(absoluteOutputPath);
         timer.logPhase('Dependencies installation');
+      } else {
+        logger.info(
+          '\n💡 No package.json found, skipping dependency installation',
+        );
       }
     }
 
+    // 执行 onComplete 钩子（在 pnpm install 之后）
+    await executeCompleteHook(templateConfig, context, absoluteOutputPath);
+    timer.logPhase('Complete hook execution');
+
     // 如果没有跳过 git，则初始化 git 仓库
     if (!skipGit) {
       runGitInit(absoluteOutputPath);
       timer.logPhase('Git initialization');
     }
 
+    // 如果没有跳过 commit，则提交初始化生成的文件
+    if (!skipCommit) {
+      commitChanges(absoluteOutputPath);
+      timer.logPhase('Git commit');
+    }
+
     // 如果没有跳过 dev，则启动开发服务器
     if (!skipDev) {
-      runNpmDev(absoluteOutputPath);
+      runDev(absoluteOutputPath);
       timer.logPhase('Dev server startup');
     } else {
       // 只有跳过 dev 时才显示 Next steps
       logger.info('\nNext steps:');
       logger.info(`  cd ${outputPath}`);
-      if (skipInstall) {
+      if (skipInstall && hasPackageJson) {
         logger.info('  pnpm install');
       }
       if (skipGit) {
-        logger.info(
-          '  git init && git add . && git commit -m "initial commit"',
-        );
+        logger.info('  git init');
       }
-      logger.info('  npm run dev');
+      if (skipCommit) {
+        logger.info('  git add --all && git commit -m "chore: init env"');
+      }
+      logger.info('  coze dev');
     }
 
     // 输出总耗时
@@ -1836,7 +2277,7 @@ const executeInit = async (
 /**
  * 注册 init 命令到 program
  */
-const registerCommand = program => {
+const registerCommand$1 = program => {
   program
     .command('init')
     .description('Initialize a new project from a template')
@@ -1845,23 +2286,328 @@ const registerCommand = program => {
     .option('-o, --output <path>', 'Output directory', process.cwd())
     .option('--skip-install', 'Skip automatic pnpm install', false)
     .option('--skip-git', 'Skip automatic git initialization', false)
+    .option(
+      '--skip-commit',
+      'Skip automatic git commit after initialization',
+      false,
+    )
     .option('--skip-dev', 'Skip automatic dev server start', false)
     .allowUnknownOption() // 允许透传参数
     .action(async (directory, options, command) => {
       // 位置参数优先级高于 --output 选项
       const outputPath = _nullishCoalesce(directory, () => ( options.output));
-      await executeInit({ ...options, output: outputPath }, command);
+      // Always use force mode - overwrite existing files without conflict check
+      const force = true;
+      await executeInit({ ...options, output: outputPath, force }, command);
     });
 };
 
-var version = "0.0.1-alpha.89faa2";
+// ABOUTME: This file implements the update command for coze CLI
+// ABOUTME: It wraps pnpm update/install to update package dependencies with logging support
+
+
+
+
+/**
+ * 日志文件名常量
+ */
+const LOG_FILE_NAME = 'update.log';
+
+/**
+ * 获取日志目录
+ * 优先使用环境变量 COZE_LOG_DIR，否则使用 ~/.coze-logs
+ */
+const getLogDir = () =>
+  process.env.COZE_LOG_DIR || path.join(os.homedir(), '.coze-logs');
+
+/**
+ * 解析日志文件路径
+ * - 如果是绝对路径，直接使用
+ * - 如果是相对路径，基于 getLogDir() + 相对路径
+ * - 如果为空，使用 getLogDir() + LOG_FILE_NAME
+ */
+const resolveLogFilePath = (logFile) => {
+  if (!logFile) {
+    return path.join(getLogDir(), LOG_FILE_NAME);
+  }
+
+  if (path.isAbsolute(logFile)) {
+    return logFile;
+  }
+
+  return path.join(getLogDir(), logFile);
+};
+
+/**
+ * 创建日志写入流
+ */
+const createLogStream = (logFilePath) => {
+  const logDir = path.dirname(logFilePath);
+
+  // 确保日志目录存在
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+
+  // 使用 'w' 标志覆盖之前的日志
+  return fs.createWriteStream(logFilePath, { flags: 'w' });
+};
+
+/**
+ * 格式化时间戳
+ */
+const formatTimestamp = () => {
+  const now = new Date();
+  return now.toISOString();
+};
+
+/**
+ * 写入带时间戳的日志
+ */
+const writeLogWithTimestamp = (stream, message) => {
+  const timestamp = formatTimestamp();
+  const lines = message.split('\n');
+  lines.forEach(line => {
+    if (line) {
+      stream.write(`[${timestamp}] ${line}\n`);
+    } else {
+      stream.write('\n');
+    }
+  });
+  // 确保数据写入磁盘
+  stream.uncork();
+};
+
+/**
+ * 同时输出到控制台和日志文件
+ */
+const logWithFile = (
+  stream,
+  level,
+  message,
+) => {
+  // 输出到控制台
+  switch (level) {
+    case 'info':
+      logger.info(message);
+      break;
+    case 'success':
+      logger.success(message);
+      break;
+    case 'error':
+      logger.error(message);
+      break;
+    default:
+      logger.info(message);
+      break;
+  }
+
+  // 写入日志文件（带时间戳）
+  writeLogWithTimestamp(stream, `[${level.toUpperCase()}] ${message}`);
+};
+
+// start_aigc
+/**
+ * 构建 pnpm add 命令
+ */
+const buildPnpmCommand = (
+  packageName,
+  options
+
+
+
+
+,
+) => {
+  const { global, version, registry, extraArgs } = options;
+
+  const parts = ['pnpm', 'add'];
+
+  // 添加全局标记
+  if (global) {
+    parts.push('-g');
+  }
+
+  // 添加包名和版本
+  if (version && version !== 'latest') {
+    parts.push(`${packageName}@${version}`);
+  } else {
+    parts.push(`${packageName}@latest`);
+  }
+
+  // 添加 registry
+  if (registry) {
+    parts.push(`--registry=${registry}`);
+  }
+
+  // 添加额外参数
+  if (extraArgs.length > 0) {
+    parts.push(...extraArgs);
+  }
+
+  return parts.join(' ');
+};
+// end_aigc
+
+// start_aigc
+/**
+ * 执行 update 命令的内部实现
+ */
+const executeUpdate = (
+  packageName,
+  options
+
+
+
+
+
+
+,
+) => {
+  let logStream = null;
+
+  try {
+    const { global, cwd, version, registry, logFile, extraArgs } = options;
+
+    // 准备日志
+    const logFilePath = resolveLogFilePath(logFile);
+
+    // 调试：确认日志路径
+    logger.info(`Log file path resolved to: ${logFilePath}`);
+
+    logStream = createLogStream(logFilePath);
+
+    // 调试：确认流已创建
+    logger.info('Log stream created successfully');
+
+    logWithFile(logStream, 'info', `Updating package: ${packageName}`);
+
+    // 构建命令
+    const command = buildPnpmCommand(packageName, {
+      global,
+      version,
+      registry,
+      extraArgs,
+    });
+
+    // 确定工作目录
+    const workingDir = cwd
+      ? path.isAbsolute(cwd)
+        ? cwd
+        : path.join(process.cwd(), cwd)
+      : process.cwd();
+
+    logWithFile(logStream, 'info', `Executing: ${command}`);
+    logWithFile(logStream, 'info', `Working directory: ${workingDir}`);
+    logWithFile(logStream, 'info', `Log file: ${logFilePath}`);
+
+    // 记录命令开始时间
+    writeLogWithTimestamp(logStream, '--- Command execution started ---');
+
+    // 同步执行命令
+    const result = shelljs.exec(command, {
+      cwd: workingDir,
+      silent: true, // 使用 silent 来捕获输出
+    });
+
+    // 将输出写入控制台和日志文件（带时间戳）
+    if (result.stdout) {
+      process.stdout.write(result.stdout);
+      writeLogWithTimestamp(logStream, result.stdout.trim());
+    }
+
+    if (result.stderr) {
+      process.stderr.write(result.stderr);
+      writeLogWithTimestamp(logStream, result.stderr.trim());
+    }
+
+    // 记录命令结束时间
+    writeLogWithTimestamp(logStream, '--- Command execution ended ---');
+
+    // 检查执行结果并记录到日志
+    if (result.code === 0) {
+      logWithFile(logStream, 'success', 'Package updated successfully');
+      logWithFile(logStream, 'info', `Log file: ${logFilePath}`);
+    } else {
+      logWithFile(
+        logStream,
+        'error',
+        `Command exited with code ${result.code}`,
+      );
+      logWithFile(
+        logStream,
+        'error',
+        `Check log file for details: ${logFilePath}`,
+      );
+    }
+
+    // 关闭日志流并等待写入完成
+    logStream.end(() => {
+      // 流关闭后再退出进程
+      if (result.code !== 0) {
+        process.exit(result.code || 1);
+      }
+    });
+  } catch (error) {
+    logger.error('Failed to update package:');
+    logger.error(error instanceof Error ? error.message : String(error));
+
+    // 写入错误到日志文件
+    if (logStream) {
+      writeLogWithTimestamp(
+        logStream,
+        `[ERROR] ${error instanceof Error ? error.message : String(error)}`,
+      );
+      // 等待流关闭后再退出
+      logStream.end(() => {
+        process.exit(1);
+      });
+    } else {
+      process.exit(1);
+    }
+  }
+};
+// end_aigc
+
+/**
+ * 注册 update 命令到 program
+ */
+const registerCommand = program => {
+  program
+    .command('update <package>')
+    .description('Update a package dependency')
+    .option('-g, --global', 'Update package globally', false)
+    .option('-c, --cwd <path>', 'Working directory for the update')
+    .option(
+      '--to <version>',
+      'Version to update to (default: latest)',
+      'latest',
+    )
+    .option('--registry <url>', 'Registry URL to use for the update')
+    .option('--log-file <path>', 'Log file path')
+    .allowUnknownOption() // 允许透传参数给 pnpm
+    .action((packageName, options, command) => {
+      // 收集所有未知选项作为额外参数
+      const extraArgs = command.args.slice(1);
+
+      executeUpdate(packageName, {
+        ...options,
+        version: options.to, // 将 --to 映射到 version
+        extraArgs,
+      });
+    });
+};
+
+var version = "0.0.1-alpha.8b5326";
 var packageJson = {
 	version: version};
 
 const commands = [
-  registerCommand,
   registerCommand$1,
   registerCommand$2,
+  registerCommand$4,
+  registerCommand$3,
+  registerCommand,
 ];
 
 const main = () => {