@nitra/cursor 12.11.1 → 12.11.2

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

@@ -1,136 +0,0 @@
----
-type: JS Module
-title: prompt.mjs
-resource: npm/scripts/coverage-classify/prompt.mjs
-docgen:
-  crc: 12bfb99a
----
-
-Модуль `prompt.mjs` — це prompt-builder для скрипта `coverage-classify`, що класифікує вцілілих мутантів зі звіту Stryker через LLM. Файл експонує дві сутності:
-
-- статичний рядок `SYSTEM_PROMPT`, який описує LLM правила класифікації та формат JSON-відповіді;
-- функцію `buildUserPrompt(mutant, cwd)`, яка для кожного конкретного мутанта збирає контекстний user-prompt: фрагмент вихідного коду навколо мутації, вміст відповідного тестового файла та дату останньої git-активності.
-
-Розділення на статичний `SYSTEM_PROMPT` і динамічний `buildUserPrompt` обґрунтоване стратегією кешування промптів через Anthropic API (`cache_control: ephemeral`) — незмінна частина (системний промпт) кешується між викликами, а змінна (контекст мутанта) формується щоразу заново.
-
-Модуль не виконує жодних мережевих викликів — він лише будує текст. Виклик LLM відбувається у викликальному коді (інший модуль `coverage-classify`).
-
-## Експорти / API
-
-| Експорт                        | Тип                       | Призначення                                                                                                                                                                                                                                                     |
-| ------------------------------ | ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `SYSTEM_PROMPT`                | `string` (named export)   | Статичний англомовний системний промпт для LLM-класифікатора мутантів. Містить опис п'яти можливих verdict-категорій (`worth-testing`, `equivalent`, `defensive`, `glue`, `wrapper`), JSON-схему відповіді та інструкції щодо рівня впевненості (`confidence`). |
-| `buildUserPrompt(mutant, cwd)` | `function` (named export) | Будує user-prompt для одного мутанта.                                                                                                                                                                                                                           |
-
-Внутрішня (не експортована) функція:
-
-- `extractTestTitles(content)` — допоміжна, витягує заголовки `describe/test/it` з тексту test-файла.
-
-Внутрішні константи (не експортуються):
-
-- `CONTEXT_LINES = 10` — кількість рядків контексту вище й нижче рядка мутанта при формуванні фрагмента вихідного коду.
-- `TEST_FILE_MAX_LINES = 2000` — поріг розміру test-файла у рядках; якщо більше — у промпт іде лише список title-ів, а не повний текст.
-
-## Функції
-
-### `extractTestTitles(content)`
-
-Внутрішня helper-функція для редукування довгих тестових файлів до списку заголовків.
-
-- **Сигнатура**: `extractTestTitles(content: string) => string`
-- **Параметри**:
-  - `content` — повний текст test-файла як рядок.
-- **Повертає**: рядок, де кожен запис має формат `describe: <title>` або `test: <title>` / `it: <title>`, з'єднаний через `\n`. Якщо у файлі не знайдено жодного блоку `describe`/`test`/`it` — повертає літерал `(no describe/test blocks found)`.
-- **Алгоритм**: проганяє по `content` глобальний `unicode/multiline` regex `^\s*(describe|test|it)\(['"\`](.+?)['"\`]`, що ловить початки тестових блоків з аргументом у одинарних, подвійних або зворотних лапках. Для кожного match-у формує рядок `<kind>: <title>` і додає до масиву, який в кінці зливається в один рядок.
-- **Side effects**: відсутні (чиста функція).
-- **Обмеження**: regex не аналізує AST, тому коментарі типу `// describe('foo'`) також можуть бути захоплені; для шаблонів промпту це прийнятна апроксимація.
-
-### `buildUserPrompt(mutant, cwd)`
-
-Основна публічна функція модуля. Збирає markdown-розмічений user-prompt з чотирма секціями: метаінформація про мутант, фрагмент вихідного коду, існуючі тести, дата останньої git-активності файла.
-
-- **Сигнатура**: `buildUserPrompt(mutant, cwd: string) => string`, де `mutant` має форму:
-  ```
-  {
-    file: string,         // шлях до файла відносно cwd
-    line: number,         // рядок мутації (1-based)
-    col: number,          // колонка мутації
-    mutantType: string,   // тип мутанта зі Stryker (наприклад "ConditionalExpression")
-    original: string,     // оригінальний фрагмент коду
-    replacement: string   // мутований фрагмент
-  }
-  ```
-- **Параметри**:
-  - `mutant` — об'єкт-опис мутанта, як зазначено вище.
-  - `cwd` — абсолютний шлях до кореня проєкту; використовується для побудови абсолютного шляху до файла й як `cwd` для виклику `git`.
-- **Повертає**: markdown-рядок із секціями `# Mutant`, `# Source context (±10 lines)`, `# Existing tests`, `# Recent activity`. Готовий бути переданим у поле `messages[].content` LLM-запиту.
-- **Side effects**:
-  - синхронні read-only file system операції: `existsSync`, `readFileSync` для джерельного файла й тестового файла;
-  - синхронний виклик процесу `git log -1 --format=%ar -- <absPath>` через `execFileSync` (read-only щодо git-репозиторію).
-- **Обробка помилок / graceful fallback**:
-  - якщо джерельний файл не існує — `srcContext = '(source file unavailable)'`;
-  - якщо тестовий файл не існує — `existingTests = '(no test file)'`;
-  - якщо `git` недоступний, файл untracked або команда падає — `recentActivity = '(no git history)'`. `catch`-блок мовчазний, помилка проковтується (за коментарем `git unavailable or file untracked — keep placeholder`).
-
-#### Алгоритм формування секцій
-
-1. **Абсолютний шлях**: `absPath = join(cwd, mutant.file)`.
-2. **Source context**:
-   - читає файл, розбиває на рядки;
-   - обчислює діапазон `[start, end)`, де `start = max(0, mutant.line - 1 - 10)`, `end = min(lines.length, mutant.line + 10)`;
-   - вирізає slice, додає до кожного рядка префікс `<absoluteLineNumber>: ` (1-based) і об'єднує через `\n`.
-3. **Existing tests** — шукає файл за конвенцією `dirname(absPath)/tests/<basename без .mjs>.test.mjs`:
-   - якщо файл існує і має <= 2000 рядків — вставляє повний вміст;
-   - якщо більше — викликає `extractTestTitles(content)` і вставляє лише заголовки тест-блоків.
-4. **Recent activity**: викликає `git log -1 --format=%ar -- <absPath>` з опціями `cwd`, `encoding: 'utf8'`, `stdio: ['ignore', 'pipe', 'ignore']` (stderr глушиться). Trim-ить результат; якщо він непорожній — підставляє у плейсхолдер.
-5. Повертає шаблонний рядок із усіма зібраними секціями.
-
-## Залежності
-
-### Зовнішні (Node.js builtins)
-
-- `node:child_process` — `execFileSync` для виклику `git log`. Прямий виклик бінарника `git` без shell-інтерпретації (аргументи — масив).
-- `node:fs` — `existsSync`, `readFileSync` для синхронного читання джерельних і тестових файлів.
-- `node:path` — `basename`, `dirname`, `join` для роботи зі шляхами.
-
-### Внутрішньопроєктні
-
-Модуль не імпортує жодних інших модулів проєкту і не має внутрішньопроєктних залежностей.
-
-### Очікувані виклики ззовні
-
-Файл є частиною комплекту `npm/scripts/coverage-classify/`. Сусідні модулі тієї ж теки (`index.mjs`, `apply.mjs`, `cache.mjs`, `verdict-schema.mjs`) ймовірно імпортують `SYSTEM_PROMPT` і `buildUserPrompt` для побудови запитів до LLM і подальшої обробки verdict-ів. Цей файл сам по собі нічого не виконує — він суто «бібліотечний».
-
-## Потік виконання / Використання
-
-Типовий сценарій споживання:
-
-1. Споживач (наприклад `index.mjs` у тій самій теці) імпортує:
-   ```
-   import { SYSTEM_PROMPT, buildUserPrompt } from './prompt.mjs'
-   ```
-2. Для кожного survived-мутанта зі Stryker-звіту:
-   - формує об'єкт `mutant` із полів звіту;
-   - викликає `const userPrompt = buildUserPrompt(mutant, process.cwd())`;
-   - відправляє у LLM-API два повідомлення:
-     - system: `SYSTEM_PROMPT` (з `cache_control: { type: 'ephemeral' }`),
-     - user: `userPrompt`.
-3. LLM повертає JSON-об'єкт за схемою, описаною у `SYSTEM_PROMPT`:
-   ```
-   {
-     "verdict": "worth-testing" | "equivalent" | "defensive" | "glue" | "wrapper",
-     "confidence": number,
-     "reason": string,
-     "suggestedTest": string  // тільки якщо verdict === "worth-testing"
-   }
-   ```
-4. Викликальний код парсить відповідь (валідація схеми ймовірно в `verdict-schema.mjs`) і застосовує її (`apply.mjs`).
-
-### Інваріанти й обмеження
-
-- `mutant.file` має бути шляхом відносно `cwd` — інакше абсолютний шлях буде некоректний і обидва файли (джерело й тест) випадуть у fallback-плейсхолдери.
-- Конвенція розташування тестів є жорсткою: `tests/<basename без .mjs>.test.mjs` поряд з джерельним файлом. Інші конвенції (наприклад `__tests__/` або `.spec.mjs`) не підтримуються — для них `existingTests` буде `(no test file)`.
-- Розширення `.mjs` зашите у `basename(absPath, '.mjs')`. Для файлів інших розширень (`.js`, `.ts`, `.vue`) `basename` залишить розширення в результаті, тому шлях до тестів стане некоректним.
-- `CONTEXT_LINES = 10` і `TEST_FILE_MAX_LINES = 2000` — внутрішні константи, не конфігуруються параметрами.
-- `git log` запускається синхронно — для великої кількості мутантів це може бути bottleneck.
-- Усі операції синхронні; модуль безпечний для послідовного використання, але не оптимізований під concurrent-доступ (хоча сам по собі stateless).

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

@@ -1,28 +0,0 @@
----
-type: JS Module
-title: verdict-schema.mjs
-resource: npm/scripts/coverage-classify/verdict-schema.mjs
-docgen:
-  crc: ecf5dfe1
-  score: 100
----
-
-Файл надає схему `VerdictSchema` для валідації вердиктів LLM-класифікатора. Функція `parseVerdict` витягує JSON-об'єкт з сирої текстової відповіді моделі та перевіряє його відповідність визначеній схемі.
-
-## Поведінка
-
-VerdictSchema
-Визначає схему для валідації вердикту LLM-класифікатора
-
-parseVerdict
-Витягує JSON-об'єкт з текстової відповіді LLM і валідує його за схемою
-
-## Публічний API
-
-VerdictSchema — Схема для структури вердикту.
-parseVerdict — Витягує JSON з тексту LLM і перевіряє його за схемою VerdictSchema.
-
-## Гарантії поведінки
-
-- Read-only: файл не виконує операцій запису у файлову систему.
-- Не звертається до мережі.

package/scripts/coverage-classify/index.mjs

@@ -1,114 +0,0 @@
-/**
- * Public API класифікатора: classify(survived, cwd, opts) → verdicts[]
- *
- * Routing:
- *   1. Cache lookup → hit → використати збережений verdict.
- *   2. Cache miss → Tier 1 (resolveModel('min')) → parseVerdict.
- *   3. Tier 1 fail (model error / bad JSON / Zod) → Tier 2 (CLOUD_MIN через pi).
- *   4. Tier 2 fail → conservative fallback worth-testing/confidence=0.
- *
- * Бекенд обирається за model-id: `omlx/...` → прямий HTTP до omlx (локально),
- * решта → pi CLI. Якщо omlx-Tier 1 недоступний, помилка падає в той самий catch
- * і класифікація відкочується на хмарний Tier 2 через pi.
- */
-import { join } from 'node:path'
-
-import { CLOUD_MIN, resolveModel } from '../../lib/models.mjs'
-import { callLlm } from '../../lib/llm.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)'
-}
-
-/**
- * Викликає LLM через спільний `callLlm` (маршрут за префіксом model-id; wire-trace).
- * @param {string} prompt текст промпта
- * @param {string} model  provider/model-id, `omlx/...` або '' для pi-дефолту
- * @returns {string} текст відповіді моделі
- * @throws {Error} якщо backend недоступний або повертає помилку
- */
-function callModel(prompt, model) {
-  return callLlm([{ role: 'user', content: prompt }], model, { timeoutMs: 60_000, caller: 'coverage' })
-}
-
-/**
- * Два тири: LOCAL_MIN → Tier 2 CLOUD_MIN → FALLBACK_VERDICT.
- * @param {{file: string, mutants: object[]}} group група мутантів одного файлу
- * @param {object} mutant конкретний мутант
- * @param {string} cwd корінь проєкту
- * @param {(prompt: string, model: string) => string} callModelFn  ін'єкція для тестів
- * @returns {object} verdict класифікації
- */
-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}`
-
-  // Tier 1: resolveModel('min') — каскад local→cloud якщо локалі нема
-  try {
-    const text = callModelFn(prompt, resolveModel('min'))
-    return parseVerdict(text)
-  } catch {
-    // Tier 2: CLOUD_MIN
-    try {
-      const text = callModelFn(prompt, CLOUD_MIN)
-      return parseVerdict(text)
-    } catch (error) {
-      console.warn(`⚠ coverage classify: ${loc} both tiers failed: ${error.message}`)
-      return { ...FALLBACK_VERDICT }
-    }
-  }
-}
-
-/**
- * Класифікує survived мутантів (resolveModel('min') → CLOUD_MIN → 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) => string}} [opts] ін'єкції для тестів
- * @returns {Promise<Array<{key: string, verdict: object}>>} verdicts
- */
-export function classify(survived, cwd, opts = {}) {
-  const cachePath = opts.cachePath ?? join(cwd, 'npm/reports/coverage-classify.cache.json')
-  const callModelFn = opts.callModel ?? callModel
-  const cacheModel = `${resolveModel('min') || 'default'}+${CLOUD_MIN || '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 = 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/scripts/coverage-classify/prompt.mjs

@@ -1,126 +0,0 @@
-/**
- * Промпт-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/scripts/coverage-classify/verdict-schema.mjs

@@ -1,35 +0,0 @@
-/**
- * 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/scripts/coverage-fix-extract.mjs

@@ -1,122 +0,0 @@
-/**
- * `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
-}