@7n/test 0.8.0 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [0.10.0] - 2026-07-02
+
+### Changed
+
+- Оновлено залежність @nitra/check-env до ^4.0.0
+
+### Fixed
+
+- Coverage/gen-tests/fix-tests тепер віддають перевагу локально встановленому vitest цільового проєкту замість підміненого шим-конфіга: власний vitest.config.js (setupFiles, environment, plugins) і провайдери оточення (happy-dom тощо) з node_modules цільового проєкту більше не ігноруються.
+
+## [0.9.1] - 2026-07-02
+
+### Changed
+
+- docs
+
+### Fixed
+
+- Виніс спільний парсинг vitest failure у `coverage-per-file.mjs` і перевів `fix-tests.mjs` на його повторне використання, щоб прибрати jscpd-дубль.
+- - Зменшено cognitive complexity генерації тестів через винесення підготовки контексту та tiered block generation у менші helper-и.
+- - Виправлено JSDoc-описи та спрощено цикл генерації тестових блоків, щоб пройти JS lint для `gen-tests.mjs`.
+
+## [0.9.0] - 2026-06-28
+
+### Changed
+
+- В нормальному циклі `assessNeed` (LLM-оцінка) повністю прибрано: coverage % < порогу є достатнім сигналом для генерації тестів. У bootstrap-режимі тепер використовується тільки `quickClassify` (локально, без LLM). Таким чином нульова кількість LLM-викликів до `assessNeed` у будь-якому сценарії.
+
 ## [0.8.0] - 2026-06-28
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7n/test",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "CLI-утиліта @7n/test",
   "keywords": [
     "7n",
@@ -41,8 +41,10 @@
   "dependencies": {
     "@earendil-works/pi-coding-agent": "^0.80.2",
     "@vitest/coverage-v8": "^4.1.9",
+    "rollup": "^4.62.2",
     "vitest": "^4.1.9",
-    "zod": "^3.23.0"
+    "zod": "^3.23.0",
+    "@nitra/check-env": "^4.0.0"
   },
   "engines": {
     "bun": ">=1.3",

package/src/assess-need.mjs

@@ -48,7 +48,10 @@ function stripComments(src) {
  */
 export function quickClassify(content) {
   const stripped = stripComments(content)
-  const lines = stripped.split('\n').map(l => l.trim()).filter(Boolean)
+  const lines = stripped
+    .split('\n')
+    .map(l => l.trim())
+    .filter(Boolean)
 
   // All lines are imports/re-exports → no testable logic
   if (lines.length > 0 && lines.every(l => WIRING_RE.test(l))) {

package/src/classify-exports.mjs

@@ -0,0 +1,108 @@
+/**
+ * Classifies named exports of a JS/MJS source file by test-generation complexity.
+ * Used to route: trivial/simple → local LLM, complex → cloud LLM.
+ */
+
+const EXPORT_RE = /^export\s+(?:async\s+)?(?:const|function|class|let)\s+(\w+)/gm
+const PRIMITIVE_LITERAL_RE = /^(?:\d[\d_]*(?:\.\d+)?|'[^']*'|"[^"]*"|true|false|null)\s*$/
+const NEXT_EXPORT_RE = /\nexport\s/m
+
+/**
+ * Patterns that flag an export as too complex for local model.
+ * Matched against the export's extracted body (up to 3000 chars).
+ */
+const COMPLEX_SIGNALS = [
+  /\bfetch\b/,
+  /\bnew\s+Date\b/,
+  /\bprocess\.env\b/,
+  /\benv\.[A-Z_]{2,}/,
+  /\bFormData\b/,
+  /\bcheckEnv\b/,
+  /\bXMLHttpRequest\b/,
+  /\bWebSocket\b/,
+  /\bsetTimeout\b|\bsetInterval\b/
+]
+
+/**
+ * @typedef {'trivial'|'simple'|'complex'} ExportComplexity
+ * @typedef {{ name: string, complexity: ExportComplexity }} ExportInfo
+ */
+
+/**
+ * Extracts all named exports and classifies each by test complexity.
+ * @param {string} content source file text
+ * @returns {ExportInfo[]} named exports with complexity labels
+ */
+export function extractExportsWithComplexity(content) {
+  const names = Array.from(content.matchAll(EXPORT_RE), m => m[1])
+  return names.map(name => ({ name, complexity: classifyExport(name, content) }))
+}
+
+/**
+ * Classifies one export by inspecting the code region that defines it.
+ * @param {string} name export name
+ * @param {string} content source file text
+ * @returns {ExportComplexity} complexity label
+ */
+function classifyExport(name, content) {
+  if (isPrimitiveConstExport(name, content)) return 'trivial'
+
+  const body = extractBody(name, content)
+  if (!body) return 'simple'
+  if (COMPLEX_SIGNALS.some(re => re.test(body))) return 'complex'
+  return 'simple'
+}
+
+/**
+ * Checks whether the export is a primitive `export const NAME = <literal>`.
+ * @param {string} name export name
+ * @param {string} content source file text
+ * @returns {boolean} true when the export is a primitive constant
+ */
+function isPrimitiveConstExport(name, content) {
+  const prefix = `export const ${name} =`
+  for (const line of content.split('\n')) {
+    if (!line.startsWith(prefix)) continue
+    return PRIMITIVE_LITERAL_RE.test(line.slice(prefix.length).trim())
+  }
+  return false
+}
+
+/**
+ * Finds the declaration start for a named export.
+ * @param {string} name export name
+ * @param {string} content source file text
+ * @returns {number} start index or `-1`
+ */
+function findExportStart(name, content) {
+  const prefixes = [
+    `export async function ${name}`,
+    `export function ${name}`,
+    `export const ${name}`,
+    `export class ${name}`,
+    `export let ${name}`
+  ]
+  let start = -1
+  for (const prefix of prefixes) {
+    const idx = content.indexOf(prefix)
+    if (idx !== -1 && (start === -1 || idx < start)) start = idx
+  }
+  return start
+}
+
+/**
+ * Extracts the code region from the export declaration to the next export.
+ * Used for complexity signal matching only — not exact AST.
+ * @param {string} name export name
+ * @param {string} content source file text
+ * @returns {string|null} declaration snippet or `null`
+ */
+function extractBody(name, content) {
+  const start = findExportStart(name, content)
+  if (start === -1) return null
+
+  const after = content.slice(start)
+  const nextExport = after.search(NEXT_EXPORT_RE)
+  const end = nextExport === -1 ? Math.min(after.length, 3000) : nextExport
+  return after.slice(0, end)
+}

package/src/coverage-classify/docs/apply.md

@@ -0,0 +1,28 @@
+---
+type: JS Module
+title: apply.mjs
+resource: npm/src/coverage-classify/apply.mjs
+docgen:
+  crc: 0f54e6a0
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  score: 100
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Файл відповідає за застосування вердиктів до рядків покриття, фільтруючи виживших мутантів. Застосовується Skip rule, якщо `verdict` належить до `{equivalent, defensive, glue, wrapper}` і `confidence` досягає заданого порогу. Для інших мутантів, включаючи ті, що мають `worth-testing` або низьку впевненість, мутанти залишаються в наборі виживших. Крім того, загальна кількість мутантів (`mutation.total`) декрементується на кількість `allowed-gaps`, а окремий список `allowedGaps` повертається для візуалізації в `COVERAGE.md`.
+
+## Поведінка
+
+isAllowedGap визначає, чи мутант відповідає критеріям для віднесення до категорії allowed-gap, що дозволяє його ігнорувати при оцінці покриття.
+applyVerdicts фільтрує виживших мутантів на основі наданих verdict-ів, зменшує загальну кількість мутантів та повертає новий набір рядків покриття разом зі списком allowedGaps.
+
+## Публічний API
+
+isAllowedGap — Визначає, чи слід вважати мутанта прийнятним пропуском (виключає його з категорії потенційно "вбиваних" мутантів).
+applyVerdicts — Призначає рішення (verdicts) до рядків покриття. Відфільтровує мутанти, які вижили, якщо вони кваліфікуються як прийнятний пропуск, і зменшує загальну кількість мутантів у системі відповідно до кількості таких прийнятних пропусків.
+
+## Гарантії поведінки
+
+- (специфічних машинно-виведених гарантій немає)

package/src/coverage-classify/docs/cache.md

@@ -0,0 +1,34 @@
+---
+type: JS Module
+title: cache.mjs
+resource: npm/src/coverage-classify/cache.mjs
+docgen:
+  crc: 53b251b1
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  score: 100
+  issues: judge:inaccurate:0.98
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Механізм кешування фіксує вердикти класифікації мутантів для прискорення аналізу. Він використовує кеш, описаний у `cache.json`, де ключами є ідентифікатори контенту у форматі `<blob-hash>:<line>:<col>:<base64url>`, що динамічно формується на основі хешу файлу (`git hash-object` або `sha1`). Збережені дані включають вердикт, рівень впевненості та причину, а інвалідація кешу спрацьовує при зміні джерела коду, що призводить до нового хешу.
+
+## Поведінка
+
+deriveBlobHash обчислює унікальний хеш контенту файлу, використовуючи `git hash-object` або SHA256 контенту у випадку відсутності Git.
+deriveCacheKey створює унікальний ключ кешу для мутанта на основі хешу файлу, номера рядка, колонки та заміни.
+readCache зчитує дані кешу з файлу, повертаючи порожній кеш у разі відсутності або некоректності.
+writeCache зберігає об'єкт кешу на диск, автоматично створюючи необхідні батьківські директорії.
+
+## Публічний API
+
+deriveBlobHash — Створює унікальний ідентифікатор вмісту файлу (SHA1 хеш).
+deriveCacheKey — Генерує ключ для кешування, що описує зміну файлу у певному стані.
+readCache — Завантажує кешовані дані з диска; повертає порожній кеш при будь-якій помилці зчитування.
+writeCache — Зберігає кешовані дані на диск, створюючи необхідну структуру каталогів.
+
+## Гарантії поведінки
+
+- Перехоплює помилки і не пропускає винятків назовні (fail-safe).
+- Кешує результати в межах одного прогону.

package/src/coverage-classify/docs/index.md

@@ -0,0 +1,40 @@
+---
+type: JS Module
+title: index.mjs
+resource: npm/src/coverage-classify/index.mjs
+docgen:
+  crc: b7eff232
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  score: 100
+  issues: judge:inaccurate:0.99
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Класифікатор визначає, чи слід вважати мутант, переданий у межах `classify`, мутантом, згенерованим тестом. Механізм працює через маршрутизацію через pi SDK (callText). Процес включає перевірку в кеші, пошук у локальній (Tier 1) моделі, пошук у хмарній (Tier 2) моделі, а у разі повної відмови систем — застосування консервативного результату. Усі результати класифікації зберігаються у кеші, який контролюється конфігурацією у `coverage-classify.cache.json`.
+
+Ключовий механізм роботи:
+Перевірка кешу з файлу `coverage-classify.cache.json`. Якщо відповідний запис знайдено, повертається збережений verdicts[]. Якщо кеш не містить результату, ініціюється послідовна класифікація: спочатку за допомогою локальної моделі (`N_LOCAL_MIN_MODEL`), а після невдачі — за допомогою хмарної моделі (`N_CLOUD_MIN_MODEL`). У випадку невдачі обох рівнів, застосовується консервативний fallback (worth-testing/confidence=0). Після успішної класифікації результат додається до кешу.
+
+## Поведінка
+
+1. Отримується кеш з файлу `coverage-classify.cache.json`. Якщо конфігурація моделей у кеші не відповідає поточній, кеш ініціалізується.
+2. Для кожного скомпільованого мутанта у наданому наборі виконується перевірка в кеші за унікальним ключем, що включає шлях до файлу, рядок, стовпець та заміну.
+3. Якщо знайдено відповідний запис у кеші, він повертається як результат класифікації.
+4. Якщо в кеші запису немає, ініціюється класифікація мутанта.
+5. Класифікація здійснюється послідовно через джерела ШІ: спочатку через модель, визначену у змінній `N_LOCAL_MIN_MODEL`, а якщо це не вдається, то через модель, визначену у змінній `N_CLOUD_MIN_MODEL`.
+6. У разі невдачі обох моделей, встановлюється консервативний результат, що вважається мутантом, вартим тестування з низькою впевненістю.
+7. Успішно класифікований результат додається до кешу з часовою відміткою.
+8. Після обробки всіх мутантів, оновлений кеш записується у файл `coverage-classify.cache.json`.
+9. Повертається список результатів класифікації для всіх мутантів.
+
+## Публічний API
+
+- classify — Визначає, які мутанти вижили, використовуючи модель для локальних даних, потім для хмарних, а якщо це не вдається, застосовує запасний варіант.
+
+## Гарантії поведінки
+
+- Read-only: не виконує операцій запису (ФС/БД).
+- Перехоплює помилки і не пропускає винятків назовні (fail-safe).
+- Кешує результати в межах одного прогону.

package/src/coverage-classify/docs/prompt.md

@@ -0,0 +1,30 @@
+---
+type: JS Module
+title: prompt.mjs
+resource: npm/src/coverage-classify/prompt.mjs
+docgen:
+  crc: 12bfb99a
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  score: 100
+  issues: judge:inaccurate:0.98
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Промпт-builder для `coverage-classify` генерує контекстні інструкції. Він визначає статичну роль класифікатора (`SYSTEM_PROMPT`), яка кешується через `cache_control: ephemeral` при виклику API. Динамічно він збирає деталі кожного мутанта (location, source $\pm$10, tests, git) у промпт, що здійснюється функцією `buildUserPrompt`. Процес працює з механізмом fail-safe, запобігаючи виникненню винятків, а кешування відбувається в межах одного прогону.
+
+## Поведінка
+
+SYSTEM_PROMPT визначає роль класифікатора мутацій і встановлює чіткий JSON-схему для відповіді, де мутації класифікуються як 'worth-testing', 'equivalent', 'defensive', 'glue' або 'wrapper'.
+buildUserPrompt збирає повний контекст для класифікації конкретного мутанта, включаючи фрагмент вихідного коду навколо місця мутації, вміст супутніх тестів та останні зміни у Git для створення деталізованого промпта.
+
+## Публічний API
+
+SYSTEM_PROMPT — Визначає основні інструкції та обмеження для AI-агента.
+buildUserPrompt — Формує запит від користувача для розпізнавання конкретного мутагенту.
+
+## Гарантії поведінки
+
+- Перехоплює помилки і не пропускає винятків назовні (fail-safe).
+- Кешує результати в межах одного прогону.

package/src/coverage-classify/docs/verdict-schema.md

@@ -0,0 +1,29 @@
+---
+type: JS Module
+title: verdict-schema.mjs
+resource: npm/src/coverage-classify/verdict-schema.mjs
+docgen:
+  crc: ecf5dfe1
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  score: 100
+  issues: judge:inaccurate:0.98
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Цей файл визначає `VerdictSchema` для структурованого відображення результатів класифікації, які генерує LLM-класифікатор (coverage-classify). Функція `parseVerdict` відповідає за вилучення та валідацію JSON-структури з необробленого тексту відповіді LLM, що дозволяє класифікувати вихід у категорії: `worth-testing`, `equivalent`, `defensive`, `glue` або `wrapper`.
+
+## Поведінка
+
+VerdictSchema: Визначає структуру даних для результатів класифікації, отриманих від LLM.
+parseVerdict: Витягує та перевіряє відповідність JSON-об'єкта з текстової відповіді LLM визначеній схемі.
+
+## Публічний API
+
+VerdictSchema — схема, що описує очікувану структуру відповіді від LLM.
+parseVerdict — видобуває та перевіряє відповідь від LLM щодо відповідності схемі VerdictSchema.
+
+## Гарантії поведінки
+
+- Read-only: не виконує операцій запису (ФС/БД).

package/src/coverage-fix-extract.mjs

@@ -7,7 +7,7 @@
  * спалює сотні тисяч токенів лише на парсинг. Натомість важкий парсинг несе цей
  * скрипт (для JS — мілісекунди, 0 токенів), а агенту віддається рівно потрібна
  * порція:
- *   - `index` — крихітний `[{file, mutants}]` для рішення про фан-аут;
+ *   - `index` — крихітний масив записів `file`/`mutants` для рішення про фан-аут;
  *   - `slice --file <path>` — промпт лише для одного файлу (контекст ±3 рядки),
  *     рівно під когнітивне навантаження одного субагента.
  *
@@ -23,7 +23,7 @@ import { buildFixPrompt } from './coverage-fix.mjs'
 const SURVIVED_SECTION = '## Вцілілі мутанти'
 
 /**
- * Огорожа json-блоку: ≥3 бектики, далі `json` і решта рядка до `\n`. Довжина
+ * Огорожа json-блоку: ≥3 зворотних апострофи, далі `json` і решта рядка до `\n`. Довжина
  * захоплюється в групу 1 — renderMarkdown пише 3, але oxfmt підвищує до 4+, коли
  * сам JSON-вміст містить ``` (типово для original/replacement мутантів).
  */
@@ -31,9 +31,9 @@ const FENCE_OPEN_RE = /(`{3,8})json[^\n]{0,200}\n/
 
 /**
  * Витягує JSON-масив вцілілих мутантів із тексту COVERAGE.md: знаходить секцію
- * `## Вцілілі мутанти`, перший огороджений ` ```json ` блок під нею і парсить.
+ * `## Вцілілі мутанти`, перший огороджений JSON-блок під нею і парсить.
  * @param {string} md повний текст COVERAGE.md
- * @returns {import('./coverage-fix.mjs').SurvivedFileGroup[]} групи вцілілих по файлах (порожньо, якщо секції/блоку немає або JSON невалідний)
+ * @returns {object[]} групи вцілілих по файлах (порожньо, якщо секції/блоку немає або JSON невалідний)
  */
 export function parseSurvivedBlock(md) {
   const sectionAt = md.indexOf(SURVIVED_SECTION)
@@ -44,9 +44,9 @@ export function parseSurvivedBlock(md) {
   const fence = open[1]
   const bodyStart = open.index + open[0].length
   const rest = after.slice(bodyStart)
-  // Закриття — рядок із тих самих бектиків. Усередині JSON реальних переводів
+  // Закриття — рядок із тих самих зворотних апострофів. Усередині JSON реальних переводів
   // рядка немає (JSON.stringify екранує їх як `\n`), тож `\n<fence>` унікально
-  // позначає кінець блоку навіть якщо значення містять бектики.
+  // позначає кінець блоку навіть якщо значення містять зворотні апострофи.
   const closeAt = rest.indexOf(`\n${fence}`)
   const json = closeAt === -1 ? rest : rest.slice(0, closeAt)
   try {
@@ -60,7 +60,7 @@ export function parseSurvivedBlock(md) {
 /**
  * Читає `COVERAGE.md` із кореня проєкту і повертає структуровані групи вцілілих.
  * @param {string} cwd корінь проєкту
- * @returns {Promise<import('./coverage-fix.mjs').SurvivedFileGroup[]>} групи вцілілих по файлах
+ * @returns {Promise<object[]>} групи вцілілих по файлах
  */
 export async function readSurvived(cwd) {
   let md
@@ -73,9 +73,9 @@ export async function readSurvived(cwd) {
 }
 
 /**
- * Згортає групи вцілілих у компактний index `[{file, mutants}]`.
- * @param {import('./coverage-fix.mjs').SurvivedFileGroup[]} survived групи вцілілих
- * @returns {Array<{file:string, mutants:number}>} файл → кількість вцілілих мутантів
+ * Згортає групи вцілілих у компактний index із полями `file` і `mutants`.
+ * @param {object[]} survived групи вцілілих
+ * @returns {object[]} файл → кількість вцілілих мутантів
  */
 export function buildIndex(survived) {
   return survived

package/src/coverage-per-file.mjs

@@ -1,27 +1,25 @@
 /**
  * Per-file coverage via vitest + lcov.
- * Runs vitest (bundled with @7n/test) in a single pass and returns
+ * Runs vitest (bundled with \@7n/test) in a single pass and returns
  * both per-file coverage data and failing tests.
- * Target projects do NOT need vitest or @vitest/coverage-v8 installed.
+ * Target projects do NOT need vitest or \@vitest/coverage-v8 installed.
  */
 import { spawnSync } from 'node:child_process'
 import { existsSync, readFileSync } from 'node:fs'
 import { mkdtemp, readdir, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
-import { createRequire } from 'node:module'
-import { join, relative, dirname } from 'node:path'
+import { join, relative } from 'node:path'
 import { env } from 'node:process'
+import { resolveVitestRun } from './lib/vitest-shim.mjs'
 
-const _require = createRequire(import.meta.url)
-const VITEST_BIN = join(dirname(_require.resolve('vitest/package.json')), 'vitest.mjs')
-
-const TEST_FILE_RE = /\.(test|spec)\.[^.]+$|[/\\]tests?[/\\]/
+const TEST_FILE_RE = /\.(test|spec)\.[^.]+$|(?:^|[/\\])tests?[/\\]/
+const VITEST_UNSUPPORTED_TEST_RE = /bun:test|Cannot find package 'bun/i
 const MAX_ERRORS_PER_FILE = 5
 const MAX_ERROR_LINES = 10
 
 /**
  * @param {string} text lcov.info content
- * @returns {Array<{file: string, pct: number, linesFound: number, linesCovered: number}>}
+ * @returns {Array<{file: string, pct: number, linesFound: number, linesCovered: number}>} per-file coverage rows parsed from lcov
  */
 function parseLcovPerFile(text) {
   const files = []
@@ -53,32 +51,37 @@ function parseLcovPerFile(text) {
 /**
  * @param {string} jsonPath path to vitest JSON results file
  * @param {string} dir project root for relative paths
- * @returns {Array<{file: string, errors: string[]}>}
+ * @returns {Array<{file: string, errors: string[]}>} список failing test-файлів з короткими помилками
  */
-function parseFailingTests(jsonPath, dir) {
+export function parseFailingTests(jsonPath, dir) {
   try {
     const data = JSON.parse(readFileSync(jsonPath, 'utf8'))
-    return (data.testResults ?? [])
-      .filter(r => r.status === 'failed')
-      .map(r => {
-        const assertionErrors = (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}`
-          })
-        // Module-level errors (import/syntax) produce no assertionResults
-        const errors =
-          assertionErrors.length > 0
-            ? assertionErrors
-            : [
-                `Suite error: ${(r.message ?? r.failureMessage ?? 'module-level failure').split('\n').slice(0, MAX_ERROR_LINES).join('\n')}`
-              ]
-        return { file: relative(dir, r.testFilePath ?? r.name), errors }
-      })
-      .filter(f => !f.file.startsWith('..'))
+    return (
+      (data.testResults ?? [])
+        .filter(r => r.status === 'failed')
+        .map(r => {
+          const assertionErrors = (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}`
+            })
+          // Module-level errors (import/syntax) produce no assertionResults
+          const errors =
+            assertionErrors.length > 0
+              ? assertionErrors
+              : [
+                  `Suite error: ${(r.message ?? r.failureMessage ?? 'module-level failure').split('\n').slice(0, MAX_ERROR_LINES).join('\n')}`
+                ]
+          return { file: relative(dir, r.testFilePath ?? r.name), errors }
+        })
+        .filter(f => !f.file.startsWith('..'))
+        // Skip test files that use a non-vitest runner (bun:test, jest, etc.)
+        // They are expected to fail and cannot be fixed by this tool.
+        .filter(f => f.errors.every(e => !VITEST_UNSUPPORTED_TEST_RE.test(e)))
+    )
   } catch {
     return []
   }
@@ -87,20 +90,23 @@ function parseFailingTests(jsonPath, dir) {
 /**
  * Runs vitest coverage + JSON reporter in a single pass.
  * Returns per-file coverage and any failing tests detected in the same run.
- *
  * @param {string} dir project root
- * @returns {Promise<{files: Array<{file: string, pct: number, linesFound: number, linesCovered: number}>, failingTests: Array<{file: string, errors: string[]}>}>}
+ * @returns {Promise<{files: Array<{file: string, pct: number, linesFound: number, linesCovered: number}>, failingTests: Array<{file: string, errors: string[]}>}>} coverage rows and failing tests from one vitest run
  */
 export async function measureCoveragePerFile(dir) {
   const lcovDir = await mkdtemp(join(tmpdir(), '7n-cov-'))
   const jsonResultsFile = join(lcovDir, 'test-results.json')
 
+  const { bin, configArgs } = resolveVitestRun(dir)
   try {
     spawnSync(
       process.execPath,
       [
-        VITEST_BIN,
+        bin,
         'run',
+        ...configArgs,
+        '--root',
+        dir,
         '--passWithNoTests',
         '--coverage',
         '--coverage.reporter=lcov',
@@ -124,15 +130,19 @@ export async function measureCoveragePerFile(dir) {
 
     return { files, failingTests }
   } finally {
-    await rm(lcovDir, { recursive: true, force: true }).catch(() => {})
+    try {
+      await rm(lcovDir, { recursive: true, force: true })
+    } catch {
+      /* ignore cleanup failures */
+    }
   }
 }
 
 /**
  * Files below the coverage threshold.
- * @param {Array<{file: string, pct: number}>} files
- * @param {number} [threshold=80]
- * @returns {Array<{file: string, pct: number}>}
+ * @param {Array<{file: string, pct: number}>} files список файлів із coverage-метриками
+ * @param {number} [threshold] coverage floor; за замовчуванням `80`
+ * @returns {Array<{file: string, pct: number}>} файли, чий coverage нижчий за threshold
  */
 export function getUncoveredFiles(files, threshold = 80) {
   return files.filter(f => f.pct < threshold)
@@ -152,19 +162,27 @@ const IGNORE_DIRS = new Set([
   '.pi',
   'docs',
   'bin',
-  'reports'
+  'reports',
+  'types'
 ])
 
+// Config/tooling files that are not unit-testable source files.
+const CONFIG_FILE_RE =
+  /^(?:vitest|jest|eslint|prettier|stryker|babel|webpack|vite|rollup|tsconfig|jsconfig|knip)\.config\./
+
 /**
  * Recursively finds source code files in a directory, excluding tests and
  * ignored directories. Used for bootstrap when no coverage data exists.
- *
  * @param {string} dir project root
- * @returns {Promise<string[]>} relative paths to source files
+ * @returns {Promise<string[]>} relative paths to source files that look unit-testable
  */
 export async function findSourceFiles(dir) {
   const results = []
 
+  /**
+   * @param {string} current absolute directory path
+   * @param {string} relBase relative path prefix
+   */
   async function walk(current, relBase) {
     let entries
     try {
@@ -177,7 +195,14 @@ export async function findSourceFiles(dir) {
       const rel = relBase ? `${relBase}/${entry.name}` : entry.name
       if (entry.isDirectory()) {
         if (!IGNORE_DIRS.has(entry.name)) await walk(join(current, entry.name), rel)
-      } else if (entry.isFile() && SOURCE_EXT_RE.test(entry.name) && !TEST_FILE_RE.test(rel)) {
+      } else if (
+        entry.isFile() &&
+        SOURCE_EXT_RE.test(entry.name) &&
+        !entry.name.endsWith('.d.ts') &&
+        !entry.name.endsWith('.d.mts') &&
+        !CONFIG_FILE_RE.test(entry.name) &&
+        !TEST_FILE_RE.test(rel)
+      ) {
         results.push(rel)
       }
     }

package/src/docs/assess-need.md

@@ -0,0 +1,31 @@
+---
+type: JS Module
+title: assess-need.mjs
+resource: npm/src/assess-need.mjs
+docgen:
+  crc: 02dd5f01
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  score: 90
+  issues: internal-name:callText,judge:inaccurate:0.98
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Модуль оцінює необхідність написання юніт-тестів для файлів, які не покриті тестами, застосовуючи спочатку швидкі локальні евристичні перевірки. У випадку невизначеності, для отримання структурованої JSON-відповіді, викликається `callText` (без інструментів). Функціонал керується публічними методами `quickClassify` та `assessNeed`. Модуль працює у read-only режимі, не взаємодіючи з ФС чи БД, та використовує механізм fail-safe для обробки помилок.
+
+## Поведінка
+
+Поведінка
+quickClassify визначає, чи виправдано написання юніт-тестів для коду на основі швидких локальних евристик, повертаючи рішення або `null`, якщо випадок неоднозначний.
+assessNeed оцінює перелік файлів з низьким покриттям, вирішуючи очевидні випадки локально та передаючи неоднозначні файли для оцінки за допомогою моделі.
+
+## Публічний API
+
+quickClassify — Швидко визначає клас об'єкта локально, не використовуючи зовнішніх ресурсів (I/O або LLM), повертаючи результат для очевидних випадків або null у випадку невизначеності.
+assessNeed — Визначає, чи потребують тестування перераховані файли, локально розв'язуючи очевидні випадки (наприклад, ре-експорти чи функції з умовами) та ініціюючи виклик LLM лише для неоднозначних файлів.
+
+## Гарантії поведінки
+
+- Read-only: не виконує операцій запису (ФС/БД).
+- Перехоплює помилки і не пропускає винятків назовні (fail-safe).