@nitra/cursor 1.8.220 → 1.8.221

package/scripts/check-k8s.mjs

@@ -325,6 +325,18 @@ const K8S_BASE_SEGMENT_RE = /(^|\/)k8s\/base\//u
 const OXLINT_SCHEMA_MODELINE_RE = /^\s*#\s*yaml-language-server:\s*\$schema=\S+/u
 const HTTPS_SCHEMA_RE = /^https:/iu
 const HASURA_GRAPHQL_ENGINE_RE = /(^|\/)hasura\/graphql-engine(?::|$)/u
+const BASE_CANON_MEMORY_RE = /^128Mi$/iu
+
+/**
+ * Видаляє хвостові символи `\n` зі стрічки без regex (щоб не тригерити sonarjs/slow-regex).
+ * @param {string} s стрічка YAML/тексту
+ * @returns {string} стрічка без trailing newlines
+ */
+function stripTrailingNewlines(s) {
+  let end = s.length
+  while (end > 0 && s.codePointAt(end - 1) === 10) end--
+  return end === s.length ? s : s.slice(0, end)
+}
 const BATCH_V1BETA1_API_VERSION_LINE_RE = /^(\s*apiVersion:\s*)["']?batch\/v1beta1["']?(\s*)$/u
 
 /**
@@ -665,15 +677,25 @@ async function validateKustomizationPatchesStructuralSort(root, yamlFilesAbs, fa
     if (kust === null) continue
     const outer = kustomizationPatchesSortedViolation(kust)
     if (outer !== null) fail(`${rel}: ${outer}`)
-    const patches = kust.patches
-    if (!Array.isArray(patches)) continue
-    for (const [i, p] of patches.entries()) {
-      if (p === null || typeof p !== 'object' || Array.isArray(p)) continue
-      const rec = /** @type {Record<string, unknown>} */ (p)
-      if (typeof rec.patch !== 'string') continue
-      const v = kustomizationInlinePatchOpsSortedViolation(rec.patch)
-      if (v !== null) fail(`${rel}: patches[${i}] (${kustomizationPatchLabel(p, i)}): ${v}`)
-    }
+    if (!Array.isArray(kust.patches)) continue
+    validateInlinePatchesSorted(rel, kust.patches, fail)
+  }
+}
+
+/**
+ * Перевіряє, що inline-`patch:` (рядок YAML/JSON) у кожному `patches[i]` має ops у канонічному порядку
+ * (`add`/`replace` за `path`). Чужі форми (без `patch`-стрічки, з `target` без inline-блока) пропускаються.
+ * @param {string} rel відносний шлях `kustomization.yaml` для повідомлень
+ * @param {unknown[]} patches масив `kust.patches` (рекордів)
+ * @param {(msg: string) => void} fail callback при порушенні
+ */
+function validateInlinePatchesSorted(rel, patches, fail) {
+  for (const [i, p] of patches.entries()) {
+    if (p === null || typeof p !== 'object' || Array.isArray(p)) continue
+    const rec = /** @type {Record<string, unknown>} */ (p)
+    if (typeof rec.patch !== 'string') continue
+    const v = kustomizationInlinePatchOpsSortedViolation(rec.patch)
+    if (v !== null) fail(`${rel}: patches[${i}] (${kustomizationPatchLabel(p, i)}): ${v}`)
   }
 }
 
@@ -2582,7 +2604,7 @@ function isBaseCanonCpuValue(cpu) {
  */
 function isBaseCanonMemoryValue(mem) {
   if (typeof mem !== 'string' || mem.trim() === '') return false
-  return /^128Mi$/iu.test(mem.trim())
+  return BASE_CANON_MEMORY_RE.test(mem.trim())
 }
 
 /**
@@ -5212,13 +5234,11 @@ function checkProdOverridesInKustomization(kust, rel, fail, passFn, needs) {
       ok = false
     }
   }
-  if (needs.needsPdbMinAvailablePatch) {
-    if (!pdbPaths.has('/spec/minAvailable')) {
-      fail(
-        `${rel}: прод-оверлей має перевизначати spec.minAvailable для PodDisruptionBudget (мінімум 1 у проді) (k8s.mdc)`
-      )
-      ok = false
-    }
+  if (needs.needsPdbMinAvailablePatch && !pdbPaths.has('/spec/minAvailable')) {
+    fail(
+      `${rel}: прод-оверлей має перевизначати spec.minAvailable для PodDisruptionBudget (мінімум 1 у проді) (k8s.mdc)`
+    )
+    ok = false
   }
   if (ok) {
     passFn(`${rel}: прод-оверрайди HPA/PDB за потреби присутні (k8s.mdc)`)
@@ -5573,18 +5593,7 @@ async function validateDeploymentsInDir(deployments, dir, root, fail, passFn) {
   const isK8sBaseLayer = isK8sYamlUnderBaseDirectory(`${relDir}/probe.yaml`)
   const deployRel = relDir === '' ? '.' : relDir
   if (isK8sBaseLayer && deployments.length > 0) {
-    const hpaAbs = join(dir, HPA_FILENAME)
-    if (existsSync(hpaAbs)) {
-      fail(
-        `${deployRel}/${HPA_FILENAME}: у шарі k8s/.../base не тримай локальний hpa.yaml — HPA живе у sibling components/ (k8s.mdc)`
-      )
-    }
-    const pdbAbs = join(dir, PDB_FILENAME)
-    if (existsSync(pdbAbs)) {
-      fail(
-        `${deployRel}/${PDB_FILENAME}: у шарі k8s/.../base не тримай локальний pdb.yaml — PDB живе у sibling components/ (k8s.mdc)`
-      )
-    }
+    failIfBaseLayerHasLocalHpaOrPdb(dir, deployRel, fail)
   }
   const hpaDocs = isK8sBaseLayer ? [] : await readDocsByKindInDir(dir, 'HorizontalPodAutoscaler', HPA_FILENAME)
   const pdbDocs = isK8sBaseLayer ? [] : await readDocsByKindInDir(dir, 'PodDisruptionBudget', PDB_FILENAME)
@@ -5600,15 +5609,47 @@ async function validateDeploymentsInDir(deployments, dir, root, fail, passFn) {
       passFn
     )
     if (isK8sBaseLayer) {
-      const deployName = manifestMetadataName(deployment)
-      const appLabel = deploymentAppLabel(deployment)
-      if (deployName !== null && appLabel !== null) {
-        await validateComponentsForBaseDeployment(dir, deployName, appLabel, root, fail, passFn)
-      }
+      await validateBaseLayerComponentsIfNamed(deployment, dir, root, fail, passFn)
     }
   }
 }
 
+/**
+ * У шарі `…/k8s/…/base/` забороняє локальні `hpa.yaml` / `pdb.yaml` (вони мають жити у sibling `components/`).
+ * @param {string} dir абсолютний каталог Deployment-маніфесту
+ * @param {string} deployRel відносний шлях для повідомлень (`.` якщо корінь репо)
+ * @param {(msg: string) => void} fail callback при порушенні
+ */
+function failIfBaseLayerHasLocalHpaOrPdb(dir, deployRel, fail) {
+  if (existsSync(join(dir, HPA_FILENAME))) {
+    fail(
+      `${deployRel}/${HPA_FILENAME}: у шарі k8s/.../base не тримай локальний hpa.yaml — HPA живе у sibling components/ (k8s.mdc)`
+    )
+  }
+  if (existsSync(join(dir, PDB_FILENAME))) {
+    fail(
+      `${deployRel}/${PDB_FILENAME}: у шарі k8s/.../base не тримай локальний pdb.yaml — PDB живе у sibling components/ (k8s.mdc)`
+    )
+  }
+}
+
+/**
+ * Якщо у Deployment є `metadata.name` і `spec.selector.matchLabels.app` — викликає
+ * `validateComponentsForBaseDeployment` для звірки sibling-`components/`. Без цих ключів
+ * каталог `components/` неможливо звʼязати з конкретним Deployment, тож пропускаємо мовчки.
+ * @param {Record<string, unknown>} deployment AST документа Deployment
+ * @param {string} dir абсолютний каталог Deployment-маніфесту
+ * @param {string} root абсолютний корінь репо
+ * @param {(msg: string) => void} fail callback при порушенні
+ * @param {(msg: string) => void} passFn callback при успіху
+ */
+async function validateBaseLayerComponentsIfNamed(deployment, dir, root, fail, passFn) {
+  const deployName = manifestMetadataName(deployment)
+  const appLabel = deploymentAppLabel(deployment)
+  if (deployName === null || appLabel === null) return
+  await validateComponentsForBaseDeployment(dir, deployName, appLabel, root, fail, passFn)
+}
+
 /**
  * Витягує документи Deployment з YAML-файлу (повертає порожній масив, якщо файл недоступний або немає Deployment).
  * @param {string} filePath абсолютний шлях до YAML-файлу
@@ -6302,6 +6343,20 @@ function applyConversionsToDoc(doc, conversions) {
   const patchesNode = doc.get('patches', true)
   if (!isSeq(patchesNode)) return false
 
+  applyPatchConversionsToPatchesNode(patchesNode, groupConversionsByPatchIndex(conversions))
+  if (patchesNode.items.length === 0) {
+    doc.delete('patches')
+  }
+  appendConvertedImagesNode(doc, conversions)
+  return true
+}
+
+/**
+ * Згруповує конвертації за індексом `patches[i]` і збирає `opIdx`-список ops, які треба видалити.
+ * @param {Array<{ index: number, opIndex: number, totalOps: number }>} conversions конвертації
+ * @returns {Map<number, { totalOps: number, opIdx: number[] }>} згруповане
+ */
+function groupConversionsByPatchIndex(conversions) {
   /** @type {Map<number, { totalOps: number, opIdx: number[] }>} */
   const byPatch = new Map()
   for (const c of conversions) {
@@ -6309,39 +6364,61 @@ function applyConversionsToDoc(doc, conversions) {
     slot.opIdx.push(c.opIndex)
     byPatch.set(c.index, slot)
   }
+  return byPatch
+}
 
+/**
+ * Застосовує згруповані конвертації до `patches:` Sequence: видаляє повністю-конвертовані
+ * patches або переписує inline `patch:` без конвертованих ops. Іде в порядку спадання
+ * індексів, щоб зберегти стабільність вилучень з масиву.
+ * @param {import('yaml').YAMLSeq & { get(i: number, keep: true): unknown, delete(i: number): void, items: unknown[] }} patchesNode YAML Seq (звужено через `isSeq` у caller-і)
+ * @param {Map<number, { totalOps: number, opIdx: number[] }>} byPatch згруповані конвертації
+ */
+function applyPatchConversionsToPatchesNode(patchesNode, byPatch) {
   const sortedIdx = [...byPatch.keys()].toSorted((a, b) => b - a)
   for (const i of sortedIdx) {
     const slot = byPatch.get(i)
     if (slot === undefined) continue
-    const { totalOps, opIdx } = slot
-    if (opIdx.length === totalOps) {
+    if (slot.opIdx.length === slot.totalOps) {
       patchesNode.delete(i)
       continue
     }
-    const patchEntry = patchesNode.get(i, true)
-    if (patchEntry === undefined || patchEntry === null) continue
-    const patchScalar = patchEntry.get('patch', true)
-    if (patchScalar === undefined || patchScalar === null || typeof patchScalar.value !== 'string') continue
-    const rewritten = rewriteInlinePatchWithoutOps(patchScalar.value, opIdx)
-    if (rewritten === null) continue
-    patchScalar.value = rewritten
+    rewriteInlinePatchAtIndex(patchesNode, i, slot.opIdx)
   }
+}
 
-  if (patchesNode.items.length === 0) {
-    doc.delete('patches')
-  }
+/**
+ * Переписує inline `patch:` у `patches[i]`, видаляючи ops зі списку. Якщо вузол не знайдено
+ * або переписування не вдалося — залишає Document без змін.
+ * @param {import('yaml').YAMLSeq & { get(i: number, keep: true): unknown, delete(i: number): void, items: unknown[] }} patchesNode YAML Seq (звужено через `isSeq` у caller-і)
+ * @param {number} i індекс у `patches:`
+ * @param {number[]} opIdx індекси ops для видалення
+ */
+function rewriteInlinePatchAtIndex(patchesNode, i, opIdx) {
+  const patchEntry = patchesNode.get(i, true)
+  if (patchEntry === undefined || patchEntry === null) return
+  const patchScalar = patchEntry.get('patch', true)
+  if (patchScalar === undefined || patchScalar === null || typeof patchScalar.value !== 'string') return
+  const rewritten = rewriteInlinePatchWithoutOps(patchScalar.value, opIdx)
+  if (rewritten === null) return
+  patchScalar.value = rewritten
+}
 
-  let imagesNode = doc.get('images', true)
-  if (!isSeq(imagesNode)) {
-    imagesNode = doc.createNode([])
+/**
+ * Дописує `images:` Seq у Document результатами конвертацій (створює, якщо немає).
+ * @param {import('yaml').Document} doc YAML Document
+ * @param {Array<{ name: string, newName: string, newTag: string | null }>} conversions конвертації
+ */
+function appendConvertedImagesNode(doc, conversions) {
+  const existing = doc.get('images', true)
+  const imagesNode = isSeq(existing) ? existing : doc.createNode([])
+  if (existing !== imagesNode) {
     doc.set('images', imagesNode)
   }
   for (const { name, newName, newTag } of conversions) {
     const entry = newTag === null ? { name, newName } : { name, newName, newTag }
     imagesNode.add(doc.createNode(entry))
   }
-  return true
 }
 
 /**
@@ -6370,7 +6447,7 @@ function rewriteInlinePatchWithoutOps(patchText, opIndices) {
   }
   if (seq.items.length === 0) return null
   seq.flow = false
-  return inner.toString().replace(/\n+$/u, '')
+  return stripTrailingNewlines(inner.toString())
 }
 
 /**

package/scripts/check-npm-module.mjs

@@ -33,9 +33,6 @@ const CHANGELOG_FIRST_VERSION_RE = /^## \[([^\]]+)\]/m
 /** Поле `version` у текстовому зрізі `package.json` (для `git show HEAD:npm/package.json`). */
 const PACKAGE_JSON_VERSION_RE = /"version":\s*"([^"]+)"/u
 
-/** Канонічний entrypoint типів для пакетів із вихідним `.js` під каталогом `npm/src` */
-const TYPES_INDEX = './types/index.d.ts'
-
 /** Файл проєкту TypeScript для emit без каталогу `src` (див. npm-module.mdc) */
 const EMIT_TYPES_CONFIG = 'npm/tsconfig.emit-types.json'
 
@@ -198,7 +195,7 @@ async function gitDiffNameOnlyNpm() {
 async function gitShowNpmPackageVersionAt(refPath) {
   try {
     const { stdout } = await execFileAsync('git', ['show', refPath], { encoding: 'utf8' })
-    const m = stdout.match(/"version":\s*"([^"]+)"/)
+    const m = stdout.match(PACKAGE_JSON_VERSION_RE)
     return m ? m[1] : null
   } catch {
     return null

package/scripts/check-php.mjs

@@ -15,9 +15,9 @@ import { createCheckReporter } from './utils/check-reporter.mjs'
 
 /**
  * Перевіряє відповідність проєкту правилам php.mdc.
- * @returns {Promise<number>} 0 — все OK, 1 — є проблеми
+ * @returns {number} 0 — все OK, 1 — є проблеми
  */
-export async function check() {
+export function check() {
   const reporter = createCheckReporter()
   const { pass, fail } = reporter
 
@@ -27,10 +27,10 @@ export async function check() {
     fail('composer.json не знайдено в корені — додай (php.mdc)')
   }
 
-  if (!existsSync('package.json')) {
-    fail('package.json не знайдено в корені — додай (php.mdc)')
-  } else {
+  if (existsSync('package.json')) {
     pass('package.json є (наявність lint-php перевіряє bun run lint-conftest → php.package_json)')
+  } else {
+    fail('package.json не знайдено в корені — додай (php.mdc)')
   }
 
   const wfPath = '.github/workflows/lint-php.yml'

package/scripts/claude-stop-hook.mjs

@@ -1,6 +1,6 @@
 /**
  * Stop-hook для Claude Code: запускається hook'ом із `.claude/settings.json` після того,
- * як агент сигналізує завершення ходу. Прозоро прокидає `npx @nitra/cursor check`
+ * як агент сигналізує завершення ходу. Прозоро прокидає `npx \@nitra/cursor check`
  * і повертає його exit code, щоб помилки правил блокували завершення.
  *
  * Захист від нескінченної рекурсії: якщо stdin містить `"stop_hook_active": true`
@@ -8,7 +8,7 @@
  * виходимо з кодом 0 без повторного запуску перевірок.
  *
  * Виклик з `bin/n-cursor.js`:
- *   `npx --no @nitra/cursor stop-hook`
+ *   `npx --no \@nitra/cursor stop-hook`
  */
 import { spawn } from 'node:child_process'
 import { once } from 'node:events'

package/scripts/lint-conftest.mjs

@@ -42,7 +42,6 @@ const POLICY_DIR = join(PACKAGE_ROOT, 'policy')
  * в інших скриптах: `node_modules`, `.git`, `dist`, `coverage`, `build`,
  * `.turbo`, `.next`. Не використовуємо bun Glob, щоб не плодити залежності
  * за межами `node:fs`.
- *
  * @typedef {{
  *   namespace: string,
  *   policyDir: string,
@@ -72,6 +71,15 @@ function loadActiveCursorRules(cwd) {
 
 const SKIP_DIR_NAMES = new Set(['node_modules', '.git', 'dist', 'coverage', 'build', '.turbo', '.next'])
 
+/** `…/k8s/<env>/configmap.yaml` (configmap безпосередньо у directory `k8s/<…>`). */
+const K8S_CONFIGMAP_PATH_RE = /(^|\/)k8s\/[^/]+\/configmap\.yaml$/u
+/** Будь-який шлях під сегментом `k8s/`. */
+const K8S_DIR_PATH_RE = /(^|\/)k8s\//u
+/** `…/k8s/<…>/hc.yaml` (HealthCheckPolicy будь-де під k8s). */
+const K8S_HC_YAML_PATH_RE = /(^|\/)k8s\/.+\/hc\.yaml$/u
+/** `…/k8s/…/base/…/hr.yaml` (HTTPRoute у base-шарі). */
+const K8S_BASE_HR_YAML_PATH_RE = /(^|\/)k8s\/.*base\/.*hr\.yaml$/u
+
 /** @type {ConftestTarget[]} */
 const TARGETS = [
   // ── bun ─────────────────────────────────────────────────────────────────
@@ -207,7 +215,7 @@ const TARGETS = [
     namespace: 'js_run.configmap',
     policyDir: 'js_run',
     rule: 'js-run',
-    walk: { match: rel => /(^|\/)k8s\/[^/]+\/configmap\.yaml$/.test(rel) }
+    walk: { match: rel => K8S_CONFIGMAP_PATH_RE.test(rel) }
   },
 
   // Усі YAML у дереві з сегментом `k8s` — пер-документні структурні правила.
@@ -215,7 +223,7 @@ const TARGETS = [
     namespace: 'k8s.manifest',
     policyDir: 'k8s',
     rule: 'k8s',
-    walk: { match: rel => /(^|\/)k8s\//.test(rel) && (rel.endsWith('.yaml') || rel.endsWith('.yml')) }
+    walk: { match: rel => K8S_DIR_PATH_RE.test(rel) && (rel.endsWith('.yaml') || rel.endsWith('.yml')) }
   },
 
   // abie HealthCheckPolicy: `hc.yaml` у дереві k8s.
@@ -223,7 +231,7 @@ const TARGETS = [
     namespace: 'abie.health_check_policy',
     policyDir: 'abie',
     rule: 'abie',
-    walk: { match: rel => /(^|\/)k8s\/.+\/hc\.yaml$/.test(rel) }
+    walk: { match: rel => K8S_HC_YAML_PATH_RE.test(rel) }
   },
 
   // abie HTTPRoute у `base/`.
@@ -231,7 +239,7 @@ const TARGETS = [
     namespace: 'abie.http_route_base',
     policyDir: 'abie',
     rule: 'abie',
-    walk: { match: rel => /(^|\/)k8s\/.*base\/.*hr\.yaml$/.test(rel) }
+    walk: { match: rel => K8S_BASE_HR_YAML_PATH_RE.test(rel) }
   }
 ]
 
@@ -245,7 +253,7 @@ const TARGETS = [
 function collectFiles(root, match) {
   /** @type {string[]} */
   const out = []
-  /** @param {string} dirAbs */
+  /** @param {string} dirAbs абсолютний шлях каталогу для рекурсивного обходу */
   function visit(dirAbs) {
     /** @type {import('node:fs').Dirent[]} */
     let entries
@@ -355,5 +363,5 @@ export function runLintConftestCli() {
 }
 
 if (import.meta.url === `file://${process.argv[1]}`) {
-  process.exit(runLintConftestCli())
+  process.exitCode = runLintConftestCli()
 }

package/scripts/lint-ga.mjs

@@ -214,7 +214,7 @@ export function runLintGaCli() {
  * Поведінка fallback:
  * - якщо `conftest` не знайдено в PATH — друкуємо `ℹ` повідомлення з підказкою встановлення й
  *   повертаємо 0 (тобто конфтест поки що **не** є обовʼязковою залежністю lint-ga; перевірки лежать
- *   паралельно в `check-ga.mjs`, і `npx @nitra/cursor check ga` все одно їх запустить);
+ *   паралельно в `check-ga.mjs`, і `npx \@nitra/cursor check ga` все одно їх запустить);
  * - якщо `conftest` є й полісі-каталог відсутній (нетипова інсталяція) — також `ℹ` skip;
  * - якщо є цільовий workflow і conftest — запускаємо `conftest test <workflow> -p <policy-dir>` і
  *   повертаємо його exit-код, щоб порушення зупиняли lint-ga, як це робить actionlint/zizmor.

package/scripts/run-shellcheck-text.mjs

@@ -65,22 +65,25 @@ function printPatchInstallHints() {
  * @returns {string[]} відсортований масив шляхів відносно cwd
  */
 export function listShellScriptPaths(cwd) {
-  const gitOk = spawnSync('git', ['rev-parse', '--is-inside-work-tree'], {
-    cwd,
-    encoding: 'utf8',
-    env: process.env
-  })
-  if (gitOk.status === 0 && gitOk.stdout.trim() === 'true') {
-    const ls = spawnSync('git', ['ls-files', '-z', '--', ':(glob)**/*.sh'], {
+  const gitPath = resolveCmd('git')
+  if (gitPath) {
+    const gitOk = spawnSync(gitPath, ['rev-parse', '--is-inside-work-tree'], {
       cwd,
       encoding: 'utf8',
       env: process.env
     })
-    if (ls.status !== 0) {
-      return []
+    if (gitOk.status === 0 && gitOk.stdout.trim() === 'true') {
+      const ls = spawnSync(gitPath, ['ls-files', '-z', '--', ':(glob)**/*.sh'], {
+        cwd,
+        encoding: 'utf8',
+        env: process.env
+      })
+      if (ls.status !== 0) {
+        return []
+      }
+      const files = ls.stdout.split('\0').filter(Boolean)
+      return new Set(files).toSorted()
     }
-    const files = ls.stdout.split('\0').filter(Boolean)
-    return new Set(files).toSorted()
   }
 
   const fromGlob = globSync('**/*.sh', {
@@ -114,51 +117,87 @@ export function runShellcheckText(cwd = process.cwd()) {
   }
 
   for (const rel of files) {
-    for (let round = 0; round < MAX_FIX_ROUNDS_PER_FILE; round++) {
-      const diffResult = spawnSync(shellcheck, ['-f', 'diff', rel], {
-        cwd: root,
-        encoding: 'utf8',
-        env: process.env,
-        maxBuffer: 10 * 1024 * 1024
-      })
-
-      if (diffResult.error) {
-        process.stderr.write(`${diffResult.error.message}\n`)
-        return 1
-      }
-
-      const code = diffResult.status ?? 1
-      const out = (diffResult.stdout ?? '').trim()
-      const err = (diffResult.stderr ?? '').trim()
-
-      if (code === 0) {
-        break
-      }
-
-      if (err.includes(NON_AUTOFIXABLE_HINT) || !out) {
-        break
-      }
+    const fixCode = autofixOneFile(shellcheck, patchBin, root, rel)
+    if (fixCode !== 0) return fixCode
+  }
 
-      const patchRun = spawnSync(patchBin, ['-p1'], {
-        cwd: root,
-        input: diffResult.stdout ?? '',
-        encoding: 'utf8',
-        env: process.env
-      })
+  return runFinalShellcheck(shellcheck, files, root)
+}
 
-      if (patchRun.status !== 0) {
-        if (patchRun.stderr?.length) {
-          process.stderr.write(patchRun.stderr)
-        }
-        if (patchRun.stdout?.length) {
-          process.stderr.write(patchRun.stdout)
-        }
-        process.stderr.write(`run-shellcheck-text: patch не застосував diff для ${rel}\n`)
-        return 1
-      }
+/**
+ * Запускає до `MAX_FIX_ROUNDS_PER_FILE` ітерацій `shellcheck -f diff` + `patch` для одного файла.
+ * Виходить з 0 у випадках: shellcheck повернув 0, нема autofixable, або порожній diff.
+ * @param {string} shellcheck абсолютний шлях до shellcheck
+ * @param {string} patchBin абсолютний шлях до patch
+ * @param {string} root абсолютний робочий каталог (cwd для spawn)
+ * @param {string} rel відносний шлях файла від `root`
+ * @returns {number} 0 — OK; 1 — помилка spawn або patch
+ */
+function autofixOneFile(shellcheck, patchBin, root, rel) {
+  for (let round = 0; round < MAX_FIX_ROUNDS_PER_FILE; round++) {
+    const diffResult = spawnSync(shellcheck, ['-f', 'diff', rel], {
+      cwd: root,
+      encoding: 'utf8',
+      env: process.env,
+      maxBuffer: 10 * 1024 * 1024
+    })
+    if (diffResult.error) {
+      process.stderr.write(`${diffResult.error.message}\n`)
+      return 1
     }
+    if (shouldStopAutofixLoop(diffResult)) return 0
+    const patchCode = applyShellcheckDiff(patchBin, root, rel, diffResult.stdout ?? '')
+    if (patchCode !== 0) return patchCode
   }
+  return 0
+}
+
+/**
+ * Чи треба зупинити цикл авто-фіксів: shellcheck повернув 0, або у stderr є пометка
+ * `none were auto-fixable`, або stdout порожній (нема дифу для застосування).
+ * @param {{ status: number | null, stdout?: string | null, stderr?: string | null }} diffResult результат spawnSync
+ * @returns {boolean} true — більше нічого фіксити
+ */
+function shouldStopAutofixLoop(diffResult) {
+  const code = diffResult.status ?? 1
+  if (code === 0) return true
+  const out = (diffResult.stdout ?? '').trim()
+  const err = (diffResult.stderr ?? '').trim()
+  return err.includes(NON_AUTOFIXABLE_HINT) || !out
+}
 
+/**
+ * Застосовує `shellcheck -f diff`-вивід через `patch -p1`. На помилку виливає stdout/stderr від patch
+ * у `process.stderr` (щоб користувач бачив, чому не застосувалося) і повертає 1.
+ * @param {string} patchBin абсолютний шлях до patch
+ * @param {string} root cwd для spawn
+ * @param {string} rel відносний шлях для повідомлення про помилку
+ * @param {string} diffStdout вміст unified-diff від shellcheck (input для patch)
+ * @returns {number} 0 — застосовано; 1 — помилка
+ */
+function applyShellcheckDiff(patchBin, root, rel, diffStdout) {
+  const patchRun = spawnSync(patchBin, ['-p1'], {
+    cwd: root,
+    input: diffStdout,
+    encoding: 'utf8',
+    env: process.env
+  })
+  if (patchRun.status === 0) return 0
+  if (patchRun.stderr?.length) process.stderr.write(patchRun.stderr)
+  if (patchRun.stdout?.length) process.stderr.write(patchRun.stdout)
+  process.stderr.write(`run-shellcheck-text: patch не застосував diff для ${rel}\n`)
+  return 1
+}
+
+/**
+ * Фінальний прогон `shellcheck` по всіх файлах — без `-f diff`, щоб отримати звичайний звіт.
+ * Будь-який ненульовий код shellcheck-а пробрасує як 1 (з виводом stdout/stderr на користувацькі stream-и).
+ * @param {string} shellcheck абсолютний шлях до shellcheck
+ * @param {string[]} files відносні шляхи файлів для перевірки
+ * @param {string} root cwd для spawn
+ * @returns {number} 0 — чисто; 1 — помилка spawn або зауваження shellcheck
+ */
+function runFinalShellcheck(shellcheck, files, root) {
   const finalRun = spawnSync(shellcheck, files, {
     cwd: root,
     encoding: 'utf8',
@@ -166,23 +205,14 @@ export function runShellcheckText(cwd = process.cwd()) {
     maxBuffer: 10 * 1024 * 1024,
     stdio: ['ignore', 'pipe', 'pipe']
   })
-
   if (finalRun.error) {
     process.stderr.write(`${finalRun.error.message}\n`)
     return 1
   }
-
-  if (finalRun.status !== 0) {
-    if (finalRun.stdout?.length) {
-      process.stdout.write(finalRun.stdout)
-    }
-    if (finalRun.stderr?.length) {
-      process.stderr.write(finalRun.stderr)
-    }
-    return 1
-  }
-
-  return 0
+  if (finalRun.status === 0) return 0
+  if (finalRun.stdout?.length) process.stdout.write(finalRun.stdout)
+  if (finalRun.stderr?.length) process.stderr.write(finalRun.stderr)
+  return 1
 }
 
 if (isRunAsCli()) {

package/scripts/sync-claude-config.mjs

@@ -21,7 +21,7 @@ import { existsSync } from 'node:fs'
 import { chmod, mkdir, readFile, readdir, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 
-/** Маркер lint Stop-hook'а (`npx --no @nitra/cursor stop-hook`). */
+/** Маркер lint Stop-hook'а (`npx --no \@nitra/cursor stop-hook`). */
 export const MANAGED_HOOK_COMMAND_MARKER = '@nitra/cursor stop-hook'
 /** Маркер ADR Stop-hook'а — підрядок шляху до bash-скрипта. */
 export const ADR_HOOK_COMMAND_MARKER = '.claude/hooks/capture-decisions.sh'

package/scripts/utils/ast-scan-utils.mjs

@@ -175,3 +175,31 @@ export function templateQuasisText(template) {
 export function isSqlListContextTemplate(template) {
   return SQL_LIST_CONTEXT_RE.test(templateQuasisText(template))
 }
+
+/**
+ * Перевіряє, чи це виклик `require('<module>')` з рядковим аргументом.
+ * Спільне для сканерів імпортів (`bunyan-imports`, `redis-imports`, ...).
+ * @param {Record<string, unknown> | null | undefined} node вузол AST
+ * @returns {string | null} ім'я модуля з аргументу, інакше `null`
+ */
+export function requireCallModule(node) {
+  if (!node || node.type !== 'CallExpression') return null
+  const callee = node.callee
+  if (!callee || callee.type !== 'Identifier' || callee.name !== 'require') return null
+  const arg = node.arguments?.[0]
+  if (!arg || arg.type !== 'Literal' || typeof arg.value !== 'string') return null
+  return arg.value
+}
+
+/**
+ * Перевіряє, чи це динамічний `import('<module>')` з рядковим аргументом.
+ * Спільне для сканерів імпортів.
+ * @param {Record<string, unknown> | null | undefined} node вузол AST
+ * @returns {string | null} ім'я модуля, інакше `null`
+ */
+export function dynamicImportModule(node) {
+  if (!node || node.type !== 'ImportExpression') return null
+  const src = node.source
+  if (!src || src.type !== 'Literal' || typeof src.value !== 'string') return null
+  return src.value
+}