@angli/unit-test-tool 0.1.0

package/src/core/tools/analyze-baseline.ts

@@ -0,0 +1,61 @@
+import path from 'node:path'
+import type { AppContext } from '../../cli/context/create-context.js'
+import type { AnalyzeBaselineResult } from '../../types/index.js'
+import { deriveStatusFromPhase } from '../state-machine/index.js'
+import { runAndReadCoverage } from '../coverage/read-coverage-summary.js'
+
+export async function analyzeBaseline(ctx: AppContext): Promise<AnalyzeBaselineResult> {
+  await ctx.fileSystem.ensureDir(ctx.paths.runtimeDir)
+  await ctx.fileSystem.ensureDir(ctx.paths.logsPath)
+  await ctx.fileSystem.ensureDir(ctx.paths.promptsDir)
+  await ctx.fileSystem.ensureDir(ctx.paths.promptRunsDir)
+  await ctx.fileSystem.ensureDir(ctx.paths.reportsDir)
+
+  const packageJson = await ctx.fileSystem.readJson<{ scripts?: Record<string, string> }>(path.join(ctx.projectPath, 'package.json'))
+  const framework = detectFramework(packageJson?.scripts ?? {})
+  const coverageSnapshot = await runAndReadCoverage(ctx)
+
+  await ctx.reportStore.saveCoverageSummary({
+    framework,
+    coverageSnapshot
+  })
+
+  const state = await ctx.stateStore.load()
+  const nextState = {
+    ...state,
+    phase: 'ANALYZE_BASELINE' as const,
+    status: deriveStatusFromPhase('ANALYZE_BASELINE'),
+    coverageSnapshot,
+    lastAction: 'analyze-baseline',
+    nextSuggestedAction: 'run',
+    updatedAt: ctx.clock.nowIso()
+  }
+  await ctx.stateStore.save(nextState)
+
+  await ctx.eventStore.append({
+    eventType: 'baseline_analyzed',
+    phase: 'ANALYZE_BASELINE',
+    message: `baseline coverage lines=${coverageSnapshot.lines ?? 'unknown'}`,
+    data: { framework, coverageSnapshot },
+    timestamp: ctx.clock.nowIso()
+  })
+
+  return {
+    ok: true,
+    phase: 'ANALYZE_BASELINE',
+    summary: `完成真实覆盖率基线分析，lines=${coverageSnapshot.lines ?? 'unknown'}%。`,
+    nextAction: 'run',
+    artifacts: {
+      coverageSummaryPath: ctx.paths.coverageSummaryPath
+    },
+    coverageSnapshot,
+    testFramework: framework
+  }
+}
+
+function detectFramework(scripts: Record<string, string>): 'jest' | 'vitest' | 'unknown' {
+  const scriptValues = Object.values(scripts).join(' ')
+  if (scriptValues.includes('vitest')) return 'vitest'
+  if (scriptValues.includes('jest')) return 'jest'
+  return 'unknown'
+}

package/src/core/tools/guard.ts

@@ -0,0 +1,89 @@
+import { execa } from 'execa'
+import type { AppContext } from '../../cli/context/create-context.js'
+
+export interface GuardOptions {
+  staleTimeoutMs?: number
+  maxRestart?: number
+  cooldownMs?: number
+}
+
+const DEFAULT_STALE_TIMEOUT_MS = 2 * 60_000
+const DEFAULT_MAX_RESTART = 3
+const DEFAULT_COOLDOWN_MS = 60_000
+
+export async function runGuard(ctx: AppContext, options: GuardOptions = {}): Promise<{ recovered: boolean; summary: string }> {
+  const lifecycle = await ctx.lifecycleStore.load()
+  if (!lifecycle) {
+    return { recovered: false, summary: '未找到 lifecycle 记录。' }
+  }
+
+  const staleTimeoutMs = options.staleTimeoutMs ?? DEFAULT_STALE_TIMEOUT_MS
+  const maxRestart = options.maxRestart ?? DEFAULT_MAX_RESTART
+  const cooldownMs = options.cooldownMs ?? DEFAULT_COOLDOWN_MS
+  const now = Date.now()
+  const lastHeartbeat = Date.parse(lifecycle.lastHeartbeat)
+  const isStale = Number.isFinite(lastHeartbeat) && now - lastHeartbeat > staleTimeoutMs
+  const isAbnormal = (lifecycle.status === 'running' && isStale) || lifecycle.status === 'crashed'
+
+  if (!isAbnormal) {
+    return { recovered: false, summary: `无需恢复：status=${lifecycle.status}` }
+  }
+
+  if (lifecycle.command !== 'start') {
+    return { recovered: false, summary: `检测到 ${lifecycle.command} 异常，但按设计不自动恢复。` }
+  }
+
+  if (lifecycle.restartCount >= maxRestart) {
+    return { recovered: false, summary: `已达到最大恢复次数 ${maxRestart}。` }
+  }
+
+  const updatedAt = Date.parse(lifecycle.updatedAt)
+  if (Number.isFinite(updatedAt) && now - updatedAt < cooldownMs) {
+    return { recovered: false, summary: `仍处于冷却期，稍后再试。` }
+  }
+
+  const nextRestartCount = lifecycle.restartCount + 1
+  const recoveringAt = ctx.clock.nowIso()
+  await ctx.lifecycleStore.patch({
+    status: 'recovering',
+    restartCount: nextRestartCount,
+    updatedAt: recoveringAt,
+    lastError: lifecycle.lastError ?? (isStale ? 'heartbeat stale' : 'crashed')
+  })
+  await ctx.eventStore.append({
+    eventType: 'lifecycle_recovering',
+    phase: 'BLOCKED',
+    message: `recover start process #${nextRestartCount}`,
+    data: { argv: lifecycle.argv },
+    timestamp: recoveringAt
+  })
+
+  const child = execa(process.execPath, lifecycle.argv, {
+    cwd: ctx.projectPath,
+    detached: true,
+    stdio: 'ignore'
+  })
+  child.unref()
+
+  return { recovered: true, summary: `已触发恢复，第 ${nextRestartCount} 次。` }
+}
+
+export async function runSchedule(
+  ctx: AppContext,
+  intervalMs: number,
+  guardOptions: GuardOptions = {}
+): Promise<void> {
+  await runGuard(ctx, guardOptions)
+  setInterval(async () => {
+    try {
+      await runGuard(ctx, guardOptions)
+    } catch (error) {
+      await ctx.eventStore.append({
+        eventType: 'schedule_guard_failed',
+        phase: 'BLOCKED',
+        message: error instanceof Error ? error.message : String(error),
+        timestamp: ctx.clock.nowIso()
+      })
+    }
+  }, intervalMs)
+}

package/src/core/tools/run-loop.ts

@@ -0,0 +1,142 @@
+import type { AppContext } from '../../cli/context/create-context.js'
+import type { BaseToolResult } from '../../types/index.js'
+import { analyzeBaseline } from './analyze-baseline.js'
+import { runWithClaudeCli } from './run-with-claude-cli.js'
+import { buildFinalReport } from '../reporter/index.js'
+
+export interface RunLoopInput {
+  targetFile?: string
+  topN?: number
+  allowedTools?: string[]
+  permissionMode?: string
+  timeoutMs?: number
+}
+
+export async function runLoop(
+  ctx: AppContext,
+  input: RunLoopInput = {}
+): Promise<BaseToolResult & { targetFile?: string }> {
+  await analyzeBaseline(ctx)
+
+  const attemptedTargets = new Set<string>()
+  let iterationCount = 0
+  let completedTargets = 0
+  let blockedTargets = 0
+  let noOpTargets = 0
+  let lastCompletedTarget: string | undefined
+  let lastResult: (BaseToolResult & { targetFile?: string }) | undefined
+
+  const maxIterations = input.targetFile ? 1 : Math.max(1, ctx.limits.maxIterationsPerRun)
+
+  let lastCoverage: number | undefined
+
+  while (iterationCount < maxIterations) {
+    iterationCount += 1
+    const result = await runWithClaudeCli(ctx, {
+      ...input,
+      excludeTargets: input.targetFile ? undefined : [...attemptedTargets]
+    })
+    lastResult = result
+
+    if (result.targetFile) attemptedTargets.add(result.targetFile)
+
+
+    const coverageSummary = await ctx.reportStore.loadCoverageSummary<{ coverageSnapshot?: { lines?: number } }>()
+    const currentCoverage = coverageSummary?.coverageSnapshot?.lines
+    lastCoverage = currentCoverage
+    if (currentCoverage !== undefined && currentCoverage >= ctx.coverageTarget) {
+      break
+    }
+
+    if (result.ok) {
+      completedTargets += 1
+      lastCompletedTarget = result.targetFile
+      await syncLoopSummary(ctx, {
+        iterationCount,
+        completedTargets,
+        blockedTargets,
+        noOpTargets,
+        lastCompletedTarget
+      })
+      continue
+    }
+
+    if (result.summary.includes('no-op')) {
+      noOpTargets += 1
+    } else {
+      blockedTargets += 1
+    }
+
+    await syncLoopSummary(ctx, {
+      iterationCount,
+      completedTargets,
+      blockedTargets,
+      noOpTargets,
+      lastCompletedTarget
+    })
+
+    if (input.targetFile) break
+    if (blockedTargets >= Math.max(1, ctx.limits.maxRetryPerTask)) break
+    if (noOpTargets >= Math.max(1, ctx.limits.loopThreshold)) break
+    if (!result.targetFile) break
+  }
+
+  const finalLoopSummary = {
+    iterationCount,
+    completedTargets,
+    blockedTargets,
+    noOpTargets,
+    lastCompletedTarget
+  }
+  await syncLoopSummary(ctx, finalLoopSummary)
+
+  const report = await buildFinalReport(ctx)
+  await ctx.reportStore.saveFinalReport(report)
+
+  if (!lastResult) {
+    return {
+      ok: false,
+      phase: 'BLOCKED',
+      summary: '自动执行未产生任何任务结果。',
+      nextAction: 'manual-intervention'
+    }
+  }
+
+  const summaryParts = [
+    `completed=${completedTargets}`,
+    `blocked=${blockedTargets}`,
+    `noop=${noOpTargets}`,
+    `iterations=${iterationCount}`
+  ]
+  if (lastCoverage !== undefined) {
+    summaryParts.push(`coverage=${lastCoverage}/${ctx.coverageTarget}`)
+  }
+
+  return {
+    ...lastResult,
+    artifacts: {
+      ...lastResult.artifacts,
+      finalReportPath: ctx.paths.finalReportPath,
+      loopSummary: JSON.stringify(finalLoopSummary)
+    },
+    summary: `自动执行结束：${summaryParts.join(', ')}`
+  }
+}
+
+async function syncLoopSummary(
+  ctx: AppContext,
+  loopSummary: {
+    iterationCount: number
+    completedTargets: number
+    blockedTargets: number
+    noOpTargets: number
+    lastCompletedTarget?: string
+  }
+) {
+  const state = await ctx.stateStore.load()
+  await ctx.stateStore.save({
+    ...state,
+    loopSummary,
+    updatedAt: ctx.clock.nowIso()
+  })
+}