@nitra/cursor 5.2.1 → 5.3.1

package/skills/fix/js/orchestrator.mjs

@@ -11,18 +11,74 @@ const DEFAULT_MAX_ITER = 3
 const ESCALATE_AFTER = 2
 
 /**
- * @param {string[]} args   CLI аргументи після 'fix'
- * @param {string}   cwd    корінь проєкту
- * @returns {Promise<number>}  0 = all clean, 1 = unresolved
+ * Парсить `--max-iter N` і збирає rule-filter (позиційні аргументи без прапорців).
+ * @param {string[]} args CLI аргументи після 'fix'
+ * @returns {{ maxIter: number, ruleFilter: string[] }} ліміт ітерацій і фільтр правил
  */
-export async function runOrchestratorCli(args, cwd) {
-  const { runLlmWorker, MODEL, MODEL_HEAVY } = await import('./llm-worker.mjs')
-
+function parseOrchestratorArgs(args) {
   const maxIterIdx = args.indexOf('--max-iter')
   const maxIter =
     maxIterIdx === -1 ? DEFAULT_MAX_ITER : Number(args[maxIterIdx + 1] ?? DEFAULT_MAX_ITER) || DEFAULT_MAX_ITER
   const skipIdxs = new Set(maxIterIdx === -1 ? [] : [maxIterIdx, maxIterIdx + 1])
   const ruleFilter = args.filter((a, i) => !a.startsWith('-') && !skipIdxs.has(i))
+  return { maxIter, ruleFilter }
+}
+
+/**
+ * Крок T0-auto: детермінований фікс без LLM, повертає правила, що лишились.
+ * @param {string} cwd корінь проєкту
+ * @param {string[]} ruleFilter фільтр правил
+ * @param {Array<{ ruleId: string }>} failed правила перед кроком
+ * @returns {Array<{ ruleId: string, ok: boolean, output: string }>} правила після T0
+ */
+function runT0Step(cwd, ruleFilter, failed) {
+  spawnSync('bun', [N_CURSOR_BIN, 'fix-t0', ...ruleFilter], { cwd, stdio: 'pipe' })
+
+  const afterT0 = runFixCheck(cwd, ruleFilter)
+  const failedAfterT0 = afterT0?.rules.filter(r => !r.ok) ?? failed
+  const t0Fixed = failed.filter(r => !failedAfterT0.some(f => f.ruleId === r.ruleId))
+
+  if (t0Fixed.length > 0) {
+    console.log(`  ⚙️  T0-auto: ${t0Fixed.map(r => r.ruleId).join(', ')}`)
+  }
+  return failedAfterT0
+}
+
+/**
+ * Крок T1: LLM через pi для кожного правила, з ескалацією моделі за провалами.
+ * @param {Array<{ ruleId: string, output: string }>} failed правила до фіксу
+ * @param {string} cwd корінь проєкту
+ * @param {Map<string, number>} failCount ruleId → кількість провалів підряд (мутується)
+ * @param {{ runLlmWorker: (ruleId: string, output: string, projectRoot: string, opts: {model: string}) => Promise<{ok: boolean, error?: string}>, MODEL: string, MODEL_HEAVY: string }} worker воркер і моделі
+ * @returns {Promise<void>}
+ */
+async function runLlmStep(failed, cwd, failCount, { runLlmWorker, MODEL, MODEL_HEAVY }) {
+  for (const rule of failed) {
+    const prevFails = failCount.get(rule.ruleId) ?? 0
+    const model = prevFails >= ESCALATE_AFTER ? MODEL_HEAVY : MODEL
+    const label = model || 'pi'
+
+    const result = await runLlmWorker(rule.ruleId, rule.output, cwd, { model })
+
+    if (result.ok) {
+      console.log(`  ⚡ LLM (${label}): ${rule.ruleId}`)
+      failCount.delete(rule.ruleId)
+    } else {
+      failCount.set(rule.ruleId, prevFails + 1)
+      const hint = (result.error ?? '').slice(0, 200)
+      console.log(`  ⚡ LLM (${label}): ${rule.ruleId} ❌  ${hint}`)
+    }
+  }
+}
+
+/**
+ * @param {string[]} args   CLI аргументи після 'fix'
+ * @param {string}   cwd    корінь проєкту
+ * @returns {Promise<number>}  0 = all clean, 1 = unresolved
+ */
+export async function runOrchestratorCli(args, cwd) {
+  const worker = await import('./llm-worker.mjs')
+  const { maxIter, ruleFilter } = parseOrchestratorArgs(args)
 
   /** @type {Map<string, number>} ruleId → кількість LLM-провалів підряд */
   const failCount = new Map()
@@ -48,37 +104,10 @@ export async function runOrchestratorCli(args, cwd) {
   if (ruleFilter.length) console.log(`   filter: ${ruleFilter.join(', ')}`)
 
   for (let iter = 1; iter <= maxIter; iter++) {
-    // ── T0-auto: детермінований фікс без LLM ──
-    spawnSync('bun', [N_CURSOR_BIN, 'fix-t0', ...ruleFilter], { cwd, stdio: 'pipe' })
-
-    const afterT0 = runFixCheck(cwd, ruleFilter)
-    const failedAfterT0 = afterT0?.rules.filter(r => !r.ok) ?? failed
-    const t0Fixed = failed.filter(r => !failedAfterT0.some(f => f.ruleId === r.ruleId))
-
-    if (t0Fixed.length > 0) {
-      console.log(`  ⚙️  T0-auto: ${t0Fixed.map(r => r.ruleId).join(', ')}`)
-    }
-
-    failed = failedAfterT0
+    failed = runT0Step(cwd, ruleFilter, failed)
     if (failed.length === 0) break
 
-    // ── T1: LLM через pi ──
-    for (const rule of failed) {
-      const prevFails = failCount.get(rule.ruleId) ?? 0
-      const model = prevFails >= ESCALATE_AFTER ? MODEL_HEAVY : MODEL
-      const label = model || 'pi'
-
-      const result = await runLlmWorker(rule.ruleId, rule.output, cwd, { model })
-
-      if (result.ok) {
-        console.log(`  ⚡ LLM (${label}): ${rule.ruleId}`)
-        failCount.delete(rule.ruleId)
-      } else {
-        failCount.set(rule.ruleId, prevFails + 1)
-        const hint = (result.error ?? '').slice(0, 200)
-        console.log(`  ⚡ LLM (${label}): ${rule.ruleId} ❌  ${hint}`)
-      }
-    }
+    await runLlmStep(failed, cwd, failCount, worker)
 
     // Перевірка після LLM
     const afterLLM = runFixCheck(cwd, ruleFilter)

package/skills/fix/js/t0.mjs

@@ -113,6 +113,43 @@ const HERE = dirname(fileURLToPath(import.meta.url))
 /** Абсолютний шлях до npm/bin/n-cursor.js відносно цього файлу */
 const N_CURSOR_BIN = join(HERE, '../../../bin/n-cursor.js')
 
+/**
+ * Запускає `_fix-check` і парсить JSON-результат.
+ * @param {string[]} ruleFilter список rule-ids (порожній — усі)
+ * @param {string}   cwd  корінь проєкту
+ * @returns {{ rules: Array<{ ruleId: string, ok: boolean, output: string }> } | { _empty: true } | { _badJson: true }} JSON або маркер помилки
+ */
+function fixCheck(ruleFilter, cwd) {
+  const r = spawnSync('bun', [N_CURSOR_BIN, '_fix-check', ...ruleFilter], { cwd, encoding: 'utf8', timeout: 120_000 })
+  const raw = r.stdout?.trim()
+  if (!raw) return { _empty: true, stderr: r.stderr }
+  try {
+    return JSON.parse(raw)
+  } catch {
+    return { _badJson: true }
+  }
+}
+
+/**
+ * Застосовує T0-auto до кожного провального правила, розділяючи на applied/skipped.
+ * @param {Array<{ ruleId: string, output: string }>} failed провальні правила
+ * @param {string} cwd корінь проєкту
+ * @returns {{ applied: Array<{ ruleId: string, actions: string[] }>, skipped: string[] }} застосовані й пропущені
+ */
+function applyT0ToFailed(failed, cwd) {
+  const applied = []
+  const skipped = []
+  for (const r of failed) {
+    const result = applyT0Auto(r.ruleId, r.output, cwd)
+    if (result.applied) {
+      applied.push({ ruleId: r.ruleId, actions: result.actions })
+    } else {
+      skipped.push(r.ruleId)
+    }
+  }
+  return { applied, skipped }
+}
+
 /**
  * CLI підкоманда `n-cursor fix-t0 [rule...]`.
  * Запускає `fix --json`, застосовує T0-auto для кожного violation,
@@ -126,22 +163,13 @@ export function runT0AutoCli(args, cwd) {
   const verbose = args.includes('--verbose') || args.includes('-v')
 
   // 1. Запустити fix --json
-  const fixResult = spawnSync('bun', [N_CURSOR_BIN, '_fix-check', ...ruleFilter], {
-    cwd,
-    encoding: 'utf8',
-    timeout: 120_000
-  })
-  const raw = fixResult.stdout?.trim()
-  if (!raw) {
+  const fixJson = fixCheck(ruleFilter, cwd)
+  if (fixJson._empty) {
     console.error(`n-cursor fix-t0: fix --json повернув порожній stdout`)
-    console.error(fixResult.stderr?.slice(0, 300) ?? '')
+    console.error(fixJson.stderr?.slice(0, 300) ?? '')
     return 1
   }
-
-  let fixJson
-  try {
-    fixJson = JSON.parse(raw)
-  } catch {
+  if (fixJson._badJson) {
     console.error(`n-cursor fix-t0: fix --json повернув невалідний JSON`)
     return 1
   }
@@ -153,16 +181,7 @@ export function runT0AutoCli(args, cwd) {
   }
 
   // 2. Застосувати T0-auto
-  const applied = []
-  const skipped = []
-  for (const r of failed) {
-    const result = applyT0Auto(r.ruleId, r.output, cwd)
-    if (result.applied) {
-      applied.push({ ruleId: r.ruleId, actions: result.actions })
-    } else {
-      skipped.push(r.ruleId)
-    }
-  }
+  const { applied, skipped } = applyT0ToFailed(failed, cwd)
 
   if (applied.length === 0) {
     console.log(`⏭️  fix-t0: T0-auto паттерн не підходить для: ${failed.map(r => r.ruleId).join(', ')}`)
@@ -176,18 +195,11 @@ export function runT0AutoCli(args, cwd) {
   }
 
   // 4. Check-gate: перевірити лише ті правила, що ми чіпали
-  const recheck = spawnSync('bun', [N_CURSOR_BIN, '_fix-check', ...applied.map(a => a.ruleId)], {
-    cwd,
-    encoding: 'utf8',
-    timeout: 120_000
-  })
-  const recheckRaw = recheck.stdout?.trim()
-  if (!recheckRaw) {
+  const recheckJson = fixCheck(applied.map(a => a.ruleId), cwd)
+  if (recheckJson._empty) {
     console.error(`fix-t0: check-gate: fix --json повернув порожній stdout`)
     return 1
   }
-
-  const recheckJson = JSON.parse(recheckRaw)
   const stillFailed = recheckJson.rules.filter(r => !r.ok)
 
   if (verbose) {

package/skills/start-check/js/check.mjs

@@ -111,7 +111,7 @@ function diffSideEffects(before, after) {
  * Запускає `start` одного воркспейсу з grace-таймаутом і класифікує результат.
  * @param {string} cwd корінь репозиторію
  * @param {string} workspace відносний шлях воркспейсу
- * @param {{graceMs?:number, type?:('server'|'cli'), spawnImpl?:Function}} [opts] grace-період, тип (інакше з package.json), інʼєкція spawn для тестів
+ * @param {{graceMs?:number, type?:('server'|'cli'), spawnImpl?:typeof import('node:child_process').spawnSync}} [opts] grace-період, тип (інакше з package.json), інʼєкція spawn для тестів
  * @returns {Promise<{workspace:string, type:string, exitCode:number|null, timedOut:boolean, status:('OK'|'FAIL'), ready:boolean, firstError:string|null, logTail:string, sideEffects:{newFiles:string[], changedTracked:string[]}}>} результат прогону
  */
 export async function runWorkspaceStart(cwd, workspace, opts = {}) {