hamster-wheel-cli 0.1.0 → 0.2.0-beta.1

package/src/cli.ts

@@ -1,15 +1,21 @@
 import { spawn } from 'node:child_process';
+import fs from 'fs-extra';
 import { Command } from 'commander';
 import { buildLoopConfig, CliOptions, defaultNotesPath, defaultPlanPath, defaultWorkflowDoc } from './config';
-import { applyShortcutArgv, loadGlobalConfig } from './global-config';
-import { generateBranchName, getCurrentBranch } from './git';
-import { buildAutoLogFilePath } from './logs';
+import { applyShortcutArgv, loadGlobalConfig, normalizeAliasName, upsertAliasEntry } from './global-config';
+import { getCurrentBranch } from './git';
+import { buildAutoLogFilePath, formatCommandLine } from './logs';
+import { runAliasViewer } from './alias-viewer';
 import { runLogsViewer } from './logs-viewer';
 import { runLoop } from './loop';
 import { defaultLogger } from './logger';
-import { runMonitor } from './monitor';
+import { buildTaskPlans, normalizeTaskList, parseMultiTaskMode } from './multi-task';
+import { resolveTerminationTarget, runMonitor } from './monitor';
+import { tailLogFile } from './log-tailer';
 import { resolvePath } from './utils';
 
+const FOREGROUND_CHILD_ENV = 'WHEEL_AI_FOREGROUND_CHILD';
+
 function parseInteger(value: string, defaultValue: number): number {
   const parsed = Number.parseInt(value, 10);
   if (Number.isNaN(parsed)) return defaultValue;
@@ -42,6 +48,108 @@ function buildBackgroundArgs(argv: string[], logFile: string, branchName?: strin
   return filtered;
 }
 
+function extractAliasCommandArgs(argv: string[], name: string): string[] {
+  const args = argv.slice(2);
+  const start = args.findIndex((arg, index) => arg === 'set' && args[index + 1] === 'alias' && args[index + 2] === name);
+  if (start < 0) return [];
+  const rest = args.slice(start + 3);
+  if (rest[0] === '--') return rest.slice(1);
+  return rest;
+}
+
+async function runForegroundWithDetach(options: {
+  argv: string[];
+  logFile: string;
+  branchName?: string;
+  injectBranch: boolean;
+  isMultiTask: boolean;
+}): Promise<void> {
+  const args = buildBackgroundArgs(options.argv, options.logFile, options.branchName, options.injectBranch);
+  const child = spawn(process.execPath, [...process.execArgv, ...args], {
+    detached: true,
+    stdio: 'ignore',
+    env: {
+      ...process.env,
+      [FOREGROUND_CHILD_ENV]: '1'
+    }
+  });
+  child.unref();
+
+  const resolvedLogFile = resolvePath(process.cwd(), options.logFile);
+  const existed = await fs.pathExists(resolvedLogFile);
+  const tailer = await tailLogFile({
+    filePath: resolvedLogFile,
+    startFromEnd: existed,
+    onLine: line => {
+      process.stdout.write(`${line}\n`);
+    },
+    onError: message => {
+      defaultLogger.warn(`日志读取失败：${message}`);
+    }
+  });
+
+  const suffixNote = options.isMultiTask ? '（多任务将追加序号）' : '';
+  console.log(`已进入前台日志查看，按 Esc 切到后台运行，日志输出至 ${resolvedLogFile}${suffixNote}`);
+
+  let cleaned = false;
+  const cleanup = async (): Promise<void> => {
+    if (cleaned) return;
+    cleaned = true;
+    await tailer.stop();
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    }
+  };
+
+  const detach = async (): Promise<void> => {
+    await cleanup();
+    console.log(`已切入后台运行，日志输出至 ${resolvedLogFile}${suffixNote}`);
+    process.exit(0);
+  };
+
+  const terminate = async (): Promise<void> => {
+    if (child.pid) {
+      try {
+        const target = resolveTerminationTarget(child.pid);
+        process.kill(target, 'SIGTERM');
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        defaultLogger.warn(`终止子进程失败：${message}`);
+      }
+    }
+    await cleanup();
+    process.exit(0);
+  };
+
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on('data', (data: Buffer) => {
+      const input = data.toString('utf8');
+      if (input === '\u001b') {
+        void detach();
+        return;
+      }
+      if (input === '\u0003') {
+        void terminate();
+      }
+    });
+  }
+
+  process.on('SIGINT', () => {
+    void terminate();
+  });
+  process.on('SIGTERM', () => {
+    void terminate();
+  });
+
+  child.on('exit', async code => {
+    await cleanup();
+    process.exit(code ?? 0);
+  });
+}
+
 /**
  * CLI 入口。
  */
@@ -57,7 +165,7 @@ export async function runCli(argv: string[]): Promise<void> {
 
   program
     .command('run')
-    .requiredOption('-t, --task <task>', '需要完成的任务描述（会进入 AI 提示）')
+    .option('-t, --task <task>', '需要完成的任务描述（可重复传入，独立处理）', collect, [])
     .option('-i, --iterations <number>', '最大迭代次数', value => parseInteger(value, 5), 5)
     .option('--ai-cli <command>', 'AI CLI 命令', 'claude')
     .option('--ai-args <args...>', 'AI CLI 参数', [])
@@ -81,33 +189,53 @@ export async function runCli(argv: string[]): Promise<void> {
     .option('--pr-body <path>', 'PR 描述文件路径（可留空自动生成）')
     .option('--draft', '以草稿形式创建 PR', false)
     .option('--reviewer <user...>', 'PR reviewers', collect, [])
+    .option('--auto-merge', 'PR 检查通过后自动合并', false)
     .option('--webhook <url>', 'webhook 通知 URL（可重复）', collect, [])
     .option('--webhook-timeout <ms>', 'webhook 请求超时（毫秒）', value => parseInteger(value, 8000))
+    .option('--multi-task-mode <mode>', '多任务执行模式（relay/serial/serial-continue/parallel，或中文描述）', 'relay')
     .option('--stop-signal <token>', 'AI 输出中的停止标记', '<<DONE>>')
     .option('--log-file <path>', '日志输出文件路径')
     .option('--background', '切入后台运行', false)
     .option('-v, --verbose', '输出调试日志', false)
+    .option('--skip-quality', '跳过代码质量检查', false)
     .action(async (options) => {
+      const tasks = normalizeTaskList(options.task as string[] | string | undefined);
+      if (tasks.length === 0) {
+        throw new Error('需要至少提供一个任务描述');
+      }
+
+      const multiTaskMode = parseMultiTaskMode(options.multiTaskMode as string | undefined);
       const useWorktree = Boolean(options.worktree);
+      if (multiTaskMode === 'parallel' && !useWorktree) {
+        throw new Error('并行模式必须启用 --worktree');
+      }
+
       const branchInput = normalizeOptional(options.branch);
       const logFileInput = normalizeOptional(options.logFile);
+      const worktreePathInput = normalizeOptional(options.worktreePath);
       const background = Boolean(options.background);
+      const isMultiTask = tasks.length > 1;
+      const isForegroundChild = process.env[FOREGROUND_CHILD_ENV] === '1';
+      const canForegroundDetach = !background && !isForegroundChild && process.stdout.isTTY && process.stdin.isTTY;
 
-      let branchName = branchInput;
-      if (useWorktree && !branchName) {
-        branchName = generateBranchName();
-      }
+      const shouldInjectBranch = Boolean(useWorktree && branchInput && !isMultiTask);
+      const branchNameForBackground = branchInput;
 
       let logFile = logFileInput;
-      if (background && !logFile) {
-        let branchForLog = branchName;
-        if (!branchForLog) {
-          try {
-            const current = await getCurrentBranch(process.cwd(), defaultLogger);
-            branchForLog = current || 'detached';
-          } catch {
-            branchForLog = 'unknown';
+      if ((background || canForegroundDetach) && !logFile) {
+        let branchForLog = 'multi-task';
+        if (!isMultiTask) {
+          branchForLog = branchNameForBackground ?? '';
+          if (!branchForLog) {
+            try {
+              const current = await getCurrentBranch(process.cwd(), defaultLogger);
+              branchForLog = current || 'detached';
+            } catch {
+              branchForLog = 'unknown';
+            }
           }
+        } else if (branchInput) {
+          branchForLog = `${branchInput}-multi`;
         }
         logFile = buildAutoLogFilePath(branchForLog);
       }
@@ -116,19 +244,43 @@ export async function runCli(argv: string[]): Promise<void> {
         if (!logFile) {
           throw new Error('后台运行需要指定日志文件');
         }
-        const args = buildBackgroundArgs(effectiveArgv, logFile, branchName, useWorktree && !branchInput);
+        const args = buildBackgroundArgs(effectiveArgv, logFile, branchNameForBackground, shouldInjectBranch);
         const child = spawn(process.execPath, [...process.execArgv, ...args], {
           detached: true,
           stdio: 'ignore'
         });
         child.unref();
         const displayLogFile = resolvePath(process.cwd(), logFile);
-        console.log(`已切入后台运行，日志输出至 ${displayLogFile}`);
+        const suffixNote = isMultiTask ? '（多任务将追加序号）' : '';
+        console.log(`已切入后台运行，日志输出至 ${displayLogFile}${suffixNote}`);
+        return;
+      }
+
+      if (canForegroundDetach) {
+        if (!logFile) {
+          throw new Error('切入后台需要指定日志文件');
+        }
+        await runForegroundWithDetach({
+          argv: effectiveArgv,
+          logFile,
+          branchName: branchNameForBackground,
+          injectBranch: shouldInjectBranch,
+          isMultiTask
+        });
         return;
       }
 
-      const cliOptions: CliOptions = {
-        task: options.task as string,
+      const taskPlans = buildTaskPlans({
+        tasks,
+        mode: multiTaskMode,
+        useWorktree,
+        baseBranch: options.baseBranch as string,
+        branchInput,
+        worktreePath: worktreePathInput,
+        logFile: logFileInput
+      });
+
+      const baseOptions = {
         iterations: options.iterations as number,
         aiCli: options.aiCli as string,
         aiArgs: (options.aiArgs as string[]) ?? [],
@@ -137,9 +289,6 @@ export async function runCli(argv: string[]): Promise<void> {
         planFile: options.planFile as string,
         workflowDoc: options.workflowDoc as string,
         useWorktree,
-        branch: branchName,
-        worktreePath: options.worktreePath as string | undefined,
-        baseBranch: options.baseBranch as string,
         runTests: Boolean(options.runTests),
         runE2e: Boolean(options.runE2e),
         unitCommand: options.unitCommand as string | undefined,
@@ -151,21 +300,78 @@ export async function runCli(argv: string[]): Promise<void> {
         prBody: options.prBody as string | undefined,
         draft: Boolean(options.draft),
         reviewers: (options.reviewer as string[]) ?? [],
+        autoMerge: Boolean(options.autoMerge),
         webhookUrls: (options.webhook as string[]) ?? [],
         webhookTimeout: options.webhookTimeout as number | undefined,
         stopSignal: options.stopSignal as string,
-        logFile,
         verbose: Boolean(options.verbose),
-        skipInstall: Boolean(options.skipInstall)
+        skipInstall: Boolean(options.skipInstall),
+        skipQuality: Boolean(options.skipQuality)
       };
 
-      const config = buildLoopConfig(cliOptions, process.cwd());
-      await runLoop(config);
+      const dynamicRelay = useWorktree && multiTaskMode === 'relay' && !branchInput;
+      let relayBaseBranch = options.baseBranch as string;
+
+      const runPlan = async (plan: typeof taskPlans[number], baseBranchOverride?: string): Promise<Awaited<ReturnType<typeof runLoop>>> => {
+        const cliOptions: CliOptions = {
+          task: plan.task,
+          ...baseOptions,
+          branch: plan.branchName,
+          worktreePath: plan.worktreePath,
+          baseBranch: baseBranchOverride ?? plan.baseBranch,
+          logFile: plan.logFile
+        };
+        const config = buildLoopConfig(cliOptions, process.cwd());
+        return runLoop(config);
+      };
+
+      if (multiTaskMode === 'parallel') {
+        const results = await Promise.allSettled(taskPlans.map(plan => runPlan(plan)));
+        const errors = results.flatMap((result, index) => {
+          if (result.status === 'fulfilled') return [];
+          const reason = result.reason instanceof Error ? result.reason.message : String(result.reason);
+          return [`任务 ${index + 1} 失败: ${reason}`];
+        });
+        if (errors.length > 0) {
+          errors.forEach(message => defaultLogger.warn(message));
+          throw new Error(errors.join('\n'));
+        }
+        return;
+      }
+
+      if (multiTaskMode === 'serial-continue') {
+        const errors: string[] = [];
+        for (const plan of taskPlans) {
+          try {
+            const baseBranch = dynamicRelay ? relayBaseBranch : plan.baseBranch;
+            const result = await runPlan(plan, baseBranch);
+            if (dynamicRelay && result.branchName) {
+              relayBaseBranch = result.branchName;
+            }
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            errors.push(`任务 ${plan.index + 1} 失败: ${message}`);
+            defaultLogger.warn(`任务 ${plan.index + 1} 执行失败，继续下一任务：${message}`);
+          }
+        }
+        if (errors.length > 0) {
+          throw new Error(errors.join('\n'));
+        }
+        return;
+      }
+
+      for (const plan of taskPlans) {
+        const baseBranch = dynamicRelay ? relayBaseBranch : plan.baseBranch;
+        const result = await runPlan(plan, baseBranch);
+        if (dynamicRelay && result.branchName) {
+          relayBaseBranch = result.branchName;
+        }
+      }
     });
 
   program
     .command('monitor')
-    .description('查看后台运行日志')
+    .description('查看后台运行日志（t 终止任务）')
     .action(async () => {
       await runMonitor();
     });
@@ -177,6 +383,34 @@ export async function runCli(argv: string[]): Promise<void> {
       await runLogsViewer();
     });
 
+  program
+    .command('set')
+    .description('写入全局配置')
+    .command('alias <name> [options...]')
+    .description('设置 alias')
+    .allowUnknownOption(true)
+    .action(async (name: string) => {
+      const normalized = normalizeAliasName(name);
+      if (!normalized) {
+        throw new Error('alias 名称不能为空且不能包含空白字符');
+      }
+      const commandArgs = extractAliasCommandArgs(effectiveArgv, name);
+      const commandLine = formatCommandLine(commandArgs);
+      if (!commandLine) {
+        throw new Error('alias 命令不能为空');
+      }
+      await upsertAliasEntry(normalized, commandLine);
+      console.log(`已写入 alias：${normalized}`);
+    });
+
+  program
+    .command('alias')
+    .alias('aliases')
+    .description('浏览全局 alias 配置')
+    .action(async () => {
+      await runAliasViewer();
+    });
+
   await program.parseAsync(effectiveArgv);
 }
 

package/src/config.ts

@@ -29,12 +29,14 @@ export interface CliOptions {
   readonly prBody?: string;
   readonly draft: boolean;
   readonly reviewers?: string[];
+  readonly autoMerge: boolean;
   readonly webhookUrls: string[];
   readonly webhookTimeout?: number;
   readonly stopSignal: string;
   readonly logFile?: string;
   readonly verbose: boolean;
   readonly skipInstall: boolean;
+  readonly skipQuality: boolean;
 }
 
 function buildAiConfig(options: CliOptions): AiCliConfig {
@@ -67,7 +69,8 @@ function buildPrConfig(options: CliOptions): PrConfig {
     title: options.prTitle,
     bodyPath: options.prBody,
     draft: options.draft,
-    reviewers: options.reviewers
+    reviewers: options.reviewers,
+    autoMerge: options.autoMerge
   };
 }
 
@@ -108,7 +111,8 @@ export function buildLoopConfig(options: CliOptions, cwd: string): LoopConfig {
     runE2e: options.runE2e,
     autoCommit: options.autoCommit,
     autoPush: options.autoPush,
-    skipInstall: options.skipInstall
+    skipInstall: options.skipInstall,
+    skipQuality: options.skipQuality
   };
 }
 

package/src/gh.ts

@@ -226,3 +226,23 @@ export async function listFailedRuns(branch: string, cwd: string, logger: Logger
     return [];
   }
 }
+
+/**
+ * 启用 PR 自动合并。
+ */
+export async function enableAutoMerge(target: string | number, cwd: string, logger: Logger): Promise<boolean> {
+  const targetValue = String(target);
+  const args = ['pr', 'merge', targetValue, '--auto', '--merge'];
+  const result = await runCommand('gh', args, {
+    cwd,
+    logger,
+    verboseLabel: 'gh',
+    verboseCommand: `gh ${args.join(' ')}`
+  });
+  if (result.exitCode !== 0) {
+    logger.warn(`启用自动合并失败: ${result.stderr || result.stdout}`);
+    return false;
+  }
+  logger.success('已启用 PR 自动合并');
+  return true;
+}

package/src/git.ts

@@ -209,7 +209,7 @@ function buildCommitArgs(message: CommitMessage): string[] {
 /**
  * 提交当前变更。
  */
-export async function commitAll(message: CommitMessage, cwd: string, logger: Logger): Promise<void> {
+export async function commitAll(message: CommitMessage, cwd: string, logger: Logger): Promise<boolean> {
   const add = await runCommand('git', ['add', '-A'], {
     cwd,
     logger,
@@ -227,9 +227,10 @@ export async function commitAll(message: CommitMessage, cwd: string, logger: Log
   });
   if (commit.exitCode !== 0) {
     logger.warn(`git commit 跳过或失败: ${commit.stderr}`);
-    return;
+    return false;
   }
   logger.success('已提交当前变更');
+  return true;
 }
 
 /**
@@ -281,5 +282,39 @@ export async function removeWorktree(worktreePath: string, repoRoot: string, log
 export function generateBranchName(): string {
   const now = new Date();
   const stamp = `${now.getFullYear()}${(now.getMonth() + 1).toString().padStart(2, '0')}${now.getDate().toString().padStart(2, '0')}-${now.getHours().toString().padStart(2, '0')}${now.getMinutes().toString().padStart(2, '0')}`;
-  return `wheel-aii/${stamp}`;
+  return `wheel-ai/${stamp}`;
+}
+
+function guessBranchType(task: string): string {
+  const text = task.toLowerCase();
+  if (/fix|bug|修复|错误|异常|问题/.test(text)) return 'fix';
+  if (/docs|readme|changelog|文档/.test(text)) return 'docs';
+  if (/test|e2e|单测|测试/.test(text)) return 'test';
+  if (/refactor|重构/.test(text)) return 'refactor';
+  if (/chore|构建|依赖|配置/.test(text)) return 'chore';
+  return 'feat';
+}
+
+function slugifyTask(task: string): string {
+  const slug = task
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return slug.slice(0, 40);
+}
+
+function buildTimestampSlug(now: Date): string {
+  const stamp = `${now.getFullYear()}${(now.getMonth() + 1).toString().padStart(2, '0')}${now.getDate().toString().padStart(2, '0')}-${now.getHours().toString().padStart(2, '0')}${now.getMinutes().toString().padStart(2, '0')}`;
+  return `auto-${stamp}`;
+}
+
+/**
+ * 基于任务生成分支名（AI 失败时兜底）。
+ */
+export function generateBranchNameFromTask(task: string, now: Date = new Date()): string {
+  const slug = slugifyTask(task);
+  const type = guessBranchType(task);
+  const suffix = slug || buildTimestampSlug(now);
+  return `${type}/${suffix}`;
 }