9장: AI 통합 CI/CD 파이프라인 구축

interface PipelineContext {
  // PR 메타데이터
  pr: {
    number: number
    title: string
    description: string
    author: string
    baseBranch: string
    headBranch: string
  }
 
  // 분석된 변경 사항
  changes: AnalyzedChange[]
 
  // 파일 내용 캐시
  fileCache: Map<string, string>
 
  // 프로젝트 맥락
  projectContext: ProjectContext
 
  // 파이프라인 설정
  config: PipelineConfig
}
 
interface AnalyzedChange {
  file: string
  diff: string
  fullContent: string
  language: string
  classification: ChangeClassification
  importance: number
  relatedFiles: string[]
}
 
async function buildPipelineContext(
  event: PREvent
): Promise<PipelineContext> {
  // 1. 변경 파일 수집
  const rawChanges = await fetchPRChanges(event)
 
  // 2. 파일 내용 캐시 구축
  const fileCache = new Map<string, string>()
  for (const change of rawChanges) {
    if (change.status !== "deleted") {
      const content = await fetchFileContent(
        event.repo, event.headBranch, change.filename
      )
      fileCache.set(change.filename, content)
    }
 
    // 관련 파일도 캐시
    const relatedFiles = findRelatedFiles(change.filename)
    for (const related of relatedFiles) {
      if (!fileCache.has(related)) {
        const content = await fetchFileContent(
          event.repo, event.headBranch, related
        )
        if (content) fileCache.set(related, content)
      }
    }
  }
 
  // 3. 변경 분류
  const analyzed = await classifyAllChanges(
    rawChanges, fileCache
  )
 
  // 4. 프로젝트 맥락 수집
  const projectContext = await loadProjectContext(event.repo)
 
  return {
    pr: {
      number: event.prNumber,
      title: event.title,
      description: event.description,
      author: event.author,
      baseBranch: event.baseBranch,
      headBranch: event.headBranch,
    },
    changes: analyzed,
    fileCache,
    projectContext,
    config: loadPipelineConfig(),
  }
}

interface StageResult {
  stage: string
  status: "success" | "failure" | "skipped"
  duration: number
  output: unknown
  tokensUsed: number
  cost: number
}
 
interface PipelineResult {
  stages: StageResult[]
  totalDuration: number
  totalTokens: number
  totalCost: number
  qualityGate: QualityGateResult
}
 
async function runPipeline(
  context: PipelineContext
): Promise<PipelineResult> {
  const stages: StageResult[] = []
  const startTime = Date.now()
 
  // Stage 1: PR 분석 (다른 단계의 입력으로 사용)
  const analysisResult = await runStage(
    "pr-analysis",
    () => analyzePR(context),
    context.config
  )
  stages.push(analysisResult)
 
  // Stage 2: 병렬 실행 (코드 리뷰, 테스트 생성, 문서 분석)
  const parallelResults = await Promise.all([
    // 코드 리뷰: PR 분석 결과의 위험도를 참고
    runStage(
      "code-review",
      () => reviewCode(context, analysisResult.output),
      context.config
    ),
    // 테스트 생성: 비즈니스 로직 변경이 있을 때만
    runStage(
      "test-generation",
      () => generateTests(context),
      context.config,
      shouldGenerateTests(context.changes)
    ),
    // 문서 영향 분석
    runStage(
      "doc-analysis",
      () => analyzeDocImpact(context),
      context.config,
      hasDocumentableChanges(context.changes)
    ),
  ])
  stages.push(...parallelResults)
 
  // Stage 3: 결과 통합
  const integrationResult = await runStage(
    "integration",
    () => integrateResults(stages, context),
    context.config
  )
  stages.push(integrationResult)
 
  // Stage 4: 품질 게이트 평가
  const qualityGate = evaluateQualityGate(
    stages, context.config
  )
 
  return {
    stages,
    totalDuration: Date.now() - startTime,
    totalTokens: stages.reduce(
      (sum, s) => sum + s.tokensUsed, 0
    ),
    totalCost: stages.reduce(
      (sum, s) => sum + s.cost, 0
    ),
    qualityGate,
  }
}
 
async function runStage<T>(
  name: string,
  executor: () => Promise<T>,
  config: PipelineConfig,
  shouldRun: boolean = true
): Promise<StageResult> {
  if (!shouldRun || !config.stages[name]?.enabled) {
    return {
      stage: name,
      status: "skipped",
      duration: 0,
      output: null,
      tokensUsed: 0,
      cost: 0,
    }
  }
 
  const start = Date.now()
  try {
    const output = await executor()
    return {
      stage: name,
      status: "success",
      duration: Date.now() - start,
      output,
      tokensUsed: 0, // 실제 구현에서 LLM 응답에서 추출
      cost: 0,
    }
  } catch (error) {
    return {
      stage: name,
      status: "failure",
      duration: Date.now() - start,
      output: { error: String(error) },
      tokensUsed: 0,
      cost: 0,
    }
  }
}

interface QualityGateConfig {
  // 코드 리뷰 기준
  codeReview: {
    maxCriticalIssues: number     // 허용 최대 Critical 이슈 수
    maxWarningIssues: number      // 허용 최대 Warning 이슈 수
    maxOverallRisk: string        // 허용 최대 위험도
  }
  // 테스트 기준
  testing: {
    requireTestsForLogicChanges: boolean
    minMutationScore: number      // 최소 뮤테이션 점수
  }
  // 문서 기준
  documentation: {
    requireDocUpdate: boolean     // API 변경 시 문서 갱신 필수
    requireInlineDocs: boolean    // 공개 함수 문서 필수
  }
}
 
interface QualityGateResult {
  passed: boolean
  checks: QualityCheck[]
  blockingIssues: string[]
  warnings: string[]
}
 
interface QualityCheck {
  name: string
  passed: boolean
  message: string
  severity: "blocking" | "warning" | "info"
}
 
function evaluateQualityGate(
  stages: StageResult[],
  config: PipelineConfig
): QualityGateResult {
  const checks: QualityCheck[] = []
 
  // 1. 코드 리뷰 품질 체크
  const reviewStage = stages.find(s => s.stage === "code-review")
  if (reviewStage?.status === "success") {
    const review = reviewStage.output as ReviewResult
 
    const criticalCount = review.comments.filter(
      c => c.severity === "critical"
    ).length
 
    checks.push({
      name: "Critical Issues",
      passed: criticalCount
        <= config.qualityGate.codeReview.maxCriticalIssues,
      message: criticalCount + " critical issues found"
        + " (max: "
        + config.qualityGate.codeReview.maxCriticalIssues
        + ")",
      severity: criticalCount > 0 ? "blocking" : "info",
    })
 
    checks.push({
      name: "Risk Level",
      passed: isRiskAcceptable(
        review.overallRisk,
        config.qualityGate.codeReview.maxOverallRisk
      ),
      message: "Risk level: " + review.overallRisk,
      severity: review.overallRisk === "critical"
        ? "blocking" : "warning",
    })
  }
 
  // 2. 테스트 커버리지 체크
  const testStage = stages.find(s => s.stage === "test-generation")
  if (testStage?.status === "success") {
    const testResult = testStage.output as TestGenerationResult
 
    checks.push({
      name: "Test Coverage",
      passed: testResult.allTestsPassed,
      message: testResult.allTestsPassed
        ? "All generated tests passed"
        : "Some generated tests failed",
      severity: testResult.allTestsPassed
        ? "info" : "warning",
    })
  } else if (
    testStage?.status === "skipped"
    && config.qualityGate.testing.requireTestsForLogicChanges
  ) {
    checks.push({
      name: "Test Coverage",
      passed: false,
      message: "Logic changes detected but no tests generated",
      severity: "warning",
    })
  }
 
  // 3. 문서 일관성 체크
  const docStage = stages.find(s => s.stage === "doc-analysis")
  if (docStage?.status === "success") {
    const docResult = docStage.output as DocImpact
 
    const hasUndocumentedAPI = docResult.affectedDocs.some(
      d => d.docType === "api"
    )
 
    if (hasUndocumentedAPI
      && config.qualityGate.documentation.requireDocUpdate) {
      checks.push({
        name: "API Documentation",
        passed: false,
        message: "API changes detected but documentation not updated",
        severity: "warning",
      })
    }
  }
 
  // 결과 종합
  const blockingIssues = checks
    .filter(c => !c.passed && c.severity === "blocking")
    .map(c => c.name + ": " + c.message)
 
  const warnings = checks
    .filter(c => !c.passed && c.severity === "warning")
    .map(c => c.name + ": " + c.message)
 
  return {
    passed: blockingIssues.length === 0,
    checks,
    blockingIssues,
    warnings,
  }
}

function generateIntegratedReport(
  result: PipelineResult,
  context: PipelineContext
): string {
  let report = "## AI Development Pipeline Report\n\n"
 
  // 품질 게이트 상태
  const gateStatus = result.qualityGate.passed
    ? "Passed" : "Failed"
  report += "### Quality Gate: " + gateStatus + "\n\n"
 
  if (result.qualityGate.blockingIssues.length > 0) {
    report += "**Blocking Issues:**\n"
    for (const issue of result.qualityGate.blockingIssues) {
      report += "- " + issue + "\n"
    }
    report += "\n"
  }
 
  if (result.qualityGate.warnings.length > 0) {
    report += "**Warnings:**\n"
    for (const warning of result.qualityGate.warnings) {
      report += "- " + warning + "\n"
    }
    report += "\n"
  }
 
  // 파이프라인 실행 요약
  report += "### Pipeline Summary\n\n"
  report += "| Stage | Status | Duration |\n"
  report += "|-------|--------|----------|\n"
  for (const stage of result.stages) {
    report += "| " + stage.stage
      + " | " + stage.status
      + " | " + (stage.duration / 1000).toFixed(1) + "s |\n"
  }
  report += "\n"
  report += "Total: "
    + (result.totalDuration / 1000).toFixed(1)
    + "s, Tokens: " + result.totalTokens
    + ", Cost: $" + result.totalCost.toFixed(3) + "\n\n"
 
  // 코드 리뷰 요약
  const reviewStage = result.stages.find(
    s => s.stage === "code-review"
  )
  if (reviewStage?.status === "success") {
    const review = reviewStage.output as ReviewResult
    report += "### Code Review\n\n"
    report += review.summary + "\n\n"
  }
 
  // PR 분석 요약
  const analysisStage = result.stages.find(
    s => s.stage === "pr-analysis"
  )
  if (analysisStage?.status === "success") {
    report += "### Change Analysis\n\n"
    const analysis = analysisStage.output as PRAnalysis
    report += analysis.summary + "\n\n"
  }
 
  // 테스트 생성 요약
  const testStage = result.stages.find(
    s => s.stage === "test-generation"
  )
  if (testStage?.status === "success") {
    const tests = testStage.output as TestGenerationResult
    report += "### Generated Tests\n\n"
    report += tests.generatedTests
      + " tests generated, "
      + tests.passedTests + " passed\n\n"
  }
 
  // 문서 분석 요약
  const docStage = result.stages.find(
    s => s.stage === "doc-analysis"
  )
  if (docStage?.status === "success") {
    const docs = docStage.output as DocImpact
    if (docs.affectedDocs.length > 0) {
      report += "### Documentation Impact\n\n"
      for (const doc of docs.affectedDocs) {
        report += "- `" + doc.filePath + "`: "
          + doc.affectedSections.join(", ") + "\n"
      }
      report += "\n"
    }
  }
 
  return report
}

name: AI Development Pipeline
 
on:
  pull_request:
    types: [opened, synchronize]
 
permissions:
  contents: read
  pull-requests: write
  checks: write
 
concurrency:
  group: ai-pipeline-$PR_NUMBER_VALUE
  cancel-in-progress: true
 
jobs:
  ai-pipeline:
    runs-on: ubuntu-latest
    if: |
      github.actor != 'dependabot[bot]' &&
      !contains(github.event.pull_request.title, '[skip-ai]')
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
 
      - uses: actions/setup-node@v4
        with:
          node-version: "20"
 
      - name: Cache dependencies
        uses: actions/cache@v4
        with:
          path: node_modules
          key: deps-$HASH_VALUE
 
      - run: npm install
 
      - name: Run AI Pipeline
        id: pipeline
        env:
          GITHUB_TOKEN: $GITHUB_TOKEN_VALUE
          ANTHROPIC_API_KEY: $ANTHROPIC_KEY_VALUE
          PR_NUMBER: $PR_NUMBER_VALUE
        run: node scripts/run-pipeline.js
 
      - name: Post Report
        if: always()
        env:
          GITHUB_TOKEN: $GITHUB_TOKEN_VALUE
        run: node scripts/post-report.js
 
      - name: Update Check Status
        if: always()
        env:
          GITHUB_TOKEN: $GITHUB_TOKEN_VALUE
        run: node scripts/update-check.js

interface CostTracker {
  // 현재 월간 사용량
  currentMonthUsage: {
    totalTokens: number
    totalCost: number
    byStage: Record<string, { tokens: number; cost: number }>
  }
  // 예산 설정
  budget: {
    monthlyLimit: number         // 월간 예산 한도
    perPRLimit: number           // PR당 예산 한도
    warningThreshold: number     // 경고 임계값 (0-1)
  }
}
 
function checkBudget(
  tracker: CostTracker,
  estimatedCost: number
): BudgetDecision {
  const monthlyRemaining =
    tracker.budget.monthlyLimit
    - tracker.currentMonthUsage.totalCost
 
  // 월간 예산 초과
  if (estimatedCost > monthlyRemaining) {
    return {
      allowed: false,
      reason: "Monthly budget exceeded",
      suggestion: "Reduce pipeline stages or wait until next month",
    }
  }
 
  // PR당 예산 초과
  if (estimatedCost > tracker.budget.perPRLimit) {
    return {
      allowed: false,
      reason: "Per-PR budget exceeded",
      suggestion: "Consider splitting the PR or reducing analysis scope",
    }
  }
 
  // 경고 임계값 도달
  const usageRatio = (
    tracker.currentMonthUsage.totalCost + estimatedCost
  ) / tracker.budget.monthlyLimit
 
  if (usageRatio > tracker.budget.warningThreshold) {
    return {
      allowed: true,
      warning: "Monthly budget usage at "
        + Math.round(usageRatio * 100) + "%",
    }
  }
 
  return { allowed: true }
}

비용 최적화 전략:
 
  모델 선택 최적화:
    - 간단한 분류 작업: 경량 모델 사용
    - 심층 코드 리뷰: 고성능 모델 사용
    - 문서 생성: 중간 성능 모델 사용
 
  캐싱:
    - 프로젝트 맥락을 캐시하여 매번 재수집 방지
    - 변경되지 않은 파일의 분석 결과 캐시
    - 동일 커밋에 대한 중복 분석 방지
 
  선택적 실행:
    - 변경 규모에 따른 단계 선택
    - 소규모 PR: 코드 리뷰만 실행
    - 대규모 PR: 전체 파이프라인 실행
 
  토큰 최적화:
    - 불필요한 코드 맥락 제거
    - 관련 없는 파일 제외
    - 프롬프트 길이 최적화

추적 메트릭:
 
  효과 메트릭:
    - AI가 발견한 문제 중 실제 수정된 비율
    - 생성된 테스트의 뮤테이션 점수
    - 문서 일관성 검사 통과율
    - 리뷰 시간 단축률
 
  비용 메트릭:
    - PR당 평균 비용
    - 월간 총 비용
    - 단계별 비용 분포
    - 토큰 효율성 (유용한 피드백 / 토큰)
 
  성능 메트릭:
    - 파이프라인 평균 실행 시간
    - 단계별 실행 시간
    - LLM API 응답 시간
    - 실패율