@7n/test 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [0.4.0] - 2026-06-26
+
+### Added
+
+- Додано `fix-tests.mjs`: виявляє падаючі unit-тести через vitest JSON reporter і викликає pi-агента для їх виправлення. Інтегровано в основний пайплайн `run.mjs` — якщо coverage порожня після першої ітерації, автоматично запускається фаза виправлення тестів.
+
+## [0.3.2] - 2026-06-26
+
+### Fixed
+
+- Виправлено відсутність `src/coverage/coverage.mjs` у npm-пакеті: директорія ігнорувалась git через паттерн `**/coverage/` у `.gitignore`. Додано виняток `!npm/src/coverage/`.
+
+## [0.3.1] - 2026-06-26
+
+### Changed
+
+- fix: unignore npm/src/coverage/ (was blocked by **/coverage/ in .gitignore)
+
 ## [0.3.0] - 2026-06-26
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7n/test",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "CLI-утиліта @7n/test",
   "keywords": [
     "7n",

package/src/coverage/coverage.mjs

@@ -0,0 +1,315 @@
+/**
+ * Канонічна команда `n coverage`: збирає метрики покриття + мутаційного
+ * тестування з усіх провайдерів, чиє правило активне в `.n-cursor.json#rules`,
+ * агрегує та записує COVERAGE.md у корінь проєкту.
+ *
+ * Discovery провайдерів — за `.n-cursor.json#rules`: для кожного `ruleId` зі
+ * списку шукаємо `<rulesDir>/<ruleId>/coverage/coverage.mjs` і динамічно
+ * імпортуємо. Якщо файлу немає — провайдер для цього правила відсутній (skip
+ * silently, не помилка).
+ *
+ * `rulesDir` резолвиться з `node_modules/@nitra/cursor/rules` у cwd проєкту.
+ * Override — через `opts.rulesDir` у `runCoverageSteps`.
+ *
+ * Лок — прямий виклик `withLock('coverage', steps)`.
+ */
+import { existsSync } from 'node:fs'
+import { readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+import { applyVerdicts } from '../coverage-classify/apply.mjs'
+import { classify } from '../coverage-classify/index.mjs'
+import { collectChangedFilesSince, resolveChangedBase } from '../scripts/lib/changed-files.mjs'
+import { readNCursorConfigLite } from '../scripts/lib/read-n-cursor-config-lite.mjs'
+import { withLock } from '../scripts/utils/with-lock.mjs'
+
+/**
+ * Знаходить rulesDir @nitra/cursor у node_modules проєкту.
+ * @param {string} cwd корінь проєкту
+ * @returns {string|null} абсолютний шлях до rules/ або null
+ */
+function resolveDefaultRulesDir(cwd) {
+  const localPath = join(cwd, 'node_modules', '@nitra', 'cursor', 'rules')
+  if (existsSync(localPath)) return localPath
+  return null
+}
+
+/**
+ * Сума двох coverage-totals.
+ * @param {{lines:{covered:number,total:number}, functions:{covered:number,total:number}}} a перший subtotal
+ * @param {{lines:{covered:number,total:number}, functions:{covered:number,total:number}}} b другий subtotal
+ * @returns {{lines:{covered:number,total:number}, functions:{covered:number,total:number}}} сумарні lines/functions
+ */
+export function addCoverage(a, b) {
+  return {
+    lines: { covered: a.lines.covered + b.lines.covered, total: a.lines.total + b.lines.total },
+    functions: {
+      covered: a.functions.covered + b.functions.covered,
+      total: a.functions.total + b.functions.total
+    }
+  }
+}
+
+/**
+ * Сума двох mutation-counts.
+ * @param {{caught:number,total:number}} a перший subtotal
+ * @param {{caught:number,total:number}} b другий subtotal
+ * @returns {{caught:number,total:number}} сумарні caught/total
+ */
+export function addMutation(a, b) {
+  return { caught: a.caught + b.caught, total: a.total + b.total }
+}
+
+/**
+ * Форматує covered/total як `XX.XX% (covered/total)`.
+ * @param {{covered:number,total:number}} metric метрика lines або functions
+ * @returns {string} відформатований рядок для таблиці COVERAGE.md
+ */
+export function formatCoverage({ covered, total }) {
+  const percent = total === 0 ? '—' : `${((covered / total) * 100).toFixed(2)}%`
+  return `${percent} (${covered}/${total})`
+}
+
+/**
+ * Форматує мутаційний score як `XX.XX%`.
+ * @param {{caught:number,total:number}} metric агрегований mutation score
+ * @returns {string} відформатований score або прочерк
+ */
+export function formatScore({ caught, total }) {
+  return total === 0 ? '—' : `${((caught / total) * 100).toFixed(2)}%`
+}
+
+/**
+ * Рендерить таблицю покриття + мутаційного тестування як Markdown.
+ * Якщо будь-який рядок містить непустий `survived`, додає секцію
+ * `## Вцілілі мутанти` з JSON-блоком для coverage-fix.
+ * Якщо `allowedGaps` непустий, додає секцію `## Allowed gaps` з таблицею
+ * verdict/confidence/reason для кожного LLM-класифікованого мутанта.
+ * Без timestamp, щоб git diff рухався лише при зміні метрик.
+ * @param {Array<{area:string, coverage:{lines:{covered:number,total:number},functions:{covered:number,total:number}}, mutation:{caught:number,total:number}, survived?: Array<{file:string,line:number,col:number,mutantType:string,original:string,replacement:string}>}>} rows рядки провайдерів
+ * @param {Array<{file:string, mutant:{line:number,col:number,mutantType:string,original:string,replacement:string}, verdict:{verdict:string,confidence:number,reason:string}}>} [allowedGaps] мутанти виключені класифікатором
+ * @returns {string} Markdown з заголовком `# Coverage`
+ */
+export function renderMarkdown(rows, allowedGaps = []) {
+  const lines = [
+    '# Coverage',
+    '',
+    '| Область | Рядки | Функції | Вбито мутацій | Score |',
+    '| --- | --- | --- | --- | --- |'
+  ]
+  for (const row of rows) {
+    lines.push(
+      `| ${row.area} | ${formatCoverage(row.coverage.lines)} | ${formatCoverage(row.coverage.functions)} | ` +
+        `${row.mutation.caught}/${row.mutation.total} | ${formatScore(row.mutation)} |`
+    )
+  }
+
+  const allSurvived = rows.flatMap(r => r.survived ?? [])
+  if (allSurvived.length > 0) {
+    lines.push('', '## Вцілілі мутанти', '', '```json', JSON.stringify(allSurvived, null, 2), '```')
+    // Зрозуміла для людини таблиця
+    for (const group of allSurvived) {
+      lines.push('', `### ${group.file}`, '', '| Рядок | Оригінал | Заміна | Тип |', '| --- | --- | --- | --- |')
+      for (const m of group.mutants) {
+        lines.push(`| ${m.line} | \`${m.original}\` | \`${m.replacement}\` | ${m.mutantType} |`)
+      }
+      if (group.exampleTest) {
+        lines.push(
+          '',
+          `**Приклад тесту** (\`${group.exampleTest.testFile}\`):`,
+          '',
+          '```js',
+          group.exampleTest.code ?? '',
+          '```'
+        )
+      }
+      if (group.recommendationText) {
+        lines.push('', '**Що треба протестувати:**', '', group.recommendationText)
+      }
+    }
+  }
+
+  if (allowedGaps.length > 0) {
+    // Group allowed gaps by file
+    const gapsByFile = new Map()
+    for (const gap of allowedGaps) {
+      if (!gapsByFile.has(gap.file)) gapsByFile.set(gap.file, [])
+      gapsByFile.get(gap.file).push(gap)
+    }
+
+    lines.push(
+      '',
+      '## Allowed gaps',
+      '',
+      `> LLM-класифікатор виключив ${allowedGaps.length} survived мутант(ів) зі знаменника mutation score.`,
+      '> Категорії: equivalent (поведінково еквівалентний), defensive (impossible state), glue/wrapper (integration test покриває).'
+    )
+
+    for (const [file, gaps] of gapsByFile) {
+      lines.push(
+        '',
+        `### ${file}`,
+        '',
+        '| Line | Mutant | Verdict | Confidence | Reason |',
+        '| --- | --- | --- | --- | --- |'
+      )
+      for (const { mutant, verdict } of gaps) {
+        const sanitizedReason = verdict.reason.replaceAll('|', String.raw`\|`).replaceAll('\n', ' ')
+        lines.push(
+          `| ${mutant.line} | \`${mutant.original}\` → \`${mutant.replacement}\` | ${verdict.verdict} | ${verdict.confidence.toFixed(2)} | ${sanitizedReason} |`
+        )
+      }
+    }
+  }
+
+  return `${lines.join('\n')}\n`
+}
+
+/**
+ * Завантажує provider-модуль з `<rulesDir>/<ruleId>/coverage/coverage.mjs`.
+ * Повертає null коли:
+ *   - файлу немає (rule без coverage-провайдера),
+ *   - файл існує, але не експортує `detect` + `collect` як функції.
+ * @param {string} rulesDir корінь rules/ (з @nitra/cursor або override)
+ * @param {string} ruleId id правила з `.n-cursor.json#rules`
+ * @returns {Promise<{detect:(cwd:string)=>Promise<boolean>, collect:(cwd:string)=>Promise<Array<object>>}|null>} provider-модуль або null
+ */
+async function loadProvider(rulesDir, ruleId) {
+  const providerPath = join(rulesDir, ruleId, 'coverage', 'coverage.mjs')
+  if (!existsSync(providerPath)) return null
+  const mod = await import(pathToFileURL(providerPath).href)
+  if (typeof mod.detect !== 'function' || typeof mod.collect !== 'function') return null
+  return mod
+}
+
+/**
+ * Будує підсумковий рядок «Разом» через сумування всіх coverage/mutation.
+ * @param {Array<{area:string, coverage:object, mutation:object}>} rows рядки провайдерів без totals
+ * @returns {{area:string, coverage:object, mutation:{caught:number,total:number}}} агрегований рядок «Разом»
+ */
+function buildTotalsRow(rows) {
+  let totalCoverage = { lines: { covered: 0, total: 0 }, functions: { covered: 0, total: 0 } }
+  let totalMutation = { caught: 0, total: 0 }
+  for (const row of rows) {
+    totalCoverage = addCoverage(totalCoverage, row.coverage)
+    totalMutation = addMutation(totalMutation, row.mutation)
+  }
+  return { area: '**Разом**', coverage: totalCoverage, mutation: totalMutation }
+}
+
+/**
+ * Читає `.n-cursor.json#coverage.classifyConfidenceThreshold` (default 1.1 — rollout mode).
+ * @param {string} cwd корінь проєкту
+ * @returns {Promise<number>} threshold у [0, 1.1]
+ */
+async function readClassifyThreshold(cwd) {
+  try {
+    const raw = await readFile(join(cwd, '.n-cursor.json'), 'utf8')
+    const parsed = JSON.parse(raw)
+    const t = parsed?.coverage?.classifyConfidenceThreshold
+    return typeof t === 'number' && Number.isFinite(t) ? t : 1.1
+  } catch {
+    return 1.1
+  }
+}
+
+/**
+ * Резолвить scope змінених файлів для `--changed`-режиму.
+ * @param {string} cwd корінь проєкту
+ * @returns {{base: string|null, files: string[]}} base-ref і relative-posix список змінених файлів
+ */
+export function resolveChangedScope(cwd) {
+  const base = resolveChangedBase(cwd)
+  return { base, files: collectChangedFilesSince(base, cwd) }
+}
+
+/**
+ * Виконує coverage-pipeline: discovery провайдерів за `.n-cursor.json#rules`,
+ * detect+collect для кожного, агрегація, запис COVERAGE.md.
+ * @param {{cwd?:string, rulesDir?:string, fix?:boolean, changed?:boolean}} [opts]
+ * @returns {Promise<number>} exit code (0 OK, 1 помилка)
+ */
+export async function runCoverageSteps(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd()
+  const rulesDir = opts.rulesDir ?? resolveDefaultRulesDir(cwd)
+
+  if (!rulesDir) {
+    console.error(
+      '✗ Не знайдено @nitra/cursor у node_modules. ' +
+        'Встанови @nitra/cursor як devDependency або передай rulesDir через opts.'
+    )
+    return 1
+  }
+
+  const config = await readNCursorConfigLite(cwd)
+  const scope = opts.changed ? resolveChangedScope(cwd) : null
+  const collectOpts = scope ? { changedFiles: scope.files, base: scope.base } : {}
+  const rows = []
+
+  for (const ruleId of config.rules) {
+    if (config.disableRules.includes(ruleId)) continue
+    const provider = await loadProvider(rulesDir, ruleId)
+    if (!provider) continue
+    if (!(await provider.detect(cwd))) continue
+    console.log(`→ ${ruleId} coverage…`)
+    rows.push(...(await provider.collect(cwd, collectOpts)))
+  }
+
+  if (rows.length === 0) {
+    if (opts.changed) {
+      console.log('✓ coverage --changed: немає змінених файлів у scope провайдерів — пропускаю')
+      return 0
+    }
+    console.error('✗ Жодного провайдера покриття не знайдено для активних правил у .n-cursor.json#rules')
+    return 1
+  }
+
+  if (opts.changed) {
+    console.log('✓ coverage --changed: змінені файли перевірено')
+    return 0
+  }
+
+  // LLM-класифікація survived мутантів (graceful skip без API key)
+  const allSurvived = rows.flatMap(r => r.survived ?? [])
+  let augmentedRows = rows
+  let allowedGaps = []
+  if (allSurvived.length > 0) {
+    const verdicts = await classify(allSurvived, cwd)
+    if (verdicts.length > 0) {
+      const threshold = await readClassifyThreshold(cwd)
+      const applied = applyVerdicts(rows, verdicts, threshold)
+      augmentedRows = applied.rows
+      allowedGaps = applied.allowedGaps
+    }
+  }
+
+  if (augmentedRows.filter(r => r.area !== '**Разом**').length > 1) {
+    augmentedRows.push(buildTotalsRow(augmentedRows.filter(r => r.area !== '**Разом**')))
+  }
+  const md = renderMarkdown(augmentedRows, allowedGaps)
+  // Stryker disable next-line StringLiteral: equivalent – writeFile(path, str, '') behaves identically to 'utf8' in Node/Bun
+  await writeFile(join(cwd, 'COVERAGE.md'), md, 'utf8')
+  console.log('✓ COVERAGE.md')
+
+  if (opts.fix) {
+    const { fixSurvivedMutants } = await import(new URL('../coverage-fix.mjs', import.meta.url).href)
+    await fixSurvivedMutants(allSurvived, cwd)
+  }
+
+  return 0
+}
+
+/**
+ * CLI entrypoint для `n coverage [--fix] [--changed]`.
+ * @param {{fix?:boolean, changed?:boolean, rulesDir?:string}} [opts]
+ * @returns {Promise<number>} exit code
+ */
+export async function runCoverageCli(opts = {}) {
+  const code = await withLock('coverage', () => runCoverageSteps(opts))
+  if (code === 0 && opts.fix) {
+    console.log('\n♻️  Повторний coverage після агента…\n')
+    return withLock('coverage', () => runCoverageSteps({ fix: false, changed: opts.changed, rulesDir: opts.rulesDir }))
+  }
+  return code
+}

package/src/fix-tests.mjs

@@ -0,0 +1,146 @@
+/**
+ * fix-tests: виявляє падаючі unit-тести і викликає pi-агента для їх виправлення.
+ *
+ * Порядок роботи:
+ *   1. getFailingTests(dir) — запускає `bunx vitest run --reporter=json` і повертає
+ *      список падаючих файлів з повідомленнями про помилки.
+ *   2. fixFailingTests(dir, opts) — якщо є падіння, будує prompt і викликає pi CLI
+ *      в агентному режимі; перевіряє результат повторним getFailingTests.
+ */
+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 MODEL = env.N_CURSOR_FIX_TESTS_MODEL ?? env.N_CLOUD_MAX_MODEL ?? ''
+const MAX_ERRORS_PER_FILE = 5
+const MAX_ERROR_LINES = 10
+
+/**
+ * Runs vitest in JSON mode and returns failing test files with error messages.
+ * @param {string} dir project root
+ * @returns {Promise<Array<{file: string, errors: string[]}>>}
+ */
+export async function getFailingTests(dir) {
+  const tmpDir = await mkdtemp(join(tmpdir(), '7n-fix-'))
+  const outputFile = join(tmpDir, 'results.json')
+
+  try {
+    spawnSync(
+      'bunx',
+      ['vitest', 'run', '--reporter=json', `--outputFile=${outputFile}`, '--passWithNoTests'],
+      { cwd: dir, stdio: 'inherit', env }
+    )
+
+    if (!existsSync(outputFile)) return []
+
+    let data
+    try {
+      data = JSON.parse(readFileSync(outputFile, 'utf8'))
+    } catch {
+      return []
+    }
+
+    return (data.testResults ?? [])
+      .filter(r => r.status === 'failed')
+      .map(r => ({
+        file: relative(dir, r.testFilePath),
+        errors: (r.assertionResults ?? [])
+          .filter(a => a.status === 'failed')
+          .slice(0, MAX_ERRORS_PER_FILE)
+          .map(a => {
+            const name = [...(a.ancestorTitles ?? []), a.title].join(' > ')
+            const msg = (a.failureMessages?.[0] ?? '').split('\n').slice(0, MAX_ERROR_LINES).join('\n')
+            return `${name}:\n${msg}`
+          })
+      }))
+      .filter(f => !f.file.startsWith('..') && f.errors.length > 0)
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true }).catch(() => {})
+  }
+}
+
+/**
+ * Builds a prompt for pi agent to fix failing tests.
+ * @param {Array<{file: string, errors: string[]}>} failures
+ * @returns {string}
+ */
+export function buildFixTestsPrompt(failures) {
+  const fileList = failures
+    .map(({ file, errors }) => {
+      const errBlock = errors.join('\n\n')
+      return `### \`${file}\`\n\`\`\`\n${errBlock}\n\`\`\``
+    })
+    .join('\n\n')
+
+  return [
+    'Виправ падаючі unit-тести. Для кожного файлу:',
+    '1. Прочитай тест-файл і source-файл що він тестує',
+    '2. Запусти: `bunx vitest run <testFile>` — переконайся в точній помилці',
+    '3. Виправ ЛИШЕ тест-файл — source-файли не чіпай',
+    '4. Запусти тест ще раз — переконайся що зелений',
+    '',
+    '## Правила:',
+    '- Міняй виключно тест-файли',
+    '- Зберігай структуру тестів (describe/it/expect)',
+    '- Якщо тест перевіряє неіснуючий API — адаптуй до реального',
+    '- НЕ видаляй тести — лише виправляй',
+    '- Якщо тест тестує видалений функціонал — закоментуй з поясненням чому',
+    '',
+    '## Падаючі файли та помилки:',
+    '',
+    fileList
+  ].join('\n')
+}
+
+/**
+ * Calls pi CLI as agent (live output) to fix failing tests.
+ * @param {string} prompt
+ * @param {string} model provider/model-id або '' для pi-дефолту
+ * @param {string} cwd
+ */
+function callPi(prompt, model, cwd) {
+  const modelArgs = model ? ['--model', model] : []
+  spawnSync('pi', ['-p', prompt, ...modelArgs, '--no-session'], {
+    cwd,
+    stdio: 'inherit',
+    timeout: 900_000
+  })
+}
+
+/**
+ * Detects and fixes failing tests using a pi agent.
+ * Returns immediately with count=0 if all tests are already passing.
+ *
+ * @param {string} dir project root
+ * @param {{
+ *   failures?: Array<{file: string, errors: string[]}>,
+ *   callPi?: (prompt: string, model: string, cwd: string) => void
+ * }} [opts]
+ * @returns {Promise<{count: number, fixed: number, remaining: number}>}
+ */
+export async function fixFailingTests(dir, opts = {}) {
+  const callPiFn = opts.callPi ?? callPi
+  const failures = opts.failures ?? (await getFailingTests(dir))
+
+  if (failures.length === 0) return { count: 0, fixed: 0, remaining: 0 }
+
+  console.log(`\n🔧 Виправляю ${failures.length} падаючих test-файлів (pi agent)...\n`)
+  for (const f of failures) {
+    console.log(`  • ${f.file} (${f.errors.length} помилок)`)
+  }
+  console.log()
+
+  const prompt = buildFixTestsPrompt(failures)
+  callPiFn(prompt, MODEL, dir)
+
+  const after = await getFailingTests(dir)
+  const fixed = failures.length - after.length
+
+  if (fixed > 0) console.log(`✓ Виправлено: ${fixed}/${failures.length} файлів`)
+  if (after.length > 0) console.log(`⚠ Залишились падати: ${after.length} файлів`)
+
+  return { count: failures.length, fixed, remaining: after.length }
+}

package/src/run.mjs

@@ -14,6 +14,7 @@
 import { measureCoveragePerFile, getUncoveredFiles } from './coverage-per-file.mjs'
 import { assessNeed } from './assess-need.mjs'
 import { generateTests } from './gen-tests.mjs'
+import { fixFailingTests, getFailingTests } from './fix-tests.mjs'
 import { runCoverageSteps } from './coverage/coverage.mjs'
 import { withLock } from './scripts/utils/with-lock.mjs'
 
@@ -35,6 +36,12 @@ export async function runAutoTest(dir, opts = {}) {
 
     const allFiles = await measureCoveragePerFile(dir)
     if (allFiles.length === 0) {
+      const failures = await getFailingTests(dir)
+      if (failures.length > 0) {
+        console.log(`\n── ${failures.length} тестів падають — виправляю (pi agent) ──\n`)
+        const { remaining } = await fixFailingTests(dir, { failures })
+        if (remaining === 0) continue
+      }
       console.log('⚠ Vitest coverage не повернула даних — перевір налаштування vitest.')
       break
     }