hamster-wheel-cli 0.1.0

package/src/ai.ts

@@ -0,0 +1,173 @@
+import { AiCliConfig, AiResult, IterationRecord, TokenUsage } from './types';
+import { runCommand } from './utils';
+import { Logger } from './logger';
+
+interface PromptInput {
+  readonly task: string;
+  readonly workflowGuide: string;
+  readonly plan: string;
+  readonly notes: string;
+  readonly iteration: number;
+}
+
+/**
+ * 构建 AI 提示文本。
+ */
+export function buildPrompt(input: PromptInput): string {
+  const sections = [
+    '# 背景任务',
+    input.task,
+    '# 工作流程基线（供 AI 自主执行）',
+    input.workflowGuide,
+    '# 当前持久化计划',
+    input.plan || '（暂无计划，首轮请生成可执行计划并写入 plan 文件）',
+    '# 历史迭代与记忆',
+    input.notes || '（首次执行，暂无历史）',
+    '# 本轮执行要求',
+    [
+      '1. 自我检查并补全需求；明确交付物与验收标准。',
+      '2. 更新/细化计划，必要时在 plan 文件中重写任务树与优先级。',
+      '3. 设计开发步骤并直接生成代码（无需再次请求确认）。',
+      '4. 进行代码自审，给出风险与改进清单。',
+      '5. 生成单元测试与 e2e 测试代码并给出运行命令；如果环境允许可直接运行命令。',
+      '6. 维护持久化记忆文件：摘要本轮关键结论、遗留问题、下一步建议。',
+      '7. 准备提交 PR 所需的标题与描述（含变更摘要、测试结果、风险）。',
+      '8. 当所有目标完成时，在输出中加入标记 <<DONE>> 以便外层停止循环。'
+    ].join('\n')
+  ];
+
+  return sections.join('\n\n');
+}
+
+function pickNumber(pattern: RegExp, text: string): number | undefined {
+  const match = pattern.exec(text);
+  if (!match || match.length < 2) return undefined;
+  const value = Number.parseInt(match[match.length - 1], 10);
+  return Number.isNaN(value) ? undefined : value;
+}
+
+/**
+ * 从日志文本中解析 token 使用量。
+ */
+export function parseTokenUsage(logs: string): TokenUsage | null {
+  const total = pickNumber(/total[_\s]tokens:\s*(\d+)/i, logs);
+  const input = pickNumber(/(input|prompt)[_\s]tokens:\s*(\d+)/i, logs);
+  const output = pickNumber(/(output|completion)[_\s]tokens:\s*(\d+)/i, logs);
+  const consumed = pickNumber(/tokens?\s+used:\s*(\d+)/i, logs) ?? pickNumber(/consumed\s+(\d+)\s+tokens?/i, logs);
+
+  const totalTokens = total ?? (input !== undefined || output !== undefined ? (input ?? 0) + (output ?? 0) : consumed);
+  if (totalTokens === undefined) return null;
+
+  return {
+    inputTokens: input,
+    outputTokens: output,
+    totalTokens
+  };
+}
+
+function addOptional(a?: number, b?: number): number | undefined {
+  if (typeof a !== 'number' && typeof b !== 'number') return undefined;
+  return (a ?? 0) + (b ?? 0);
+}
+
+/**
+ * 合并多轮 token 统计。
+ */
+export function mergeTokenUsage(previous: TokenUsage | null, current?: TokenUsage | null): TokenUsage | null {
+  if (!current) return previous;
+  if (!previous) return { ...current };
+  return {
+    inputTokens: addOptional(previous.inputTokens, current.inputTokens),
+    outputTokens: addOptional(previous.outputTokens, current.outputTokens),
+    totalTokens: previous.totalTokens + current.totalTokens
+  };
+}
+
+/**
+ * 调用 AI CLI 并返回输出。
+ */
+export async function runAi(prompt: string, ai: AiCliConfig, logger: Logger, cwd: string): Promise<AiResult> {
+  const args = [...ai.args];
+  const verboseCommand = ai.promptArg
+    ? [ai.command, ...ai.args, ai.promptArg, '<prompt>'].join(' ')
+    : [ai.command, ...ai.args, '<stdin>'].join(' ');
+  const streamPrefix = `[${ai.command}] `;
+  const streamErrorPrefix = `[${ai.command} stderr] `;
+
+  let result;
+  if (ai.promptArg) {
+    args.push(ai.promptArg, prompt);
+    result = await runCommand(ai.command, args, {
+      cwd,
+      logger,
+      verboseLabel: 'ai',
+      verboseCommand,
+      stream: {
+        enabled: true,
+        stdoutPrefix: streamPrefix,
+        stderrPrefix: streamErrorPrefix
+      }
+    });
+  } else {
+    result = await runCommand(ai.command, args, {
+      cwd,
+      input: prompt,
+      logger,
+      verboseLabel: 'ai',
+      verboseCommand,
+      stream: {
+        enabled: true,
+        stdoutPrefix: streamPrefix,
+        stderrPrefix: streamErrorPrefix
+      }
+    });
+  }
+
+  if (result.exitCode !== 0) {
+    throw new Error(`AI CLI 执行失败: ${result.stderr || result.stdout}`);
+  }
+
+  logger.success('AI 输出完成');
+  const usage = parseTokenUsage([result.stdout, result.stderr].filter(Boolean).join('\n'));
+  return {
+    output: result.stdout.trim(),
+    usage
+  };
+}
+
+/**
+ * 生成 notes 迭代记录文本。
+ */
+export function formatIterationRecord(record: IterationRecord): string {
+  const lines = [
+    `### 迭代 ${record.iteration} ｜ ${record.timestamp}`,
+    '',
+    '#### 提示上下文',
+    '```',
+    record.prompt,
+    '```',
+    '',
+    '#### AI 输出',
+    '```',
+    record.aiOutput,
+    '```',
+    ''
+  ];
+
+  if (record.testResults && record.testResults.length > 0) {
+    lines.push('#### 测试结果');
+    record.testResults.forEach(result => {
+      const label = result.kind === 'unit' ? '单元测试' : 'e2e 测试';
+      const status = result.success ? '✅ 通过' : '❌ 失败';
+      lines.push(`${status} ｜ ${label} ｜ 命令: ${result.command} ｜ 退出码: ${result.exitCode}`);
+      if (!result.success) {
+        lines.push('```');
+        lines.push(result.stderr || result.stdout || '（无输出）');
+        lines.push('```');
+        lines.push('');
+      }
+    });
+  }
+
+  return lines.join('\n');
+}

package/src/cli.ts

@@ -0,0 +1,189 @@
+import { spawn } from 'node:child_process';
+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 { runLogsViewer } from './logs-viewer';
+import { runLoop } from './loop';
+import { defaultLogger } from './logger';
+import { runMonitor } from './monitor';
+import { resolvePath } from './utils';
+
+function parseInteger(value: string, defaultValue: number): number {
+  const parsed = Number.parseInt(value, 10);
+  if (Number.isNaN(parsed)) return defaultValue;
+  return parsed;
+}
+
+function collect(value: string, previous: string[]): string[] {
+  return [...previous, value];
+}
+
+function normalizeOptional(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function hasOption(argv: string[], option: string): boolean {
+  return argv.some(arg => arg === option || arg.startsWith(`${option}=`));
+}
+
+function buildBackgroundArgs(argv: string[], logFile: string, branchName?: string, injectBranch = false): string[] {
+  const rawArgs = argv.slice(1);
+  const filtered = rawArgs.filter(arg => !(arg === '--background' || arg.startsWith('--background=')));
+  if (!hasOption(filtered, '--log-file')) {
+    filtered.push('--log-file', logFile);
+  }
+  if (injectBranch && branchName && !hasOption(filtered, '--branch')) {
+    filtered.push('--branch', branchName);
+  }
+  return filtered;
+}
+
+/**
+ * CLI 入口。
+ */
+export async function runCli(argv: string[]): Promise<void> {
+  const globalConfig = await loadGlobalConfig(defaultLogger);
+  const effectiveArgv = applyShortcutArgv(argv, globalConfig);
+  const program = new Command();
+
+  program
+    .name('wheel-ai')
+    .description('基于 AI CLI 的持续迭代开发工具')
+    .version('1.0.0');
+
+  program
+    .command('run')
+    .requiredOption('-t, --task <task>', '需要完成的任务描述（会进入 AI 提示）')
+    .option('-i, --iterations <number>', '最大迭代次数', value => parseInteger(value, 5), 5)
+    .option('--ai-cli <command>', 'AI CLI 命令', 'claude')
+    .option('--ai-args <args...>', 'AI CLI 参数', [])
+    .option('--ai-prompt-arg <flag>', '用于传入 prompt 的参数（为空则使用 stdin）')
+    .option('--notes-file <path>', '持久化记忆文件', defaultNotesPath())
+    .option('--plan-file <path>', '计划文件', defaultPlanPath())
+    .option('--workflow-doc <path>', 'AI 工作流程说明文件', defaultWorkflowDoc())
+    .option('--worktree', '在独立 worktree 上执行', false)
+    .option('--branch <name>', 'worktree 分支名（默认自动生成或当前分支）')
+    .option('--worktree-path <path>', 'worktree 路径，默认 ../worktrees/<branch>')
+    .option('--base-branch <name>', '创建分支的基线分支', 'main')
+    .option('--skip-install', '跳过开始任务前的依赖检查', false)
+    .option('--run-tests', '运行单元测试命令', false)
+    .option('--run-e2e', '运行 e2e 测试命令', false)
+    .option('--unit-command <cmd>', '单元测试命令', 'yarn test')
+    .option('--e2e-command <cmd>', 'e2e 测试命令', 'yarn e2e')
+    .option('--auto-commit', '自动 git commit', false)
+    .option('--auto-push', '自动 git push', false)
+    .option('--pr', '使用 gh 创建 PR', false)
+    .option('--pr-title <title>', 'PR 标题')
+    .option('--pr-body <path>', 'PR 描述文件路径（可留空自动生成）')
+    .option('--draft', '以草稿形式创建 PR', false)
+    .option('--reviewer <user...>', 'PR reviewers', collect, [])
+    .option('--webhook <url>', 'webhook 通知 URL（可重复）', collect, [])
+    .option('--webhook-timeout <ms>', 'webhook 请求超时（毫秒）', value => parseInteger(value, 8000))
+    .option('--stop-signal <token>', 'AI 输出中的停止标记', '<<DONE>>')
+    .option('--log-file <path>', '日志输出文件路径')
+    .option('--background', '切入后台运行', false)
+    .option('-v, --verbose', '输出调试日志', false)
+    .action(async (options) => {
+      const useWorktree = Boolean(options.worktree);
+      const branchInput = normalizeOptional(options.branch);
+      const logFileInput = normalizeOptional(options.logFile);
+      const background = Boolean(options.background);
+
+      let branchName = branchInput;
+      if (useWorktree && !branchName) {
+        branchName = generateBranchName();
+      }
+
+      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';
+          }
+        }
+        logFile = buildAutoLogFilePath(branchForLog);
+      }
+
+      if (background) {
+        if (!logFile) {
+          throw new Error('后台运行需要指定日志文件');
+        }
+        const args = buildBackgroundArgs(effectiveArgv, logFile, branchName, useWorktree && !branchInput);
+        const child = spawn(process.execPath, [...process.execArgv, ...args], {
+          detached: true,
+          stdio: 'ignore'
+        });
+        child.unref();
+        const displayLogFile = resolvePath(process.cwd(), logFile);
+        console.log(`已切入后台运行，日志输出至 ${displayLogFile}`);
+        return;
+      }
+
+      const cliOptions: CliOptions = {
+        task: options.task as string,
+        iterations: options.iterations as number,
+        aiCli: options.aiCli as string,
+        aiArgs: (options.aiArgs as string[]) ?? [],
+        aiPromptArg: options.aiPromptArg as string | undefined,
+        notesFile: options.notesFile as string,
+        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,
+        e2eCommand: options.e2eCommand as string | undefined,
+        autoCommit: Boolean(options.autoCommit),
+        autoPush: Boolean(options.autoPush),
+        pr: Boolean(options.pr),
+        prTitle: options.prTitle as string | undefined,
+        prBody: options.prBody as string | undefined,
+        draft: Boolean(options.draft),
+        reviewers: (options.reviewer as string[]) ?? [],
+        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)
+      };
+
+      const config = buildLoopConfig(cliOptions, process.cwd());
+      await runLoop(config);
+    });
+
+  program
+    .command('monitor')
+    .description('查看后台运行日志')
+    .action(async () => {
+      await runMonitor();
+    });
+
+  program
+    .command('logs')
+    .description('查看历史日志')
+    .action(async () => {
+      await runLogsViewer();
+    });
+
+  await program.parseAsync(effectiveArgv);
+}
+
+if (require.main === module) {
+  runCli(process.argv).catch(error => {
+    const message = error instanceof Error ? error.stack ?? error.message : String(error);
+    defaultLogger.error(message);
+    process.exitCode = 1;
+  });
+}

package/src/config.ts

@@ -0,0 +1,134 @@
+import path from 'node:path';
+import { AiCliConfig, LoopConfig, PrConfig, TestConfig, WebhookConfig, WorktreeConfig, WorkflowFiles } from './types';
+import { resolvePath } from './utils';
+
+/**
+ * CLI 参数解析后的配置。
+ */
+export interface CliOptions {
+  readonly task: string;
+  readonly iterations: number;
+  readonly aiCli: string;
+  readonly aiArgs: string[];
+  readonly aiPromptArg?: string;
+  readonly notesFile: string;
+  readonly planFile: string;
+  readonly workflowDoc: string;
+  readonly useWorktree: boolean;
+  readonly branch?: string;
+  readonly worktreePath?: string;
+  readonly baseBranch: string;
+  readonly runTests: boolean;
+  readonly runE2e: boolean;
+  readonly unitCommand?: string;
+  readonly e2eCommand?: string;
+  readonly autoCommit: boolean;
+  readonly autoPush: boolean;
+  readonly pr: boolean;
+  readonly prTitle?: string;
+  readonly prBody?: string;
+  readonly draft: boolean;
+  readonly reviewers?: string[];
+  readonly webhookUrls: string[];
+  readonly webhookTimeout?: number;
+  readonly stopSignal: string;
+  readonly logFile?: string;
+  readonly verbose: boolean;
+  readonly skipInstall: boolean;
+}
+
+function buildAiConfig(options: CliOptions): AiCliConfig {
+  return {
+    command: options.aiCli,
+    args: options.aiArgs,
+    promptArg: options.aiPromptArg
+  };
+}
+
+function buildWorktreeConfig(options: CliOptions): WorktreeConfig {
+  return {
+    useWorktree: options.useWorktree,
+    branchName: options.branch,
+    worktreePath: options.worktreePath,
+    baseBranch: options.baseBranch
+  };
+}
+
+function buildTestConfig(options: CliOptions): TestConfig {
+  return {
+    unitCommand: options.unitCommand,
+    e2eCommand: options.e2eCommand
+  };
+}
+
+function buildPrConfig(options: CliOptions): PrConfig {
+  return {
+    enable: options.pr,
+    title: options.prTitle,
+    bodyPath: options.prBody,
+    draft: options.draft,
+    reviewers: options.reviewers
+  };
+}
+
+function buildWebhookConfig(options: CliOptions): WebhookConfig | undefined {
+  if (!options.webhookUrls || options.webhookUrls.length === 0) return undefined;
+  return {
+    urls: options.webhookUrls,
+    timeoutMs: options.webhookTimeout
+  };
+}
+
+function buildWorkflowFiles(options: CliOptions, cwd: string): WorkflowFiles {
+  return {
+    workflowDoc: resolvePath(cwd, options.workflowDoc),
+    notesFile: resolvePath(cwd, options.notesFile),
+    planFile: resolvePath(cwd, options.planFile)
+  };
+}
+
+/**
+ * 构建循环执行所需的配置对象。
+ */
+export function buildLoopConfig(options: CliOptions, cwd: string): LoopConfig {
+  return {
+    task: options.task,
+    iterations: options.iterations,
+    stopSignal: options.stopSignal,
+    ai: buildAiConfig(options),
+    workflowFiles: buildWorkflowFiles(options, cwd),
+    git: buildWorktreeConfig(options),
+    tests: buildTestConfig(options),
+    pr: buildPrConfig(options),
+    webhooks: buildWebhookConfig(options),
+    cwd,
+    logFile: options.logFile ? resolvePath(cwd, options.logFile) : undefined,
+    verbose: options.verbose,
+    runTests: options.runTests,
+    runE2e: options.runE2e,
+    autoCommit: options.autoCommit,
+    autoPush: options.autoPush,
+    skipInstall: options.skipInstall
+  };
+}
+
+/**
+ * 默认 notes 文件路径。
+ */
+export function defaultNotesPath(): string {
+  return path.join('memory', 'notes.md');
+}
+
+/**
+ * 默认 plan 文件路径。
+ */
+export function defaultPlanPath(): string {
+  return path.join('memory', 'plan.md');
+}
+
+/**
+ * 默认工作流说明文件路径。
+ */
+export function defaultWorkflowDoc(): string {
+  return path.join('docs', 'ai-workflow.md');
+}

package/src/deps.ts

@@ -0,0 +1,210 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { Logger } from './logger';
+import { runCommand } from './utils';
+
+/**
+ * 支持的包管理器类型。
+ */
+export type PackageManager = 'yarn' | 'pnpm' | 'npm';
+
+type PackageManagerSource = 'packageManager' | 'lockfile' | 'default';
+
+/**
+ * 解析包管理器所需的提示信息。
+ */
+export interface PackageManagerHints {
+  readonly packageManagerField?: string;
+  readonly hasYarnLock: boolean;
+  readonly hasPnpmLock: boolean;
+  readonly hasNpmLock: boolean;
+  readonly hasNpmShrinkwrap: boolean;
+}
+
+/**
+ * 包管理器解析结果。
+ */
+export interface PackageManagerResolution {
+  readonly manager: PackageManager;
+  readonly source: PackageManagerSource;
+  readonly hasLock: boolean;
+}
+
+function parsePackageManagerField(value?: string): PackageManager | null {
+  if (!value) return null;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === 'yarn' || normalized.startsWith('yarn@')) return 'yarn';
+  if (normalized === 'pnpm' || normalized.startsWith('pnpm@')) return 'pnpm';
+  if (normalized === 'npm' || normalized.startsWith('npm@')) return 'npm';
+  return null;
+}
+
+function hasLockForManager(manager: PackageManager, hints: PackageManagerHints): boolean {
+  if (manager === 'yarn') return hints.hasYarnLock;
+  if (manager === 'pnpm') return hints.hasPnpmLock;
+  return hints.hasNpmLock || hints.hasNpmShrinkwrap;
+}
+
+/**
+ * 根据 packageManager 字段或锁文件推断包管理器。
+ */
+export function resolvePackageManager(hints: PackageManagerHints): PackageManagerResolution {
+  const fromField = parsePackageManagerField(hints.packageManagerField);
+  if (fromField) {
+    return {
+      manager: fromField,
+      source: 'packageManager',
+      hasLock: hasLockForManager(fromField, hints)
+    };
+  }
+
+  if (hints.hasYarnLock) {
+    return {
+      manager: 'yarn',
+      source: 'lockfile',
+      hasLock: true
+    };
+  }
+  if (hints.hasPnpmLock) {
+    return {
+      manager: 'pnpm',
+      source: 'lockfile',
+      hasLock: true
+    };
+  }
+  if (hints.hasNpmLock || hints.hasNpmShrinkwrap) {
+    return {
+      manager: 'npm',
+      source: 'lockfile',
+      hasLock: true
+    };
+  }
+
+  return {
+    manager: 'yarn',
+    source: 'default',
+    hasLock: false
+  };
+}
+
+/**
+ * 生成安装依赖命令。
+ */
+export function buildInstallCommand(resolution: PackageManagerResolution): string {
+  switch (resolution.manager) {
+    case 'yarn': {
+      const args = ['yarn', 'install'];
+      if (resolution.hasLock) {
+        args.push('--frozen-lockfile');
+      } else {
+        args.push('--no-lockfile');
+      }
+      return args.join(' ');
+    }
+    case 'pnpm': {
+      const args = ['pnpm', 'install'];
+      if (resolution.hasLock) {
+        args.push('--frozen-lockfile');
+      }
+      return args.join(' ');
+    }
+    case 'npm': {
+      const args = resolution.hasLock ? ['npm', 'ci'] : ['npm', 'install'];
+      args.push('--no-audit', '--no-fund');
+      return args.join(' ');
+    }
+    default: {
+      return 'yarn install';
+    }
+  }
+}
+
+function resolveSourceLabel(source: PackageManagerSource): string {
+  switch (source) {
+    case 'packageManager':
+      return 'packageManager 字段';
+    case 'lockfile':
+      return '锁文件';
+    case 'default':
+      return '默认策略';
+    default:
+      return '未知来源';
+  }
+}
+
+function extractPackageManagerField(value: unknown): string | undefined {
+  if (typeof value !== 'object' || value === null) return undefined;
+  const candidate = value as Record<string, unknown>;
+  const field = candidate.packageManager;
+  return typeof field === 'string' ? field : undefined;
+}
+
+async function readPackageManagerHints(cwd: string, logger: Logger): Promise<PackageManagerHints | null> {
+  const packageJsonPath = path.join(cwd, 'package.json');
+  const hasPackageJson = await fs.pathExists(packageJsonPath);
+  if (!hasPackageJson) return null;
+
+  let packageManagerField: string | undefined;
+  try {
+    const packageJson = await fs.readJson(packageJsonPath);
+    packageManagerField = extractPackageManagerField(packageJson);
+  } catch (error) {
+    logger.warn(`读取 package.json 失败，将改用锁文件判断包管理器: ${String(error)}`);
+  }
+
+  const [hasYarnLock, hasPnpmLock, hasNpmLock, hasNpmShrinkwrap] = await Promise.all([
+    fs.pathExists(path.join(cwd, 'yarn.lock')),
+    fs.pathExists(path.join(cwd, 'pnpm-lock.yaml')),
+    fs.pathExists(path.join(cwd, 'package-lock.json')),
+    fs.pathExists(path.join(cwd, 'npm-shrinkwrap.json'))
+  ]);
+
+  return {
+    packageManagerField,
+    hasYarnLock,
+    hasPnpmLock,
+    hasNpmLock,
+    hasNpmShrinkwrap
+  };
+}
+
+/**
+ * 确保依赖已安装（按锁文件或 packageManager 字段选择包管理器）。
+ */
+export async function ensureDependencies(cwd: string, logger: Logger): Promise<void> {
+  const hints = await readPackageManagerHints(cwd, logger);
+  if (!hints) {
+    logger.info('未检测到 package.json，跳过依赖检查');
+    return;
+  }
+
+  const resolution = resolvePackageManager(hints);
+  const sourceLabel = resolveSourceLabel(resolution.source);
+  logger.info(`依赖检查：使用 ${resolution.manager}（来源：${sourceLabel}）`);
+
+  if (resolution.source === 'default') {
+    logger.warn('未检测到 packageManager 配置或锁文件，将按默认策略安装依赖');
+  }
+
+  const command = buildInstallCommand(resolution);
+  logger.info(`开始安装依赖: ${command}`);
+
+  const result = await runCommand('bash', ['-lc', command], {
+    cwd,
+    logger,
+    verboseLabel: 'deps',
+    verboseCommand: `bash -lc "${command}"`,
+    stream: {
+      enabled: true,
+      stdoutPrefix: '[deps] ',
+      stderrPrefix: '[deps err] '
+    }
+  });
+
+  if (result.exitCode !== 0) {
+    const details = result.stderr || result.stdout || '无输出';
+    throw new Error(`依赖安装失败: ${details}`);
+  }
+
+  logger.success('依赖检查完成');
+}