@coze-arch/cli 0.0.1-alpha.dffbaa → 0.0.1-alpha.e02657

package/lib/cli.js

@@ -7,10 +7,10 @@ var fs = require('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');
@@ -585,7 +585,7 @@ 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')
@@ -727,7 +727,7 @@ const parseConfigContent = (content) => {
     return config ;
   } catch (error) {
     // TOML 解析失败，继续尝试其他格式
-    // eslint-disable-next-line no-console
+
     console.debug('TOML parse failed:', error);
   }
 
@@ -739,7 +739,7 @@ const parseConfigContent = (content) => {
     }
   } catch (error) {
     // YAML 解析失败，继续尝试其他格式
-    // eslint-disable-next-line no-console
+
     console.debug('YAML parse failed:', error);
   }
 
@@ -823,27 +823,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;
+};
 
-  const getLogPath = (logFile) => path.join(logDir, logFile);
+/**
+ * 注释掉 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}`);
+
+    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 +1104,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 +1158,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 +1185,7 @@ const executeRun = async (
 /**
  * 注册 dev/build/start 命令到 program
  */
-const registerCommand$1 = program => {
+const registerCommand$2 = program => {
   // dev 命令
   program
     .command('dev')
@@ -1177,6 +1437,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
 /**
  * 递归获取目录中的所有文件
  *
@@ -1248,22 +1513,356 @@ const convertDotfileName = (filePath) => {
 };
 
 /**
- * 复制并处理模板文件到目标目录
+ * 复制 node_modules 目录（如果存在）
  *
- * @param templatePath - 模板目录路径
- * @param outputPath - 输出目录路径
+ * @param sourceNodeModules - 源 node_modules 路径
+ * @param targetNodeModules - 目标 node_modules 路径
+ */
+const copyNodeModules = (
+  sourceNodeModules,
+  targetNodeModules,
+) => {
+  if (!fs.existsSync(sourceNodeModules)) {
+    return;
+  }
+
+  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');
+  }
+};
+// end_aigc
+
+// ABOUTME: File rendering utilities for template processing
+// ABOUTME: Handles file content rendering, hook execution, and file writing
+
+
+
+
+
+
+
+
+// start_aigc
+/**
+ * 执行文件渲染钩子
+ *
+ * @param templateConfig - 模板配置
+ * @param fileInfo - 文件渲染信息
  * @param context - 模板上下文
+ * @returns 处理后的文件信息，或 null 表示跳过该文件
  */
-const processTemplateFiles = async (
-  templatePath,
-  outputPath,
+const executeFileRenderHook = async (
+  templateConfig,
+  fileInfo,
   context,
 ) => {
+  if (!templateConfig.onFileRender) {
+    return fileInfo;
+  }
+
+  const result = await templateConfig.onFileRender(
+    fileInfo,
+    context,
+  );
+
+  // false: 跳过文件
+  if (result === false) {
+    return null;
+  }
+
+  // undefined/void: 使用默认内容
+  if (result === undefined || result === null) {
+    return fileInfo;
+  }
+
+  // string: 作为 content，其他不变
+  if (typeof result === 'string') {
+    return {
+      ...fileInfo,
+      content: result,
+    };
+  }
+
+  // FileRenderInfo: 使用新对象的信息
+  return result;
+};
+
+/**
+ * 准备单个文件的渲染信息（不实际写入）
+ * 用于 dry-run 阶段，收集所有将要写入的文件信息
+ *
+ * @param options - 准备选项
+ * @returns 文件渲染信息，或 null 表示该文件被跳过
+ */
+const prepareFileInfo = async (options
+
+
+
+
+) => {
+  const { file, templatePath, context, templateConfig } = options;
+
+  const srcPath = path.join(templatePath, file);
+  const destFile = convertDotfileName(file);
+
+  logger.verbose(
+    `  - Preparing: ${file}${destFile !== file ? ` -> ${destFile}` : ''}`,
+  );
+
+  // 判断是否为二进制文件
+  const isBinary = !shouldRenderFile(srcPath);
+  let content;
+  let wasRendered = false;
+
+  if (isBinary) {
+    // 二进制文件，读取为 buffer 然后转为 base64
+    const buffer = await fs$1.readFile(srcPath);
+    content = buffer.toString('base64');
+  } else {
+    // 文本文件，渲染后的内容
+    content = await renderTemplate(srcPath, context);
+    wasRendered = true;
+  }
+
+  // 构造文件信息对象
+  const fileInfo = {
+    path: file,
+    destPath: destFile,
+    content,
+    isBinary,
+    wasRendered,
+  };
+
+  // 执行文件渲染钩子
+  const processedFileInfo = await executeFileRenderHook(
+    templateConfig,
+    fileInfo,
+    context,
+  );
+
+  // 如果返回 null，表示该文件被 hook 跳过
+  if (processedFileInfo === null) {
+    logger.verbose('    ⊘ Skipped by onFileRender hook');
+    return null;
+  }
+
+  return processedFileInfo;
+};
+
+/**
+ * 写入渲染后的文件到目标路径
+ *
+ * @param options - 写入选项
+ */
+const writeRenderedFile = async (options
+
+
+
+) => {
+  const { fileInfo, srcPath, destPath } = options;
+
+  logger.verbose(`  - Writing: ${fileInfo.destPath}`);
+
+  // 确保目标目录存在
+  await ensureDir(path.dirname(destPath));
+
+  // 写入文件
+  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 modifiedBuffer = Buffer.from(fileInfo.content, 'base64');
+      await fs$1.writeFile(destPath, modifiedBuffer);
+      logger.verbose('    ✓ Written (binary, modified by hook)');
+    }
+  } else {
+    // 文本文件
+    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;
+};
+
+/**
+ * 检测文件冲突
+ *
+ * @param outputPath - 输出目录路径
+ * @param filesToWrite - 将要写入的文件路径列表
+ * @returns 冲突的文件路径列表
+ */
+const detectFileConflicts = (
+  outputPath,
+  filesToWrite,
+) => {
+  logger.verbose('\nChecking for file conflicts...');
+
+  const conflicts = [];
+
+  for (const file of filesToWrite) {
+    const fullPath = path.join(outputPath, file);
+    if (fs.existsSync(fullPath)) {
+      conflicts.push(file);
+      logger.verbose(`  ⚠ Conflict detected: ${file}`);
+    }
+  }
+
+  if (conflicts.length === 0) {
+    logger.verbose('  ✓ No conflicts detected');
+  } else {
+    logger.verbose(`  ⚠ ${conflicts.length} conflicts detected`);
+  }
+
+  return conflicts;
+};
+// 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. 冲突检测：检查是否有文件会被覆盖
+ * 5. 实际写入：渲染并写入所有文件
+ * 6. 复制 node_modules（如果存在）
+ *
+ * @param options - 处理选项
+ */
+const processTemplateFiles = async (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(
@@ -1279,6 +1878,7 @@ const processTemplateFiles = async (
     throw error;
   }
 
+  // 阶段 1: 扫描所有模板文件
   const files = await getAllFiles(templatePath);
 
   logger.verbose(`  - Found ${files.length} files to process`);
@@ -1288,102 +1888,50 @@ const processTemplateFiles = async (
     return;
   }
 
-  await Promise.all(
-    files.map(async file => {
-      const srcPath = path.join(templatePath, file);
-      const destFile = convertDotfileName(file);
-      const destPath = path.join(outputPath, destFile);
+  // 阶段 2: Dry-run - 收集所有将要写入的文件
+  const filesToWrite = await collectFilesToRender({
+    files,
+    templatePath,
+    context,
+    templateConfig,
+  });
 
-      logger.verbose(
-        `  - Processing: ${file}${destFile !== file ? ` -> ${destFile}` : ''}`,
-      );
+  // 阶段 3: 冲突检测
+  const conflicts = detectFileConflicts(outputPath, filesToWrite);
 
-      // 确保目标目录存在
-      await ensureDir(path.dirname(destPath));
+  if (conflicts.length > 0) {
+    // 有冲突，抛出详细的错误信息
+    const conflictList = conflicts.map(f => `  - ${f}`).join('\n');
+    throw new Error(
+      `File conflicts detected in output directory: ${outputPath}\n\n` +
+        `The following files already exist and would be overwritten:\n${conflictList}\n\n` +
+        'Please remove these files or use a different output directory.',
+    );
+  }
 
-      if (shouldRenderFile(srcPath)) {
-        // 渲染文本文件
-        const rendered = await renderTemplate(srcPath, context);
-        await fs$1.writeFile(destPath, rendered, 'utf-8');
-        logger.verbose('    ✓ Rendered and written');
-      } else {
-        // 直接复制二进制文件
-        await fs$1.copyFile(srcPath, destPath);
-        logger.verbose('    ✓ Copied');
-      }
-    }),
+  // 阶段 4: 实际写入文件
+  logger.verbose('\nWriting files...');
+  await Promise.all(
+    files.map(file =>
+      processSingleFile({
+        file,
+        templatePath,
+        outputPath,
+        context,
+        templateConfig,
+      }),
+    ),
   );
 
   logger.verbose('✓ All files processed successfully');
 
-  // 单独处理 node_modules 目录（如果存在）
+  // 阶段 5: 单独处理 node_modules 目录（如果存在）
   const sourceNodeModules = path.join(templatePath, 'node_modules');
   const targetNodeModules = path.join(outputPath, 'node_modules');
 
-  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.',
-    );
-  }
+  copyNodeModules(sourceNodeModules, targetNodeModules);
 };
+// end_aigc
 
 /**
  * 模板引擎执行选项
@@ -1463,15 +2011,40 @@ 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;
 };
 
+/**
+ * 模板引擎执行结果
+ */
+
+
+
+
+
+
+
+
+
 /**
  * 执行完整的模板渲染流程
  */
@@ -1495,15 +2068,24 @@ const execute = async (
   });
 
   // 5. 准备输出目录
-  const absoluteOutputPath = await prepareOutputDirectory(outputPath);
+  const absoluteOutputPath = prepareOutputDirectory(outputPath);
 
   // 6. 处理模板文件
-  await processTemplateFiles(templatePath, absoluteOutputPath, context);
+  await processTemplateFiles({
+    templatePath,
+    outputPath: absoluteOutputPath,
+    context,
+    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(); } }
@@ -1611,13 +2193,20 @@ const runGitInit = (projectPath) => {
 /**
  * 运行开发服务器(后台模式)
  * 启动后台子进程运行开发服务器，父进程可以直接退出
+ * 使用 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 统一处理
   });
@@ -1659,12 +2248,13 @@ const executeInit = async (
     logger.info(`Initializing project with template: ${templateName}`);
     timer.logPhase('Initialization');
 
-    // 执行模板引擎，返回绝对路径
-    const absoluteOutputPath = await execute({
+    // 执行模板引擎，返回结果对象
+    const result = await execute({
       templateName,
       outputPath,
       command,
     });
+    const { outputPath: absoluteOutputPath, templateConfig, context } = result;
 
     timer.logPhase('Template engine execution');
     logger.success('Project created successfully!');
@@ -1685,6 +2275,10 @@ const executeInit = async (
       }
     }
 
+    // 执行 onComplete 钩子（在 pnpm install 之后）
+    await executeCompleteHook(templateConfig, context, absoluteOutputPath);
+    timer.logPhase('Complete hook execution');
+
     // 如果没有跳过 git，则初始化 git 仓库
     if (!skipGit) {
       runGitInit(absoluteOutputPath);
@@ -1693,7 +2287,7 @@ const executeInit = async (
 
     // 如果没有跳过 dev，则启动开发服务器
     if (!skipDev) {
-      runNpmDev(absoluteOutputPath);
+      runDev(absoluteOutputPath);
       timer.logPhase('Dev server startup');
     } else {
       // 只有跳过 dev 时才显示 Next steps
@@ -1707,7 +2301,7 @@ const executeInit = async (
           '  git init && git add . && git commit -m "initial commit"',
         );
       }
-      logger.info('  npm run dev');
+      logger.info('  coze dev');
     }
 
     // 输出总耗时
@@ -1723,7 +2317,7 @@ const executeInit = async (
 /**
  * 注册 init 命令到 program
  */
-const registerCommand = program => {
+const registerCommand$1 = program => {
   program
     .command('init')
     .description('Initialize a new project from a template')
@@ -1741,14 +2335,312 @@ const registerCommand = program => {
     });
 };
 
-var version = "0.0.1-alpha.dffbaa";
+// 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.e02657";
 var packageJson = {
 	version: version};
 
 const commands = [
-  registerCommand,
   registerCommand$1,
   registerCommand$2,
+  registerCommand$4,
+  registerCommand$3,
+  registerCommand,
 ];
 
 const main = () => {