Claude Code 无头模式：自动化脚本与自主编程任务指南

import { execSync } from 'child_process';

function runHeadlessTask(prompt: string): string {
  try {
    const sanitizePrompt = prompt.replace(/"/g, '\"');
    const output = execSync(`claude -p "${sanitizePrompt}"`, {
      encoding: 'utf-8',
      stdio: ['pipe', 'pipe', 'pipe']
    });
    return output;
  } catch (error: any) {
    throw new Error(`无头任务执行失败: ${error.stderr || error.message}`);
  }
}

// 示例：在 Schema 变更后自动重新生成测试数据
const log = runHeadlessTask(
  '读取 src/models/user.ts 中的更新 Schema，并重新生成 tests/fixtures/users.json 中的所有测试数据以匹配新字段'
);
console.log('执行结果日志:', log);

import { exec } from 'child_process';
import { promisify } from 'util';

const execAsync = promisify(exec);

interface ClaudeJsonPayload {
  response: string;
  files_changed: Array<{
    path: string;
    operation: 'created' | 'modified' | 'deleted';
    diff?: string;
  }>;
  tokens_used: number;
  model: string;
}

async function extractModifiedFiles(prompt: string): Promise<string[]> {
  const command = `claude -p "${prompt}" --format json --no-session-persistence`;
  const { stdout } = await execAsync(command);

  const payload: ClaudeJsonPayload = JSON.parse(stdout);
  
  // 提取所有被修改的文件路径
  return payload.files_changed
    .filter(item => item.operation === 'modified')
    .map(item => item.path);
}

# CI/CD 流水线中推荐使用的标准无状态命令
claude -p "将 src/utils/logger.ts 重构为使用结构化 JSON 输出" \
  --format json \
  --no-session-persistence

import { spawn } from 'child_process';

interface AgentTask {
  id: string;
  repoPath: string;
  prompt: string;
}

interface AgentResult {
  id: string;
  success: boolean;
  output: string;
  error?: string;
}

async function executeAgentTask(task: AgentTask): Promise<AgentResult> {
  return new Promise((resolve) => {
    const child = spawn('claude', [
      '-p', task.prompt,
      '--format', 'json',
      '--no-session-persistence'
    ], {
      cwd: task.repoPath,
      shell: true
    });

    let stdout = '';
    let stderr = '';

    child.stdout.on('data', (data) => { stdout += data.toString(); });
    child.stderr.on('data', (data) => { stderr += data.toString(); });

    child.on('close', (code) => {
      if (code === 0) {
        resolve({ id: task.id, success: true, output: stdout });
      } else {
        resolve({ id: task.id, success: false, output: stdout, error: stderr });
      }
    });
  });
}

// 带有并发度控制的批量并行执行函数
async function runBatch(tasks: AgentTask[], maxConcurrency: number = 3): Promise<AgentResult[]> {
  const results: AgentResult[] = [];
  const executing: Promise<AgentResult>[] = [];

  for (const task of tasks) {
    const p = executeAgentTask(task).then(res => {
      executing.splice(executing.indexOf(p), 1);
      return res;
    });
    
    results.push(p as any);
    executing.push(p);

    if (executing.length >= maxConcurrency) {
      await Promise.race(executing);
    }
  }

  return Promise.all(results);
}

name: 单元测试失败自动分析

on:
  workflow_run:
    workflows: ["Unit Tests"]
    types: [completed]

jobs:
  analyze-failure:
    if: ${{ github.event.workflow_run.conclusion == 'failure' }}
    runs-on: ubuntu-latest
    steps:
      - name: 检出代码
        uses: actions/checkout@v4

      - name: 配置 Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: 安装 Claude CLI
        run: npm install -g @anthropic-ai/claude-code

      - name: 获取失败测试日志
        run: |
          gh run view ${{ github.event.workflow_run.id }} --log-failed > test-failure.log

      - name: 执行无头 Claude 分析
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude -p "分析 test-failure.log 中的错误信息，给出修复建议并以 JSON 格式输出补丁" \
            --format json \
            --no-session-persistence > analysis-result.json

      - name: 上传分析结果 Artifact
        uses: actions/upload-artifact@v4
        with:
          name: claude-analysis
          path: analysis-result.json

import { execSync } from 'child_process';

async function executeWithRetry(
  prompt: string, 
  retries: number = 3, 
  delayMs: number = 2000
): Promise<string> {
  for (let attempt = 1; attempt <= retries; attempt++) {
    try {
      const command = `claude -p "${prompt.replace(/"/g, '\"')}" --no-session-persistence`;
      return execSync(command, { encoding: 'utf-8', timeout: 120000 });
    } catch (error: any) {
      const isLastAttempt = attempt === retries;
      console.warn(`第 ${attempt} 次执行失败: ${error.message}`);

      if (isLastAttempt) {
        throw new Error(`在尝试 ${retries} 次后任务依然失败。Stderr: ${error.stderr}`);
      }

      // 计算指数退避延迟时间
      const backoff = delayMs * Math.pow(2, attempt - 1);
      await new Promise((res) => setTimeout(res, backoff));
    }
  }
  throw new Error('未知的异常终止状态');
}