@7n/test 0.9.0 → 0.10.1

package/src/fix-tests.mjs

@@ -1,157 +1,303 @@
 /**
- * fix-tests: виявляє падаючі unit-тести і викликає pi-агента для їх виправлення.
+ * fix-tests: виявляє падаючі unit-тести і виправляє їх через pi SDK (text mode).
  *
  * Порядок роботи:
  *   1. getFailingTests(dir) — запускає vitest run --reporter=json і повертає
  *      список падаючих файлів з повідомленнями про помилки.
- *   2. fixFailingTests(dir, opts) — якщо є падіння, будує prompt і викликає pi CLI
- *      в агентному режимі; перевіряє результат повторним getFailingTests.
+ *   2. fixFailingTests(dir, opts) — для кожного падаючого файлу:
+ *        a. Читає поточний вміст тест-файлу та source-файлу
+ *        b. callText → отримує виправлений код у ```js блоці
+ *        c. writeFileSync → записує файл напряму (без Edit інструментів агента)
+ *        d. Повторює до MAX_FIX_ATTEMPTS якщо ще залишились падіння
+ *
+ * Перехід з callAgent (Edit-інструменти) на callText+write усуває проблему
+ * точного матчу рядків що містять URL, backtick-рядки та спецсимволи.
  */
 import { spawnSync } from 'node:child_process'
-import { existsSync, readFileSync } from 'node:fs'
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
 import { mkdtemp, rm } from 'node:fs/promises'
-import { createRequire } from 'node:module'
 import { tmpdir } from 'node:os'
-import { join, relative, dirname } from 'node:path'
+import { join, relative } from 'node:path'
 import { env } from 'node:process'
+import { callText } from './lib/pi-client.mjs'
+import { findTestRules } from './gen-tests.mjs'
+import { parseFailingTests } from './coverage-per-file.mjs'
+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 MODEL = env.N_CURSOR_FIX_TESTS_MODEL ?? env.N_CLOUD_MAX_MODEL ?? undefined
+const MAX_SRC_BYTES = 4000
+const TEST_DIR_MARKERS = ['/tests/', '\\tests\\']
+const TEST_FILE_SUFFIX = '.test.mjs'
+const SOURCE_FILE_SUFFIX = '.js'
+const FILE_MARKER_PREFIX = '<!--'
+const FILE_MARKER_SUFFIX = '-->'
+const FILE_MARKER_LABEL = 'file:'
+const CODE_FENCE_START_RE = /^```(?:js|javascript|mjs|ts)?$/
+const CODE_FENCE_END = '```'
 
-const MODEL = env.N_CURSOR_FIX_TESTS_MODEL ?? env.N_CLOUD_MAX_MODEL ?? ''
-const MAX_ERRORS_PER_FILE = 5
-const MAX_ERROR_LINES = 10
+/**
+ * Infers a source file path from a conventional `tests/<name>.test.mjs` path.
+ * @param {string} absPath absolute test file path
+ * @returns {string|null} inferred source path or null when convention does not match
+ */
+function inferSourcePath(absPath) {
+  const marker = TEST_DIR_MARKERS.find(item => absPath.includes(item))
+  if (!marker || !absPath.endsWith(TEST_FILE_SUFFIX)) return null
+  const markerAt = absPath.lastIndexOf(marker)
+  const dir = absPath.slice(0, markerAt)
+  const stem = absPath.slice(markerAt + marker.length, -TEST_FILE_SUFFIX.length)
+  if (!stem || stem.includes('/') || stem.includes('\\')) return null
+  return `${dir}${marker[0]}${stem}${SOURCE_FILE_SUFFIX}`
+}
+
+/**
+ * Parses an HTML file marker from a single LLM response line.
+ * @param {string} line response line
+ * @returns {string|null} file path from marker or null
+ */
+function parseFileMarker(line) {
+  const trimmed = line.trim()
+  if (!trimmed.startsWith(FILE_MARKER_PREFIX) || !trimmed.endsWith(FILE_MARKER_SUFFIX)) return null
+  const inner = trimmed.slice(FILE_MARKER_PREFIX.length, -FILE_MARKER_SUFFIX.length).trim()
+  if (!inner.startsWith(FILE_MARKER_LABEL)) return null
+  const file = inner.slice(FILE_MARKER_LABEL.length).trim()
+  return file || null
+}
 
 /**
  * Runs vitest in JSON mode and returns failing test files with error messages.
  * @param {string} dir project root
- * @returns {Promise<Array<{file: string, errors: string[]}>>}
+ * @returns {Promise<Array<{file: string, errors: string[]}>>} failing test files with error messages
  */
 export async function getFailingTests(dir) {
   const tmpDir = await mkdtemp(join(tmpdir(), '7n-fix-'))
   const outputFile = join(tmpDir, 'results.json')
 
+  const { bin, configArgs } = resolveVitestRun(dir)
   try {
     spawnSync(
       process.execPath,
-      [VITEST_BIN, 'run', '--reporter=json', `--outputFile=${outputFile}`, '--passWithNoTests'],
-      {
-        cwd: dir,
-        stdio: 'inherit',
-        env
-      }
+      [bin, 'run', ...configArgs, '--root', dir, '--reporter=json', `--outputFile=${outputFile}`, '--passWithNoTests'],
+      { cwd: dir, stdio: 'inherit', env }
     )
 
     if (!existsSync(outputFile)) return []
 
-    let data
+    return parseFailingTests(outputFile, dir)
+  } finally {
     try {
-      data = JSON.parse(readFileSync(outputFile, 'utf8'))
+      await rm(tmpDir, { recursive: true, force: true })
     } catch {
-      return []
+      /* ignore cleanup errors */
     }
-
-    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}`
-          })
-        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('..'))
-  } finally {
-    await rm(tmpDir, { recursive: true, force: true }).catch(() => {})
   }
 }
 
 /**
- * Builds a prompt for pi agent to fix failing tests.
- * @param {Array<{file: string, errors: string[]}>} failures
- * @returns {string}
+ * Extracts the first fenced JavaScript block from LLM text output.
+ * @param {string} text LLM response text.
+ * @returns {string} Extracted code or an empty string.
  */
-export function buildFixTestsPrompt(failures) {
-  const fileList = failures
-    .map(({ file, errors }) => {
-      const errBlock = errors.join('\n\n')
-      return `### \`${file}\`\n\`\`\`\n${errBlock}\n\`\`\``
-    })
-    .join('\n\n')
+function extractCode(text) {
+  const start = text.indexOf('```')
+  if (start === -1) return ''
+  const bodyStart = text.indexOf('\n', start)
+  if (bodyStart === -1) return ''
+  const end = text.indexOf('\n```', bodyStart + 1)
+  if (end === -1) return ''
+  return text.slice(bodyStart + 1, end).trim()
+}
+
+/**
+ * Builds a prompt to fix one failing test file.
+ * Includes current file content so the LLM doesn't need file-read tools.
+ * @param {Array<{file: string, errors: string[]}>} failures failing test files
+ * @param {string} [dir] project root
+ * @returns {string} prompt text for the LLM
+ */
+export function buildFixTestsPrompt(failures, dir) {
+  const testRules = dir ? findTestRules(dir) : null
+
+  const sections = failures.map(({ file, errors }) => {
+    const absPath = dir ? join(dir, file) : file
+    const testCode = existsSync(absPath) ? readFileSync(absPath, 'utf8').slice(0, 6000) : '(файл не знайдено)'
+
+    // Heuristically find source file: strip tests/ prefix from path
+    const sourcePath = inferSourcePath(absPath)
+    const sourceCode =
+      sourcePath && existsSync(sourcePath) ? readFileSync(sourcePath, 'utf8').slice(0, MAX_SRC_BYTES) : null
+
+    const errBlock = errors.join('\n\n')
+
+    return [
+      `### \`${file}\``,
+      '',
+      '**Помилки:**',
+      '```',
+      errBlock,
+      '```',
+      '',
+      '**Поточний тест-файл:**',
+      '```js',
+      testCode,
+      '```',
+      ...(sourceCode ? ['', '**Source (для довідки, не міняй):**', '```js', sourceCode, '```'] : [])
+    ].join('\n')
+  })
 
   return [
-    'Виправ падаючі unit-тести. Для кожного файлу:',
-    '1. Прочитай тест-файл і source-файл що він тестує',
-    '2. Запусти: `bunx vitest run <testFile>` — переконайся в точній помилці',
-    '3. Виправ ЛИШЕ тест-файл — source-файли не чіпай',
-    '4. Запусти тест ще раз — переконайся що зелений',
+    'Виправ падаючі unit-тести. Поверни ПОВНИЙ вміст КОЖНОГО виправленого тест-файлу.',
     '',
     '## Правила:',
-    '- Міняй виключно тест-файли',
-    '- Зберігай структуру тестів (describe/it/expect)',
+    '- Міняй виключно тест-файли — source-файли не чіпай',
+    '- Зберігай структуру тестів (describe/it/expect) — НЕ видаляй тести',
     '- Якщо тест перевіряє неіснуючий API — адаптуй до реального',
-    '- НЕ видаляй тести — лише виправляй',
-    '- Якщо тест тестує видалений функціонал — закоментуй з поясненням чому',
+    '- Файл .mjs = чистий JavaScript, НЕ TypeScript. НІКОЛИ: `as Type`, generics',
+    '- `import { vi, describe, it, expect, beforeEach, afterEach, beforeAll, afterAll } from "vitest"` — імпортуй ВСЕ що використовуєш',
+    '- Замість `fn as vi.Mock` → `vi.mocked(fn)`',
+    '- `vi.spyOn(process, "env")` НЕ ПРАЦЮЄ — use `vi.stubEnv("KEY", "val")` + `afterEach(() => vi.unstubAllEnvs())`',
+    '- `vi.spyOn(Date).mockReturnValue(...)` НЕ ПРАЦЮЄ з `new Date()` — use `vi.useFakeTimers()` + `vi.setSystemTime(new Date(...))` + `afterEach(() => vi.useRealTimers())`',
+    "- `sendMessage` викликає fetch з одним аргументом (URL-рядком) — перевіряй через `expect.stringContaining(...)`, НЕ через об'єктний matcher",
+    '- `describe()` callback НЕ може бути async. `await` тільки у: top-level async IIFE, `beforeAll(async () => {})`, або `it(async () => {})`',
+    "- `vi.mock` hoisting: фабрика виконується до будь-якого `const`/`let` у модулі. Якщо потрібен спільний mock-об'єкт — оголошуй його через `vi.hoisted()`: `const { mockFn } = vi.hoisted(() => ({ mockFn: vi.fn() }))`; потім використовуй в factory та тестах",
+    '- Якщо AssertionError показує `Expected: "A" Received: "B"` — функція реально повертає B. ВИПРАВ expected на точне значення з рядка "Received:", не переосмислюй логіку функції',
+    '- Для regex/escape функцій: тестуй по одному символу (`expect(esc("*")).toBe("\\\\*")`), НЕ комбінований рядок — легко помилитись в подвійному екрануванні',
+    ...(testRules ? ['', '## Конвенції тестів цього проєкту (.cursor/rules/n-test.mdc):', testRules] : []),
+    '',
+    '## Падаючі файли:',
     '',
-    '## Падаючі файли та помилки:',
+    ...sections,
     '',
-    fileList
+    'Для кожного файлу поверни його ПОВНИЙ вміст у блоці:',
+    '<!-- file: <шлях до файлу> -->',
+    '```js',
+    '... повний вміст ...',
+    '```'
   ].join('\n')
 }
 
 /**
- * Calls pi CLI as agent (live output) to fix failing tests.
- * @param {string} prompt
- * @param {string} model provider/model-id або '' для pi-дефолту
- * @param {string} cwd
+ * Parses fenced JavaScript blocks with file markers from LLM response.
+ * @param {string} text LLM response text.
+ * @returns {Array<{file: string|null, code: string}>} Parsed file/code pairs.
  */
-function callPi(prompt, model, cwd) {
-  const modelArgs = model ? ['--model', model] : []
-  spawnSync('pi', ['-p', prompt, ...modelArgs, '--no-session'], {
-    cwd,
-    stdio: 'inherit',
-    timeout: 900_000
-  })
+function parseFixedFiles(text) {
+  const results = []
+  const lines = text.split('\n')
+
+  let lineIndex = 0
+  while (lineIndex < lines.length) {
+    const file = parseFileMarker(lines[lineIndex])
+    if (!file) {
+      lineIndex++
+      continue
+    }
+
+    const fenceStart = lines.findIndex((line, index) => index > lineIndex && CODE_FENCE_START_RE.test(line.trim()))
+    if (fenceStart === -1) break
+
+    const fenceEnd = lines.findIndex((line, index) => index > fenceStart && line.trim() === CODE_FENCE_END)
+    if (fenceEnd === -1) break
+
+    const code = lines
+      .slice(fenceStart + 1, fenceEnd)
+      .join('\n')
+      .trim()
+    if (code) results.push({ file, code })
+    lineIndex = fenceEnd + 1
+  }
+
+  // Fallback: single unnamed block when only one file is being fixed
+  if (results.length === 0) {
+    const code = extractCode(text)
+    if (code) results.push({ file: null, code })
+  }
+  return results
 }
 
+const MAX_FIX_ATTEMPTS = 3
+
 /**
- * Detects and fixes failing tests using a pi agent.
+ * Writes generated fixes to existing test files.
+ * @param {Array<{file: string|null, code: string}>} fixed Parsed fixes.
+ * @param {Array<{file: string, errors: string[]}>} remaining Current failing files.
+ * @param {string} dir Project root.
+ * @returns {void}
+ */
+function writeFixedFiles(fixed, remaining, dir) {
+  for (const { file, code } of fixed) {
+    let absPath = null
+    if (file) {
+      absPath = join(dir, file)
+    } else if (remaining.length === 1) {
+      absPath = join(dir, remaining[0].file)
+    }
+    if (!absPath) {
+      console.error('  ✗ не вдалось визначити файл для запису (немає маркера <!-- file: ... -->)')
+      continue
+    }
+    if (!existsSync(absPath)) {
+      console.error(`  ✗ файл не існує: ${relative(dir, absPath)}`)
+      continue
+    }
+    writeFileSync(absPath, code + '\n', 'utf8')
+    console.log(`  ✓ Записано: ${relative(dir, absPath)}`)
+  }
+}
+
+/**
+ * Detects and fixes failing tests using pi SDK text mode + direct writeFileSync.
  * Returns immediately with count=0 if all tests are already passing.
- *
  * @param {string} dir project root
  * @param {{
  *   failures?: Array<{file: string, errors: string[]}>,
- *   callPi?: (prompt: string, model: string, cwd: string) => void
- * }} [opts]
- * @returns {Promise<{count: number, fixed: number, remaining: number}>}
+ *   callTextFn?: (prompt: string, opts?: object) => Promise<string>
+ * }} [opts] overrides for callText and pre-fetched failures
+ * @returns {Promise<{count: number, fixed: number, remaining: number}>} fix result summary
  */
 export async function fixFailingTests(dir, opts = {}) {
-  const callPiFn = opts.callPi ?? callPi
+  const callTextFn = opts.callTextFn ?? (prompt => callText(prompt, { model: MODEL, cwd: dir }))
   const failures = opts.failures ?? (await getFailingTests(dir))
 
   if (failures.length === 0) return { count: 0, fixed: 0, remaining: 0 }
 
-  console.log(`\n🔧 Виправляю ${failures.length} падаючих test-файлів (pi agent)...\n`)
+  console.log(`\n🔧 Виправляю ${failures.length} падаючих test-файлів (pi text mode)...\n`)
   for (const f of failures) {
     console.log(`  • ${f.file} (${f.errors.length} помилок)`)
   }
   console.log()
 
-  const prompt = buildFixTestsPrompt(failures)
-  callPiFn(prompt, MODEL, dir)
+  let remaining = failures
+  for (let attempt = 1; attempt <= MAX_FIX_ATTEMPTS && remaining.length > 0; attempt++) {
+    if (attempt > 1) {
+      console.log(`\n🔄 Спроба ${attempt}/${MAX_FIX_ATTEMPTS}: залишилось ${remaining.length} файлів...\n`)
+    }
+
+    const prompt = buildFixTestsPrompt(remaining, dir)
+    let response
+    try {
+      response = await callTextFn(prompt)
+    } catch (error) {
+      console.error(`  ✗ pi помилка: ${error.message}`)
+      break
+    }
+
+    const fixed = parseFixedFiles(response)
+
+    if (fixed.length === 0) {
+      console.error('  ✗ pi не повернула виправлений код')
+      break
+    }
+
+    writeFixedFiles(fixed, remaining, dir)
+
+    remaining = await getFailingTests(dir)
+  }
 
-  const after = await getFailingTests(dir)
-  const fixed = failures.length - after.length
+  const fixedCount = failures.length - remaining.length
 
-  if (fixed > 0) console.log(`✓ Виправлено: ${fixed}/${failures.length} файлів`)
-  if (after.length > 0) console.log(`⚠ Залишились падати: ${after.length} файлів`)
+  if (fixedCount > 0) console.log(`✓ Виправлено: ${fixedCount}/${failures.length} файлів`)
+  if (remaining.length > 0) console.log(`⚠ Залишились падати: ${remaining.length} файлів`)
 
-  return { count: failures.length, fixed, remaining: after.length }
+  return { count: failures.length, fixed: fixedCount, remaining: remaining.length }
 }