@nitra/cursor 3.25.1 → 3.27.0

package/skills/fix/js/llm-worker.mjs

@@ -0,0 +1,181 @@
+/**
+ * LLM-worker для n-fix оркестратора — C1 pattern:
+ *   script збирає контекст (rule .mdc + файли з violation) →
+ *   pi повертає JSON зі змінами →
+ *   script застосовує.
+ *
+ * Всі LLM-виклики через `pi` (користувач налаштовує ключі самостійно).
+ * Tool-use не використовується — LLM отримує повний контекст у промпті.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+
+export const MODEL_HAIKU = 'claude-haiku-4-5-20251001'
+export const MODEL_SONNET = 'claude-sonnet-4-6'
+
+/**
+ * Витягує відносні шляхи файлів із violation output.
+ * Шукає патерни типу `path/to/file.ext` або `[ws] path/to/file.ext:123`.
+ *
+ * @param {string} output violation output з fix check
+ * @returns {string[]} унікальні відносні шляхи
+ */
+function extractFilePaths(output) {
+  const seen = new Set()
+  const results = []
+  // Матчить шляхи: слово/крапка/тире, з розширенням, необов'язковий :рядок на кінці
+  const re = /(?:^|\s|\[[\w/]+\]\s)([\w./][\w./\-]*\.(?:json|js|mjs|ts|vue|yml|yaml|toml|mdc|md|sh|py))(?::\d+)?/gm
+  for (const m of output.matchAll(re)) {
+    const p = m[1]
+    if (!seen.has(p)) { seen.add(p); results.push(p) }
+  }
+  return results
+}
+
+/**
+ * Будує prompt для pi: правило + порушення + поточний вміст файлів.
+ *
+ * @param {string} ruleId
+ * @param {string} ruleMdc   вміст .mdc-файлу правила
+ * @param {string} output    violation output
+ * @param {Array<{path:string, content:string}>} files
+ * @returns {string}
+ */
+function buildPrompt(ruleId, ruleMdc, output, files) {
+  const filesBlock = files.length === 0
+    ? '(no files identified)'
+    : files.map(f => `<file path="${f.path}">\n${f.content}\n</file>`).join('\n\n')
+
+  return [
+    `You fix project structure violations. Return ONLY valid JSON — no explanation, no markdown.`,
+    ``,
+    `Rule (n-${ruleId}.mdc):`,
+    `---`,
+    ruleMdc,
+    `---`,
+    ``,
+    `Violation output:`,
+    output,
+    ``,
+    `Current file contents:`,
+    filesBlock,
+    ``,
+    `Return JSON with this exact shape:`,
+    `{"changes":[{"path":"relative/path/to/file","content":"full corrected file content"}]}`,
+    ``,
+    `Rules:`,
+    `- "path" is relative to the project root`,
+    `- "content" is the complete new file content (not a diff)`,
+    `- Only include files that actually need to change`,
+    `- If nothing can be fixed automatically, return {"changes":[],"error":"reason"}`,
+  ].join('\n')
+}
+
+/**
+ * Запускає pi і повертає stdout як рядок.
+ *
+ * @param {string} prompt
+ * @param {string} model
+ * @returns {{ text: string, error?: string }}
+ */
+function callPi(prompt, model) {
+  const r = spawnSync(
+    'pi',
+    ['-p', prompt, '--model', model, '--no-session', '--mode', 'text', '--no-tools'],
+    { encoding: 'utf8', timeout: 120_000 }
+  )
+  if (r.error) return { text: '', error: r.error.message }
+  if (r.status !== 0) {
+    const stderr = r.stderr?.slice(0, 300) ?? ''
+    return { text: '', error: `pi exit ${r.status}: ${stderr}` }
+  }
+  return { text: r.stdout?.trim() ?? '' }
+}
+
+/**
+ * Парсить JSON-відповідь від pi.
+ * pi може обгорнути JSON у ```json ... ```, тому пробуємо витягти.
+ *
+ * @param {string} text
+ * @returns {{ changes: Array<{path:string,content:string}>, error?: string } | null}
+ */
+function parseResponse(text) {
+  // Спроба 1: прямий JSON
+  try { return JSON.parse(text) } catch { /* fallthrough */ }
+
+  // Спроба 2: витягти з ```json ... ```
+  const m = text.match(/```(?:json)?\s*([\s\S]*?)```/)
+  if (m) {
+    try { return JSON.parse(m[1].trim()) } catch { /* fallthrough */ }
+  }
+
+  // Спроба 3: перший { ... } блок
+  const start = text.indexOf('{')
+  const end = text.lastIndexOf('}')
+  if (start !== -1 && end > start) {
+    try { return JSON.parse(text.slice(start, end + 1)) } catch { /* fallthrough */ }
+  }
+
+  return null
+}
+
+/**
+ * LLM-worker: виправляє одне rule-порушення через pi (C1 pattern).
+ *
+ * @param {string} ruleId
+ * @param {string} violationOutput  output з fix check для цього rule
+ * @param {string} projectRoot      абсолютний шлях до кореня проєкту
+ * @param {{ model?: string }} opts
+ * @returns {Promise<{ ok: boolean, error?: string }>}
+ */
+export async function runLlmWorker(ruleId, violationOutput, projectRoot, opts = {}) {
+  const model = opts.model ?? MODEL_HAIKU
+
+  // 1. Читаємо rule .mdc
+  const mdcPath = join(projectRoot, '.cursor', 'rules', `n-${ruleId}.mdc`)
+  const ruleMdc = existsSync(mdcPath) ? readFileSync(mdcPath, 'utf8') : '(rule file not found)'
+
+  // 2. Витягуємо файли з violation output і читаємо їх
+  const filePaths = extractFilePaths(violationOutput)
+  const files = filePaths
+    .map(p => {
+      const abs = join(projectRoot, p)
+      if (!existsSync(abs)) return null
+      try {
+        return { path: p, content: readFileSync(abs, 'utf8') }
+      } catch {
+        return null
+      }
+    })
+    .filter(Boolean)
+
+  // 3. Будуємо prompt і викликаємо pi
+  const prompt = buildPrompt(ruleId, ruleMdc, violationOutput, files)
+  const { text, error: piError } = callPi(prompt, model)
+
+  if (piError) return { ok: false, error: piError }
+  if (!text) return { ok: false, error: 'pi returned empty response' }
+
+  // 4. Парсимо відповідь
+  const parsed = parseResponse(text)
+  if (!parsed) return { ok: false, error: `cannot parse pi response: ${text.slice(0, 200)}` }
+  if (parsed.error) return { ok: false, error: parsed.error }
+
+  const changes = parsed.changes ?? []
+  if (changes.length === 0) return { ok: false, error: 'pi returned no changes' }
+
+  // 5. Застосовуємо зміни
+  for (const change of changes) {
+    if (!change.path || typeof change.content !== 'string') continue
+    const abs = join(projectRoot, change.path)
+    try {
+      writeFileSync(abs, change.content, 'utf8')
+    } catch (e) {
+      return { ok: false, error: `write ${change.path}: ${e.message}` }
+    }
+  }
+
+  return { ok: true }
+}

package/skills/fix/js/orchestrator.mjs

@@ -0,0 +1,128 @@
+/**
+ * Автономний оркестратор n-fix: convergence-loop без участі агента-LLM.
+ *
+ * Тири:
+ *   T0      — детерміністична перевірка (runFixCheck, 0 LLM)
+ *   T0-auto — regex-парсинг violation → програмний фікс (0 LLM)
+ *   T1      — LLM через pi (haiku → sonnet ескалація)
+ *   check-gate — re-run T0 після кожного тіру; loop до maxIter
+ *
+ * meta.json: { "orchestrator": true } — CLI маршрутизує `fix` сюди.
+ */
+
+import { spawnSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { join } from 'node:path'
+
+const HERE = fileURLToPath(new URL('.', import.meta.url))
+const N_CURSOR_BIN = join(HERE, '../../../bin/n-cursor.js')
+
+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
+ */
+export async function runOrchestratorCli(args, cwd) {
+  const { runLlmWorker, MODEL_HAIKU, MODEL_SONNET } = await import('./llm-worker.mjs')
+
+  const maxIterIdx = args.indexOf('--max-iter')
+  const maxIter =
+    maxIterIdx !== -1
+      ? Number(args[maxIterIdx + 1] ?? DEFAULT_MAX_ITER) || 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))
+
+  console.log(`🔄 n-cursor fix`)
+  if (ruleFilter.length) console.log(`   rules: ${ruleFilter.join(', ')}`)
+
+  /** @type {Map<string, number>} ruleId → кількість LLM-провалів підряд */
+  const failCount = new Map()
+
+  for (let iter = 1; iter <= maxIter; iter++) {
+    console.log(`\n── Ітерація ${iter}/${maxIter} ──`)
+
+    // ── T0: check ──
+    const state = runFixCheck(cwd, ruleFilter)
+    if (!state) {
+      console.error(`❌ fix: перевірка повернула помилку`)
+      return 1
+    }
+
+    const failed = state.rules.filter(r => !r.ok)
+    if (failed.length === 0) {
+      console.log(`✅ fix: 0/${state.total} порушень`)
+      return 0
+    }
+
+    console.log(`   ❌ ${failed.length}: ${failed.map(r => r.ruleId).join(', ')}`)
+
+    // ── T0-auto: детермінований фікс без LLM ──
+    spawnSync('bun', [N_CURSOR_BIN, 'fix-t0', ...ruleFilter], { cwd, stdio: 'inherit' })
+
+    const stateAfterT0 = runFixCheck(cwd, ruleFilter)
+    const failedAfterT0 = stateAfterT0?.rules.filter(r => !r.ok) ?? failed
+    if (failedAfterT0.length === 0) {
+      console.log(`✅ fix: всі правила закриті T0-auto`)
+      return 0
+    }
+
+    // ── T1: LLM через pi ──
+    for (const rule of failedAfterT0) {
+      const prevFails = failCount.get(rule.ruleId) ?? 0
+      const model = prevFails >= ESCALATE_AFTER ? MODEL_SONNET : MODEL_HAIKU
+      const tier = prevFails >= ESCALATE_AFTER ? 'sonnet' : 'haiku'
+
+      console.log(`\n⚡ [${tier}] → ${rule.ruleId}`)
+
+      const result = await runLlmWorker(rule.ruleId, rule.output, cwd, { model })
+
+      if (result.ok) {
+        console.log(`   ✅ закрито`)
+        failCount.delete(rule.ruleId)
+      } else {
+        failCount.set(rule.ruleId, prevFails + 1)
+        console.log(`   ❌ (${prevFails + 1}× fail): ${result.error ?? ''}`)
+      }
+    }
+  }
+
+  // ── Фінальна перевірка ──
+  const final = runFixCheck(cwd, ruleFilter)
+  const finalFailed = final?.rules.filter(r => !r.ok) ?? []
+
+  if (finalFailed.length === 0) {
+    console.log(`\n✅ fix: чисто`)
+    return 0
+  }
+
+  console.log(`\n❌ fix: ${finalFailed.length} unresolved після ${maxIter} ітерацій`)
+  console.log(`   ${finalFailed.map(r => r.ruleId).join(', ')}`)
+  return 1
+}
+
+/**
+ * Внутрішня check-gate: запускає fix-перевірки і повертає структурований результат.
+ * Не є публічним CLI — викликається лише оркестратором.
+ *
+ * @param {string}   cwd
+ * @param {string[]} ruleFilter
+ * @returns {{ total: number, failed: number, rules: Array<{ ruleId: string, ok: boolean, output: string }> } | null}
+ */
+function runFixCheck(cwd, ruleFilter = []) {
+  const r = spawnSync('bun', [N_CURSOR_BIN, '_fix-check', ...ruleFilter], {
+    cwd,
+    encoding: 'utf8',
+    timeout: 120_000,
+  })
+  const stdout = r.stdout?.trim()
+  if (!stdout) return null
+  try {
+    return JSON.parse(stdout)
+  } catch {
+    return null
+  }
+}

package/skills/fix/js/t0.mjs

@@ -0,0 +1,229 @@
+/**
+ * T0-auto: детермінований рівень виправлень для n-fix оркестратора.
+ *
+ * Парсить `output` з `n-cursor fix --json` → застосовує програмний фікс без LLM.
+ * Умова застосування: violation-message містить конкретне цільове значення
+ * (назву файлу, рядок для вставки, ім'я залежності), яке можна видобути regex.
+ *
+ * Ієрархія: T0 (rm/create, знаний тип) → T0-auto (parse violation) → T1 (LLM).
+ * T0-auto запускається першим у конвергентному циклі; T1 — лише для решти.
+ *
+ * Публічний API:
+ *   applyT0Auto(ruleId, violationOutput, cwd) → { applied: boolean, actions: string[] }
+ *   listT0AutoRules()                         → string[]  (ids що мають хоч один паттерн)
+ *   runT0AutoCli(args, cwd)                   → Promise<number>  (exit 0=clean, 1=violation)
+ */
+import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+/**
+ * Патерни T0-auto.
+ * Кожен паттерн: {
+ *   id:      string         — унікальна назва паттерну (для логу)
+ *   test:    (output)=>bool — чи підходить цей output до паттерну
+ *   apply:   (match, cwd)=>{ ok: bool, action: string } — застосувати фікс
+ * }
+ */
+const PATTERNS = [
+  // ── vscode-ext-add ──────────────────────────────────────────────────────────
+  // Violation: «recommendations має містити "tsandall.opa"»
+  // Fix: додати рядок у .vscode/extensions.json#recommendations
+  {
+    id: 'vscode-ext-add',
+    test: out => /recommendations має містити "[^"]+"/.test(out),
+    apply: (out, cwd) => {
+      const matches = [...out.matchAll(/recommendations має містити "([^"]+)"/g)]
+      if (matches.length === 0) return { ok: false, action: 'no match' }
+
+      const extPath = join(cwd, '.vscode/extensions.json')
+      if (!existsSync(extPath)) {
+        return { ok: false, action: '.vscode/extensions.json не знайдено' }
+      }
+
+      let parsed
+      try {
+        parsed = JSON.parse(readFileSync(extPath, 'utf8'))
+      } catch {
+        return { ok: false, action: '.vscode/extensions.json: невалідний JSON' }
+      }
+
+      const recs = Array.isArray(parsed.recommendations) ? parsed.recommendations : []
+      const toAdd = matches.map(m => m[1]).filter(e => !recs.includes(e))
+      if (toAdd.length === 0) return { ok: false, action: 'вже є' }
+
+      parsed.recommendations = [...recs, ...toAdd]
+      writeFileSync(extPath, JSON.stringify(parsed, null, 2) + '\n', 'utf8')
+      return { ok: true, action: `додано до extensions.json: ${toAdd.join(', ')}` }
+    },
+  },
+
+  // ── rm-forbidden-file ────────────────────────────────────────────────────────
+  // Violation: «Знайдено заборонений файл: package-lock.json»
+  // Fix: видалити файл
+  {
+    id: 'rm-forbidden-file',
+    test: out => /Знайдено заборонений файл: \S+/.test(out),
+    apply: (out, cwd) => {
+      const matches = [...out.matchAll(/Знайдено заборонений файл: (\S+)/g)]
+      if (matches.length === 0) return { ok: false, action: 'no match' }
+
+      const removed = []
+      for (const m of matches) {
+        const filePath = join(cwd, m[1])
+        if (existsSync(filePath)) {
+          rmSync(filePath, { force: true })
+          removed.push(m[1])
+        }
+      }
+      if (removed.length === 0) return { ok: false, action: 'файлів не знайдено' }
+      return { ok: true, action: `видалено: ${removed.join(', ')}` }
+    },
+  },
+]
+
+/**
+ * Застосовує всі T0-auto паттерни до одного violation-output.
+ *
+ * @param {string} ruleId id правила (для логу)
+ * @param {string} violationOutput рядок з поля `output` у `fix --json`
+ * @param {string} cwd корінь проєкту
+ * @returns {{ applied: boolean, actions: string[] }}
+ */
+export function applyT0Auto(ruleId, violationOutput, cwd) {
+  const actions = []
+  let applied = false
+
+  for (const p of PATTERNS) {
+    if (!p.test(violationOutput)) continue
+    const result = p.apply(violationOutput, cwd)
+    actions.push(`[${p.id}] ${result.action}`)
+    if (result.ok) {
+      applied = true
+    }
+  }
+
+  return { applied, actions }
+}
+
+/**
+ * Повертає список id правил, для яких є хоча б один T0-auto паттерн
+ * (визначається по violation-output із `fix --json`).
+ *
+ * @param {{ ruleId: string, output: string }[]} failedRules
+ * @returns {string[]}
+ */
+export function filterT0AutoRules(failedRules) {
+  return failedRules
+    .filter(r => PATTERNS.some(p => p.test(r.output)))
+    .map(r => r.ruleId)
+}
+
+// ─── CLI entry-point ──────────────────────────────────────────────────────────
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+/** Абсолютний шлях до npm/bin/n-cursor.js відносно цього файлу */
+const N_CURSOR_BIN = join(HERE, '../../../bin/n-cursor.js')
+
+/**
+ * CLI підкоманда `n-cursor fix-t0 [rule...]`.
+ * Запускає `fix --json`, застосовує T0-auto для кожного violation,
+ * повторно перевіряє check-gate, виводить підсумок.
+ *
+ * @param {string[]} args аргументи підкоманди (опційний список rule-ids)
+ * @param {string}   cwd  корінь проєкту
+ * @returns {Promise<number>} 0 — T0-auto закрив всі або немає порушень; 1 — лишились
+ */
+export async function runT0AutoCli(args, cwd) {
+  const ruleFilter = args.filter(a => !a.startsWith('--'))
+  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) {
+    console.error(`n-cursor fix-t0: fix --json повернув порожній stdout`)
+    console.error(fixResult.stderr?.slice(0, 300) ?? '')
+    return 1
+  }
+
+  let fixJson
+  try {
+    fixJson = JSON.parse(raw)
+  } catch {
+    console.error(`n-cursor fix-t0: fix --json повернув невалідний JSON`)
+    return 1
+  }
+
+  const failed = fixJson.rules.filter(r => !r.ok)
+  if (failed.length === 0) {
+    console.log(`✅ fix-t0: всі правила чисті — T0 не потрібен`)
+    return 0
+  }
+
+  // 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)
+    }
+  }
+
+  if (applied.length === 0) {
+    console.log(`⏭️  fix-t0: T0-auto паттерн не підходить для: ${failed.map(r => r.ruleId).join(', ')}`)
+    return 1
+  }
+
+  // 3. Вивести що зробили
+  for (const { ruleId, actions } of applied) {
+    console.log(`⚙️  ${ruleId}:`)
+    for (const a of actions) console.log(`   ${a}`)
+  }
+
+  // 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) {
+    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) {
+    for (const r of recheckJson.rules) {
+      console.log(`  ${r.ok ? '✅' : '❌'} ${r.ruleId}`)
+    }
+  }
+
+  if (stillFailed.length > 0) {
+    console.log(`❌ fix-t0 check-gate: ${stillFailed.map(r => r.ruleId).join(', ')} — лишились`)
+    if (skipped.length > 0) {
+      console.log(`⏭️  без T0 паттерну: ${skipped.join(', ')} → потрібен LLM`)
+    }
+    return 1
+  }
+
+  const totalFixed = applied.length
+  const total = failed.length
+  console.log(
+    `✅ fix-t0: ${totalFixed}/${total} правил закрито T0-auto` +
+    (skipped.length > 0 ? `; ${skipped.join(', ')} → T1 (LLM)` : '')
+  )
+  return 0
+}

package/skills/fix/meta.json

@@ -1 +1 @@
-{ "auto": "завжди", "worktree": true }
+{ "auto": "завжди", "worktree": true, "orchestrator": true }