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

package/src/cli.ts

@@ -1,15 +1,82 @@
 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,
+  getGlobalConfigPath,
+  loadGlobalConfig,
+  normalizeAliasName,
+  parseAliasEntries,
+  splitCommandArgs,
+  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';
+
+type OptionValueMode = 'none' | 'single' | 'variadic';
+
+interface RunOptionSpec {
+  readonly name: string;
+  readonly flags: readonly string[];
+  readonly valueMode: OptionValueMode;
+}
+
+interface ParsedArgSegment {
+  readonly name?: string;
+  readonly tokens: string[];
+}
+
+const RUN_OPTION_SPECS: RunOptionSpec[] = [
+  { name: 'task', flags: ['-t', '--task'], valueMode: 'single' },
+  { name: 'iterations', flags: ['-i', '--iterations'], valueMode: 'single' },
+  { name: 'ai-cli', flags: ['--ai-cli'], valueMode: 'single' },
+  { name: 'ai-args', flags: ['--ai-args'], valueMode: 'variadic' },
+  { name: 'ai-prompt-arg', flags: ['--ai-prompt-arg'], valueMode: 'single' },
+  { name: 'notes-file', flags: ['--notes-file'], valueMode: 'single' },
+  { name: 'plan-file', flags: ['--plan-file'], valueMode: 'single' },
+  { name: 'workflow-doc', flags: ['--workflow-doc'], valueMode: 'single' },
+  { name: 'worktree', flags: ['--worktree'], valueMode: 'none' },
+  { name: 'branch', flags: ['--branch'], valueMode: 'single' },
+  { name: 'worktree-path', flags: ['--worktree-path'], valueMode: 'single' },
+  { name: 'base-branch', flags: ['--base-branch'], valueMode: 'single' },
+  { name: 'skip-install', flags: ['--skip-install'], valueMode: 'none' },
+  { name: 'run-tests', flags: ['--run-tests'], valueMode: 'none' },
+  { name: 'run-e2e', flags: ['--run-e2e'], valueMode: 'none' },
+  { name: 'unit-command', flags: ['--unit-command'], valueMode: 'single' },
+  { name: 'e2e-command', flags: ['--e2e-command'], valueMode: 'single' },
+  { name: 'auto-commit', flags: ['--auto-commit'], valueMode: 'none' },
+  { name: 'auto-push', flags: ['--auto-push'], valueMode: 'none' },
+  { name: 'pr', flags: ['--pr'], valueMode: 'none' },
+  { name: 'pr-title', flags: ['--pr-title'], valueMode: 'single' },
+  { name: 'pr-body', flags: ['--pr-body'], valueMode: 'single' },
+  { name: 'draft', flags: ['--draft'], valueMode: 'none' },
+  { name: 'reviewer', flags: ['--reviewer'], valueMode: 'variadic' },
+  { name: 'auto-merge', flags: ['--auto-merge'], valueMode: 'none' },
+  { name: 'webhook', flags: ['--webhook'], valueMode: 'single' },
+  { name: 'webhook-timeout', flags: ['--webhook-timeout'], valueMode: 'single' },
+  { name: 'multi-task-mode', flags: ['--multi-task-mode'], valueMode: 'single' },
+  { name: 'stop-signal', flags: ['--stop-signal'], valueMode: 'single' },
+  { name: 'log-file', flags: ['--log-file'], valueMode: 'single' },
+  { name: 'background', flags: ['--background'], valueMode: 'none' },
+  { name: 'verbose', flags: ['-v', '--verbose'], valueMode: 'none' },
+  { name: 'skip-quality', flags: ['--skip-quality'], valueMode: 'none' }
+];
+
+const RUN_OPTION_FLAG_MAP = new Map<string, RunOptionSpec>(
+  RUN_OPTION_SPECS.flatMap(spec => spec.flags.map(flag => [flag, spec] as const))
+);
+
 function parseInteger(value: string, defaultValue: number): number {
   const parsed = Number.parseInt(value, 10);
   if (Number.isNaN(parsed)) return defaultValue;
@@ -42,6 +109,218 @@ 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;
+}
+
+function isAliasCommandToken(token: string): boolean {
+  return token === 'alias' || token === 'aliases';
+}
+
+function extractAliasRunArgs(argv: string[], name: string): string[] {
+  const args = argv.slice(2);
+  const start = args.findIndex(
+    (arg, index) => isAliasCommandToken(arg) && args[index + 1] === 'run' && args[index + 2] === name
+  );
+  if (start < 0) return [];
+  const rest = args.slice(start + 3);
+  if (rest[0] === '--') return rest.slice(1);
+  return rest;
+}
+
+function normalizeAliasCommandArgs(args: string[]): string[] {
+  let start = 0;
+  if (args[start] === 'wheel-ai') {
+    start += 1;
+  }
+  if (args[start] === 'run') {
+    start += 1;
+  }
+  return args.slice(start);
+}
+
+function resolveRunOptionSpec(token: string): { spec: RunOptionSpec; inlineValue?: string } | null {
+  const equalIndex = token.indexOf('=');
+  const flag = equalIndex > 0 ? token.slice(0, equalIndex) : token;
+  const spec = RUN_OPTION_FLAG_MAP.get(flag);
+  if (!spec) return null;
+  if (equalIndex > 0) {
+    return { spec, inlineValue: token.slice(equalIndex + 1) };
+  }
+  return { spec };
+}
+
+function parseArgSegments(tokens: string[]): ParsedArgSegment[] {
+  const segments: ParsedArgSegment[] = [];
+  let index = 0;
+  while (index < tokens.length) {
+    const token = tokens[index];
+    if (token === '--') {
+      segments.push({ tokens: tokens.slice(index) });
+      break;
+    }
+
+    const match = resolveRunOptionSpec(token);
+    if (!match) {
+      segments.push({ tokens: [token] });
+      index += 1;
+      continue;
+    }
+
+    if (match.inlineValue !== undefined) {
+      segments.push({ name: match.spec.name, tokens: [token] });
+      index += 1;
+      continue;
+    }
+
+    if (match.spec.valueMode === 'none') {
+      segments.push({ name: match.spec.name, tokens: [token] });
+      index += 1;
+      continue;
+    }
+
+    if (match.spec.valueMode === 'single') {
+      const next = tokens[index + 1];
+      if (next !== undefined) {
+        segments.push({ name: match.spec.name, tokens: [token, next] });
+        index += 2;
+      } else {
+        segments.push({ name: match.spec.name, tokens: [token] });
+        index += 1;
+      }
+      continue;
+    }
+
+    const values: string[] = [];
+    let cursor = index + 1;
+    while (cursor < tokens.length) {
+      const next = tokens[cursor];
+      if (next === '--') break;
+      const nextMatch = resolveRunOptionSpec(next);
+      if (nextMatch) break;
+      values.push(next);
+      cursor += 1;
+    }
+    segments.push({ name: match.spec.name, tokens: [token, ...values] });
+    index = cursor;
+  }
+
+  return segments;
+}
+
+function mergeAliasCommandArgs(aliasTokens: string[], additionTokens: string[]): string[] {
+  const aliasSegments = parseArgSegments(aliasTokens);
+  const additionSegments = parseArgSegments(additionTokens);
+  const overrideNames = new Set(
+    additionSegments.flatMap(segment => (segment.name ? [segment.name] : []))
+  );
+
+  const merged = [
+    ...aliasSegments.filter(segment => !segment.name || !overrideNames.has(segment.name)),
+    ...additionSegments
+  ];
+
+  return merged.flatMap(segment => segment.tokens);
+}
+
+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 入口。
  */
@@ -54,10 +333,14 @@ export async function runCli(argv: string[]): Promise<void> {
     .name('wheel-ai')
     .description('基于 AI CLI 的持续迭代开发工具')
     .version('1.0.0');
+  program.addHelpText(
+    'after',
+    '\n别名执行：\n  wheel-ai alias run <alias> <addition...>\n  追加命令与 alias 重叠时，以追加为准。\n'
+  );
 
   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 +364,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 +419,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 +464,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 +475,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 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);
       };
 
-      const config = buildLoopConfig(cliOptions, process.cwd());
-      await 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 +558,76 @@ 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}`);
+    });
+
+  const aliasCommand = program
+    .command('alias')
+    .alias('aliases')
+    .description('浏览全局 alias 配置（alias run 可执行并追加命令）');
+
+  aliasCommand
+    .command('run <name> [addition...]')
+    .description('执行 alias 并追加命令')
+    .allowUnknownOption(true)
+    .allowExcessArguments(true)
+    .action(async (name: string) => {
+      const normalized = normalizeAliasName(name);
+      if (!normalized) {
+        throw new Error('alias 名称不能为空且不能包含空白字符');
+      }
+
+      const filePath = getGlobalConfigPath();
+      const exists = await fs.pathExists(filePath);
+      if (!exists) {
+        throw new Error(`未找到 alias 配置文件：${filePath}`);
+      }
+
+      const content = await fs.readFile(filePath, 'utf8');
+      const entries = parseAliasEntries(content);
+      const entry = entries.find(item => item.name === normalized);
+      if (!entry) {
+        throw new Error(`未找到 alias：${normalized}`);
+      }
+
+      const aliasTokens = normalizeAliasCommandArgs(splitCommandArgs(entry.command));
+      const additionTokens = extractAliasRunArgs(effectiveArgv, normalized);
+      const mergedTokens = mergeAliasCommandArgs(aliasTokens, additionTokens);
+      if (mergedTokens.length === 0) {
+        throw new Error('alias 命令不能为空');
+      }
+
+      const nextArgv = [process.argv[0], process.argv[1], 'run', ...mergedTokens];
+      const originalArgv = process.argv;
+      process.argv = nextArgv;
+      try {
+        await runCli(nextArgv);
+      } finally {
+        process.argv = originalArgv;
+      }
+    });
+
+  aliasCommand.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;
+}