@7n/test 0.2.0

package/src/coverage-classify/index.mjs

@@ -0,0 +1,112 @@
+/**
+ * Public API класифікатора: classify(survived, cwd, opts) → verdicts[]
+ *
+ * Routing через pi SDK (callText):
+ *   1. Cache lookup → hit → використати збережений verdict.
+ *   2. Cache miss → Tier 1 (N_LOCAL_MIN_MODEL через pi) → parseVerdict.
+ *   3. Tier 1 fail → Tier 2 (N_CLOUD_MIN_MODEL через pi) → parseVerdict.
+ *   4. Tier 2 fail → conservative fallback worth-testing/confidence=0.
+ */
+import { env } from 'node:process'
+import { join } from 'node:path'
+
+import { callText } from '../lib/pi-client.mjs'
+import { deriveCacheKey, readCache, writeCache } from './cache.mjs'
+import { buildUserPrompt, SYSTEM_PROMPT } from './prompt.mjs'
+import { parseVerdict } from './verdict-schema.mjs'
+
+const FALLBACK_VERDICT = {
+  verdict: 'worth-testing',
+  confidence: 0,
+  reason: 'LLM-classification unavailable, conservative fallback (treat as worth-testing)'
+}
+
+/**
+ * Викликає pi через callText з опційним model-id.
+ * @param {string} prompt
+ * @param {string} model provider/model-id або '' для pi-дефолту
+ * @param {string} cwd
+ * @returns {Promise<string>}
+ */
+function callModel(prompt, model, cwd) {
+  return callText(prompt, { cwd, ...(model ? { model } : {}) })
+}
+
+/**
+ * Два тири: N_LOCAL_MIN_MODEL → N_CLOUD_MIN_MODEL → FALLBACK_VERDICT.
+ * @param {{file: string, mutants: object[]}} group
+ * @param {object} mutant
+ * @param {string} cwd
+ * @param {(prompt: string, model: string, cwd: string) => Promise<string>} callModelFn
+ * @returns {Promise<object>} verdict
+ */
+async function classifyOne(group, mutant, cwd, callModelFn) {
+  const prompt = `${SYSTEM_PROMPT}\n\n${buildUserPrompt({ ...mutant, file: group.file }, cwd)}`
+  const loc = `${group.file}:${mutant.line}:${mutant.col}`
+  const tier1 = env.N_LOCAL_MIN_MODEL ?? ''
+  const tier2 = env.N_CLOUD_MIN_MODEL ?? ''
+
+  try {
+    const text = await callModelFn(prompt, tier1, cwd)
+    return parseVerdict(text)
+  } catch {
+    try {
+      const text = await callModelFn(prompt, tier2, cwd)
+      return parseVerdict(text)
+    } catch (error) {
+      console.warn(`⚠ coverage classify: ${loc} both tiers failed: ${error.message}`)
+      return { ...FALLBACK_VERDICT }
+    }
+  }
+}
+
+/**
+ * Класифікує survived мутантів через pi (N_LOCAL_MIN_MODEL → N_CLOUD_MIN_MODEL → fallback).
+ * @param {Array<{file: string, mutants: object[], exampleTest?: object|null, recommendationText?: string|null}>} survived
+ * @param {string} cwd
+ * @param {{cachePath?: string, callModel?: (prompt: string, model: string, cwd: string) => Promise<string>}} [opts]
+ * @returns {Promise<Array<{key: string, verdict: object}>>}
+ */
+export async function classify(survived, cwd, opts = {}) {
+  const cachePath = opts.cachePath ?? join(cwd, 'npm/reports/coverage-classify.cache.json')
+  const callModelFn = opts.callModel ?? callModel
+  const tier1 = env.N_LOCAL_MIN_MODEL ?? ''
+  const tier2 = env.N_CLOUD_MIN_MODEL ?? ''
+  const cacheModel = `${tier1 || 'default'}+${tier2 || 'cloud'}`
+
+  const cache = readCache(cachePath)
+  if (cache.model !== cacheModel) {
+    cache.entries = {}
+    cache.model = cacheModel
+  }
+
+  const verdicts = []
+  for (const group of survived) {
+    for (const mutant of group.mutants) {
+      const lookupKey = `${group.file}:${mutant.line}:${mutant.col}:${mutant.replacement}`
+      const cacheKey = deriveCacheKey(join(cwd, group.file), mutant)
+
+      let verdict = null
+      if (cacheKey && cache.entries[cacheKey]) {
+        const cached = cache.entries[cacheKey]
+        verdict = {
+          verdict: cached.verdict,
+          confidence: cached.confidence,
+          reason: cached.reason,
+          ...(cached.suggestedTest ? { suggestedTest: cached.suggestedTest } : {})
+        }
+      }
+      if (!verdict) {
+        verdict = await classifyOne(group, mutant, cwd, callModelFn)
+        if (cacheKey) {
+          cache.entries[cacheKey] = { ...verdict, classifiedAt: new Date().toISOString() }
+        }
+      }
+
+      verdicts.push({ key: lookupKey, verdict })
+    }
+  }
+
+  writeCache(cachePath, cache)
+  return verdicts
+}

package/src/coverage-classify/prompt.mjs

@@ -0,0 +1,126 @@
+/**
+ * Промпт-builder для coverage-classify.
+ * SYSTEM_PROMPT — статичний, кешується через cache_control: ephemeral у API call.
+ * buildUserPrompt — асемблює per-mutant контекст (location, source ±10, tests, git).
+ */
+import { execFileSync } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { basename, dirname, join } from 'node:path'
+
+const CONTEXT_LINES = 10
+const TEST_FILE_MAX_LINES = 2000
+
+export const SYSTEM_PROMPT = `You are a mutation testing classifier.
+
+For each survived Stryker mutant, classify it into exactly one verdict:
+
+- **worth-testing**: pure logic with real branches that should be tested. The mutant
+  exposes a missing assertion in a unit test. Recommend a test approach.
+- **equivalent**: the mutated code is behaviorally indistinguishable from the original
+  (e.g., both branches produce the same observable output, or the mutant lies on dead
+  code). You MUST cite a concrete reason referencing input flow or output equivalence.
+- **defensive**: the branch guards against an impossible state given input contracts
+  or type system. You MUST identify the invariant that makes the state unreachable.
+- **glue**: thin CLI entrypoint, factory, or boilerplate (e.g., runStandardRule
+  wrapper, fix.mjs stubs). Integration tests via subprocess cover the behavior.
+  Name the integration test or pattern.
+- **wrapper**: thin shell around an external tool (spawnSync, fetch, dynamic import).
+  The wrapper has no logic worth unit-testing in isolation; behavior comes from the
+  wrapped tool. Name the integration test or pattern.
+
+Output ONLY a single JSON object matching this schema:
+
+\`\`\`
+{
+  "verdict": "worth-testing" | "equivalent" | "defensive" | "glue" | "wrapper",
+  "confidence": number 0-1,
+  "reason": string (20-500 chars; concrete code-level reference, not "seems like"),
+  "suggestedTest": string (max 300 chars; required only when verdict is worth-testing)
+}
+\`\`\`
+
+Confidence guidance:
+- 0.9+: cite specific code fragment, identifier, or input contract proving the verdict.
+- 0.7-0.9: strong inference from visible code structure.
+- <0.7: ambiguity, lacking context, or unfamiliar pattern. Be honest.
+
+Never invent integration test names. If you cannot identify a covering test, use
+worth-testing with low confidence instead of glue/wrapper.
+`
+
+/**
+ * Витягує describe/test/it title з рядка тексту.
+ * @param {string} content повний текст test-файла
+ * @returns {string} список "describe: <title>" / "test: <title>" або порожній
+ */
+function extractTestTitles(content) {
+  const titles = []
+  for (const match of content.matchAll(/^[ \t]{0,16}(describe|test|it)\(['"`](.{1,300}?)['"`]/gmu)) {
+    titles.push(`${match[1]}: ${match[2]}`)
+  }
+  return titles.join('\n') || '(no describe/test blocks found)'
+}
+
+/**
+ * Будує користувацький промпт для класифікації одного мутанта.
+ * @param {{file: string, line: number, col: number, mutantType: string, original: string, replacement: string}} mutant параметри мутанта (file — відносний до cwd)
+ * @param {string} cwd корінь проєкту
+ * @returns {string} user prompt
+ */
+export function buildUserPrompt(mutant, cwd) {
+  const absPath = join(cwd, mutant.file)
+
+  // Source context
+  let srcContext = '(source file unavailable)'
+  if (existsSync(absPath)) {
+    const lines = readFileSync(absPath, 'utf8').split('\n')
+    const start = Math.max(0, mutant.line - 1 - CONTEXT_LINES)
+    const end = Math.min(lines.length, mutant.line + CONTEXT_LINES)
+    srcContext = lines
+      .slice(start, end)
+      .map((l, i) => `${start + i + 1}: ${l}`)
+      .join('\n')
+  }
+
+  // Existing tests
+  const testPath = join(dirname(absPath), 'tests', `${basename(absPath, '.mjs')}.test.mjs`)
+  let existingTests = '(no test file)'
+  if (existsSync(testPath)) {
+    const content = readFileSync(testPath, 'utf8')
+    if (content.split('\n').length > TEST_FILE_MAX_LINES) {
+      existingTests = extractTestTitles(content)
+    } else {
+      existingTests = content
+    }
+  }
+
+  // Recent git activity (graceful если нет git або untracked)
+  let recentActivity = '(no git history)'
+  try {
+    const out = execFileSync('git', ['log', '-1', '--format=%ar', '--', absPath], {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    }).trim()
+    if (out) recentActivity = out
+  } catch {
+    // git unavailable or file untracked — keep placeholder
+  }
+
+  return `# Mutant
+File: ${mutant.file}
+Line: ${mutant.line}:${mutant.col}
+Type: ${mutant.mutantType}
+Original code: \`${mutant.original}\`
+Mutated to: \`${mutant.replacement}\`
+
+# Source context (±${CONTEXT_LINES} lines)
+${srcContext}
+
+# Existing tests
+${existingTests}
+
+# Recent activity
+File last modified: ${recentActivity}
+`
+}

package/src/coverage-classify/verdict-schema.mjs

@@ -0,0 +1,35 @@
+/**
+ * Zod-схема для verdict-відповіді LLM-класифікатора (coverage-classify).
+ * parseVerdict — витяг JSON з raw-text LLM-відповіді + validate.
+ *
+ * Категорії:
+ *   - worth-testing: pure logic, real branches — пиши тест
+ *   - equivalent:    мутант поведінково еквівалентний (не killable)
+ *   - defensive:     гілка для impossible state (не killable)
+ *   - glue:          CLI entry / runStandardRule wrapper (integration covers)
+ *   - wrapper:       тонкий spawn/fetch wrapper (integration covers)
+ */
+import { z } from 'zod'
+
+export const VerdictSchema = z.object({
+  verdict: z.enum(['worth-testing', 'equivalent', 'defensive', 'glue', 'wrapper']),
+  confidence: z.number().min(0).max(1),
+  reason: z.string().min(20).max(500),
+  suggestedTest: z.string().max(300).optional()
+})
+
+/**
+ * Витягує JSON-об'єкт з raw-text LLM-відповіді і валідує через VerdictSchema.
+ * @param {string} rawText raw-text відповідь LLM
+ * @returns {{verdict: string, confidence: number, reason: string, suggestedTest?: string}} verdict
+ * @throws {Error} якщо JSON не знайдено, не парситься, або не відповідає схемі
+ */
+export function parseVerdict(rawText) {
+  const jsonStart = rawText.indexOf('{')
+  const jsonEnd = rawText.lastIndexOf('}')
+  if (jsonStart === -1 || jsonEnd === -1) {
+    throw new Error('No JSON object found in LLM response')
+  }
+  const json = JSON.parse(rawText.slice(jsonStart, jsonEnd + 1))
+  return VerdictSchema.parse(json)
+}

package/src/coverage-fix-extract.mjs

@@ -0,0 +1,122 @@
+/**
+ * `n-cursor coverage-fix index|slice` — read-only витяг вцілілих мутантів із
+ * `COVERAGE.md` для скілу `n-coverage-fix`.
+ *
+ * Мотивація: `COVERAGE.md` може важити мегабайти (секція `## Вцілілі мутанти`
+ * з JSON-блоком на сотні файлів). Якщо цей файл читає LLM-оркестратор, він
+ * спалює сотні тисяч токенів лише на парсинг. Натомість важкий парсинг несе цей
+ * скрипт (для JS — мілісекунди, 0 токенів), а агенту віддається рівно потрібна
+ * порція:
+ *   - `index` — крихітний `[{file, mutants}]` для рішення про фан-аут;
+ *   - `slice --file <path>` — промпт лише для одного файлу (контекст ±3 рядки),
+ *     рівно під когнітивне навантаження одного субагента.
+ *
+ * Команда read-only: лише парсить наявний `COVERAGE.md`, нічого не мутує і не
+ * перезапускає Stryker (тож не входить у root-guard).
+ */
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+import { buildFixPrompt } from './coverage-fix.mjs'
+
+/** Заголовок секції вцілілих мутантів у COVERAGE.md (контракт із renderMarkdown). */
+const SURVIVED_SECTION = '## Вцілілі мутанти'
+
+/**
+ * Огорожа json-блоку: ≥3 бектики, далі `json` і решта рядка до `\n`. Довжина
+ * захоплюється в групу 1 — renderMarkdown пише 3, але oxfmt підвищує до 4+, коли
+ * сам JSON-вміст містить ``` (типово для original/replacement мутантів).
+ */
+const FENCE_OPEN_RE = /(`{3,8})json[^\n]{0,200}\n/
+
+/**
+ * Витягує JSON-масив вцілілих мутантів із тексту COVERAGE.md: знаходить секцію
+ * `## Вцілілі мутанти`, перший огороджений ` ```json ` блок під нею і парсить.
+ * @param {string} md повний текст COVERAGE.md
+ * @returns {import('./coverage-fix.mjs').SurvivedFileGroup[]} групи вцілілих по файлах (порожньо, якщо секції/блоку немає або JSON невалідний)
+ */
+export function parseSurvivedBlock(md) {
+  const sectionAt = md.indexOf(SURVIVED_SECTION)
+  if (sectionAt === -1) return []
+  const after = md.slice(sectionAt)
+  const open = after.match(FENCE_OPEN_RE)
+  if (!open) return []
+  const fence = open[1]
+  const bodyStart = open.index + open[0].length
+  const rest = after.slice(bodyStart)
+  // Закриття — рядок із тих самих бектиків. Усередині JSON реальних переводів
+  // рядка немає (JSON.stringify екранує їх як `\n`), тож `\n<fence>` унікально
+  // позначає кінець блоку навіть якщо значення містять бектики.
+  const closeAt = rest.indexOf(`\n${fence}`)
+  const json = closeAt === -1 ? rest : rest.slice(0, closeAt)
+  try {
+    const parsed = JSON.parse(json)
+    return Array.isArray(parsed) ? parsed : []
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Читає `COVERAGE.md` із кореня проєкту і повертає структуровані групи вцілілих.
+ * @param {string} cwd корінь проєкту
+ * @returns {Promise<import('./coverage-fix.mjs').SurvivedFileGroup[]>} групи вцілілих по файлах
+ */
+export async function readSurvived(cwd) {
+  let md
+  try {
+    md = await readFile(join(cwd, 'COVERAGE.md'), 'utf8')
+  } catch {
+    return []
+  }
+  return parseSurvivedBlock(md)
+}
+
+/**
+ * Згортає групи вцілілих у компактний index `[{file, mutants}]`.
+ * @param {import('./coverage-fix.mjs').SurvivedFileGroup[]} survived групи вцілілих
+ * @returns {Array<{file:string, mutants:number}>} файл → кількість вцілілих мутантів
+ */
+export function buildIndex(survived) {
+  return survived
+    .filter(group => group && typeof group.file === 'string' && Array.isArray(group.mutants))
+    .map(group => ({ file: group.file, mutants: group.mutants.length }))
+}
+
+const USAGE = 'Usage: n-cursor coverage-fix <index | slice --file <path>>'
+
+/**
+ * CLI: `index` друкує компактний JSON-масив, `slice --file <path>` — промпт для
+ * одного файлу. Обидва read-only (читають лише COVERAGE.md).
+ * @param {string[]} args аргументи після `coverage-fix`
+ * @param {string} [cwd] корінь проєкту (ін'єкція для тестів)
+ * @returns {Promise<number>} exit code
+ */
+export async function runCoverageFixCli(args, cwd = process.cwd()) {
+  const sub = args[0]
+  const survived = await readSurvived(cwd)
+
+  if (sub === 'index') {
+    process.stdout.write(`${JSON.stringify(buildIndex(survived))}\n`)
+    return 0
+  }
+
+  if (sub === 'slice') {
+    const flagAt = args.indexOf('--file')
+    const file = flagAt === -1 ? undefined : args[flagAt + 1]
+    if (!file) {
+      console.error(USAGE)
+      return 1
+    }
+    const group = survived.find(g => g && g.file === file)
+    if (!group) {
+      console.error(`✗ Файл не знайдено серед вцілілих мутантів: ${file}`)
+      return 1
+    }
+    process.stdout.write(`${await buildFixPrompt([group], cwd)}\n`)
+    return 0
+  }
+
+  console.error(USAGE)
+  return 1
+}

package/src/coverage-fix.mjs

@@ -0,0 +1,117 @@
+/**
+ * `n coverage --fix`: запускає pi-агента для написання тестів
+ * по вцілілих мутантах Stryker. Агент отримує список мутантів з контекстом
+ * (file, line, оригінальний код, вцілілий варіант, тип мутації) і самостійно
+ * знаходить або створює відповідні test-файли.
+ *
+ * Модель: CLOUD_MAX (складна агентна задача) або N_CURSOR_COVERAGE_FIX_MODEL.
+ */
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { env } from 'node:process'
+
+const MODEL = env.N_CURSOR_COVERAGE_FIX_MODEL ?? env.N_CLOUD_MAX_MODEL ?? ''
+
+/**
+ * @typedef {{line:number, col:number, mutantType:string, original:string, replacement:string}} MutantDetail
+ * @typedef {{file:string, mutants:MutantDetail[], exampleTest:{testFile:string,code:string|null}|null, recommendationText:string|null}} SurvivedFileGroup
+ */
+
+/**
+ * Запускає pi-агента для написання тестів по вцілілих мутантах.
+ * @param {SurvivedFileGroup[]} survived вцілілі мутанти, згруповані по файлах
+ * @param {string} projectRoot абсолютний шлях до кореня проєкту
+ * @param {{ callPi?: (prompt: string, model: string, opts: { cwd: string }) => void }} [opts] ін'єкції для тестів
+ * @returns {Promise<void>}
+ */
+export async function fixSurvivedMutants(survived, projectRoot, opts = {}) {
+  const totalMutants = survived.reduce((s, g) => s + g.mutants.length, 0)
+  if (totalMutants === 0) {
+    console.log('✓ Всі мутанти вбиті — доповнення тестів не потрібне')
+    return
+  }
+
+  const prompt = await buildFixPrompt(survived, projectRoot)
+  console.log(`\n🤖 coverage --fix: запускаю агента для ${totalMutants} вцілілих мутантів...\n`)
+
+  const callPiFn = opts.callPi ?? callPi
+  callPiFn(prompt, MODEL, { cwd: projectRoot })
+}
+
+/**
+ * Викликає pi в агентному режимі з live-output до stdout.
+ * @param {string} prompt текст промпта
+ * @param {string} model  provider/model-id або '' для pi-дефолту
+ * @param {{ cwd?: string }} [piOpts] опційні параметри (cwd)
+ */
+function callPi(prompt, model, { cwd } = {}) {
+  const modelArgs = model ? ['--model', model] : []
+  spawnSync('pi', ['-p', prompt, ...modelArgs, '--no-session'], {
+    cwd,
+    stdio: 'inherit',
+    timeout: 900_000
+  })
+}
+
+/**
+ * Формує rich-промпт для агента: список вцілілих мутантів згрупований по файлах,
+ * з контекстом ±3 рядки навколо кожного мутанта з source-файлу.
+ * @param {SurvivedFileGroup[]} survived групи вцілілих мутантів по файлах
+ * @param {string} projectRoot корінь проєкту
+ * @returns {Promise<string>} текст rich-промпту
+ */
+export async function buildFixPrompt(survived, projectRoot) {
+  const sections = []
+
+  for (const { file, mutants, exampleTest } of survived) {
+    let srcLines = []
+    try {
+      const src = await readFile(join(projectRoot, file), 'utf8')
+      srcLines = src.split('\n')
+    } catch {
+      // файл може бути недоступним — пропускаємо контекст, але продовжуємо
+    }
+
+    const mutantDescriptions = mutants
+      .map(m => {
+        const ctxStart = Math.max(0, m.line - 4)
+        const ctxEnd = Math.min(srcLines.length, m.line + 3)
+        const context = srcLines
+          .slice(ctxStart, ctxEnd)
+          .map((l, i) => `${ctxStart + i + 1}: ${l}`)
+          .join('\n')
+        return [
+          `  - Рядок ${m.line}, колонка ${m.col}, тип мутації \`${m.mutantType}\``,
+          `    Оригінал: \`${m.original}\``,
+          `    Вижив варіант: \`${m.replacement}\``,
+          context ? `    Контекст:\n\`\`\`\n${context}\n\`\`\`` : ''
+        ]
+          .filter(Boolean)
+          .join('\n')
+      })
+      .join('\n')
+
+    const exampleSection = exampleTest?.code
+      ? `\n\nПриклад тесту з \`${exampleTest.testFile}\`:\n\`\`\`js\n${exampleTest.code}\n\`\`\``
+      : ''
+
+    sections.push(`### \`${file}\`${exampleSection}\n${mutantDescriptions}`)
+  }
+
+  return [
+    'Твоє завдання — написати unit-тести, що вбивають наступні вцілілі мутанти Stryker.',
+    'Для кожного мутанта: знайди або створи відповідний test-файл, додай тест-кейс,',
+    'що явно перевіряє цю гілку/умову і провалиться якщо код замінити на "вцілілий варіант".',
+    '',
+    '## Вцілілі мутанти',
+    '',
+    ...sections,
+    '',
+    '## Правила',
+    '- Не змінюй source-файли — лише test-файли.',
+    '- Використовуй той самий test-фреймворк, що вже в проєкті.',
+    '- Запусти `bun test` (або відповідну команду) після кожного файлу — переконайся, що 0 fail.',
+    '- Якщо мутант охоплений іншим новим тестом — не дублюй.'
+  ].join('\n')
+}

package/src/coverage-per-file.mjs

@@ -0,0 +1,85 @@
+/**
+ * Per-file coverage via vitest + lcov.
+ * Runs `bunx vitest run --coverage --coverage.reporter=lcov` and parses lcov.info
+ * per source file. Returns relative paths (to dir) with line coverage %.
+ */
+import { spawnSync } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join, relative } from 'node:path'
+import { env } from 'node:process'
+
+const TEST_FILE_RE = /\.(test|spec)\.[^.]+$|[/\\]tests?[/\\]/
+
+/**
+ * @param {string} text lcov.info content
+ * @returns {Array<{file: string, pct: number, linesFound: number, linesCovered: number}>}
+ */
+function parseLcovPerFile(text) {
+  const files = []
+  let currentFile = null
+  let lf = 0
+  let lh = 0
+  for (const line of text.split('\n')) {
+    if (line.startsWith('SF:')) {
+      currentFile = line.slice(3).trim()
+      lf = 0
+      lh = 0
+    } else if (line.startsWith('LF:')) {
+      lf = Number(line.slice(3))
+    } else if (line.startsWith('LH:')) {
+      lh = Number(line.slice(3))
+    } else if (line === 'end_of_record' && currentFile) {
+      files.push({
+        file: currentFile,
+        pct: lf === 0 ? 100 : Math.round((lh / lf) * 10000) / 100,
+        linesFound: lf,
+        linesCovered: lh
+      })
+      currentFile = null
+    }
+  }
+  return files
+}
+
+/**
+ * Runs vitest coverage and returns per-file line coverage data.
+ * @param {string} dir project root
+ * @returns {Promise<Array<{file: string, pct: number, linesFound: number, linesCovered: number}>>}
+ */
+export async function measureCoveragePerFile(dir) {
+  const lcovDir = await mkdtemp(join(tmpdir(), '7n-cov-'))
+  try {
+    spawnSync(
+      'bunx',
+      [
+        'vitest',
+        'run',
+        '--passWithNoTests',
+        '--coverage',
+        '--coverage.reporter=lcov',
+        `--coverage.reportsDirectory=${lcovDir}`
+      ],
+      { cwd: dir, stdio: 'inherit', env }
+    )
+    const lcovPath = join(lcovDir, 'lcov.info')
+    if (!existsSync(lcovPath)) return []
+    const allFiles = parseLcovPerFile(readFileSync(lcovPath, 'utf8'))
+    return allFiles
+      .map(f => ({ ...f, file: relative(dir, f.file) }))
+      .filter(f => !f.file.startsWith('..') && !TEST_FILE_RE.test(f.file))
+  } finally {
+    await rm(lcovDir, { recursive: true, force: true }).catch(() => {})
+  }
+}
+
+/**
+ * Files below the coverage threshold.
+ * @param {Array<{file: string, pct: number}>} files
+ * @param {number} [threshold=80]
+ * @returns {Array<{file: string, pct: number}>}
+ */
+export function getUncoveredFiles(files, threshold = 80) {
+  return files.filter(f => f.pct < threshold)
+}