@nitra/cursor 1.8.220 → 1.8.222

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,25 @@ 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
+/** `kustomization.yaml` будь-де під сегментом `k8s/`. */
+const K8S_KUSTOMIZATION_PATH_RE = /(^|\/)k8s\/.*\/kustomization\.yaml$/u
+/** `…/k8s/.../base/.../kustomization.yaml`. */
+const K8S_BASE_KUSTOMIZATION_PATH_RE = /(^|\/)k8s\/.*base\/(?:.*\/)?kustomization\.yaml$/u
+/** Будь-який ресурсний `*.yaml` під сегментом `…/k8s/.../base/...`, окрім `kustomization.yaml`. */
+const K8S_BASE_MANIFEST_PATH_RE = /(^|\/)k8s\/.*base\//u
+/** `…/k8s/.../svc.yaml` (cluster-IP Service). */
+const K8S_SVC_YAML_PATH_RE = /(^|\/)k8s\/.+\/svc\.yaml$/u
+/** `…/k8s/.../svc-hl.yaml` (headless Service). */
+const K8S_SVC_HL_YAML_PATH_RE = /(^|\/)k8s\/.+\/svc-hl\.yaml$/u
+
 /** @type {ConftestTarget[]} */
 const TARGETS = [
   // ── bun ─────────────────────────────────────────────────────────────────
@@ -207,15 +225,77 @@ 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` — пер-документні структурні правила.
   {
     namespace: 'k8s.manifest',
-    policyDir: 'k8s',
+    policyDir: 'k8s/manifest',
+    rule: 'k8s',
+    walk: { match: rel => K8S_DIR_PATH_RE.test(rel) && (rel.endsWith('.yaml') || rel.endsWith('.yml')) }
+  },
+
+  // Gateway API + HealthCheckPolicy — застосовується до будь-якого YAML під k8s
+  // (правила перевіряють лише відповідні kind / apiVersion).
+  {
+    namespace: 'k8s.gateway',
+    policyDir: 'k8s/gateway',
+    rule: 'k8s',
+    walk: { match: rel => K8S_DIR_PATH_RE.test(rel) && (rel.endsWith('.yaml') || rel.endsWith('.yml')) }
+  },
+
+  // Структурні перевірки HPA / PDB (apiVersion / behavior / metrics / selector).
+  {
+    namespace: 'k8s.hpa_pdb',
+    policyDir: 'k8s/hpa_pdb',
+    rule: 'k8s',
+    walk: { match: rel => K8S_DIR_PATH_RE.test(rel) && (rel.endsWith('.yaml') || rel.endsWith('.yml')) }
+  },
+
+  // Kustomization-файли: resources sort, patches sort, JSON6902 conflicts.
+  {
+    namespace: 'k8s.kustomization',
+    policyDir: 'k8s/kustomization',
     rule: 'k8s',
-    walk: { match: rel => /(^|\/)k8s\//.test(rel) && (rel.endsWith('.yaml') || rel.endsWith('.yml')) }
+    walk: { match: rel => K8S_KUSTOMIZATION_PATH_RE.test(rel) }
+  },
+
+  // svc.yaml — cluster-IP Service.
+  {
+    namespace: 'k8s.svc_yaml',
+    policyDir: 'k8s/svc_yaml',
+    rule: 'k8s',
+    walk: { match: rel => K8S_SVC_YAML_PATH_RE.test(rel) }
+  },
+
+  // svc-hl.yaml — headless Service з суфіксом `-hl`.
+  {
+    namespace: 'k8s.svc_hl_yaml',
+    policyDir: 'k8s/svc_hl_yaml',
+    rule: 'k8s',
+    walk: { match: rel => K8S_SVC_HL_YAML_PATH_RE.test(rel) }
+  },
+
+  // base/kustomization.yaml — обов'язкове непорожнє поле `namespace:`.
+  {
+    namespace: 'k8s.base_kustomization',
+    policyDir: 'k8s/base_kustomization',
+    rule: 'k8s',
+    walk: { match: rel => K8S_BASE_KUSTOMIZATION_PATH_RE.test(rel) }
+  },
+
+  // Ресурсні маніфести під `…/k8s/.../base/...` (окрім kustomization.yaml).
+  {
+    namespace: 'k8s.base_manifest',
+    policyDir: 'k8s/base_manifest',
+    rule: 'k8s',
+    walk: {
+      match: rel =>
+        K8S_BASE_MANIFEST_PATH_RE.test(rel) &&
+        !K8S_BASE_KUSTOMIZATION_PATH_RE.test(rel) &&
+        (rel.endsWith('.yaml') || rel.endsWith('.yml'))
+    }
   },
 
   // abie HealthCheckPolicy: `hc.yaml` у дереві k8s.
@@ -223,7 +303,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 +311,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 +325,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 +435,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/lint-rego.mjs

@@ -1,13 +1,17 @@
 /**
  * Лінт Rego-полісі (`conftest.mdc` + `rego.mdc`): preflight на `opa` і `regal`,
- * далі послідовно `opa check --strict` і `regal lint`.
+ * далі послідовно `opa check --strict`, `regal lint` і опційний
+ * `conftest verify` (для `*_test.rego`-файлів) якщо conftest у PATH.
  *
- * Чому два інструменти:
+ * Чому два-три інструменти:
  * - `opa check --strict` — компіляція з типами і строгим режимом (мертвий код, неоднозначні
  *   правила, незадекларовані змінні). Ловить помилки, які `regal` навмисно лишає поза скоупом
  *   (він — про стиль і ідіоматичність, а не про компіляцію).
  * - `regal lint` (https://docs.styra.com/regal) — статичний лінтер Rego: ловить v0-синтаксис,
  *   неявні set-rules та інші відхилення від `rego.v1`, плюс bugs/idiomatic/performance-правила.
+ * - `conftest verify` (опційно) — виконує `test_*` правила у `*_test.rego` (юніт-тести політик).
+ *   Якщо conftest відсутній у PATH — пропускаємо без помилки (тести опційні в локальному середовищі;
+ *   у CI потрібно встановити conftest).
  *
  * Без preflight-у на бінарники лінт мовчки злетить з невиразним повідомленням від shell —
  * друкуємо явні install-hints (як це робить `lint-ga.mjs` для shellcheck/uv). `opa` додатково
@@ -16,7 +20,7 @@
  *
  * Цілі лінту: `npm/policy/` (місце, де поки що живуть Rego-полісі пакета `@nitra/cursor`).
  * Якщо в репозиторії з’являться інші *.rego поза цим деревом, додай шлях у `LINT_TARGETS` —
- * обидва інструменти приймають кілька шляхів і самі рекурсивно обходять директорії.
+ * усі три інструменти приймають кілька шляхів і самі рекурсивно обходять директорії.
  */
 import { spawnSync } from 'node:child_process'
 import { existsSync } from 'node:fs'
@@ -110,7 +114,18 @@ export function runLintRego(cwd = process.cwd()) {
   const opaCode = runStep(opa, ['check', '--strict', ...targets], root)
   if (opaCode !== 0) return opaCode
 
-  return runStep(regal, ['lint', ...targets], root)
+  const regalCode = runStep(regal, ['lint', ...targets], root)
+  if (regalCode !== 0) return regalCode
+
+  const conftest = resolveCmd('conftest')
+  if (!conftest) {
+    console.log(
+      'ℹ conftest не знайдено в PATH — пропускаю `conftest verify` (юніт-тести *_test.rego).\n' +
+        '  Встанови, щоб запустити локально: brew install conftest (macOS) або https://www.conftest.dev/install/'
+    )
+    return 0
+  }
+  return runStep(conftest, ['verify', ...targets.flatMap(t => ['-p', t])], root)
 }
 
 process.exitCode = runLintRego()

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
+}

package/scripts/utils/bun-sql-scan.mjs

@@ -56,6 +56,9 @@ const PG_FORMAT_SHIM_FUNC_NAMES = new Set(['format', 'pgFormat', 'sqlFormat', 'p
 // як named export з модуля-обгортки.
 const QUOTE_HELPER_NAMES = new Set(['quoteLiteral', 'quoteIdent', 'escapeLiteral', 'escapeIdent'])
 
+// Імена першого параметра pg-style query-обгортки (`function query(text, params)` тощо).
+const PG_QUERY_FIRST_PARAM_RE = /^(text|sql|query)$/u
+
 /**
  * @param {unknown} node AST node
  * @param {string} name імʼя змінної
@@ -280,19 +283,21 @@ function asPgLeftoverCall(node) {
   return { name: /** @type {'connect' | 'end'} */ (prop.name) }
 }
 
+// Локальний alias на `isUnsafeCall` — щоб у nodeContainsUnsafeCall (під query-шимом)
+// був семантично-говорящий call-site, але без дубля логіки з основним сканом.
+const isUnsafeCallNode = isUnsafeCall
+
 /**
- * Чи це CallExpression `<obj>.unsafe(...)` (для пошуку в тілі query-шиму).
- * Дублює `isUnsafeCall` з основного скану, але локально — щоб не залежати
- * від порядку оголошень у файлі.
- * @param {unknown} node AST node
- * @returns {boolean} true для `<obj>.unsafe(...)`
+ * Витягує ім'я ключа з AST `Property.key`. Підтримує `Identifier` (`{ foo: … }`)
+ * та `Literal` (`{ 'foo': … }` / `{ 5: … }`); інші форми (computed expression тощо) — `null`.
+ * @param {unknown} key AST `Property.key`
+ * @returns {string | number | null} ім'я ключа або null
  */
-function isUnsafeCallNode(node) {
-  if (!node || node.type !== 'CallExpression') return false
-  const callee = node.callee
-  if (!callee || callee.type !== 'MemberExpression' || callee.computed) return false
-  const prop = callee.property
-  return !!prop && prop.type === 'Identifier' && prop.name === 'unsafe'
+function propertyKeyName(key) {
+  if (!key || typeof key !== 'object') return null
+  if (key.type === 'Identifier' && typeof key.name === 'string') return key.name
+  if (key.type === 'Literal' && (typeof key.value === 'string' || typeof key.value === 'number')) return key.value
+  return null
 }
 
 /**
@@ -325,10 +330,8 @@ function nodeContainsPgFormatPlaceholder(root) {
       found = true
       return
     }
-    if (t === 'TemplateLiteral') {
-      if (PG_FORMAT_PLACEHOLDER_RE.test(templateQuasisText(n))) {
-        found = true
-      }
+    if (t === 'TemplateLiteral' && PG_FORMAT_PLACEHOLDER_RE.test(templateQuasisText(n))) {
+      found = true
     }
   })
   return found
@@ -406,7 +409,6 @@ export function findPgFormatShimDefinitionInText(content, virtualPath = 'scan.ts
  * - значення — функція з 1–2 параметрами, перший — Identifier з типовим
  *   pg-іменем (`text` / `sql` / `query`);
  * - у тілі функції є виклик `<obj>.unsafe(...)`.
- *
  * @param {string} content вихідний код
  * @param {string} [virtualPath] шлях для вибору `lang`
  * @returns {{ line: number, snippet: string }[]} список порушень
@@ -419,31 +421,48 @@ export function findPgFormatLikeQueryWrapperInText(content, virtualPath = 'scan.
   /** @type {{ line: number, snippet: string }[]} */
   const out = []
   walkAstWithAncestors(program, [], node => {
-    if (node.type !== 'ObjectExpression') return
-    const properties = node.properties
-    if (!Array.isArray(properties)) return
-    for (const prop of properties) {
-      if (!prop || prop.type !== 'Property') continue
-      const key = prop.key
-      const keyName = key && key.type === 'Identifier' ? key.name : key && key.type === 'Literal' ? key.value : null
-      if (keyName !== 'query') continue
-      const value = prop.value
-      if (!value || (value.type !== 'FunctionExpression' && value.type !== 'ArrowFunctionExpression')) continue
-      const params = value.params
-      const firstName = Array.isArray(params) && params[0]?.type === 'Identifier' ? params[0].name : null
-      const looksLikePgQuery =
-        Array.isArray(params) && params.length >= 1 && params.length <= 2 && /^(text|sql|query)$/u.test(firstName || '')
-      if (!looksLikePgQuery) continue
-      if (!nodeContainsUnsafeCall(value.body)) continue
+    if (node.type !== 'ObjectExpression' || !Array.isArray(node.properties)) return
+    for (const prop of node.properties) {
+      const queryProp = asPgFormatLikeQueryProp(prop)
+      if (!queryProp) continue
       out.push({
-        line: offsetToLine(content, prop.start),
-        snippet: normalizeSnippet(content.slice(prop.start, prop.end))
+        line: offsetToLine(content, queryProp.start),
+        snippet: normalizeSnippet(content.slice(queryProp.start, queryProp.end))
       })
     }
   })
   return out
 }
 
+/**
+ * Чи є цей вузол `Property` тим самим pg-сумісним `{ query(text, params) { … unsafe … } }`?
+ * Повертає сам `prop` (для зручного `start`/`end`) або `null`.
+ * @param {unknown} prop AST вузол `Property`
+ * @returns {{ start: number, end: number } | null} `prop` як власний рекорд або `null`
+ */
+function asPgFormatLikeQueryProp(prop) {
+  if (!prop || typeof prop !== 'object' || prop.type !== 'Property') return null
+  if (propertyKeyName(prop.key) !== 'query') return null
+  const value = prop.value
+  if (!value || (value.type !== 'FunctionExpression' && value.type !== 'ArrowFunctionExpression')) return null
+  if (!hasPgQuerySignature(value.params)) return null
+  if (!nodeContainsUnsafeCall(value.body)) return null
+  return { start: prop.start, end: prop.end }
+}
+
+/**
+ * Чи виглядає сигнатура функції як pg-style `query(text, params?)`: 1–2 параметри,
+ * перший — Identifier з типовим pg-іменем (`text` / `sql` / `query`).
+ * @param {unknown} params AST `params` (масив)
+ * @returns {boolean} true, якщо схоже на pg-обгортку
+ */
+function hasPgQuerySignature(params) {
+  if (!Array.isArray(params) || params.length < 1 || params.length > 2) return false
+  const first = params[0]
+  if (!first || first.type !== 'Identifier' || typeof first.name !== 'string') return false
+  return PG_QUERY_FIRST_PARAM_RE.test(first.name)
+}
+
 /**
  * Чи є у піддереві виклик `<obj>.unsafe(...)`.
  * @param {unknown} root корінь піддерева

package/scripts/utils/bunyan-imports.mjs

@@ -11,69 +11,18 @@
  */
 import { parseSync } from 'oxc-parser'
 
-import { langFromPath, offsetToLine } from './ast-scan-utils.mjs'
+import {
+  dynamicImportModule,
+  langFromPath,
+  normalizeSnippet,
+  offsetToLine,
+  requireCallModule,
+  walkAstWithAncestors
+} from './ast-scan-utils.mjs'
 
-const SOURCE_FILE_RE = /\.([cm]?[jt]sx?)$/
+const SOURCE_FILE_RE = /\.([cm]?[jt]sx?)$/u
 const FORBIDDEN_MODULES = new Set(['@nitra/bunyan', 'bunyan'])
 
-/**
- * Стискає пробіли для повідомлення про порушення.
- * @param {string} s фрагмент коду
- * @returns {string} скорочений однорядковий рядок
- */
-function normalizeSnippet(s) {
-  return s.replaceAll(/\s+/g, ' ').trim().slice(0, 160)
-}
-
-/**
- * Перевіряє, чи це виклик `require('<module>')` з рядковим аргументом.
- * @param {Record<string, unknown> | null | undefined} node вузол AST
- * @returns {string | null} ім'я модуля з аргументу, інакше `null`
- */
-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`
- */
-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
-}
-
-/**
- * Простий рекурсивний обхід AST: заходимо в усі об'єкти/масиви, щоб знайти require/import-вузли.
- * @param {unknown} node корінь або під-вузол AST
- * @param {(n: unknown) => void} visit виклик для кожного об'єкта-вузла
- * @returns {void}
- */
-function walkAst(node, visit) {
-  if (!node || typeof node !== 'object') return
-  if (Array.isArray(node)) {
-    for (const item of node) walkAst(item, visit)
-    return
-  }
-  if (typeof node.type === 'string') {
-    visit(node)
-  }
-  for (const key of Object.keys(node)) {
-    if (key !== 'parent') {
-      const v = node[key]
-      if (v && typeof v === 'object') walkAst(v, visit)
-    }
-  }
-}
-
 /**
  * Знаходить заборонені імпорти/require з `@nitra/bunyan` у тексті.
  * @param {string} content вихідний код
@@ -107,7 +56,7 @@ export function findBunyanImportsInText(content, virtualPath = 'scan.ts') {
     }
   }
 
-  walkAst(result.program, node => {
+  walkAstWithAncestors(result.program, [], node => {
     const reqMod = requireCallModule(node)
     if (reqMod && FORBIDDEN_MODULES.has(reqMod)) {
       out.push({