clawt 1.0.0

package/src/commands/run.ts

@@ -0,0 +1,310 @@
+import type { Command } from 'commander';
+import type { ChildProcess } from 'node:child_process';
+import { spawnSync } from 'node:child_process';
+import { logger } from '../logger/index.js';
+import { ClawtError } from '../errors/index.js';
+import { MESSAGES } from '../constants/index.js';
+import type { RunOptions, ClaudeCodeResult, TaskResult, TaskSummary } from '../types/index.js';
+import {
+  validateMainWorktree,
+  validateClaudeCodeInstalled,
+  createWorktrees,
+  spawnProcess,
+  killAllChildProcesses,
+  cleanupWorktrees,
+  getConfigValue,
+  printSuccess,
+  printError,
+  printWarning,
+  printInfo,
+  printSeparator,
+  printDoubleSeparator,
+  confirmAction,
+} from '../utils/index.js';
+import type { WorktreeInfo } from '../types/index.js';
+
+/**
+ * 注册 run 命令：批量创建 worktree 并执行 Claude Code 任务
+ * @param {Command} program - Commander 实例
+ */
+export function registerRunCommand(program: Command): void {
+  program
+    .command('run')
+    .description('批量创建 worktree 并启动 Claude Code 执行任务')
+    .requiredOption('-b, --branch <branchName>', '分支名')
+    .option('--tasks <task...>', '任务列表（可多次指定），不传则在 worktree 中打开 Claude Code 交互式界面')
+    .action(async (options: RunOptions) => {
+      await handleRun(options);
+    });
+}
+
+/**
+ * 在指定 worktree 中启动 Claude Code CLI 交互式界面
+ * 使用 spawnSync + inherit stdio，让用户直接与 Claude Code 交互
+ * @param {WorktreeInfo} worktree - worktree 信息
+ */
+function launchInteractiveClaude(worktree: WorktreeInfo): void {
+  const commandStr = getConfigValue('claudeCodeCommand');
+  const parts = commandStr.split(/\s+/).filter(Boolean);
+  const cmd = parts[0];
+  const args = parts.slice(1);
+
+  printInfo(`正在 worktree 中启动 Claude Code 交互式界面...`);
+  printInfo(`  分支: ${worktree.branch}`);
+  printInfo(`  路径: ${worktree.path}`);
+  printInfo(`  指令: ${commandStr}`);
+  printInfo('');
+
+  const result = spawnSync(cmd, args, {
+    cwd: worktree.path,
+    stdio: 'inherit',
+  });
+
+  if (result.error) {
+    throw new ClawtError(`启动 Claude Code 失败: ${result.error.message}`);
+  }
+
+  if (result.status !== null && result.status !== 0) {
+    printWarning(`Claude Code 退出码: ${result.status}`);
+  }
+}
+
+/** executeClaudeTask 的返回结构，包含子进程引用和结果 Promise */
+interface ClaudeTaskHandle {
+  /** 子进程实例，用于在中断时终止 */
+  child: ChildProcess;
+  /** 任务结果 Promise */
+  promise: Promise<TaskResult>;
+}
+
+/**
+ * 在指定 worktree 中执行 Claude Code 任务
+ * @param {WorktreeInfo} worktree - worktree 信息
+ * @param {string} task - 任务描述
+ * @returns {ClaudeTaskHandle} 包含子进程引用和结果 Promise
+ */
+function executeClaudeTask(worktree: WorktreeInfo, task: string): ClaudeTaskHandle {
+  const child = spawnProcess(
+    'claude',
+    ['-p', task, '--output-format', 'json', '--permission-mode', 'bypassPermissions'],
+    {
+      cwd: worktree.path,
+      // stdin 必须设置为 'ignore'，不能用 'pipe'
+      // 原因：claude -p 是非交互模式，不需要 stdin 输入。如果 stdin 为 'pipe'，
+      // 父进程会创建一个可写流连接到子进程但从不写入也不关闭，
+      // claude 检测到 stdin 是管道后会尝试读取输入，导致进程永远卡住
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+
+  const promise = new Promise<TaskResult>((resolve) => {
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout?.on('data', (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    child.stderr?.on('data', (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      let result: ClaudeCodeResult | null = null;
+      let success = code === 0;
+
+      try {
+        if (stdout.trim()) {
+          result = JSON.parse(stdout.trim()) as ClaudeCodeResult;
+          success = !result.is_error;
+        }
+      } catch {
+        logger.warn(`解析 Claude Code 输出失败: ${stdout.substring(0, 200)}`);
+      }
+
+      resolve({
+        task,
+        branch: worktree.branch,
+        worktreePath: worktree.path,
+        success,
+        result,
+        error: success ? undefined : stderr || '任务执行失败',
+      });
+    });
+
+    child.on('error', (err) => {
+      resolve({
+        task,
+        branch: worktree.branch,
+        worktreePath: worktree.path,
+        success: false,
+        result: null,
+        error: err.message,
+      });
+    });
+  });
+
+  return { child, promise };
+}
+
+/**
+ * 输出单个任务完成通知
+ * @param {TaskResult} taskResult - 任务结果
+ */
+function printTaskNotification(taskResult: TaskResult): void {
+  const { success, worktreePath, branch, result } = taskResult;
+  const status = success ? '完成' : '失败';
+  const icon = success ? '✓' : '✗';
+  const durationStr = result ? `${(result.duration_ms / 1000).toFixed(1)}s` : 'N/A';
+  const costStr = result ? `$${result.total_cost_usd.toFixed(2)}` : 'N/A';
+  const resultStr = success ? 'success' : 'failed';
+
+  if (success) {
+    printSuccess(`${icon} [${status}] worktree: ${worktreePath}`);
+  } else {
+    printError(`${icon} [${status}] worktree: ${worktreePath}`);
+  }
+  printInfo(`  分支: ${branch}`);
+  printInfo(`  耗时: ${durationStr}`);
+  printInfo(`  花费: ${costStr}`);
+  printInfo(`  结果: ${resultStr}`);
+  printSeparator();
+}
+
+/**
+ * 输出所有任务的汇总信息
+ * @param {TaskSummary} summary - 汇总信息
+ */
+function printTaskSummary(summary: TaskSummary): void {
+  printDoubleSeparator();
+  printInfo(`全部任务已完成 (${summary.total}/${summary.total})`);
+  printInfo(`  成功: ${summary.succeeded}`);
+  printInfo(`  失败: ${summary.failed}`);
+  printInfo(`  总耗时: ${(summary.totalDurationMs / 1000).toFixed(1)}s`);
+  printInfo(`  总花费: $${summary.totalCostUsd.toFixed(2)}`);
+  printDoubleSeparator();
+}
+
+/**
+ * 处理用户中断（Ctrl+C）后的清理流程
+ * 根据全局配置决定自动清理或交互式确认
+ * @param {WorktreeInfo[]} worktrees - 本次创建的 worktree 列表
+ */
+async function handleInterruptCleanup(worktrees: WorktreeInfo[]): Promise<void> {
+  const autoDelete = getConfigValue('autoDeleteBranch');
+
+  if (autoDelete) {
+    // 全局配置了自动删除，直接清理
+    cleanupWorktrees(worktrees);
+    printSuccess(MESSAGES.INTERRUPT_AUTO_CLEANED(worktrees.length));
+    return;
+  }
+
+  // 交互式确认是否清理
+  const shouldClean = await confirmAction(MESSAGES.INTERRUPT_CONFIRM_CLEANUP);
+
+  if (shouldClean) {
+    cleanupWorktrees(worktrees);
+    printSuccess(MESSAGES.INTERRUPT_CLEANED(worktrees.length));
+  } else {
+    printInfo(MESSAGES.INTERRUPT_KEPT);
+  }
+}
+
+/**
+ * 执行 run 命令的核心逻辑
+ * 不传 --tasks 时创建单个 worktree 并打开 Claude Code 交互式界面
+ * 传 --tasks 时批量创建 worktree 并并行执行任务
+ * @param {RunOptions} options - 命令选项
+ */
+async function handleRun(options: RunOptions): Promise<void> {
+  validateMainWorktree();
+  validateClaudeCodeInstalled();
+
+  // 未传 --tasks 时，创建单个 worktree 并打开 Claude Code 交互式界面
+  if (!options.tasks || options.tasks.length === 0) {
+    const worktrees = createWorktrees(options.branch, 1);
+    const worktree = worktrees[0];
+    printSuccess(MESSAGES.WORKTREE_CREATED(1));
+
+    launchInteractiveClaude(worktree);
+    return;
+  }
+
+  const tasks = options.tasks.map((t) => t.trim()).filter(Boolean);
+
+  if (tasks.length === 0) {
+    throw new ClawtError('任务列表不能为空');
+  }
+
+  const count = tasks.length;
+  logger.info(`run 命令执行，分支: ${options.branch}，任务数: ${count}`);
+
+  // 创建 worktree
+  const worktrees = createWorktrees(options.branch, count);
+  printSuccess(MESSAGES.WORKTREE_CREATED(worktrees.length));
+  for (const wt of worktrees) {
+    printInfo(`  分支: ${wt.branch}  路径: ${wt.path}`);
+  }
+  printInfo('');
+
+  // 并行执行 Claude Code 任务，每个完成时实时通知
+  const startTime = Date.now();
+  const handles = worktrees.map((wt, index) => {
+    const task = tasks[index];
+    logger.info(`启动任务 ${index + 1}: ${task} (worktree: ${wt.path})`);
+    return executeClaudeTask(wt, task);
+  });
+
+  // 收集所有子进程引用，用于中断时终止
+  const childProcesses = handles.map((h) => h.child);
+
+  // 监听 SIGINT（Ctrl+C），终止所有子进程并触发清理流程
+  let interrupted = false;
+  const sigintHandler = async () => {
+    if (interrupted) return;
+    interrupted = true;
+
+    printInfo('');
+    printWarning(MESSAGES.INTERRUPTED);
+    killAllChildProcesses(childProcesses);
+
+    // 等待所有子进程退出后再执行清理
+    await Promise.allSettled(handles.map((h) => h.promise));
+
+    await handleInterruptCleanup(worktrees);
+    process.exit(1);
+  };
+  process.on('SIGINT', sigintHandler);
+
+  const taskPromises = handles.map((handle) =>
+    handle.promise.then((result) => {
+      // 被中断时不再输出通知
+      if (!interrupted) {
+        printTaskNotification(result);
+      }
+      return result;
+    }),
+  );
+
+  const results = await Promise.all(taskPromises);
+
+  // 正常完成，移除 SIGINT 监听器
+  process.removeListener('SIGINT', sigintHandler);
+
+  // 被中断时不输出汇总（已在 sigintHandler 中处理退出）
+  if (interrupted) return;
+
+  const totalDurationMs = Date.now() - startTime;
+
+  // 汇总
+  const summary: TaskSummary = {
+    total: results.length,
+    succeeded: results.filter((r) => r.success).length,
+    failed: results.filter((r) => !r.success).length,
+    totalDurationMs,
+    totalCostUsd: results.reduce((sum, r) => sum + (r.result?.total_cost_usd ?? 0), 0),
+  };
+
+  printTaskSummary(summary);
+}

package/src/commands/validate.ts

@@ -0,0 +1,137 @@
+import type { Command } from 'commander';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import Enquirer from 'enquirer';
+import { logger } from '../logger/index.js';
+import { ClawtError } from '../errors/index.js';
+import { MESSAGES } from '../constants/index.js';
+import type { ValidateOptions } from '../types/index.js';
+import {
+  validateMainWorktree,
+  getProjectName,
+  getGitTopLevel,
+  getProjectWorktreeDir,
+  isWorkingDirClean,
+  gitAddAll,
+  gitStashPush,
+  gitStashApply,
+  gitStashPop,
+  gitStashList,
+  gitRestoreStaged,
+  gitResetHard,
+  gitCleanForce,
+  getStatusPorcelain,
+  printSuccess,
+  printError,
+  printWarning,
+  printInfo,
+} from '../utils/index.js';
+
+/**
+ * 注册 validate 命令：在主 worktree 验证其他分支的变更
+ * @param {Command} program - Commander 实例
+ */
+export function registerValidateCommand(program: Command): void {
+  program
+    .command('validate')
+    .description('在主 worktree 验证某个 worktree 分支的变更')
+    .requiredOption('-b, --branch <branchName>', '要验证的分支名')
+    .action(async (options: ValidateOptions) => {
+      await handleValidate(options);
+    });
+}
+
+/**
+ * 处理主 worktree 工作区有未提交更改的情况
+ * @param {string} mainWorktreePath - 主 worktree 路径
+ */
+async function handleDirtyMainWorktree(mainWorktreePath: string): Promise<void> {
+  printWarning('主 worktree 当前分支有未提交的更改，请选择处理方式：\n');
+
+  // @ts-expect-error enquirer 类型声明未导出 Select 类，但运行时存在
+  const choice = await new Enquirer.Select({
+    message: '选择处理方式',
+    choices: [
+      {
+        name: 'reset',
+        message: 'reset (推荐) - 丢弃所有更改 (git reset --hard HEAD && git clean -fd)',
+      },
+      {
+        name: 'stash',
+        message: 'stash        - 暂存更改 (git add . && git stash)',
+      },
+      {
+        name: 'exit',
+        message: 'exit         - 退出，手动处理',
+      },
+    ],
+    initial: 0,
+  }).run();
+
+  if (choice === 'exit') {
+    throw new ClawtError('用户选择退出');
+  }
+
+  if (choice === 'reset') {
+    gitResetHard(mainWorktreePath);
+    gitCleanForce(mainWorktreePath);
+  } else if (choice === 'stash') {
+    gitAddAll(mainWorktreePath);
+    gitStashPush('clawt:auto-stash', mainWorktreePath);
+  }
+
+  // 再次检查是否干净
+  if (!isWorkingDirClean(mainWorktreePath)) {
+    throw new ClawtError('工作区仍然不干净，请手动处理');
+  }
+}
+
+/**
+ * 执行 validate 命令的核心逻辑
+ * @param {ValidateOptions} options - 命令选项
+ */
+async function handleValidate(options: ValidateOptions): Promise<void> {
+  validateMainWorktree();
+
+  const projectName = getProjectName();
+  const mainWorktreePath = getGitTopLevel();
+  const projectDir = getProjectWorktreeDir();
+  const targetWorktreePath = join(projectDir, options.branch);
+
+  logger.info(`validate 命令执行，分支: ${options.branch}`);
+
+  // 检查目标 worktree 是否存在
+  if (!existsSync(targetWorktreePath)) {
+    throw new ClawtError(MESSAGES.WORKTREE_NOT_FOUND(options.branch));
+  }
+
+  // 步骤 1：检测主 worktree 工作区状态
+  if (!isWorkingDirClean(mainWorktreePath)) {
+    await handleDirtyMainWorktree(mainWorktreePath);
+  }
+
+  // 步骤 2：在目标 worktree 中创建 stash
+  if (isWorkingDirClean(targetWorktreePath)) {
+    printInfo(MESSAGES.TARGET_WORKTREE_CLEAN);
+    return;
+  }
+
+  const stashMessage = `clawt:validate:${options.branch}`;
+  gitAddAll(targetWorktreePath);
+  gitStashPush(stashMessage, targetWorktreePath);
+  gitStashApply(targetWorktreePath);
+  gitRestoreStaged(targetWorktreePath);
+
+  // 步骤 3：在主 worktree 应用 stash
+  const stashList = gitStashList(mainWorktreePath);
+  const firstLine = stashList.split('\n')[0] || '';
+
+  if (!firstLine.includes(stashMessage)) {
+    throw new ClawtError(MESSAGES.STASH_CHANGED);
+  }
+
+  gitStashPop(0, mainWorktreePath);
+
+  // 步骤 4：输出成功提示
+  printSuccess(MESSAGES.VALIDATE_SUCCESS(options.branch));
+}

package/src/constants/branch.ts

@@ -0,0 +1,6 @@
+/**
+ * 分支名中的非法字符正则
+ * 包含：/ \ . 空格 ~ : * ? [ ] ^
+ * 以及连续的 ..（目录遍历）
+ */
+export const INVALID_BRANCH_CHARS = /[\/\\.\s~:*?[\]^]+/g;

package/src/constants/config.ts

@@ -0,0 +1,8 @@
+import type { ClawtConfig } from '../types/index.js';
+
+/** 默认配置 */
+export const DEFAULT_CONFIG: ClawtConfig = {
+  autoDeleteBranch: false,
+  /** 默认 Claude Code CLI 启动指令，用于不传 --tasks 时在 worktree 中打开交互式界面 */
+  claudeCodeCommand: 'claude',
+};

package/src/constants/exitCodes.ts

@@ -0,0 +1,9 @@
+/** 退出码定义 */
+export const EXIT_CODES = {
+  /** 成功 */
+  SUCCESS: 0,
+  /** 一般错误 */
+  ERROR: 1,
+  /** 参数错误 */
+  ARGUMENT_ERROR: 2,
+} as const;

package/src/constants/index.ts

@@ -0,0 +1,6 @@
+export { CLAWT_HOME, CONFIG_PATH, LOGS_DIR, WORKTREES_DIR } from './paths.js';
+export { INVALID_BRANCH_CHARS } from './branch.js';
+export { MESSAGES } from './messages.js';
+export { EXIT_CODES } from './exitCodes.js';
+export { ENABLE_BRACKETED_PASTE, DISABLE_BRACKETED_PASTE, PASTE_THRESHOLD_MS } from './terminal.js';
+export { DEFAULT_CONFIG } from './config.js';

package/src/constants/messages.ts

@@ -0,0 +1,61 @@
+/** 提示消息模板 */
+export const MESSAGES = {
+  /** 不在主 worktree 根目录 */
+  NOT_MAIN_WORKTREE: '请在主 worktree 的根目录下执行 clawt',
+  /** Git 未安装 */
+  GIT_NOT_INSTALLED: 'Git 未安装或不在 PATH 中，请先安装 Git',
+  /** Claude Code CLI 未安装 */
+  CLAUDE_NOT_INSTALLED: 'Claude Code CLI 未安装，请先安装：npm install -g @anthropic-ai/claude-code',
+  /** 分支已存在 */
+  BRANCH_EXISTS: (name: string) => `分支 ${name} 已存在，无法创建`,
+  /** 分支名被转换 */
+  BRANCH_SANITIZED: (original: string, sanitized: string) =>
+    `分支名已转换: ${original} → ${sanitized}`,
+  /** worktree 创建成功 */
+  WORKTREE_CREATED: (count: number) => `✓ 已创建 ${count} 个 worktree`,
+  /** worktree 移除成功 */
+  WORKTREE_REMOVED: (path: string) => `✓ 已移除 worktree: ${path}`,
+  /** 没有 worktree */
+  NO_WORKTREES: '(无 worktree)',
+  /** 目标 worktree 不存在 */
+  WORKTREE_NOT_FOUND: (name: string) => `worktree ${name} 不存在`,
+  /** 主 worktree 有未提交更改 */
+  MAIN_WORKTREE_DIRTY: '主 worktree 有未提交的更改，请先处理',
+  /** 目标 worktree 无更改 */
+  TARGET_WORKTREE_CLEAN: '该 worktree 的分支上没有任何更改，无需验证',
+  /** stash 已变更 */
+  STASH_CHANGED: 'git stash list 已变更，请重新执行',
+  /** validate 成功 */
+  VALIDATE_SUCCESS: (branch: string) =>
+    `✓ 已将分支 ${branch} 的变更应用到主 worktree\n  可以开始验证了`,
+  /** merge 成功 */
+  MERGE_SUCCESS: (branch: string, message: string) =>
+    `✓ 分支 ${branch} 已成功合并到当前分支\n  提交信息: ${message}\n  已推送到远程仓库`,
+  /** merge 成功（无提交信息，目标 worktree 已提交过） */
+  MERGE_SUCCESS_NO_MESSAGE: (branch: string) =>
+    `✓ 分支 ${branch} 已成功合并到当前分支\n  已推送到远程仓库`,
+  /** merge 冲突 */
+  MERGE_CONFLICT: '合并存在冲突，请手动处理',
+  /** merge 后清理 worktree 和分支成功 */
+  WORKTREE_CLEANED: (branch: string) => `✓ 已清理 worktree 和分支: ${branch}`,
+  /** 请提供提交信息 */
+  COMMIT_MESSAGE_REQUIRED: '请提供提交信息（-m 参数）',
+  /** 目标 worktree 有未提交修改但未指定 -m */
+  TARGET_WORKTREE_DIRTY_NO_MESSAGE: '目标 worktree 有未提交的修改，请通过 -m 参数提供提交信息',
+  /** 目标 worktree 既干净又无本地提交 */
+  TARGET_WORKTREE_NO_CHANGES: '目标 worktree 没有任何可合并的变更（工作区干净且无本地提交）',
+  /** 检测到用户中断 */
+  INTERRUPTED: '检测到退出指令，已停止 Claude Code 任务',
+  /** 中断后自动清理完成 */
+  INTERRUPT_AUTO_CLEANED: (count: number) => `✓ 已自动清理 ${count} 个 worktree 和对应分支`,
+  /** 中断后手动确认清理 */
+  INTERRUPT_CONFIRM_CLEANUP: '是否移除刚刚创建的 worktree 和对应分支？',
+  /** 中断后清理完成 */
+  INTERRUPT_CLEANED: (count: number) => `✓ 已清理 ${count} 个 worktree 和对应分支`,
+  /** 中断后保留 worktree */
+  INTERRUPT_KEPT: '已保留 worktree，可稍后使用 clawt remove 手动清理',
+  /** 分隔线 */
+  SEPARATOR: '────────────────────────────────────────',
+  /** 粗分隔线 */
+  DOUBLE_SEPARATOR: '════════════════════════════════════════',
+} as const;

package/src/constants/paths.ts

@@ -0,0 +1,14 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+/** clawt 主目录 ~/.clawt/ */
+export const CLAWT_HOME = join(homedir(), '.clawt');
+
+/** 全局配置文件路径 ~/.clawt/config.json */
+export const CONFIG_PATH = join(CLAWT_HOME, 'config.json');
+
+/** 日志目录 ~/.clawt/logs/ */
+export const LOGS_DIR = join(CLAWT_HOME, 'logs');
+
+/** worktree 统一存放目录 ~/.clawt/worktrees/ */
+export const WORKTREES_DIR = join(CLAWT_HOME, 'worktrees');

package/src/constants/terminal.ts

@@ -0,0 +1,13 @@
+/** 启用 Bracketed Paste Mode 的 ANSI 转义序列 */
+export const ENABLE_BRACKETED_PASTE = '\x1b[?2004h';
+
+/** 禁用 Bracketed Paste Mode 的 ANSI 转义序列 */
+export const DISABLE_BRACKETED_PASTE = '\x1b[?2004l';
+
+/**
+ * 粘贴检测的时间阈值（毫秒）
+ * 粘贴时字符在同一事件循环内批量到达，间隔接近 0ms
+ * 手动按键间隔通常 > 50ms
+ * 作为 Bracketed Paste Mode 不可用时的降级方案
+ */
+export const PASTE_THRESHOLD_MS = 10;

package/src/errors/index.ts

@@ -0,0 +1,20 @@
+import { EXIT_CODES } from '../constants/index.js';
+
+/**
+ * Clawt 自定义错误类
+ * 携带退出码信息，用于统一错误处理
+ */
+export class ClawtError extends Error {
+  /** 退出码 */
+  public readonly exitCode: number;
+
+  /**
+   * @param {string} message - 错误消息
+   * @param {number} exitCode - 退出码，默认为 EXIT_CODES.ERROR (1)
+   */
+  constructor(message: string, exitCode: number = EXIT_CODES.ERROR) {
+    super(message);
+    this.name = 'ClawtError';
+    this.exitCode = exitCode;
+  }
+}

package/src/index.ts

@@ -0,0 +1,55 @@
+import { Command } from 'commander';
+import { ClawtError } from './errors/index.js';
+import { logger } from './logger/index.js';
+import { EXIT_CODES } from './constants/index.js';
+import { printError, ensureClawtDirs } from './utils/index.js';
+import { registerListCommand } from './commands/list.js';
+import { registerCreateCommand } from './commands/create.js';
+import { registerRemoveCommand } from './commands/remove.js';
+import { registerRunCommand } from './commands/run.js';
+import { registerValidateCommand } from './commands/validate.js';
+import { registerMergeCommand } from './commands/merge.js';
+
+// 确保全局目录结构存在
+ensureClawtDirs();
+
+const program = new Command();
+
+program
+  .name('clawt')
+  .description('本地并行执行多个Claude Code Agent任务，融合 Git Worktree 与 Claude Code CLI 的命令行工具')
+  .version('1.0.0');
+
+// 注册所有命令
+registerListCommand(program);
+registerCreateCommand(program);
+registerRemoveCommand(program);
+registerRunCommand(program);
+registerValidateCommand(program);
+registerMergeCommand(program);
+
+// 全局未捕获异常处理
+process.on('uncaughtException', (error) => {
+  if (error instanceof ClawtError) {
+    printError(error.message);
+    logger.error(error.message);
+    process.exit(error.exitCode);
+  }
+  printError(error.message || '未知错误');
+  logger.error(`未捕获异常: ${error.message}\n${error.stack}`);
+  process.exit(EXIT_CODES.ERROR);
+});
+
+process.on('unhandledRejection', (reason) => {
+  const error = reason instanceof Error ? reason : new Error(String(reason));
+  if (error instanceof ClawtError) {
+    printError(error.message);
+    logger.error(error.message);
+    process.exit(error.exitCode);
+  }
+  printError(error.message || '未知错误');
+  logger.error(`未处理的 Promise 拒绝: ${error.message}`);
+  process.exit(EXIT_CODES.ERROR);
+});
+
+program.parse(process.argv);

package/src/logger/index.ts

@@ -0,0 +1,34 @@
+import winston from 'winston';
+import DailyRotateFile from 'winston-daily-rotate-file';
+import { LOGS_DIR } from '../constants/index.js';
+import { existsSync, mkdirSync } from 'node:fs';
+
+// 确保日志目录存在
+if (!existsSync(LOGS_DIR)) {
+  mkdirSync(LOGS_DIR, { recursive: true });
+}
+
+/** 日志格式：[2025-02-06 14:30:22] [INFO]  消息内容 */
+const logFormat = winston.format.printf(({ level, message, timestamp }) => {
+  const upperLevel = level.toUpperCase().padEnd(5);
+  return `[${timestamp}] [${upperLevel}] ${message}`;
+});
+
+/** 日志滚动传输：按日期滚动，保留 30 天，单文件最大 10MB */
+const dailyRotateTransport = new DailyRotateFile({
+  dirname: LOGS_DIR,
+  filename: 'clawt-%DATE%.log',
+  datePattern: 'YYYY-MM-DD',
+  maxSize: '10m',
+  maxFiles: '30d',
+});
+
+/** winston 日志实例 */
+export const logger = winston.createLogger({
+  level: 'debug',
+  format: winston.format.combine(
+    winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+    logFormat,
+  ),
+  transports: [dailyRotateTransport],
+});