@elyun/bylane 1.29.0 → 1.31.0

package/src/pipeline.js

@@ -0,0 +1,195 @@
+/**
+ * pipeline.js
+ * 에이전트 파이프라인 상태 추적 및 cascade cancel
+ */
+import { readState, writeState } from './state.js'
+
+const STATE_DIR = '.bylane/state'
+
+/** 파이프라인별 에이전트 실행 순서 */
+export const PIPELINES = {
+  A: ['issue-agent', 'code-agent', 'test-agent', 'commit-agent', 'pr-agent', 'review-agent', 'notify-agent'],
+  B: ['code-agent', 'test-agent', 'commit-agent', 'pr-agent', 'review-agent', 'notify-agent'],
+  C_review: ['review-agent'],
+  C_respond: ['respond-agent'],
+  D: []   // 단일 에이전트, 동적 지정
+}
+
+/** 파이프라인 상태 기록 기본 TTL (30분) */
+export const PIPELINE_STALE_MS = 30 * 60 * 1000
+
+/**
+ * 파이프라인 시작 기록
+ * @param {{ type: string, issueNumber?: number, steps: string[] }} opts
+ */
+export function startPipeline({ type, issueNumber, steps }) {
+  const now = new Date().toISOString()
+  writeState('pipeline', {
+    status: 'in_progress',
+    pipelineType: type,
+    issueNumber: issueNumber ?? null,
+    startedAt: now,
+    currentStep: steps[0] ?? null,
+    steps: steps.map(agent => ({ agent, status: 'pending' }))
+  }, STATE_DIR)
+}
+
+/**
+ * 현재 파이프라인 단계 업데이트
+ * @param {string} agentName
+ * @param {'in_progress'|'completed'|'failed'} status
+ */
+export function updatePipelineStep(agentName, status) {
+  const pipeline = readState('pipeline', STATE_DIR)
+  if (!pipeline || pipeline.status !== 'in_progress') return
+
+  const steps = (pipeline.steps ?? []).map(step =>
+    step.agent === agentName
+      ? { ...step, status, [`${status}At`]: new Date().toISOString() }
+      : step
+  )
+
+  // 다음 단계 결정
+  const currentIdx = steps.findIndex(s => s.agent === agentName)
+  const nextStep = (status === 'completed' && currentIdx < steps.length - 1)
+    ? steps[currentIdx + 1].agent
+    : null
+
+  // 전체 완료 여부
+  const allDone = steps.every(s => s.status === 'completed')
+  const anyFailed = steps.some(s => s.status === 'failed')
+
+  writeState('pipeline', {
+    ...pipeline,
+    status: allDone ? 'completed' : anyFailed ? 'failed' : 'in_progress',
+    currentStep: nextStep ?? pipeline.currentStep,
+    steps
+  }, STATE_DIR)
+}
+
+/**
+ * 파이프라인 완료 처리
+ */
+export function completePipeline() {
+  const pipeline = readState('pipeline', STATE_DIR)
+  if (!pipeline) return
+  writeState('pipeline', {
+    ...pipeline,
+    status: 'completed',
+    completedAt: new Date().toISOString()
+  }, STATE_DIR)
+}
+
+/**
+ * 활성 파이프라인 조회
+ * @returns {Object|null}
+ */
+export function getActivePipeline() {
+  const pipeline = readState('pipeline', STATE_DIR)
+  if (!pipeline || pipeline.status !== 'in_progress') return null
+  return pipeline
+}
+
+/**
+ * stale 파이프라인 감지 및 cascade cancel.
+ * 파이프라인이 staleMs 동안 업데이트 없으면 하위 에이전트를 모두 cancelled 처리한다.
+ *
+ * @param {number} [staleMs=PIPELINE_STALE_MS]
+ * @returns {{ cancelled: string[], pipelineCancelled: boolean }}
+ */
+export function cancelStalePipeline(staleMs = PIPELINE_STALE_MS) {
+  const pipeline = readState('pipeline', STATE_DIR)
+  if (!pipeline || pipeline.status !== 'in_progress') {
+    return { cancelled: [], pipelineCancelled: false }
+  }
+
+  const lastUpdate = pipeline.updatedAt || pipeline.startedAt
+  const age = Date.now() - new Date(lastUpdate).getTime()
+  if (age < staleMs) {
+    return { cancelled: [], pipelineCancelled: false }
+  }
+
+  const now = new Date().toISOString()
+  const cancelled = []
+
+  // 파이프라인 소속 에이전트 중 in_progress/pending → cancelled
+  for (const step of pipeline.steps ?? []) {
+    if (step.status === 'in_progress' || step.status === 'pending') {
+      const agentState = readState(step.agent, STATE_DIR)
+      if (agentState && (agentState.status === 'in_progress' || agentState.status === 'idle')) {
+        writeState(step.agent, {
+          ...agentState,
+          status: 'cancelled',
+          cancelledAt: now,
+          reason: 'pipeline_stale'
+        }, STATE_DIR)
+        cancelled.push(step.agent)
+      }
+    }
+  }
+
+  // 파이프라인 자체도 cancelled
+  writeState('pipeline', {
+    ...pipeline,
+    status: 'cancelled',
+    cancelledAt: now,
+    reason: `${Math.floor(age / 60000)}분간 업데이트 없음`,
+    steps: (pipeline.steps ?? []).map(step =>
+      step.status === 'in_progress' || step.status === 'pending'
+        ? { ...step, status: 'cancelled', cancelledAt: now }
+        : step
+    )
+  }, STATE_DIR)
+
+  return { cancelled, pipelineCancelled: true }
+}
+
+/**
+ * 파이프라인에서 실패한 에이전트의 하류 에이전트를 blocked 처리한다.
+ * (cleanup에서 호출)
+ *
+ * @returns {{ blocked: string[] }}
+ */
+export function blockDownstreamOfFailed() {
+  const pipeline = readState('pipeline', STATE_DIR)
+  if (!pipeline || pipeline.status !== 'in_progress') {
+    return { blocked: [] }
+  }
+
+  const steps = pipeline.steps ?? []
+  const blocked = []
+  let foundFailed = false
+
+  for (const step of steps) {
+    if (step.status === 'failed') {
+      foundFailed = true
+      continue
+    }
+    // 실패 에이전트 이후의 pending 단계 → blocked
+    if (foundFailed && step.status === 'pending') {
+      const agentState = readState(step.agent, STATE_DIR)
+      if (!agentState || agentState.status === 'idle' || !agentState.status) {
+        writeState(step.agent, {
+          agent: step.agent,
+          status: 'blocked',
+          blockedAt: new Date().toISOString(),
+          reason: 'upstream_failed'
+        }, STATE_DIR)
+      }
+      blocked.push(step.agent)
+    }
+  }
+
+  if (blocked.length > 0) {
+    writeState('pipeline', {
+      ...pipeline,
+      steps: steps.map(step =>
+        blocked.includes(step.agent)
+          ? { ...step, status: 'blocked', blockedAt: new Date().toISOString() }
+          : step
+      )
+    }, STATE_DIR)
+  }
+
+  return { blocked }
+}

package/src/queue-utils.js

@@ -0,0 +1,119 @@
+/**
+ * queue-utils.js
+ * 큐 상태 관리 공용 유틸 — reconcile, expire, GC
+ */
+
+/** 큐 항목 TTL: 24시간 이상 pending이면 expired */
+export const QUEUE_TTL_MS = 24 * 60 * 60 * 1000
+
+/** GC 대상: resolved/expired 후 1시간 경과 시 제거 */
+export const GC_AGE_MS = 60 * 60 * 1000
+
+/**
+ * 현재 GitHub에서 가져온 PR 번호 목록과 큐를 대조하여
+ * 더 이상 액션이 필요 없는 항목을 resolved로 전환한다.
+ *
+ * @param {Array} queue  기존 큐 배열
+ * @param {Set<number>} activePrNumbers  현재 액션 필요한 PR 번호 Set
+ * @returns {{ queue: Array, resolvedCount: number }}
+ */
+export function reconcileQueue(queue, activePrNumbers) {
+  let resolvedCount = 0
+  const now = new Date().toISOString()
+
+  const result = queue.map(item => {
+    // pending인데 현재 GitHub에서 더 이상 해당 PR이 액션 필요 목록에 없음
+    if (item.status === 'pending' && !activePrNumbers.has(item.number)) {
+      resolvedCount++
+      return { ...item, status: 'resolved', resolvedAt: now, reason: 'no_longer_actionable' }
+    }
+    return item
+  })
+
+  return { queue: result, resolvedCount }
+}
+
+/**
+ * TTL 초과된 pending 항목을 expired로 전환한다.
+ *
+ * @param {Array} queue  큐 배열
+ * @param {number} [ttlMs=QUEUE_TTL_MS]  TTL (밀리초)
+ * @returns {{ queue: Array, expiredCount: number }}
+ */
+export function expireStaleItems(queue, ttlMs = QUEUE_TTL_MS) {
+  const now = Date.now()
+  let expiredCount = 0
+
+  const result = queue.map(item => {
+    if (item.status === 'pending' && item.detectedAt) {
+      const age = now - new Date(item.detectedAt).getTime()
+      if (age > ttlMs) {
+        expiredCount++
+        return { ...item, status: 'expired', expiredAt: new Date().toISOString() }
+      }
+    }
+    return item
+  })
+
+  return { queue: result, expiredCount }
+}
+
+/**
+ * resolved/expired 항목 중 일정 시간이 지난 것을 큐에서 제거한다.
+ *
+ * @param {Array} queue  큐 배열
+ * @param {number} [gcAgeMs=GC_AGE_MS]  GC 기준 시간 (밀리초)
+ * @returns {{ queue: Array, removedCount: number }}
+ */
+export function gcQueue(queue, gcAgeMs = GC_AGE_MS) {
+  const now = Date.now()
+  const before = queue.length
+
+  const result = queue.filter(item => {
+    if (item.status === 'resolved' || item.status === 'expired') {
+      const ts = item.resolvedAt || item.expiredAt
+      if (ts && now - new Date(ts).getTime() > gcAgeMs) {
+        return false
+      }
+    }
+    return true
+  })
+
+  return { queue: result, removedCount: before - result.length }
+}
+
+/**
+ * reconcile + expire + GC 를 한 번에 실행한다.
+ *
+ * @param {Array} queue  기존 큐 배열
+ * @param {Set<number>|null} activePrNumbers  현재 액션 필요한 PR 번호 Set (null이면 reconcile 생략)
+ * @param {{ ttlMs?: number, gcAgeMs?: number }} [opts]
+ * @returns {{ queue: Array, resolvedCount: number, expiredCount: number, removedCount: number }}
+ */
+export function maintainQueue(queue, activePrNumbers, opts = {}) {
+  const { ttlMs = QUEUE_TTL_MS, gcAgeMs = GC_AGE_MS } = opts
+
+  let resolvedCount = 0
+  let expiredCount = 0
+  let removedCount = 0
+  let current = queue
+
+  // 1. Reconcile (activePrNumbers가 있을 때만)
+  if (activePrNumbers) {
+    const r = reconcileQueue(current, activePrNumbers)
+    current = r.queue
+    resolvedCount = r.resolvedCount
+  }
+
+  // 2. Expire stale pending items
+  const e = expireStaleItems(current, ttlMs)
+  current = e.queue
+  expiredCount = e.expiredCount
+
+  // 3. GC resolved/expired items
+  const g = gcQueue(current, gcAgeMs)
+  current = g.queue
+  removedCount = g.removedCount
+
+  return { queue: current, resolvedCount, expiredCount, removedCount }
+}

package/src/respond-loop.js

@@ -9,6 +9,7 @@ import { mkdirSync } from 'fs'
 import { writeState, readState, appendLog } from './state.js'
 import { loadConfig } from './config.js'
 import { killExistingLoop, createAbsoluteTimer } from './loop-utils.js'
+import { maintainQueue } from './queue-utils.js'
 
 const config = loadConfig()
 const INTERVAL_MS = config.loop?.intervalMs ?? 300000
@@ -162,7 +163,21 @@ async function poll() {
     }
   }
 
-  saveQueue(Object.values(queueMap))
+  // 큐 유지보수: reconcile + expire + GC
+  const activePrNumbers = new Set(prs.map(pr => pr.number))
+  const maintained = maintainQueue(Object.values(queueMap), activePrNumbers)
+
+  if (maintained.resolvedCount > 0) {
+    appendLog('respond-loop', `${maintained.resolvedCount}개 항목 resolved (더 이상 액션 불필요)`, STATE_DIR)
+  }
+  if (maintained.expiredCount > 0) {
+    appendLog('respond-loop', `${maintained.expiredCount}개 항목 expired (TTL 초과)`, STATE_DIR)
+  }
+  if (maintained.removedCount > 0) {
+    appendLog('respond-loop', `${maintained.removedCount}개 완료 항목 GC 제거`, STATE_DIR)
+  }
+
+  saveQueue(maintained.queue)
 
   if (newCount > 0) {
     appendLog('respond-loop', `${newCount}개 PR이 큐에 추가됨`, STATE_DIR)
@@ -180,7 +195,14 @@ const { stop } = createAbsoluteTimer(poll, INTERVAL_MS)
 // 종료 처리
 function shutdown() {
   stop()
-  writeState('respond-loop', { status: 'stopped' }, STATE_DIR)
+  writeState('respond-loop', { status: 'stopped', stoppedAt: new Date().toISOString() }, STATE_DIR)
+
+  // 큐 상태도 stopped로 전환
+  const queueState = readState('respond-queue', STATE_DIR)
+  if (queueState) {
+    writeState('respond-queue', { ...queueState, status: 'stopped' }, STATE_DIR)
+  }
+
   process.exit(0)
 }
 process.on('SIGINT', shutdown)

package/src/review-loop.js

@@ -8,6 +8,7 @@ import { mkdirSync } from 'fs'
 import { writeState, readState, appendLog } from './state.js'
 import { loadConfig } from './config.js'
 import { killExistingLoop, createAbsoluteTimer } from './loop-utils.js'
+import { maintainQueue } from './queue-utils.js'
 
 const config = loadConfig()
 const INTERVAL_MS = config.loop?.intervalMs ?? 300000
@@ -109,7 +110,21 @@ async function poll() {
     }
   }
 
-  saveQueue(Object.values(queueMap))
+  // 큐 유지보수: reconcile + expire + GC
+  const activePrNumbers = new Set(prs.map(pr => pr.number))
+  const maintained = maintainQueue(Object.values(queueMap), activePrNumbers)
+
+  if (maintained.resolvedCount > 0) {
+    appendLog('review-loop', `${maintained.resolvedCount}개 항목 resolved (더 이상 리뷰 요청 없음)`, STATE_DIR)
+  }
+  if (maintained.expiredCount > 0) {
+    appendLog('review-loop', `${maintained.expiredCount}개 항목 expired (TTL 초과)`, STATE_DIR)
+  }
+  if (maintained.removedCount > 0) {
+    appendLog('review-loop', `${maintained.removedCount}개 완료 항목 GC 제거`, STATE_DIR)
+  }
+
+  saveQueue(maintained.queue)
 
   if (newCount > 0) {
     appendLog('review-loop', `${newCount}개 PR이 큐에 추가됨`, STATE_DIR)
@@ -127,7 +142,14 @@ const { stop } = createAbsoluteTimer(poll, INTERVAL_MS)
 // 종료 처리
 function shutdown() {
   stop()
-  writeState('review-loop', { status: 'stopped' }, STATE_DIR)
+  writeState('review-loop', { status: 'stopped', stoppedAt: new Date().toISOString() }, STATE_DIR)
+
+  // 큐 상태도 stopped로 전환
+  const queueState = readState('review-queue', STATE_DIR)
+  if (queueState) {
+    writeState('review-queue', { ...queueState, status: 'stopped' }, STATE_DIR)
+  }
+
   process.exit(0)
 }
 process.on('SIGINT', shutdown)

package/tests/pipeline.test.js

@@ -0,0 +1,171 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdirSync, rmSync, writeFileSync } from 'fs'
+import { join } from 'path'
+import { writeState, readState } from '../src/state.js'
+import {
+  startPipeline, updatePipelineStep, completePipeline,
+  getActivePipeline, cancelStalePipeline, blockDownstreamOfFailed,
+  PIPELINES
+} from '../src/pipeline.js'
+
+const STATE_DIR = '.bylane/state'
+
+beforeEach(() => mkdirSync(STATE_DIR, { recursive: true }))
+afterEach(() => rmSync('.bylane', { recursive: true, force: true }))
+
+describe('startPipeline', () => {
+  it('파이프라인 상태를 기록한다', () => {
+    startPipeline({ type: 'A', issueNumber: 42, steps: PIPELINES.A })
+    const state = readState('pipeline', STATE_DIR)
+
+    expect(state.status).toBe('in_progress')
+    expect(state.pipelineType).toBe('A')
+    expect(state.issueNumber).toBe(42)
+    expect(state.currentStep).toBe('issue-agent')
+    expect(state.steps).toHaveLength(7)
+    expect(state.steps[0]).toMatchObject({ agent: 'issue-agent', status: 'pending' })
+  })
+})
+
+describe('updatePipelineStep', () => {
+  it('에이전트 상태를 업데이트하고 다음 단계로 이동한다', () => {
+    startPipeline({ type: 'B', steps: ['code-agent', 'test-agent', 'commit-agent'] })
+
+    updatePipelineStep('code-agent', 'in_progress')
+    let state = readState('pipeline', STATE_DIR)
+    expect(state.steps[0].status).toBe('in_progress')
+
+    updatePipelineStep('code-agent', 'completed')
+    state = readState('pipeline', STATE_DIR)
+    expect(state.steps[0].status).toBe('completed')
+    expect(state.currentStep).toBe('test-agent')
+    expect(state.status).toBe('in_progress')
+  })
+
+  it('마지막 에이전트 완료 시 파이프라인도 completed', () => {
+    startPipeline({ type: 'D', steps: ['review-agent'] })
+    updatePipelineStep('review-agent', 'completed')
+    const state = readState('pipeline', STATE_DIR)
+    expect(state.status).toBe('completed')
+  })
+
+  it('에이전트 실패 시 파이프라인 상태가 failed', () => {
+    startPipeline({ type: 'B', steps: ['code-agent', 'test-agent'] })
+    updatePipelineStep('code-agent', 'failed')
+    const state = readState('pipeline', STATE_DIR)
+    expect(state.status).toBe('failed')
+  })
+
+  it('파이프라인이 없으면 무시한다', () => {
+    // 에러 없이 실행되어야 함
+    updatePipelineStep('code-agent', 'completed')
+  })
+})
+
+describe('completePipeline', () => {
+  it('파이프라인을 완료 처리한다', () => {
+    startPipeline({ type: 'A', steps: ['issue-agent'] })
+    completePipeline()
+    const state = readState('pipeline', STATE_DIR)
+    expect(state.status).toBe('completed')
+    expect(state.completedAt).toBeTruthy()
+  })
+})
+
+describe('getActivePipeline', () => {
+  it('in_progress 파이프라인을 반환한다', () => {
+    startPipeline({ type: 'A', steps: ['issue-agent'] })
+    expect(getActivePipeline()).toBeTruthy()
+  })
+
+  it('completed 파이프라인은 null', () => {
+    startPipeline({ type: 'A', steps: ['issue-agent'] })
+    completePipeline()
+    expect(getActivePipeline()).toBeNull()
+  })
+
+  it('파이프라인 없으면 null', () => {
+    expect(getActivePipeline()).toBeNull()
+  })
+})
+
+describe('cancelStalePipeline', () => {
+  it('stale 파이프라인의 에이전트를 cascade cancel한다', () => {
+    // 30분 전에 시작된 파이프라인 시뮬레이션 — writeState는 updatedAt을 현재로 덮어쓰므로 직접 작성
+    const oldTime = new Date(Date.now() - 31 * 60 * 1000).toISOString()
+    writeFileSync(join(STATE_DIR, 'pipeline.json'), JSON.stringify({
+      agent: 'pipeline',
+      status: 'in_progress',
+      pipelineType: 'B',
+      startedAt: oldTime,
+      updatedAt: oldTime,
+      currentStep: 'code-agent',
+      steps: [
+        { agent: 'code-agent', status: 'in_progress' },
+        { agent: 'test-agent', status: 'pending' }
+      ],
+      log: []
+    }, null, 2))
+    // 에이전트 상태도 생성
+    writeState('code-agent', { status: 'in_progress', startedAt: oldTime }, STATE_DIR)
+
+    const result = cancelStalePipeline()
+
+    expect(result.pipelineCancelled).toBe(true)
+    expect(result.cancelled).toContain('code-agent')
+
+    const codeState = readState('code-agent', STATE_DIR)
+    expect(codeState.status).toBe('cancelled')
+    expect(codeState.reason).toBe('pipeline_stale')
+
+    const pipelineState = readState('pipeline', STATE_DIR)
+    expect(pipelineState.status).toBe('cancelled')
+  })
+
+  it('fresh 파이프라인은 건드리지 않는다', () => {
+    startPipeline({ type: 'A', steps: ['issue-agent'] })
+    const result = cancelStalePipeline()
+    expect(result.pipelineCancelled).toBe(false)
+    expect(readState('pipeline', STATE_DIR).status).toBe('in_progress')
+  })
+
+  it('파이프라인이 없으면 아무것도 안 한다', () => {
+    const result = cancelStalePipeline()
+    expect(result.cancelled).toEqual([])
+  })
+})
+
+describe('blockDownstreamOfFailed', () => {
+  it('실패 에이전트 하류를 blocked 처리한다', () => {
+    writeState('pipeline', {
+      status: 'in_progress',
+      steps: [
+        { agent: 'code-agent', status: 'completed' },
+        { agent: 'test-agent', status: 'failed' },
+        { agent: 'commit-agent', status: 'pending' },
+        { agent: 'pr-agent', status: 'pending' }
+      ]
+    }, STATE_DIR)
+
+    const result = blockDownstreamOfFailed()
+
+    expect(result.blocked).toEqual(['commit-agent', 'pr-agent'])
+
+    const commitState = readState('commit-agent', STATE_DIR)
+    expect(commitState.status).toBe('blocked')
+    expect(commitState.reason).toBe('upstream_failed')
+  })
+
+  it('실패 없으면 아무것도 안 한다', () => {
+    writeState('pipeline', {
+      status: 'in_progress',
+      steps: [
+        { agent: 'code-agent', status: 'completed' },
+        { agent: 'test-agent', status: 'in_progress' }
+      ]
+    }, STATE_DIR)
+
+    const result = blockDownstreamOfFailed()
+    expect(result.blocked).toEqual([])
+  })
+})