@nitra/cursor 12.11.0 → 12.11.2

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

@@ -1,207 +0,0 @@
----
-type: JS Module
-title: cache.mjs
-resource: npm/scripts/coverage-classify/cache.mjs
-docgen:
-  crc: 53b251b1
----
-
-Модуль `cache.mjs` реалізує **file-hash-keyed cache** для вердиктів класифікатора покриття мутаційного тестування (`coverage-classify`). Призначення — уникати повторної (зазвичай дорогої — через LLM) класифікації того ж самого мутанта в незмінному файлі.
-
-Ключова ідея кешу:
-
-- Ключ кешу формується з трьох компонентів:
-  1. `blob-hash` — sha1-хеш контенту source-файла (отримується через `git hash-object` з fallback на власне sha1 від `readFileSync`).
-  2. Координати мутанта в файлі: `line:col`.
-  3. `base64url` від рядка-replacement мутанта (щоб ключ був безпечним для будь-яких символів).
-- Формат ключа: `` `<blob-hash>:<line>:<col>:<base64url(replacement)>` ``.
-
-Логіка інвалідації:
-
-- Будь-яка зміна source-файла → новий `blob-hash` → старий ключ більше ніколи не співпадає → `cache miss` → мутант буде перекласифіковано.
-- Інвалідація автоматична: жодного TTL, версіонування user-input або ручного очищення не потрібно.
-
-Схема кешу на диску:
-
-```json
-{
-  "version": 1,
-  "model": "string|null",
-  "entries": {
-    "<key>": {
-      "verdict": "...",
-      "confidence": "...",
-      "reason": "...",
-      "suggestedTest": "...",
-      "classifiedAt": "..."
-    }
-  }
-}
-```
-
-Поле `version` використовується як schema-guard: при зміні константи `CACHE_VERSION` всі старі файли кешу автоматично трактуються як порожні (без помилок), що дозволяє безпечно еволюціонувати схему.
-
-## Експорти / API
-
-Модуль експортує три іменовані функції (ESM):
-
-| Функція                            | Призначення                                                                    |
-| ---------------------------------- | ------------------------------------------------------------------------------ |
-| `deriveBlobHash(filePath)`         | Обчислити sha1-хеш контенту файла.                                             |
-| `deriveCacheKey(filePath, mutant)` | Сформувати повний ключ кешу для конкретного мутанта в конкретному стані файла. |
-| `readCache(cachePath)`             | Безпечно прочитати cache з диска з порожнім fallback.                          |
-| `writeCache(cachePath, cache)`     | Записати cache на диск (з автостворенням батьківських директорій).             |
-
-Внутрішня (не експортована) константа:
-
-- `CACHE_VERSION = 1` — поточна версія schema.
-
-## Функції
-
-### `deriveBlobHash(filePath)`
-
-Обчислює 40-символьний hex sha1-хеш контенту файла.
-
-- **Сигнатура:** `deriveBlobHash(filePath: string): string | null`
-- **Параметри:**
-  - `filePath` — абсолютний шлях до source-файла.
-- **Повертає:**
-  - 40-символьний hex-рядок (sha1) — якщо файл прочитано.
-  - `null` — якщо файл не існує (`existsSync` повернув `false`).
-- **Алгоритм:**
-  1. Якщо файл відсутній — повернути `null`.
-  2. Спробувати викликати `git hash-object <file>` через `execFileSync` з кодуванням `utf8` і обрізати whitespace (`.trim()`). Це детерміністичний хеш в межах working tree; точно такий же хеш Git використовує внутрішньо для blob-ів.
-  3. Якщо `git` недоступний або кинув помилку — fallback: прочитати файл (`readFileSync`) і обчислити `createHash('sha1').update(content).digest('hex')`.
-- **Side effects:** виконує зовнішній процес `git`; читає файл (у fallback-гілці).
-- **Чому два шляхи:** `git hash-object` працює швидше для великих репозиторіїв і додає до хешу префікс `blob <size>\0` як справжній Git. Однак скрипт може бути запущений у середовищі без `git` (CI worker, контейнер) — звідси sha1-fallback. Для двох однакових файлів обидва методи дають **різні** хеші, але це **не критично**, бо ключ кешу самосумісний у межах одного запуску — головне, щоб хеш був детерміністичним для тих самих байтів.
-
-### `deriveCacheKey(filePath, mutant)`
-
-Формує ключ кешу для конкретного мутанта в конкретному стані файла.
-
-- **Сигнатура:** `deriveCacheKey(filePath: string, mutant: { line: number, col: number, replacement: string }): string | null`
-- **Параметри:**
-  - `filePath` — абсолютний шлях до source-файла, в якому міститься мутант.
-  - `mutant` — об'єкт-опис мутанта:
-    - `line: number` — номер рядка (1-based, як прийнято в Stryker/інших мутаторах).
-    - `col: number` — номер колонки.
-    - `replacement: string` — рядок-заміна, який мутатор вставляє замість оригінального коду.
-- **Повертає:**
-  - Рядок виду `` `<sha1>:<line>:<col>:<base64url>` ``.
-  - `null` — якщо `deriveBlobHash` повернув `null` (файл недоступний → ключ створити неможливо).
-- **Алгоритм:**
-  1. Отримати `blobHash` через `deriveBlobHash(filePath)`.
-  2. Якщо `null` — повернути `null` (попереджаючий контракт: caller має обробити cache-miss).
-  3. Закодувати `mutant.replacement` як `base64url` (без `=` padding і без `/`/`+`, що робить його безпечним і для filename, і для key).
-  4. Зібрати ключ template-literal-ом.
-- **Side effects:** ті ж, що й у `deriveBlobHash` (виклик `git`/`readFileSync`).
-- **Чому `base64url`:** `replacement` може містити будь-які символи (двокрапки, переноси рядків, юнікод). `base64url` гарантує однорядковий ASCII-ключ без колізій по роздільнику `:`.
-
-### `readCache(cachePath)`
-
-Безпечно читає cache з диска. Будь-яка аномалія (відсутність файла, битий JSON, чужа схема) **не кидає** помилку, а повертає порожній cache.
-
-- **Сигнатура:** `readCache(cachePath: string): { version: number, model: string | null, entries: Record<string, object> }`
-- **Параметри:**
-  - `cachePath` — абсолютний шлях до файла `cache.json`.
-- **Повертає:** об'єкт cache-схеми. Або реальні дані з диска, або **empty cache**:
-
-  ```js
-  { version: CACHE_VERSION, model: null, entries: {} }
-  ```
-
-- **Алгоритм (5 умов повернення empty):**
-  1. Файл не існує (`!existsSync(cachePath)`) → empty.
-  2. `JSON.parse` кинув виняток → empty (catch).
-  3. `data?.version !== CACHE_VERSION` (включно з `data === null`/`undefined`) → empty.
-  4. `!data.entries` → empty.
-  5. `typeof data.entries !== 'object'` або `Array.isArray(data.entries)` → empty.
-  6. Інакше повернути `data` як є.
-- **Side effects:** читає файл з диска (`readFileSync` з кодуванням `utf8`).
-- **Інваріант:** ніколи не кидає винятки — гарантовано повертає валідний cache-об'єкт.
-
-### `writeCache(cachePath, cache)`
-
-Серіалізує cache в JSON і записує на диск.
-
-- **Сигнатура:** `writeCache(cachePath: string, cache: { version: number, model: string | null, entries: Record<string, object> }): void`
-- **Параметри:**
-  - `cachePath` — абсолютний шлях, куди писати (наприклад `<repo>/.cache/coverage-classify/cache.json`).
-  - `cache` — cache-об'єкт у відповідності до schema.
-- **Повертає:** `void`.
-- **Алгоритм:**
-  1. `mkdirSync(dirname(cachePath), { recursive: true })` — гарантовано створює всі батьківські директорії; не падає, якщо вони вже існують.
-  2. `writeFileSync(cachePath, JSON.stringify(cache, null, 2) + '\n', 'utf8')` — двопробільний indent для людиночитності + trailing newline (POSIX-конвенція).
-- **Side effects:** створює директорії, перезаписує файл повністю (атомарність не гарантується — це звичайний `writeFileSync`).
-
-## Залежності
-
-Лише модулі стандартної бібліотеки Node.js (ESM):
-
-| Імпорт                                                     | Звідки               | Призначення                                                        |
-| ---------------------------------------------------------- | -------------------- | ------------------------------------------------------------------ |
-| `execFileSync`                                             | `node:child_process` | Виклик `git hash-object` як зовнішнього процесу.                   |
-| `createHash`                                               | `node:crypto`        | sha1-fallback, якщо `git` недоступний.                             |
-| `existsSync`, `mkdirSync`, `readFileSync`, `writeFileSync` | `node:fs`            | Sync-FS-операції для cache та source-файлів.                       |
-| `dirname`                                                  | `node:path`          | Виокремити батьківську директорію з cache-шляху перед `mkdirSync`. |
-
-Зовнішніх npm-залежностей **немає**. Усі імпорти — з prefix `node:` (рекомендований формат для Node.js core-модулів).
-
-Опціональна зовнішня залежність: бінарник `git` у `$PATH`. Якщо його немає — модуль автоматично переходить на sha1-fallback.
-
-## Потік виконання / Використання
-
-Типовий sequence використання у класифікаторі:
-
-1. На старті прогону: `cache = readCache(cachePath)`.
-2. Для кожного мутанта:
-   1. `key = deriveCacheKey(filePath, mutant)`.
-   2. Якщо `key === null` — пропустити (файл-джерело недоступний) або повторити пізніше.
-   3. Якщо `cache.entries[key]` існує — використати збережений verdict, **не** викликати LLM.
-   4. Інакше — викликати класифікатор (LLM/heuristic), отримати `verdict` і записати:
-      ```js
-      cache.entries[key] = { verdict, confidence, reason, suggestedTest, classifiedAt: new Date().toISOString() }
-      ```
-3. На завершенні прогону: `writeCache(cachePath, cache)`.
-
-Граничні випадки та їх обробка:
-
-- **Source файл видалили** → `deriveBlobHash` повертає `null` → `deriveCacheKey` повертає `null`. Caller повинен пропустити кешування.
-- **Git недоступний** → автоматичний fallback на sha1. Ключі будуть відрізнятися від ключів, отриманих через `git hash-object` для того ж файла. Тому при міграції оточення можливий повний cache-miss — але це безпечно (просто повторна класифікація).
-- **Cache-файл пошкоджений** → `readCache` повертає empty cache. Жодних винятків. Старий битий вміст буде перезаписаний при наступному `writeCache`.
-- **Зміна `CACHE_VERSION`** → всі попередні файли кешу мовчки трактуються як empty. Безпечний шлях для еволюції schema.
-
-Приклад мінімального використання:
-
-```js
-import { readCache, writeCache, deriveCacheKey } from './cache.mjs'
-
-const cachePath = '/abs/path/to/cache.json'
-const cache = readCache(cachePath)
-
-const key = deriveCacheKey('/abs/path/to/src/foo.js', { line: 10, col: 5, replacement: '' })
-if (key && cache.entries[key]) {
-  // Cache hit — використати готовий verdict.
-  const verdict = cache.entries[key]
-  console.log(verdict)
-} else if (key) {
-  // Cache miss — викликати класифікатор і зберегти.
-  const verdict = await classify(/* ... */)
-  cache.entries[key] = { ...verdict, classifiedAt: new Date().toISOString() }
-}
-
-writeCache(cachePath, cache)
-```
-
-## Rebuild Test
-
-Розумова перевірка: чи можна за цією документацією відтворити модуль без читання source? Так:
-
-- Заявлені 4 експорти (`deriveBlobHash`, `deriveCacheKey`, `readCache`, `writeCache`) — всі описані з сигнатурами, типами параметрів, повертанням, side effects і алгоритмом.
-- Внутрішня константа `CACHE_VERSION = 1` згадана.
-- Schema cache-файла наведена.
-- Алгоритм формування ключа (3 компоненти + base64url для replacement) пояснений однозначно.
-- Fallback-логіка `git hash-object` → `sha1(readFileSync)` описана.
-- Поведінка `readCache` при кожному типі помилки (5 пунктів) перерахована.
-- Імпорти node-core модулів перелічені з їх роллю.
-- Жодного зовнішнього npm-пакета не використано.

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

@@ -1,14 +0,0 @@
----
-type: JS Module
-title: index.mjs
-resource: npm/scripts/coverage-classify/index.mjs
-docgen:
-  crc: 06249ac8
----
-
-| Файл                                    | Тип       | Опис                                                                                                   |
-| --------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------ |
-| [apply.mjs](apply.md)                   | JS Module | Модуль apply.mjs із пакета coverage-classify відповідає за \*\*застосування вердиктів класифікатора му |
-| [cache.mjs](cache.md)                   | JS Module | Модуль cache.mjs реалізує **file-hash-keyed cache** для вердиктів класифікатора покриття мутаційного   |
-| [prompt.mjs](prompt.md)                 | JS Module | Модуль prompt.mjs — це prompt-builder для скрипта coverage-classify, що класифікує вцілілих мутантів   |
-| [verdict-schema.mjs](verdict-schema.md) | JS Module | Файл надає схему VerdictSchema для валідації вердиктів LLM-класифікатора.                              |

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}
-`
-}