@7n/test 0.11.0 → 0.11.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.11.2] - 2026-07-04
+
+### Fixed
+
+- 🤖 fix(core): кап runtime-probe виходів (shape-summary + tmp-cwd) і bounded backoff на omlx memory-guard замість миттєвого падіння
+
+## [0.11.1] - 2026-07-04
+
+### Changed
+
+- 🤖 fix(core): omlx memory-guard помилка тепер друкує тіло запиту й завершує процес замість retry
+
 ## [0.11.0] - 2026-07-03
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7n/test",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "CLI-утиліта @7n/test",
   "keywords": [
     "7n",

package/src/docs/gen-tests.md

@@ -3,7 +3,7 @@ type: JS Module
 title: gen-tests.mjs
 resource: npm/src/gen-tests.mjs
 docgen:
-  crc: 899f36bc
+  crc: 243806c4
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
   score: 100
   issues: judge:inaccurate:0.99

package/src/fix-tests.mjs

@@ -19,7 +19,7 @@ import { mkdtemp, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join, relative } from 'node:path'
 import { env } from 'node:process'
-import { callText } from './lib/pi-client.mjs'
+import { callText, MEMORY_ERROR_RE } 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'
@@ -278,6 +278,9 @@ export async function fixFailingTests(dir, opts = {}) {
     try {
       response = await callTextFn(prompt)
     } catch (error) {
+      // memory-guard: не звичайна per-file помилка — RAM-стеля фіксована, продовжувати
+      // до наступного файлу немає сенсу. Пробиваємо нагору до CLI, аби процес завершився.
+      if (MEMORY_ERROR_RE.test(error.message ?? '')) throw error
       console.error(`  ✗ pi помилка: ${error.message}`)
       break
     }

package/src/gen-tests.mjs

@@ -16,7 +16,7 @@
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { spawnSync } from 'node:child_process'
 import { join, relative, dirname } from 'node:path'
-import { callText } from './lib/pi-client.mjs'
+import { callText, MEMORY_ERROR_RE } from './lib/pi-client.mjs'
 import { resolveVitestRun } from './lib/vitest-shim.mjs'
 import { extractExportsWithComplexity } from './classify-exports.mjs'
 import { analyzeModule } from './lib/ast-analyze.mjs'
@@ -51,7 +51,6 @@ const MOCK_TYPE_RE = /:\s*\w*Mock\b/
 const FETCH_CALL_RE = /\bfetch\s*\(/
 const TIME_DEPS_RE = /\bnew\s+Date\b|\bgetHours\b|\bgetDay\b|\bgetMinutes\b|\bDate\.now\b/
 const VITEST_FAIL_RE = /Failed Tests|FAIL /
-const MEMORY_ERROR_RE = /memory guard|memory limit|prefill would require/i
 const EXPECTED_LINE_RE = /Expected:\s+"([^"]+)"/
 const RECEIVED_LINE_RE = /Received:\s+"([^"]+)"/
 const TO_CONTAIN_RE = /to contain '([^='\s]+)=([^']+)'/
@@ -703,13 +702,15 @@ function buildRetryDiagnostics(lastErrors, prevErrorSig, staleCount, label) {
  * @param {number} attempt current attempt number
  * @param {number} maxAttempts retry limit
  * @param {string} label display name for logging
- * @returns {{stop: boolean, reset: boolean, lastErrors: string|null}} loop-control state
+ * @returns {{stop: boolean, lastErrors: string|null}} loop-control state
  */
 function resolveLoopCallFailure(error, attempt, maxAttempts, label) {
+  // memory-guard: не звичайна per-file помилка — RAM-стеля фіксована, продовжувати
+  // до наступного файлу немає сенсу. Пробиваємо нагору до CLI, аби процес завершився.
+  if (MEMORY_ERROR_RE.test(error.message ?? '')) throw error
   console.log(`    ${label} ✗ LLM error (спроба ${attempt}): ${error.message}`)
-  if (attempt >= maxAttempts) return { stop: true, reset: false, lastErrors: null }
-  if (MEMORY_ERROR_RE.test(error.message)) return { stop: false, reset: true, lastErrors: null }
-  return { stop: false, reset: false, lastErrors: `LLM error: ${error.message}` }
+  if (attempt >= maxAttempts) return { stop: true, lastErrors: null }
+  return { stop: false, lastErrors: `LLM error: ${error.message}` }
 }
 
 /**
@@ -760,14 +761,7 @@ async function generateBlockWithLoop(
     } catch (error) {
       const failure = resolveLoopCallFailure(error, attempt, maxAttempts, label)
       if (failure.stop) break
-      if (failure.reset) {
-        lastBlock = null
-        lastErrors = null
-        prevErrorSig = null
-        staleCount = 0
-      } else {
-        lastErrors = failure.lastErrors
-      }
+      lastErrors = failure.lastErrors
       continue
     }
 
@@ -879,6 +873,7 @@ async function generateSharedHeader(ctx, dir, callTextFn) {
     if (header) return header
     console.error(`  ✗ cloud не повернув header для ${file}`)
   } catch (error) {
+    if (MEMORY_ERROR_RE.test(error.message ?? '')) throw error
     console.error(`  ✗ cloud header error: ${error.message}`)
   }
   return null
@@ -1116,6 +1111,7 @@ async function generateOneTest(fileInfo, dir, callTextFn) {
   try {
     response = await callTextFn(prompt, { cwd: dir })
   } catch (error) {
+    if (MEMORY_ERROR_RE.test(error.message ?? '')) throw error
     console.error(`  ✗ pi помилка для ${fileInfo.file}: ${error.message}`)
     return null
   }

package/src/lib/docs/pi-client.md

@@ -3,7 +3,7 @@ type: JS Module
 title: pi-client.mjs
 resource: npm/src/lib/pi-client.mjs
 docgen:
-  crc: f2c45cdc
+  crc: 0aa22b9a
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
   score: 100
   issues: judge:inaccurate:0.98

package/src/lib/pi-client.mjs

@@ -8,9 +8,16 @@
  *
  * Both retry transient connection failures (e.g. a shared local model server
  * that's momentarily busy under concurrent load) with exponential backoff
- * instead of failing the caller's file on the first hiccup.
+ * instead of failing the caller's file on the first hiccup. A memory-guard
+ * rejection gets its own longer bounded backoff: oMLX обслуговує один промпт
+ * одночасно, тож відмова зазвичай відображає залишкову пам'ять попереднього
+ * запиту, яку сервер вивільняє сам за десятки секунд. Лише після
+ * `N_PI_MEMORY_RETRY_ATTEMPTS` невдач тіло запиту друкується в stdout і
+ * помилка прокидається як термінальна (виклики-власники процесу мають дати
+ * їй впасти, не ковтати як звичайну per-file помилку).
  */
 import { createAgentSession, SessionManager, ModelRegistry, AuthStorage } from '@earendil-works/pi-coding-agent'
+import { randomInt } from 'node:crypto'
 import { env } from 'node:process'
 import { setTimeout as sleep } from 'node:timers/promises'
 
@@ -25,26 +32,101 @@ async function getRegistry() {
 }
 
 const RETRYABLE_ERROR_RE = /connection error|ECONNREFUSED|ETIMEDOUT|fetch failed|network/i
+/** Matches a local model server (e.g. oMLX) rejecting a prompt for lack of RAM. */
+export const MEMORY_ERROR_RE = /memory guard|memory limit|prefill would require/i
 const MAX_ATTEMPTS = Number(env.N_PI_RETRY_ATTEMPTS) || 4
 const BASE_DELAY_MS = Number(env.N_PI_RETRY_DELAY_MS) || 1500
 const MAX_DELAY_MS = 15_000
+/** Скільки разів пробуємо промпт, відкинутий memory guard (включно з першою спробою). */
+const MEMORY_MAX_ATTEMPTS = Number(env.N_PI_MEMORY_RETRY_ATTEMPTS) || 3
+/** Базова затримка перед повтором після memory-guard відмови (експоненційно: 15s → 30s → …). */
+const MEMORY_BASE_DELAY_MS = Number(env.N_PI_MEMORY_RETRY_DELAY_MS) || 15_000
+const MEMORY_MAX_DELAY_MS = 60_000
+
+/**
+ * Витягує структуровані поля oMLX-помилки з тексту повідомлення, якщо тіло
+ * 400 (`omlx_code`/`estimated_bytes`/`limit_bytes`) потрапило в message.
+ * `estimated_bytes`/`limit_bytes` — байти GPU/Metal-пам'яті сервера,
+ * ТІЛЬКИ для діагностики й логів (не «скільки символів промпту зрізати»).
+ * @param {string} message текст помилки від SDK/сервера
+ * @returns {{omlxCode?: string, estimatedBytes?: number, limitBytes?: number} | null} знайдені поля або `null`
+ */
+function parseOmlxErrorDetails(message) {
+  const code = /"(?:omlx_)?code"\s*:\s*"([^"]+)"/.exec(message)?.[1]
+  const estimated = /"estimated_bytes"\s*:\s*(\d+)/.exec(message)?.[1]
+  const limit = /"limit_bytes"\s*:\s*(\d+)/.exec(message)?.[1]
+  if (!code && !estimated && !limit) return null
+  const details = {}
+  if (code) details.omlxCode = code
+  if (estimated) details.estimatedBytes = Number(estimated)
+  if (limit) details.limitBytes = Number(limit)
+  return details
+}
+
+/**
+ * Розпізнає memory-guard відмову і збагачує помилку структурованими полями
+ * (`omlxCode`, `estimatedBytes`, `limitBytes`), коли вони доступні в message.
+ * @param {Error} error помилка з виклику моделі
+ * @returns {boolean} `true`, якщо це memory-guard відмова
+ */
+function isMemoryGuardError(error) {
+  const details = parseOmlxErrorDetails(error.message ?? '')
+  if (details) Object.assign(error, details)
+  return error.omlxCode === 'prefill_memory_exceeded' || MEMORY_ERROR_RE.test(error.message ?? '')
+}
+
+/**
+ * Термінальний вихід після вичерпання memory-retry: друкує тіло запиту в
+ * stdout (лише тут — не на проміжних спробах) і кидає помилку далі,
+ * зберігаючи структуровані поля й оригінал у `cause`. Виклики-власники
+ * процесу (CLI) мають дати їй впасти, не ковтати як per-file помилку.
+ * @param {Error} error memory-guard помилка останньої спроби
+ * @param {string} requestBody промпт, надісланий моделі
+ * @returns {never} завжди кидає
+ */
+function failOnMemoryGuard(error, requestBody) {
+  console.log('--- omlx memory-guard: тіло запиту ---')
+  console.log(requestBody)
+  console.log(`✗ omlx memory-guard: ${error.message}`)
+  const wrapped = new Error(`omlx memory-guard: ${error.message}`, { cause: error })
+  for (const key of ['omlxCode', 'estimatedBytes', 'limitBytes']) {
+    if (error[key] !== undefined) wrapped[key] = error[key]
+  }
+  throw wrapped
+}
 
 /**
  * Retries `fn` with exponential backoff + jitter when it throws a transient
  * connection-ish error (shared local model server busy/restarting); other
- * errors (auth, malformed request) are re-thrown immediately.
+ * errors (auth, malformed request) are re-thrown immediately. A memory-guard
+ * rejection has its own bounded schedule (`MEMORY_MAX_ATTEMPTS` спроб,
+ * затримки від `MEMORY_BASE_DELAY_MS` експоненційно): одно-слотова черга
+ * oMLX вивільняє залишкову пам'ять попереднього запиту сама, тож повтор
+ * того самого промпту після паузи легітимний. Після вичерпання —
+ * `failOnMemoryGuard` (друк тіла + термінальний throw).
  * @template T
  * @param {() => Promise<T>} fn operation to retry
+ * @param {string} requestBody prompt sent to the model, printed if a memory-guard error exhausts its retries
  * @returns {Promise<T>} result of the first successful attempt
  */
-async function withRetry(fn) {
-  for (let attempt = 1; ; attempt++) {
+async function withRetry(fn, requestBody) {
+  let memoryAttempts = 0
+  let connAttempts = 0
+  for (;;) {
     try {
       return await fn()
     } catch (error) {
-      if (attempt >= MAX_ATTEMPTS || !RETRYABLE_ERROR_RE.test(error.message ?? '')) throw error
-      const delay = Math.min(BASE_DELAY_MS * 2 ** (attempt - 1), MAX_DELAY_MS)
-      const jitter = delay * (0.5 + Math.random() * 0.5)
+      if (isMemoryGuardError(error)) {
+        memoryAttempts++
+        if (memoryAttempts >= MEMORY_MAX_ATTEMPTS) failOnMemoryGuard(error, requestBody)
+        const delay = Math.min(MEMORY_BASE_DELAY_MS * 2 ** (memoryAttempts - 1), MEMORY_MAX_DELAY_MS)
+        await sleep(delay * (0.5 + randomInt(5000) / 10000))
+        continue
+      }
+      connAttempts++
+      if (connAttempts >= MAX_ATTEMPTS || !RETRYABLE_ERROR_RE.test(error.message ?? '')) throw error
+      const delay = Math.min(BASE_DELAY_MS * 2 ** (connAttempts - 1), MAX_DELAY_MS)
+      const jitter = delay * (0.5 + randomInt(5000) / 10000)
       await sleep(jitter)
     }
   }
@@ -90,7 +172,7 @@ export async function callText(prompt, opts = {}) {
       .filter(c => c.type === 'text')
       .map(c => c.text)
       .join('')
-  })
+  }, prompt)
 }
 
 /**
@@ -109,5 +191,5 @@ export async function callAgent(prompt, cwd) {
     })
 
     await session.prompt(prompt)
-  })
+  }, prompt)
 }

package/src/lib/runtime-probe.mjs

@@ -9,10 +9,26 @@
  * 4. probeHelpers — extracts non-exported helper functions from source and calls them
  *    with generic param combos to reveal their actual output shapes.
  */
-import { readFileSync } from 'node:fs'
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs'
 import { spawnSync } from 'node:child_process'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 
 const PROBE_TIMEOUT_MS = 10_000
+/**
+ * Кап на серіалізований probe-вихід (символів). Довший вихід замінюється
+ * shape-summary — стислим описом форми замість значення: гігантський дамп
+ * (напр. функція, що читає файл проєкту) інакше роздуває LLM-промпт до
+ * сотень тисяч символів і впирається в memory guard моделі, а обрізаний
+ * JSON модель копіює в expected як сміття.
+ */
+const PROBE_OUTPUT_MAX_CHARS = 600
+/** Максимум probe-рядків на один export — багато середніх виходів теж не мають роздувати промпт. */
+const PROBE_MAX_ENTRIES_PER_EXPORT = 12
+/** Глибина рекурсії shape-summary. */
+const SHAPE_MAX_DEPTH = 4
+/** Скільки ключів об'єкта показує shape-summary до «…». */
+const SHAPE_MAX_KEYS = 8
 
 /** Generic argument combos to try when probing async/fetch functions. */
 const FETCH_ARG_COMBOS = [
@@ -70,6 +86,97 @@ const PROBE_INPUTS = [
   ['42', '42']
 ]
 
+/**
+ * Рекурсивно описує форму значення без самих даних.
+ * @param {unknown} value розпарсене JSON-значення
+ * @param {number} [depth] залишкова глибина рекурсії; за замовчуванням `SHAPE_MAX_DEPTH`
+ * @returns {string} стислий опис форми, напр. `Array(34) of {file: string, mutants: Array(12)}`
+ */
+export function describeShape(value, depth = SHAPE_MAX_DEPTH) {
+  if (value === null) return 'null'
+  if (Array.isArray(value)) {
+    if (value.length === 0) return 'Array(0)'
+    if (depth <= 0) return `Array(${value.length})`
+    return `Array(${value.length}) of ${describeShape(value[0], depth - 1)}`
+  }
+  const type = typeof value
+  if (type === 'object') {
+    const keys = Object.keys(value)
+    if (depth <= 0 || keys.length === 0) return 'Object'
+    const shown = keys.slice(0, SHAPE_MAX_KEYS)
+    const inner =
+      depth > 1 ? shown.map(k => `${k}: ${describeShape(value[k], depth - 1)}`).join(', ') : shown.join(', ')
+    return `{${inner}${keys.length > shown.length ? ', …' : ''}}`
+  }
+  if (type === 'string') return 'string'
+  return type
+}
+
+/**
+ * Обмежує серіалізований probe-вихід: до `PROBE_OUTPUT_MAX_CHARS` — без змін,
+ * довший — shape-summary замість значення (модель бачить структуру для
+ * asserts на форму, але не тягне дамп у промпт і не копіює його в expected).
+ * @param {string} serialized JSON-серіалізований вихід probe
+ * @returns {string} оригінал або `[shape-summary, ~N chars] <форма>`
+ */
+export function capProbeOutput(serialized) {
+  if (typeof serialized !== 'string' || serialized.length <= PROBE_OUTPUT_MAX_CHARS) return serialized
+  let shape
+  try {
+    shape = describeShape(JSON.parse(serialized))
+  } catch {
+    shape = 'string'
+  }
+  const summary = `[shape-summary, ~${serialized.length} chars] ${shape}`
+  return summary.length > PROBE_OUTPUT_MAX_CHARS ? `${summary.slice(0, PROBE_OUTPUT_MAX_CHARS - 1)}…` : summary
+}
+
+/**
+ * Застосовує кап виходів і ліміт кількості рядків до результатів `probeModule`.
+ * @param {Record<string, Array<{input: string, output: string}> | {constant: string}>} results сирі результати з дочірнього процесу
+ * @returns {typeof results} результати з capped-виходами
+ */
+function capModuleResults(results) {
+  const capped = {}
+  for (const [name, section] of Object.entries(results)) {
+    if (Array.isArray(section)) {
+      capped[name] = section
+        .slice(0, PROBE_MAX_ENTRIES_PER_EXPORT)
+        .map(entry => ({ ...entry, output: capProbeOutput(entry.output) }))
+    } else if (section && typeof section === 'object' && 'constant' in section) {
+      capped[name] = { constant: capProbeOutput(section.constant) }
+    } else {
+      capped[name] = section
+    }
+  }
+  return capped
+}
+
+/**
+ * Запускає node з probe-скриптом у порожній тимчасовій cwd: відносні
+ * I/O-читання probe-ованих функцій (напр. `readFile('COVERAGE.md')` при
+ * порожньому аргументі шляху) не бачать файлів проєкту — вихід
+ * детермінований між машинами і не може випадково затягнути великий
+ * файл репозиторію у LLM-промпт.
+ * @param {string} script код для виконання
+ * @param {number} [timeout] ліміт очікування в мс; за замовчуванням `PROBE_TIMEOUT_MS`
+ * @returns {import('node:child_process').SpawnSyncReturns<string>} результат spawnSync
+ */
+function spawnProbe(script, timeout = PROBE_TIMEOUT_MS) {
+  const cwd = mkdtempSync(join(tmpdir(), 'n-probe-'))
+  try {
+    return spawnSync('node', ['--input-type=module'], {
+      input: script,
+      encoding: 'utf8',
+      timeout,
+      env: { ...process.env },
+      cwd
+    })
+  } finally {
+    rmSync(cwd, { recursive: true, force: true })
+  }
+}
+
 /**
  * Пробує експорти модуля у дочірньому процесі й повертає фактичні виходи.
  * @param {string} absFilePath абсолютний шлях до джерела модуля
@@ -122,18 +229,13 @@ for (const name of names) {
 process.stdout.write(JSON.stringify(results))
 `
 
-  const proc = spawnSync('node', ['--input-type=module'], {
-    input: script,
-    encoding: 'utf8',
-    timeout: PROBE_TIMEOUT_MS,
-    env: { ...process.env }
-  })
+  const proc = spawnProbe(script)
 
   if (!proc.stdout) return {}
   try {
     const parsed = JSON.parse(proc.stdout)
     if (parsed.__importError) return {}
-    return parsed
+    return capModuleResults(parsed)
   } catch {
     return {}
   }
@@ -150,12 +252,7 @@ process.stdout.write(JSON.stringify(results))
  * @returns {Record<string, unknown> | null} розпарсений JSON або `null` при помилці
  */
 function runProbeScript(script, timeout = PROBE_TIMEOUT_MS) {
-  const proc = spawnSync('node', ['--input-type=module'], {
-    input: script,
-    encoding: 'utf8',
-    timeout,
-    env: { ...process.env }
-  })
+  const proc = spawnProbe(script, timeout)
   if (!proc.stdout) return null
   try {
     const parsed = JSON.parse(proc.stdout)
@@ -211,6 +308,33 @@ process.stdout.write(JSON.stringify(results))
   return runProbeScript(script) ?? {}
 }
 
+/**
+ * Застосовує кап до результатів `probeHelpers`: завеликий `result`
+ * замінюється shape-summary рядком, кількість комбо на helper обмежується.
+ * @param {Record<string, Array<{params: Record<string, unknown>, result: unknown}>>} results сирі результати helper-probe
+ * @returns {typeof results} результати з capped-виходами
+ */
+function capHelperResults(results) {
+  const capped = {}
+  for (const [name, entries] of Object.entries(results)) {
+    if (!Array.isArray(entries)) {
+      capped[name] = entries
+      continue
+    }
+    capped[name] = entries.slice(0, PROBE_MAX_ENTRIES_PER_EXPORT).map(entry => {
+      let serialized
+      try {
+        serialized = JSON.stringify(entry.result)
+      } catch {
+        return entry
+      }
+      if (typeof serialized !== 'string' || serialized.length <= PROBE_OUTPUT_MAX_CHARS) return entry
+      return { ...entry, result: capProbeOutput(serialized) }
+    })
+  }
+  return capped
+}
+
 // ---------------------------------------------------------------------------
 // Probe 3: time-variant detection
 // ---------------------------------------------------------------------------
@@ -386,5 +510,5 @@ for (const name of ${names}) {
 }
 process.stdout.write(JSON.stringify(results))
 `
-  return runProbeScript(script) ?? {}
+  return capHelperResults(runProbeScript(script) ?? {})
 }