@nitra/cursor 1.32.0 → 1.35.1

package/scripts/coverage-classify/index.mjs

@@ -0,0 +1,129 @@
+/**
+ * Public API класифікатора: classify(survived, cwd, opts) → verdicts[]
+ *
+ * Orchestration:
+ *   1. Перевірка ANTHROPIC_API_KEY + dynamic import SDK (graceful skip).
+ *   2. Для кожного мутанта: cache lookup → класифікація → cache write.
+ *   3. На неуспішну класифікацію після retries — conservative fallback worth-testing/confidence=0.
+ *
+ * Prompt caching: system-prompt передається з cache_control: ephemeral —
+ * усі мутанти одного прогону reuse кешований префікс на стороні API.
+ */
+import { join } from 'node:path'
+import { env } from 'node:process'
+import { setTimeout } from 'node:timers/promises'
+
+import { deriveCacheKey, readCache, writeCache } from './cache.mjs'
+import { buildUserPrompt, SYSTEM_PROMPT } from './prompt.mjs'
+import { parseVerdict } from './verdict-schema.mjs'
+
+const MODEL = 'claude-sonnet-4-6'
+const MAX_RETRIES = 2
+const DEFAULT_RETRY_DELAY_MS = 1000
+
+const FALLBACK_VERDICT = {
+  verdict: 'worth-testing',
+  confidence: 0,
+  reason: 'LLM-classification unavailable, conservative fallback (treat as worth-testing)'
+}
+
+/**
+ * Класифікує survived мутантів через Claude API.
+ * Без API key / без SDK / при критичних помилках — повертає [] (graceful skip).
+ * @param {Array<{file: string, mutants: Array<object>, exampleTest?: object|null, recommendationText?: string|null}>} survived список survived груп (як у COVERAGE.md)
+ * @param {string} cwd корінь проєкту
+ * @param {{cachePath?: string, client?: object, retryDelayMs?: number}} [opts] ін'єкції для тестів
+ * @returns {Promise<Array<{key: string, verdict: object}>>} verdicts
+ */
+export async function classify(survived, cwd, opts = {}) {
+  const cachePath = opts.cachePath ?? join(cwd, 'npm/reports/coverage-classify.cache.json')
+  const retryDelayMs = opts.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS
+
+  if (!env.ANTHROPIC_API_KEY) {
+    console.warn('⚠ coverage classify: ANTHROPIC_API_KEY not set, classification skipped')
+    return []
+  }
+
+  let SDK
+  try {
+    SDK = await import('@anthropic-ai/sdk')
+  } catch {
+    console.warn('⚠ coverage classify: @anthropic-ai/sdk not installed, classification skipped')
+    return []
+  }
+  const Anthropic = SDK.default
+  const client = opts.client ?? new Anthropic()
+
+  const cache = readCache(cachePath)
+  if (cache.model !== MODEL) {
+    cache.entries = {}
+    cache.model = MODEL
+  }
+
+  const verdicts = []
+  for (const group of survived) {
+    for (const mutant of group.mutants) {
+      const lookupKey = `${group.file}:${mutant.line}:${mutant.col}:${mutant.replacement}`
+      const cacheKey = deriveCacheKey(join(cwd, group.file), mutant)
+
+      let verdict = null
+      if (cacheKey && cache.entries[cacheKey]) {
+        const cached = cache.entries[cacheKey]
+        verdict = {
+          verdict: cached.verdict,
+          confidence: cached.confidence,
+          reason: cached.reason,
+          ...(cached.suggestedTest ? { suggestedTest: cached.suggestedTest } : {})
+        }
+      }
+      if (!verdict) {
+        verdict = await classifyOne(client, group, mutant, cwd, retryDelayMs)
+        if (cacheKey) {
+          cache.entries[cacheKey] = { ...verdict, classifiedAt: new Date().toISOString() }
+        }
+      }
+
+      verdicts.push({ key: lookupKey, verdict })
+    }
+  }
+
+  writeCache(cachePath, cache)
+  return verdicts
+}
+
+/**
+ * Один виклик API з retry. На фейл після MAX_RETRIES — повертає FALLBACK_VERDICT.
+ * @param {{messages: {create: Function}}} client SDK client
+ * @param {{file: string}} group group для контексту
+ * @param {object} mutant mutant data
+ * @param {string} cwd корінь
+ * @param {number} retryDelayMs base delay для exp-backoff (0 у тестах)
+ * @returns {Promise<object>} verdict (parsed або fallback)
+ */
+async function classifyOne(client, group, mutant, cwd, retryDelayMs) {
+  const userPrompt = buildUserPrompt({ ...mutant, file: group.file }, cwd)
+  let lastError = null
+
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const response = await client.messages.create({
+        model: MODEL,
+        max_tokens: 1024,
+        system: [{ type: 'text', text: SYSTEM_PROMPT, cache_control: { type: 'ephemeral' } }],
+        messages: [{ role: 'user', content: userPrompt }]
+      })
+      const text = response?.content?.[0]?.text ?? ''
+      return parseVerdict(text)
+    } catch (err) {
+      lastError = err
+      if (attempt < MAX_RETRIES && retryDelayMs > 0) {
+        await setTimeout(retryDelayMs * Math.pow(2, attempt))
+      }
+    }
+  }
+
+  console.warn(
+    `⚠ coverage classify: ${group.file}:${mutant.line}:${mutant.col} failed after ${MAX_RETRIES + 1} attempts: ${lastError?.message ?? 'unknown'}`
+  )
+  return { ...FALLBACK_VERDICT }
+}

package/scripts/coverage-classify/prompt.mjs

@@ -0,0 +1,126 @@
+/**
+ * Промпт-builder для coverage-classify.
+ * SYSTEM_PROMPT — статичний, кешується через cache_control: ephemeral у API call.
+ * buildUserPrompt — асемблює per-mutant контекст (location, source ±10, tests, git).
+ */
+import { execFileSync } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { basename, dirname, join } from 'node:path'
+
+const CONTEXT_LINES = 10
+const TEST_FILE_MAX_LINES = 2000
+
+export const SYSTEM_PROMPT = `You are a mutation testing classifier.
+
+For each survived Stryker mutant, classify it into exactly one verdict:
+
+- **worth-testing**: pure logic with real branches that should be tested. The mutant
+  exposes a missing assertion in a unit test. Recommend a test approach.
+- **equivalent**: the mutated code is behaviorally indistinguishable from the original
+  (e.g., both branches produce the same observable output, or the mutant lies on dead
+  code). You MUST cite a concrete reason referencing input flow or output equivalence.
+- **defensive**: the branch guards against an impossible state given input contracts
+  or type system. You MUST identify the invariant that makes the state unreachable.
+- **glue**: thin CLI entrypoint, factory, or boilerplate (e.g., runStandardRule
+  wrapper, fix.mjs stubs). Integration tests via subprocess cover the behavior.
+  Name the integration test or pattern.
+- **wrapper**: thin shell around an external tool (spawnSync, fetch, dynamic import).
+  The wrapper has no logic worth unit-testing in isolation; behavior comes from the
+  wrapped tool. Name the integration test or pattern.
+
+Output ONLY a single JSON object matching this schema:
+
+\`\`\`
+{
+  "verdict": "worth-testing" | "equivalent" | "defensive" | "glue" | "wrapper",
+  "confidence": number 0-1,
+  "reason": string (20-500 chars; concrete code-level reference, not "seems like"),
+  "suggestedTest": string (max 300 chars; required only when verdict is worth-testing)
+}
+\`\`\`
+
+Confidence guidance:
+- 0.9+: cite specific code fragment, identifier, or input contract proving the verdict.
+- 0.7-0.9: strong inference from visible code structure.
+- <0.7: ambiguity, lacking context, or unfamiliar pattern. Be honest.
+
+Never invent integration test names. If you cannot identify a covering test, use
+worth-testing with low confidence instead of glue/wrapper.
+`
+
+/**
+ * Витягує describe/test/it title з рядка тексту.
+ * @param {string} content повний текст test-файла
+ * @returns {string} список "describe: <title>" / "test: <title>" або порожній
+ */
+function extractTestTitles(content) {
+  const titles = []
+  for (const match of content.matchAll(/^\s*(describe|test|it)\(['"`](.+?)['"`]/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

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