@angli/unit-test-tool 0.1.0

package/src/cli/commands/verify.ts

@@ -0,0 +1,17 @@
+import { Command } from 'commander'
+import { createContext } from '../context/create-context.js'
+import { verifyAll } from '../../core/tools/verify-all.js'
+
+export function registerVerifyCommand(program: Command) {
+  program
+    .command('verify')
+    .option('--project <path>', 'project path')
+    .action(async (options) => {
+      const ctx = await createContext({
+        projectPath: options.project ?? process.cwd(),
+        coverageTarget: 80
+      })
+      const result = await verifyAll(ctx)
+      console.log(result.summary)
+    })
+}

package/src/cli/context/create-context.ts

@@ -0,0 +1,142 @@
+import path from 'node:path'
+import type { TestBotConfig, RuntimePaths, RuntimeLimits, CommandSet, PromptBuilderSet, StateFile, AppRuntimeCache } from '../../types/index.js'
+import type { Logger } from '../../types/logger.js'
+import { buildPaths } from '../../utils/paths.js'
+import { createFileSystem } from '../../utils/fs.js'
+import { createClock } from '../../utils/clock.js'
+import { createCommandRunner } from '../../utils/command-runner.js'
+import { createStateStore } from '../../core/storage/state-store.js'
+import { createReportStore } from '../../core/storage/report-store.js'
+import { createEventStore } from '../../core/storage/event-store.js'
+import { createLifecycleStore } from '../../core/storage/lifecycle-store.js'
+import { createLogger } from '../../utils/logger.js'
+import { buildCommandSet } from '../../utils/commands.js'
+import { buildPromptBuilders } from '../../utils/prompts.js'
+
+export interface CreateContextInput {
+  projectPath: string
+  coverageTarget: number
+  configOverrides?: Partial<TestBotConfig>
+}
+
+export interface AppContext {
+  projectPath: string
+  coverageTarget: number
+  mode: 'serial' | 'parallel'
+  logger: Logger
+  clock: ReturnType<typeof createClock>
+  fileSystem: ReturnType<typeof createFileSystem>
+  commandRunner: ReturnType<typeof createCommandRunner>
+  config: TestBotConfig
+  paths: RuntimePaths
+  commands: CommandSet
+  prompts: PromptBuilderSet
+  limits: RuntimeLimits
+  cache: AppRuntimeCache
+  runId: string
+  stateStore: ReturnType<typeof createStateStore>
+  eventStore: ReturnType<typeof createEventStore>
+  reportStore: ReturnType<typeof createReportStore>
+  lifecycleStore: ReturnType<typeof createLifecycleStore>
+}
+
+export async function createContext(input: CreateContextInput): Promise<AppContext> {
+  const projectPath = input.projectPath
+  const paths = buildPaths(projectPath)
+  const fileSystem = createFileSystem()
+  const persistedConfig = await fileSystem.readJson<TestBotConfig>(paths.configPath)
+  const config = await loadConfig(projectPath, input.coverageTarget, persistedConfig, input.configOverrides)
+  const projectPackageJson = await fileSystem.readJson<{ scripts?: Record<string, string> }>(path.join(projectPath, 'package.json'))
+  const logger = createLogger(config.logLevel ?? 'info')
+  const clock = createClock()
+  const commandRunner = createCommandRunner({ cwd: projectPath })
+  const commands = buildCommandSet(config, projectPackageJson?.scripts ?? {})
+  const prompts = buildPromptBuilders(config.promptOverrides)
+  const limits: RuntimeLimits = {
+    maxIterationsPerRun: config.maxIterationsPerRun ?? 5,
+    maxRetryPerTask: config.maxRetryPerTask ?? 2,
+    loopThreshold: config.loopThreshold ?? 2,
+    concurrency: config.concurrency ?? 8,
+    llmTopN: config.llmTopN ?? 20,
+    llmAdjustRange: config.llmAdjustRange ?? 10
+  }
+
+  const initialState: StateFile = {
+    phase: 'INIT',
+    status: 'idle',
+    totals: {
+      pending: 0,
+      running: 0,
+      passed: 0,
+      failed: 0,
+      blocked: 0
+    },
+    lastAction: 'init',
+    nextSuggestedAction: 'analyze',
+    updatedAt: clock.nowIso()
+  }
+
+  const cache: AppRuntimeCache = {}
+  const runId = buildRunId(clock.nowIso())
+
+  return {
+    projectPath,
+    coverageTarget: config.coverageTarget,
+    mode: config.mode,
+    logger,
+    clock,
+    fileSystem,
+    commandRunner,
+    config,
+    paths,
+    commands,
+    prompts,
+    limits,
+    cache,
+    runId,
+    stateStore: createStateStore(paths, fileSystem, initialState),
+    reportStore: createReportStore(paths, fileSystem),
+    eventStore: createEventStore(paths, fileSystem),
+    lifecycleStore: createLifecycleStore(paths, fileSystem)
+  }
+}
+
+function buildRunId(timestamp: string): string {
+  const compact = timestamp.replace(/[-:]/g, '').replace(/\..+$/, '')
+  return `r${compact}Z`
+}
+
+async function loadConfig(
+  projectPath: string,
+  coverageTarget: number,
+  persisted?: Partial<TestBotConfig>,
+  overrides?: Partial<TestBotConfig>
+): Promise<TestBotConfig> {
+  const defaultConfig: TestBotConfig = {
+    projectPath,
+    coverageTarget,
+    include: ['src/**/*'],
+    exclude: ['node_modules/**', 'dist/**', 'coverage/**'],
+    mode: 'serial',
+    concurrency: 1,
+    maxIterationsPerRun: 5,
+    maxRetryPerTask: 2,
+    loopThreshold: 2,
+    allowSourceEdit: false,
+    testDirNames: ['__test__', '__tests__'],
+    commandOverrides: {},
+    priorityPaths: [],
+    deferredPaths: [],
+    excludePaths: [],
+    llmTopN: 20,
+    llmAdjustRange: 10
+  }
+
+  return {
+    ...defaultConfig,
+    ...persisted,
+    ...overrides,
+    projectPath,
+    coverageTarget: overrides?.coverageTarget ?? persisted?.coverageTarget ?? coverageTarget
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,27 @@
+import { Command } from 'commander'
+import { registerInitCommand } from './commands/init.js'
+import { registerAnalyzeCommand } from './commands/analyze.js'
+import { registerVerifyCommand } from './commands/verify.js'
+import { registerStatusCommand } from './commands/status.js'
+import { registerStartCommand } from './commands/start.js'
+import { registerRunCommand } from './commands/run.js'
+import { registerGuardCommand } from './commands/guard.js'
+import { registerScheduleCommand } from './commands/schedule.js'
+
+const program = new Command()
+
+program
+  .name('testbot')
+  .description('Unit test auto-completion tool')
+  .version('0.1.0')
+
+registerInitCommand(program)
+registerAnalyzeCommand(program)
+registerRunCommand(program)
+registerVerifyCommand(program)
+registerStatusCommand(program)
+registerStartCommand(program)
+registerGuardCommand(program)
+registerScheduleCommand(program)
+
+program.parseAsync(process.argv)

package/src/cli/utils/scan-dir.ts

@@ -0,0 +1,5 @@
+export function buildIncludeFromScanDir(scanDir?: string): string[] | undefined {
+  if (!scanDir) return undefined
+  const normalized = scanDir.replace(/\\/g, '/').replace(/\/+$/, '')
+  return normalized ? [`${normalized}/**/*`] : undefined
+}

package/src/core/analyzers/coverage-analyzer.ts

@@ -0,0 +1,10 @@
+import type { CandidateFile, CoverageSnapshot } from '../../types/index.js'
+
+export function coverageAnalyzer(candidate: CandidateFile, coverageSnapshot?: CoverageSnapshot) {
+  const gap = coverageSnapshot?.coverageGap ?? 0
+  return {
+    lineRate: coverageSnapshot?.lines,
+    branchRate: coverageSnapshot?.branches,
+    coverageGap: gap
+  }
+}

package/src/core/analyzers/dependency-complexity-analyzer.ts

@@ -0,0 +1,25 @@
+import type { AppContext } from '../../cli/context/create-context.js'
+import type { CandidateFile } from '../../types/index.js'
+
+export async function dependencyComplexityAnalyzer(ctx: AppContext, candidate: CandidateFile) {
+  const content = await ctx.fileSystem.readText(`${ctx.projectPath}/${candidate.targetFile}`)
+  if (!content) {
+    return {
+      importCount: 0,
+      externalDependencyCount: 0,
+      complexityLevel: 'low' as const
+    }
+  }
+
+  const importLines = content.split('\n').filter((line) => line.startsWith('import') || line.includes('require('))
+  const importCount = importLines.length
+  const externalDependencyCount = importLines.filter((line) => line.includes("from '") || line.includes('require(')).length
+
+  const complexityLevel = importCount > 15 ? 'high' : importCount > 5 ? 'medium' : 'low'
+
+  return {
+    importCount,
+    externalDependencyCount,
+    complexityLevel: complexityLevel as 'low' | 'medium' | 'high'
+  }
+}

package/src/core/analyzers/existing-test-analyzer.ts

@@ -0,0 +1,76 @@
+import path from 'node:path'
+import type { AppContext } from '../../cli/context/create-context.js'
+import type { CandidateFile } from '../../types/index.js'
+import fg from 'fast-glob'
+
+export async function existingTestAnalyzer(ctx: AppContext, candidate: CandidateFile) {
+  const base = path.basename(candidate.targetFile, path.extname(candidate.targetFile))
+  const testFilesByBaseName = await getTestFilesByBaseName(ctx)
+  const matches = testFilesByBaseName[base] ?? []
+  const relatedMatches = matches.filter((file) => isRelatedTestPath(candidate.targetFile, file))
+
+  return {
+    hasExistingTest: relatedMatches.length > 0,
+    testFilePaths: relatedMatches,
+    partialCoverageLikely: relatedMatches.length > 0
+  }
+}
+
+function isRelatedTestPath(targetFile: string, testFile: string): boolean {
+  const normalizedTarget = normalizePath(targetFile)
+  const normalizedTest = normalizePath(testFile)
+  const targetDir = path.dirname(normalizedTarget)
+  const targetDirName = path.basename(targetDir)
+  const targetBase = path.basename(normalizedTarget, path.extname(normalizedTarget))
+  const testBase = path.basename(normalizedTest, path.extname(normalizedTest))
+
+  if (testBase === targetBase || testBase === `${targetBase}.test` || testBase === `${targetBase}.spec`) return true
+  if (normalizedTest.startsWith(`${targetDir}/`)) return true
+  if (normalizedTest.includes(`/${targetDirName}/`)) return true
+
+  return false
+}
+
+function normalizePath(filePath: string): string {
+  return filePath.replace(/\\/g, '/')
+}
+
+async function getTestFilesByBaseName(ctx: AppContext): Promise<Record<string, string[]>> {
+  if (ctx.cache.testFilesByBaseName) return ctx.cache.testFilesByBaseName
+
+  const testDirNames = await detectTestDirNames(ctx)
+  const patterns = [
+    '**/*.test.*',
+    '**/*.spec.*',
+    ...testDirNames.map((dir) => `**/${dir}/**/*.*`)
+  ]
+  const files = await fg(patterns, { cwd: ctx.projectPath, ignore: ctx.config.exclude, onlyFiles: true })
+
+  const index: Record<string, string[]> = {}
+
+  for (const file of files) {
+    const base = path.basename(file, path.extname(file))
+    if (!index[base]) index[base] = []
+    index[base].push(file)
+  }
+
+  ctx.cache.testFilesByBaseName = index
+  return index
+}
+
+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/analyzers/failure-history-analyzer.ts

@@ -0,0 +1,12 @@
+import type { AppContext } from '../../cli/context/create-context.js'
+import type { CandidateFile } from '../../types/index.js'
+
+export async function failureHistoryAnalyzer(_ctx: AppContext, _candidate: CandidateFile) {
+  return {
+    previousAttemptCount: 0,
+    loopDetected: false,
+    blockedBefore: false,
+    failurePenaltyScore: 0,
+    lastFailureCategory: undefined
+  }
+}

package/src/core/analyzers/file-classifier-analyzer.ts

@@ -0,0 +1,25 @@
+import path from 'node:path'
+import type { AppContext } from '../../cli/context/create-context.js'
+import type { CandidateFile } from '../../types/index.js'
+
+export async function fileClassifierAnalyzer(_ctx: AppContext, candidate: CandidateFile) {
+  const ext = path.extname(candidate.targetFile)
+  const lower = candidate.targetFile.toLowerCase()
+  const uiSignal = /component|view|widget/.test(lower)
+  const domSignal = /dom|browser/.test(lower)
+  const frameworkSignal = /tsx?$/.test(ext)
+
+  let ruleCategory = 'unknown'
+  if (/util|helper|math|logic|transform/.test(lower)) ruleCategory = 'pure-logic'
+  else if (/service|api/.test(lower)) ruleCategory = 'business-logic'
+  else if (uiSignal) ruleCategory = 'ui-heavy'
+  else if (/model|mapper|serializer/.test(lower)) ruleCategory = 'data-transform'
+
+  return {
+    ruleCategory,
+    semanticCategory: ruleCategory,
+    uiSignal,
+    domSignal,
+    frameworkSignal
+  }
+}

package/src/core/analyzers/index.ts

@@ -0,0 +1,51 @@
+import type { AnalyzerFacts, CandidateFile, CoverageSnapshot } from '../../types/index.js'
+import type { AppContext } from '../../cli/context/create-context.js'
+import { coverageAnalyzer } from './coverage-analyzer.js'
+import { pathPriorityAnalyzer } from './path-priority-analyzer.js'
+import { fileClassifierAnalyzer } from './file-classifier-analyzer.js'
+import { dependencyComplexityAnalyzer } from './dependency-complexity-analyzer.js'
+import { existingTestAnalyzer } from './existing-test-analyzer.js'
+import { failureHistoryAnalyzer } from './failure-history-analyzer.js'
+import { llmSemanticAnalyzer } from './llm-semantic-analyzer.js'
+
+export interface AnalyzerResult {
+  facts: AnalyzerFacts
+  warnings: string[]
+}
+
+export async function runAnalyzers(
+  ctx: AppContext,
+  candidate: CandidateFile,
+  coverageSnapshot?: CoverageSnapshot
+): Promise<AnalyzerResult> {
+  const warnings: string[] = []
+
+  const coverage = coverageAnalyzer(candidate, coverageSnapshot)
+  const pathPriority = pathPriorityAnalyzer(candidate, ctx.config)
+  const existingTest = await existingTestAnalyzer(ctx, candidate)
+  const fileClassification = await fileClassifierAnalyzer(ctx, candidate)
+  const dependencyComplexity = await dependencyComplexityAnalyzer(ctx, candidate)
+  const failureHistory = await failureHistoryAnalyzer(ctx, candidate)
+
+  let llmSemantic: AnalyzerFacts['llmSemantic'] | undefined
+  try {
+    llmSemantic = await llmSemanticAnalyzer(ctx, candidate)
+  } catch (error) {
+    warnings.push(`llmSemanticAnalyzer failed: ${String(error)}`)
+  }
+
+  return {
+    facts: {
+      targetFile: candidate.targetFile,
+      coverage,
+      pathPriority,
+      existingTest,
+      fileClassification,
+      dependencyComplexity,
+      failureHistory,
+      llmSemantic,
+      analyzerWarnings: warnings
+    },
+    warnings
+  }
+}

package/src/core/analyzers/llm-semantic-analyzer.ts

@@ -0,0 +1,6 @@
+import type { AppContext } from '../../cli/context/create-context.js'
+import type { CandidateFile } from '../../types/index.js'
+
+export async function llmSemanticAnalyzer(_ctx: AppContext, _candidate: CandidateFile) {
+  return undefined
+}

package/src/core/analyzers/path-priority-analyzer.ts

@@ -0,0 +1,41 @@
+import type { CandidateFile, TestBotConfig } from '../../types/index.js'
+
+export function pathPriorityAnalyzer(candidate: CandidateFile, config: TestBotConfig) {
+  const priorityPaths = config.priorityPaths ?? []
+  const deferredPaths = config.deferredPaths ?? []
+  const excludePaths = config.excludePaths ?? []
+
+  const target = candidate.targetFile
+
+  const matchedExclude = excludePaths.find((p) => target.startsWith(p))
+  if (matchedExclude) {
+    return {
+      label: 'excluded' as const,
+      score: -999,
+      matchedPath: matchedExclude
+    }
+  }
+
+  const matchedPriority = priorityPaths.find((p) => target.startsWith(p))
+  if (matchedPriority) {
+    return {
+      label: 'priority' as const,
+      score: 100,
+      matchedPath: matchedPriority
+    }
+  }
+
+  const matchedDeferred = deferredPaths.find((p) => target.startsWith(p))
+  if (matchedDeferred) {
+    return {
+      label: 'deferred' as const,
+      score: -100,
+      matchedPath: matchedDeferred
+    }
+  }
+
+  return {
+    label: 'normal' as const,
+    score: 0
+  }
+}

package/src/core/coverage/read-coverage-summary.ts

@@ -0,0 +1,224 @@
+import path from 'node:path'
+import type { AppContext } from '../../cli/context/create-context.js'
+import type { CoverageSnapshot } from '../../types/index.js'
+
+const DEFAULT_COVERAGE_FILES = [
+  path.join('coverage', 'coverage-summary.json'),
+  path.join('coverage', 'coverage-final.json'),
+  'coverage-summary.json',
+  'coverage-final.json'
+]
+
+const EXCLUDED_DIRS = new Set(['node_modules', '.git', '.unit_test_tool_workspace'])
+
+type CoverageSummaryTotals = {
+  total?: {
+    lines?: { pct?: number }
+    statements?: { pct?: number }
+    functions?: { pct?: number }
+    branches?: { pct?: number }
+  }
+  lines?: { pct?: number }
+  statements?: { pct?: number }
+  functions?: { pct?: number }
+  branches?: { pct?: number }
+}
+
+type CoverageSummaryFileEntry = {
+  lines?: { pct?: number }
+  statements?: { pct?: number }
+  functions?: { pct?: number }
+  branches?: { pct?: number }
+}
+
+type CoverageFinalEntry = {
+  s?: Record<string, number>
+  f?: Record<string, number>
+  b?: Record<string, number[]>
+  l?: Record<string, number>
+}
+
+export async function runAndReadCoverage(ctx: AppContext): Promise<CoverageSnapshot> {
+  ctx.logger.info(`[coverage] step=run status=start cmd=${ctx.commands.analyzeBaseline}`)
+  const result = await ctx.commandRunner.run(ctx.commands.analyzeBaseline)
+  ctx.logger.info(`[coverage] step=run status=done exit=${result.exitCode}`)
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr?.trim()
+    const stdout = result.stdout?.trim()
+    const message = stderr || stdout || 'coverage command failed'
+    throw new Error(message)
+  }
+
+  const summary = await readCoverageSummary(ctx)
+  if (!summary) {
+    const searched = await listCoverageSearchPaths(ctx)
+    throw new Error(
+      `coverage summary not found after command: ${ctx.commands.analyzeBaseline}. searched=${searched.join(', ') || 'none'}`
+    )
+  }
+  return summary
+}
+
+export async function readCoverageSummary(ctx: AppContext): Promise<CoverageSnapshot | undefined> {
+  const searchPaths = await listCoverageSearchPaths(ctx)
+  for (const relativePath of searchPaths) {
+    const fullPath = path.join(ctx.projectPath, relativePath)
+    const data = await ctx.fileSystem.readJson<Record<string, CoverageSummaryFileEntry | CoverageSummaryTotals | CoverageFinalEntry>>(fullPath)
+    if (!data) continue
+    const snapshot = parseCoverageSummary(data as Record<string, CoverageSummaryFileEntry | CoverageSummaryTotals>)
+    if (snapshot) return snapshot
+    const finalSnapshot = parseCoverageFinal(data as Record<string, CoverageFinalEntry>)
+    if (finalSnapshot) return finalSnapshot
+  }
+  return undefined
+}
+
+async function listCoverageSearchPaths(ctx: AppContext): Promise<string[]> {
+  const discovered = await findCoverageFiles(ctx.projectPath, '.')
+  return Array.from(new Set([...DEFAULT_COVERAGE_FILES, ...discovered]))
+}
+
+async function findCoverageFiles(projectPath: string, relativeDir: string): Promise<string[]> {
+  const fs = await import('node:fs/promises')
+  const dirPath = path.join(projectPath, relativeDir)
+  let entries: Array<{ name: string; isDirectory(): boolean; isFile(): boolean }>
+  try {
+    entries = await fs.readdir(dirPath, { withFileTypes: true })
+  } catch {
+    return []
+  }
+
+  const matches: string[] = []
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (EXCLUDED_DIRS.has(entry.name)) continue
+      matches.push(...await findCoverageFiles(projectPath, path.join(relativeDir, entry.name)))
+      continue
+    }
+    if (!entry.isFile()) continue
+    if (entry.name !== 'coverage-summary.json' && entry.name !== 'coverage-final.json') continue
+    matches.push(path.join(relativeDir, entry.name).replace(/^\.\//, ''))
+  }
+  return matches
+}
+
+function parseCoverageSummary(
+  summary: Record<string, CoverageSummaryFileEntry | CoverageSummaryTotals>
+): CoverageSnapshot | undefined {
+  const totalEntry = summary.total as CoverageSummaryTotals | undefined
+  if (!totalEntry) return undefined
+
+  const totals = totalEntry.total ?? totalEntry
+  const snapshot: CoverageSnapshot = {
+    lines: totals.lines?.pct,
+    statements: totals.statements?.pct,
+    functions: totals.functions?.pct,
+    branches: totals.branches?.pct,
+    rawSummary: JSON.stringify(totals)
+  }
+
+  const fileEntries: CoverageSnapshot['fileEntries'] = {}
+  for (const [key, entry] of Object.entries(summary)) {
+    if (key === 'total') continue
+    const fileEntry = entry as CoverageSummaryFileEntry
+    fileEntries[key] = {
+      lines: fileEntry.lines?.pct,
+      statements: fileEntry.statements?.pct,
+      functions: fileEntry.functions?.pct,
+      branches: fileEntry.branches?.pct
+    }
+  }
+
+  snapshot.fileEntries = fileEntries
+  return snapshot
+}
+
+function parseCoverageFinal(finalReport: Record<string, CoverageFinalEntry>): CoverageSnapshot | undefined {
+  const summary = summarizeCoverageFinal(finalReport)
+  if (!summary) return undefined
+
+  return {
+    lines: summary.lines,
+    statements: summary.statements,
+    functions: summary.functions,
+    branches: summary.branches,
+    rawSummary: JSON.stringify(summary),
+    fileEntries: summary.fileEntries
+  }
+}
+
+function summarizeCoverageFinal(finalReport: Record<string, CoverageFinalEntry>) {
+  const files = Object.entries(finalReport).filter(([key]) => key !== 'total')
+  if (files.length === 0) return undefined
+
+  let totalStatements = 0
+  let coveredStatements = 0
+  let totalFunctions = 0
+  let coveredFunctions = 0
+  let totalBranches = 0
+  let coveredBranches = 0
+  let totalLines = 0
+  let coveredLines = 0
+
+  const fileEntries: CoverageSnapshot['fileEntries'] = {}
+
+  for (const [filePath, entry] of files) {
+    const statement = summarizeRecord(entry.s)
+    const fn = summarizeRecord(entry.f)
+    const branch = summarizeBranches(entry.b)
+    const line = summarizeRecord(entry.l)
+
+    totalStatements += statement.total
+    coveredStatements += statement.covered
+    totalFunctions += fn.total
+    coveredFunctions += fn.covered
+    totalBranches += branch.total
+    coveredBranches += branch.covered
+    totalLines += line.total
+    coveredLines += line.covered
+
+    fileEntries[filePath] = {
+      statements: toPct(statement.covered, statement.total),
+      functions: toPct(fn.covered, fn.total),
+      branches: toPct(branch.covered, branch.total),
+      lines: toPct(line.covered, line.total)
+    }
+  }
+
+  return {
+    statements: toPct(coveredStatements, totalStatements),
+    functions: toPct(coveredFunctions, totalFunctions),
+    branches: toPct(coveredBranches, totalBranches),
+    lines: toPct(coveredLines, totalLines),
+    fileEntries
+  }
+}
+
+function summarizeRecord(record?: Record<string, number>) {
+  if (!record) return { total: 0, covered: 0 }
+  let total = 0
+  let covered = 0
+  for (const value of Object.values(record)) {
+    total += 1
+    if (value > 0) covered += 1
+  }
+  return { total, covered }
+}
+
+function summarizeBranches(record?: Record<string, number[]>) {
+  if (!record) return { total: 0, covered: 0 }
+  let total = 0
+  let covered = 0
+  for (const values of Object.values(record)) {
+    total += values.length
+    for (const value of values) {
+      if (value > 0) covered += 1
+    }
+  }
+  return { total, covered }
+}
+
+function toPct(covered: number, total: number): number | undefined {
+  if (total === 0) return undefined
+  return Math.round((covered / total) * 10000) / 100
+}