@angli/unit-test-tool 0.1.0

package/src/core/tools/verify-all.ts

@@ -0,0 +1,83 @@
+import path from 'node:path'
+import type { AppContext } from '../../cli/context/create-context.js'
+import type { VerifyAllResult } from '../../types/index.js'
+import { readCoverageSummary } from '../coverage/read-coverage-summary.js'
+
+export async function verifyAll(ctx: AppContext): Promise<VerifyAllResult> {
+  const testDirs = await detectTestDirNames(ctx)
+  ctx.logger.info(`[verify] step=test-dirs value=${testDirs.join(',')}`)
+  ctx.logger.info(`[verify] step=run status=start cmd=${ctx.commands.verifyFull}`)
+  const verifyResult = await ctx.commandRunner.run(ctx.commands.verifyFull)
+
+  if (verifyResult.exitCode !== 0) {
+    if (verifyResult.stdout) console.log(`[verify] stdout:\n${verifyResult.stdout}`)
+    if (verifyResult.stderr) console.log(`[verify] stderr:\n${verifyResult.stderr}`)
+  }
+
+  const ok = verifyResult.exitCode === 0
+  const coverageSnapshot = ok ? await readCoverageSummary(ctx) : undefined
+  const coverageValue = coverageSnapshot?.lines
+  const coveragePassed = ok ? coverageValue !== undefined && coverageValue >= ctx.coverageTarget : false
+
+  ctx.logger.info(`[verify] step=run status=done ok=${ok} exit=${verifyResult.exitCode} coverage=${coverageValue ?? 'unknown'} target=${ctx.coverageTarget}`)
+
+  const state = await ctx.stateStore.load()
+  const nextState = {
+    ...state,
+    phase: 'VERIFYING_FULL' as const,
+    status: (ok ? 'running' : 'failed') as 'running' | 'failed',
+    lastAction: 'verify-all',
+    nextSuggestedAction: ok ? 'report' : 'manual-intervention',
+    updatedAt: ctx.clock.nowIso()
+  }
+  await ctx.stateStore.save(nextState)
+
+  if (ok) {
+    await ctx.eventStore.append({
+      eventType: 'verify_full_passed',
+      phase: 'VERIFYING_FULL',
+      message: `verify all passed, coverage=${coverageValue ?? 'unknown'} target=${ctx.coverageTarget}`,
+      data: { coverageSnapshot, coverageTarget: ctx.coverageTarget },
+      timestamp: ctx.clock.nowIso()
+    })
+  } else {
+    await ctx.eventStore.append({
+      eventType: 'verify_full_failed',
+      phase: 'VERIFYING_FULL',
+      message: 'verify all failed',
+      data: { stderr: verifyResult.stderr },
+      timestamp: ctx.clock.nowIso()
+    })
+  }
+
+  return {
+    ok,
+    phase: 'VERIFYING_FULL',
+    summary: ok ? '全量验证通过。' : '全量验证失败。',
+    nextAction: ok ? 'report' : 'manual-intervention',
+    artifacts: {
+      stdout: verifyResult.stdout,
+      stderr: verifyResult.stderr
+    },
+    coveragePassed,
+    testPassed: ok,
+    coverageSnapshot
+  }
+}
+
+async function detectTestDirNames(ctx: AppContext): Promise<string[]> {
+  if (ctx.cache.detectedTestDirNames) return ctx.cache.detectedTestDirNames
+
+  const configured = ctx.config.testDirNames?.filter(Boolean) ?? ['__test__', '__tests__']
+  const jestConfigPath = path.join(ctx.projectPath, 'jest.config.js')
+  const jestConfig = await ctx.fileSystem.readText(jestConfigPath)
+  if (!jestConfig) {
+    ctx.cache.detectedTestDirNames = configured
+    return configured
+  }
+
+  const detected = configured.filter((dir) => jestConfig.includes(dir))
+  const result = detected.length > 0 ? detected : configured
+  ctx.cache.detectedTestDirNames = result
+  return result
+}

package/src/core/worktrees/is-git-repo.ts

@@ -0,0 +1,10 @@
+import { execa } from 'execa'
+
+export async function isGitRepo(projectPath: string): Promise<boolean> {
+  try {
+    await execa('git', ['rev-parse', '--is-inside-work-tree'], { cwd: projectPath })
+    return true
+  } catch {
+    return false
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,291 @@
+export type WorkflowPhase = 'INIT' | 'ANALYZE_BASELINE' | 'WRITING_TESTS' | 'VERIFYING_FULL' | 'BLOCKED' | 'DONE'
+
+export interface AppRuntimeCache {
+  detectedTestDirNames?: string[]
+  testFilesByBaseName?: Record<string, string[]>
+  attemptedTargets?: string[]
+}
+
+export interface RuntimePaths {
+  runtimeDir: string
+  configPath: string
+  statePath: string
+  logsPath: string
+  promptsDir: string
+  promptRunsDir: string
+  eventsPath: string
+  reportsDir: string
+  coverageSummaryPath: string
+  finalReportPath: string
+  lifecyclePath: string
+}
+
+export interface RuntimeLimits {
+  maxIterationsPerRun: number
+  maxRetryPerTask: number
+  loopThreshold: number
+  concurrency: number
+  llmTopN: number
+  llmAdjustRange: number
+}
+
+export interface CommandSet {
+  analyzeBaseline: string
+  verifyFull: string
+  incrementalTest(targetFile?: string): string
+  lint: string
+  typecheck: string
+  format?: string
+}
+
+export interface PromptBuilderSet {
+  buildSystemPrompt(): string
+  buildTaskPrompt(task: TaskItem): string
+  buildRetryPrompt(task: TaskItem, failure: string): string
+  buildEditBoundaryPrompt(task: TaskItem): string
+}
+
+export interface PromptOverridesConfig {
+  systemAppend?: string
+  taskAppend?: string
+  retryAppend?: string
+}
+
+export interface TestBotConfig {
+  projectPath: string
+  coverageTarget: number
+  testFramework?: 'jest' | 'vitest' | 'unknown'
+  include: string[]
+  exclude: string[]
+  mode: 'serial' | 'parallel'
+  concurrency?: number
+  maxIterationsPerRun?: number
+  maxRetryPerTask?: number
+  loopThreshold?: number
+  allowSourceEdit?: boolean
+  testDirNames?: string[]
+  commandOverrides?: Partial<Record<'analyzeBaseline' | 'verifyFull' | 'lint' | 'typecheck' | 'format' | 'incrementalTest', string>>
+  priorityPaths?: string[]
+  deferredPaths?: string[]
+  excludePaths?: string[]
+  llmTopN?: number
+  llmAdjustRange?: number
+  logLevel?: string
+  promptOverrides?: PromptOverridesConfig
+}
+
+export type LifecycleStatus = 'running' | 'exited' | 'crashed' | 'recovering'
+
+export interface LifecycleFile {
+  runId: string
+  command: 'start' | 'run'
+  pid: number
+  argv: string[]
+  startedAt: string
+  lastHeartbeat: string
+  status: LifecycleStatus
+  exitCode?: number
+  restartCount: number
+  lastError?: string
+  updatedAt: string
+}
+
+export interface CoverageSnapshot {
+  lines?: number
+  statements?: number
+  functions?: number
+  branches?: number
+  rawSummary?: string
+  sourceFileCount?: number
+  testFileCount?: number
+  lowCoverageFiles?: string[]
+  coverageGap?: number
+  fileEntries?: Record<string, {
+    lines?: number
+    statements?: number
+    functions?: number
+    branches?: number
+  }>
+}
+
+export interface CandidateFile {
+  targetFile: string
+  matchedPriority?: 'priority' | 'normal' | 'deferred' | 'excluded'
+}
+
+export interface AnalyzerFacts {
+  targetFile: string
+  coverage: {
+    lineRate?: number
+    branchRate?: number
+    coverageGap?: number
+  }
+  pathPriority: {
+    label: 'priority' | 'normal' | 'deferred' | 'excluded'
+    score: number
+    matchedPath?: string
+  }
+  fileClassification: {
+    ruleCategory?: string
+    semanticCategory?: string
+    uiSignal?: boolean
+    domSignal?: boolean
+    frameworkSignal?: boolean
+  }
+  dependencyComplexity: {
+    importCount: number
+    externalDependencyCount: number
+    complexityLevel: 'low' | 'medium' | 'high'
+    hiddenCouplingRisk?: 'low' | 'medium' | 'high'
+  }
+  existingTest: {
+    hasExistingTest: boolean
+    testFilePaths: string[]
+    partialCoverageLikely?: boolean
+  }
+  failureHistory: {
+    previousAttemptCount: number
+    loopDetected: boolean
+    blockedBefore: boolean
+    failurePenaltyScore: number
+    lastFailureCategory?: string
+  }
+  llmSemantic?: {
+    priorityGroup?: 'P0' | 'P1' | 'P2'
+    strategySuggestion?: string
+    businessReason?: string
+    deferReason?: string
+    riskTag?: 'low' | 'medium' | 'high'
+    testabilityScoreAdjustment?: number
+  }
+  analyzerWarnings?: string[]
+}
+
+export interface TaskItem {
+  taskId: string
+  targetFile: string
+  testFiles: string[]
+  score: number
+  reasons: string[]
+  estimatedDifficulty: 'low' | 'medium' | 'high'
+  strategy: string
+  status: 'pending' | 'running' | 'passed' | 'failed' | 'blocked'
+  attemptCount: number
+  failureCategory?: string
+  lastError?: string
+  priorityGroup?: 'P0' | 'P1' | 'P2'
+  businessReason?: string
+  deferReason?: string
+  riskTag?: 'low' | 'medium' | 'high'
+  testDirNames?: string[]
+  analyzerFacts?: AnalyzerFacts
+}
+
+export interface RuleRankedCandidate {
+  taskId: string
+  targetFile: string
+  baseScore: number
+  pathPriority: 'priority' | 'normal' | 'deferred'
+  estimatedDifficulty: 'low' | 'medium' | 'high'
+  reasons: string[]
+  suggestedStrategy?: string
+  analyzerFacts: AnalyzerFacts
+}
+
+export interface StateFile {
+  phase: WorkflowPhase
+  status: 'idle' | 'running' | 'blocked' | 'done' | 'failed'
+  currentTaskId?: string
+  lastError?: string
+  coverageSnapshot?: CoverageSnapshot
+  totals: {
+    pending: number
+    running: number
+    passed: number
+    failed: number
+    blocked: number
+  }
+  loopSummary?: {
+    iterationCount: number
+    completedTargets: number
+    blockedTargets: number
+    noOpTargets: number
+    lastCompletedTarget?: string
+  }
+  lastAction?: string
+  nextSuggestedAction?: string
+  updatedAt: string
+}
+
+export interface EventRecord {
+  eventType: string
+  phase: WorkflowPhase
+  taskId?: string
+  message: string
+  data?: Record<string, unknown>
+  timestamp: string
+}
+
+export interface BaseToolResult {
+  ok: boolean
+  phase: WorkflowPhase
+  summary: string
+  nextAction?: string
+  artifacts?: Record<string, string | string[] | undefined>
+  errors?: Array<{ code: string; message: string }>
+}
+
+export interface AnalyzeBaselineResult extends BaseToolResult {
+  coverageSnapshot?: CoverageSnapshot
+  testFramework?: TestBotConfig['testFramework']
+}
+
+export interface VerifyAllResult extends BaseToolResult {
+  coveragePassed: boolean
+  testPassed: boolean
+  coverageSnapshot?: CoverageSnapshot
+}
+
+export interface ClaudeCliExecutionInput {
+  cwd: string
+  prompt: string
+  systemPrompt?: string
+  appendSystemPrompt?: string
+  allowedTools?: string[]
+  permissionMode?: string
+  outputFormat?: 'text' | 'json' | 'stream-json'
+  timeoutMs?: number
+  onProgress?: (elapsedMs: number) => void
+  taskMeta: {
+    taskId: string
+    targetFile: string
+    strategy: string
+    attemptCount: number
+  }
+}
+
+export interface ClaudeCliExecutionResult {
+  ok: boolean
+  exitCode: number | null
+  stdout: string
+  stderr: string
+  durationMs: number
+  failureCategory?:
+    | 'CLI_NOT_FOUND'
+    | 'CLI_EXIT_NON_ZERO'
+    | 'CLI_TIMEOUT'
+    | 'OUTPUT_PARSE_FAILED'
+    | 'PERMISSION_DENIED'
+    | 'RUNTIME_ENV_ERROR'
+  taskMeta: ClaudeCliExecutionInput['taskMeta']
+}
+
+export interface FinalReport {
+  generatedAt: string
+  totals: StateFile['totals']
+  blockedTasks: string[]
+  failedTasks: string[]
+  coveragePassed: boolean
+  loopSummary?: StateFile['loopSummary']
+  suggestedNextAction?: string
+}

package/src/types/logger.ts

@@ -0,0 +1,6 @@
+export interface Logger {
+  info(message: string, meta?: Record<string, unknown>): void
+  warn(message: string, meta?: Record<string, unknown>): void
+  error(message: string, meta?: Record<string, unknown>): void
+  debug(message: string, meta?: Record<string, unknown>): void
+}

package/src/utils/clock.ts

@@ -0,0 +1,10 @@
+export function createClock() {
+  return {
+    now(): Date {
+      return new Date()
+    },
+    nowIso(): string {
+      return new Date().toISOString()
+    }
+  }
+}

package/src/utils/command-runner.ts

@@ -0,0 +1,24 @@
+import { execa } from 'execa'
+
+export interface CommandRunnerOptions {
+  cwd: string
+}
+
+export function createCommandRunner(options: CommandRunnerOptions) {
+  return {
+    async run(command: string, timeoutMs = 120000): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+      const result = await execa(command, {
+        cwd: options.cwd,
+        shell: true,
+        reject: false,
+        timeout: timeoutMs
+      })
+
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode ?? 0
+      }
+    }
+  }
+}

package/src/utils/commands.ts

@@ -0,0 +1,42 @@
+import type { CommandSet, TestBotConfig } from '../types/index.js'
+
+export interface ScriptMap {
+  test?: string
+  lint?: string
+  typecheck?: string
+  'test:coverage'?: string
+}
+
+export function buildCommandSet(config: TestBotConfig, scripts: ScriptMap = {}): CommandSet {
+  const verifyFromScript = scripts.test ? 'npm test' : undefined
+  const coverageScript = scripts['test:coverage'] ? 'npm run test:coverage' : undefined
+  const lintScript = scripts.lint ? 'npm run lint' : undefined
+  const typecheckScript = scripts.typecheck ? 'npm run typecheck' : undefined
+
+  return {
+    analyzeBaseline:
+      config.commandOverrides?.analyzeBaseline ??
+      coverageScript ??
+      'npm test -- --coverage --runInBand',
+    verifyFull:
+      config.commandOverrides?.verifyFull ??
+      verifyFromScript ??
+      'npm test -- --runInBand',
+    incrementalTest: (targetFile?: string) => {
+      const base =
+        config.commandOverrides?.incrementalTest ??
+        verifyFromScript ??
+        'npm test -- --runInBand'
+      if (!targetFile) {
+        return base
+      }
+      return `${base} ${JSON.stringify(targetFile)}`
+    },
+    lint: config.commandOverrides?.lint ?? lintScript ?? 'npm run lint',
+    typecheck:
+      config.commandOverrides?.typecheck ??
+      typecheckScript ??
+      'npx tsc -p tsconfig.json --noEmit',
+    format: config.commandOverrides?.format ?? 'npm run lint'
+  }
+}

package/src/utils/duration.ts

@@ -0,0 +1,20 @@
+export function parseDuration(input: string): number | undefined {
+  const trimmed = input.trim()
+  if (!trimmed) return undefined
+  const match = trimmed.match(/^(\d+)(ms|s|m|h)?$/)
+  if (!match) return undefined
+  const value = Number(match[1])
+  const unit = match[2] ?? 'ms'
+  switch (unit) {
+    case 'ms':
+      return value
+    case 's':
+      return value * 1000
+    case 'm':
+      return value * 60 * 1000
+    case 'h':
+      return value * 60 * 60 * 1000
+    default:
+      return undefined
+  }
+}

package/src/utils/fs.ts

@@ -0,0 +1,50 @@
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+
+export function createFileSystem() {
+  return {
+    async ensureDir(dirPath: string): Promise<void> {
+      await fs.mkdir(dirPath, { recursive: true })
+    },
+    async fileExists(filePath: string): Promise<boolean> {
+      try {
+        await fs.access(filePath)
+        return true
+      } catch {
+        return false
+      }
+    },
+    async readJson<T>(filePath: string): Promise<T | undefined> {
+      const exists = await this.fileExists(filePath)
+      if (!exists) return undefined
+      const content = await fs.readFile(filePath, 'utf8')
+      return JSON.parse(content) as T
+    },
+    async writeJson(filePath: string, value: unknown): Promise<void> {
+      await fs.mkdir(path.dirname(filePath), { recursive: true })
+      await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8')
+    },
+    async appendLine(filePath: string, line: string): Promise<void> {
+      await fs.mkdir(path.dirname(filePath), { recursive: true })
+      await fs.appendFile(filePath, `${line}\n`, 'utf8')
+    },
+    async appendText(filePath: string, content: string): Promise<void> {
+      await fs.mkdir(path.dirname(filePath), { recursive: true })
+      await fs.appendFile(filePath, content, 'utf8')
+    },
+    async readText(filePath: string): Promise<string | undefined> {
+      const exists = await this.fileExists(filePath)
+      if (!exists) return undefined
+      return fs.readFile(filePath, 'utf8')
+    },
+    async writeText(filePath: string, content: string): Promise<void> {
+      await fs.mkdir(path.dirname(filePath), { recursive: true })
+      await fs.writeFile(filePath, content, 'utf8')
+    },
+    async readDir(dirPath: string): Promise<string[]> {
+      const exists = await this.fileExists(dirPath)
+      if (!exists) return []
+      return fs.readdir(dirPath)
+    }
+  }
+}

package/src/utils/logger.ts

@@ -0,0 +1,12 @@
+import type { Logger } from '../types/logger.js'
+import pino from 'pino'
+
+export function createLogger(level: string): Logger {
+  const logger = pino({ level })
+  return {
+    info: (message, meta) => logger.info(meta ?? {}, message),
+    warn: (message, meta) => logger.warn(meta ?? {}, message),
+    error: (message, meta) => logger.error(meta ?? {}, message),
+    debug: (message, meta) => logger.debug(meta ?? {}, message)
+  }
+}

package/src/utils/paths.ts

@@ -0,0 +1,24 @@
+import path from 'node:path'
+import type { RuntimePaths } from '../types/index.js'
+
+export function buildPaths(projectPath: string): RuntimePaths {
+  const runtimeDir = path.join(projectPath, '.unit_test_tool_workspace')
+  const logsPath = path.join(runtimeDir, 'logs')
+  const promptsDir = path.join(runtimeDir, 'prompts')
+  const promptRunsDir = path.join(runtimeDir, 'prompt-runs')
+  const reportsDir = path.join(runtimeDir, 'reports')
+
+  return {
+    runtimeDir,
+    configPath: path.join(runtimeDir, 'config.json'),
+    statePath: path.join(runtimeDir, 'state.json'),
+    logsPath,
+    promptsDir,
+    promptRunsDir,
+    eventsPath: path.join(logsPath, 'events.jsonl'),
+    reportsDir,
+    coverageSummaryPath: path.join(reportsDir, 'coverage-summary.json'),
+    finalReportPath: path.join(reportsDir, 'final-report.json'),
+    lifecyclePath: path.join(runtimeDir, 'lifecycle.json')
+  }
+}

package/src/utils/process-lifecycle.ts

@@ -0,0 +1,92 @@
+import type { AppContext } from '../cli/context/create-context.js'
+import type { LifecycleFile } from '../types/index.js'
+
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 30_000
+
+export type LifecycleOptions = {
+  command: 'start' | 'run'
+  argv: string[]
+  heartbeatIntervalMs?: number
+}
+
+export async function startLifecycle(ctx: AppContext, options: LifecycleOptions): Promise<{ stop: () => Promise<void> }> {
+  const startedAt = ctx.clock.nowIso()
+  const lifecycle: LifecycleFile = {
+    runId: ctx.runId,
+    command: options.command,
+    pid: process.pid,
+    argv: options.argv,
+    startedAt,
+    lastHeartbeat: startedAt,
+    status: 'running',
+    restartCount: 0,
+    updatedAt: startedAt
+  }
+
+  await ctx.lifecycleStore.save(lifecycle)
+  await ctx.eventStore.append({
+    eventType: 'lifecycle_started',
+    phase: 'INIT',
+    message: `${options.command} started`,
+    data: { pid: process.pid, argv: options.argv },
+    timestamp: startedAt
+  })
+
+  const interval = setInterval(async () => {
+    const now = ctx.clock.nowIso()
+    await ctx.lifecycleStore.patch({
+      lastHeartbeat: now,
+      updatedAt: now
+    })
+  }, options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS)
+
+  const stop = async (status: LifecycleFile['status'], exitCode?: number, lastError?: string) => {
+    clearInterval(interval)
+    const now = ctx.clock.nowIso()
+    await ctx.lifecycleStore.patch({
+      status,
+      exitCode,
+      lastError,
+      updatedAt: now
+    })
+    await ctx.eventStore.append({
+      eventType: 'lifecycle_stopped',
+      phase: 'DONE',
+      message: `${options.command} ${status}`,
+      data: { exitCode, lastError },
+      timestamp: now
+    })
+  }
+
+  const handleExit = async (code?: number) => {
+    await stop(code === 0 ? 'exited' : 'crashed', code)
+  }
+
+  const handleSignal = async (signal: NodeJS.Signals) => {
+    await stop('exited', undefined, `signal:${signal}`)
+    process.exit(0)
+  }
+
+  const handleError = async (error: unknown) => {
+    const message = error instanceof Error ? error.message : String(error)
+    await stop('crashed', 1, message)
+    process.exit(1)
+  }
+
+  process.on('exit', handleExit)
+  process.on('SIGINT', handleSignal)
+  process.on('SIGTERM', handleSignal)
+  process.on('uncaughtException', handleError)
+  process.on('unhandledRejection', handleError)
+
+  return {
+    stop: async () => {
+      process.off('exit', handleExit)
+      process.off('SIGINT', handleSignal)
+      process.off('SIGTERM', handleSignal)
+      process.off('uncaughtException', handleError)
+      process.off('unhandledRejection', handleError)
+      await stop('exited', 0)
+    }
+  }
+}

package/src/utils/prompts.ts

@@ -0,0 +1,22 @@
+import type { PromptBuilderSet, TaskItem, PromptOverridesConfig } from '../types/index.js'
+import { buildSystemPrompt } from '../core/prompts/system-prompt.js'
+import { buildTaskPrompt } from '../core/prompts/task-prompt.js'
+import { buildRetryPrompt } from '../core/prompts/retry-prompt.js'
+import { buildEditBoundaryPrompt } from '../core/prompts/edit-boundary-prompt.js'
+
+export function buildPromptBuilders(overrides?: PromptOverridesConfig): PromptBuilderSet {
+  return {
+    buildSystemPrompt() {
+      return buildSystemPrompt(overrides)
+    },
+    buildTaskPrompt(task: TaskItem) {
+      return buildTaskPrompt(task, overrides)
+    },
+    buildRetryPrompt(task: TaskItem, failure: string) {
+      return buildRetryPrompt(task, failure, overrides)
+    },
+    buildEditBoundaryPrompt(task: TaskItem) {
+      return buildEditBoundaryPrompt(task)
+    }
+  }
+}