@nitra/cursor 1.8.206 → 1.8.208

package/scripts/check-vue.mjs

@@ -32,7 +32,6 @@ import { loadCursorIgnorePaths } from './utils/load-cursor-config.mjs'
 import { walkDir } from './utils/walkDir.mjs'
 import { getMonorepoPackageRootDirs } from './utils/workspaces.mjs'
 
-const MAJOR_VERSION_RE = /(\d+)/
 const ESBUILD_RE = /\besbuild\b/
 
 /** Регулярний вираз для triple-slash `reference types="vite/client"` у `src/vite-env.d.ts`. */
@@ -245,20 +244,6 @@ async function checkViteClientEnvAndEditorConfig(rootDir, prefix, passFn, fail)
   passFn(`${prefix}jsconfig.json присутній`)
 }
 
-function checkViteVersion(devDeps, prefix, passFn, fail) {
-  const v = devDeps.vite
-  if (!v) {
-    fail(`${prefix}vite відсутній в devDependencies`)
-    return
-  }
-  const match = v.match(MAJOR_VERSION_RE)
-  if (match && Number(match[1]) >= 8) {
-    passFn(`${prefix}vite >= 8: ${v}`)
-  } else {
-    fail(`${prefix}vite має бути >= 8, знайдено: ${v}`)
-  }
-}
-
 /**
  * Витягує текст аргументів першого виклику `AutoImport(` з vite.config зі збалансованими дужками.
  * Повертає `null`, якщо виклик не знайдено або дужки не збалансовані (тоді перевірка `'vue'`
@@ -458,7 +443,9 @@ async function checkVuePackage(rootDir, ignorePaths, fail, passFn) {
   }
 
   checkRequiredDep(deps, 'vue', prefix, passFn, fail, 'vue відсутній в dependencies')
-  checkViteVersion(devDeps, prefix, passFn, fail)
+  // `vite >= 8` перенесено в Rego (`npm/policy/vue/package_json/`); запуск
+  // через `bun run lint-conftest`. Залишені вимоги — present-/missing-deps
+  // (vue-macros, unplugin-auto-import, тощо) — у самому JS-чекері.
   checkRequiredDep(
     devDeps,
     '@vitejs/plugin-vue',

package/scripts/lint-conftest.mjs

@@ -0,0 +1,351 @@
+/**
+ * Прогоняє `conftest test` по всіх Rego-полісі з `npm/policy/` (окрім `ga/*`,
+ * які вже виконуються через `lint-ga.mjs`).
+ *
+ * Кожна полісі має свій namespace, опційний `rule` (id у `.n-cursor.json:rules`,
+ * інакше таргет пропускається — як гейтинг у `check-*.mjs`), і список цільових
+ * файлів — single-file або walk-предикат для дерева. Якщо цільових файлів немає
+ * або правило не активне — таргет мовчки пропускається.
+ *
+ * Поведінка fallback:
+ *  - якщо `conftest` не в `PATH` — друкуємо `ℹ` повідомлення з підказкою
+ *    встановлення і повертаємо 0 (структурні JS-перевірки в `check-*.mjs`
+ *    лишаються паралельно). Те саме рішення — у `lint-ga.mjs`.
+ *  - якщо `npm/policy/` не існує (нетипова інсталяція) — також `ℹ` skip.
+ *
+ * Перший ненульовий exit-код conftest — повертаємо як результат, але всі
+ * наступні таргети все одно виконуємо, щоб одразу побачити повний список
+ * порушень (а не виправляти по одному).
+ *
+ * Експортовано окремо `runLintConftestCli` — використовується з
+ * `bin/n-cursor.js` як підкоманда `lint-conftest`.
+ */
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { spawnSync } from 'node:child_process'
+import { dirname, join, sep } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { resolveCmd } from './utils/resolve-cmd.mjs'
+
+/** Каталог пакету `@nitra/cursor`, від якого ресолвимо вшиту директорію policy/. */
+const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)))
+
+/** Шлях до кореня Rego-полісі. У npm-tarball публікується через `files: ["policy"]`. */
+const POLICY_DIR = join(PACKAGE_ROOT, 'policy')
+
+/**
+ * Опис одного таргета: namespace + спосіб розвʼязати цільові файли.
+ *
+ * `single` — конкретний файл відносно cwd, перевіряється `existsSync`-ом.
+ * `walk` — рекурсивний обхід від cwd із простим суфікс-предикатом
+ * (наприклад `name === 'package.json'`). Глибокі ігнори — як у `walkDir`
+ * в інших скриптах: `node_modules`, `.git`, `dist`, `coverage`, `build`,
+ * `.turbo`, `.next`. Не використовуємо bun Glob, щоб не плодити залежності
+ * за межами `node:fs`.
+ *
+ * @typedef {{
+ *   namespace: string,
+ *   policyDir: string,
+ *   rule?: string,
+ *   single?: string,
+ *   walk?: { match: (relPosix: string) => boolean }
+ * }} ConftestTarget
+ */
+
+/**
+ * Зчитує `rules` з `.n-cursor.json` у cwd. Повертає множину рядків — або `null`,
+ * якщо файлу немає чи поле некоректне (тоді гейтинг вимикаємо — як у `check-bun.mjs`).
+ * @param {string} cwd корінь репо
+ * @returns {Set<string> | null} множина активних правил або null
+ */
+function loadActiveCursorRules(cwd) {
+  const path = join(cwd, '.n-cursor.json')
+  if (!existsSync(path)) return null
+  try {
+    const raw = JSON.parse(readFileSync(path, 'utf8'))
+    if (!Array.isArray(raw?.rules)) return null
+    return new Set(raw.rules.map(String))
+  } catch {
+    return null
+  }
+}
+
+const SKIP_DIR_NAMES = new Set(['node_modules', '.git', 'dist', 'coverage', 'build', '.turbo', '.next'])
+
+/** @type {ConftestTarget[]} */
+const TARGETS = [
+  // ── bun ─────────────────────────────────────────────────────────────────
+  { namespace: 'bun.bunfig', policyDir: 'bun', rule: 'bun', single: 'bunfig.toml' },
+  { namespace: 'bun.package_json', policyDir: 'bun', rule: 'bun', single: 'package.json' },
+
+  // ── text ────────────────────────────────────────────────────────────────
+  { namespace: 'text.oxfmtrc', policyDir: 'text', rule: 'text', single: '.oxfmtrc.json' },
+  { namespace: 'text.cspell', policyDir: 'text', rule: 'text', single: '.cspell.json' },
+  { namespace: 'text.markdownlint', policyDir: 'text', rule: 'text', single: '.markdownlint-cli2.jsonc' },
+  { namespace: 'text.package_json', policyDir: 'text', rule: 'text', single: 'package.json' },
+
+  // ── style-lint ──────────────────────────────────────────────────────────
+  { namespace: 'style_lint.package_json', policyDir: 'style_lint', rule: 'style-lint', single: 'package.json' },
+  {
+    namespace: 'style_lint.lint_style_yml',
+    policyDir: 'style_lint',
+    rule: 'style-lint',
+    single: '.github/workflows/lint-style.yml'
+  },
+
+  // ── php ─────────────────────────────────────────────────────────────────
+  { namespace: 'php.package_json', policyDir: 'php', rule: 'php', single: 'package.json' },
+  {
+    namespace: 'php.lint_php_yml',
+    policyDir: 'php',
+    rule: 'php',
+    single: '.github/workflows/lint-php.yml'
+  },
+
+  // ── npm-module ──────────────────────────────────────────────────────────
+  {
+    namespace: 'npm_module.root_package_json',
+    policyDir: 'npm_module',
+    rule: 'npm-module',
+    single: 'package.json'
+  },
+  {
+    namespace: 'npm_module.npm_package_json',
+    policyDir: 'npm_module',
+    rule: 'npm-module',
+    single: 'npm/package.json'
+  },
+  {
+    namespace: 'npm_module.emit_types_config',
+    policyDir: 'npm_module',
+    rule: 'npm-module',
+    single: 'npm/tsconfig.emit-types.json'
+  },
+  {
+    namespace: 'npm_module.npm_publish_yml',
+    policyDir: 'npm_module',
+    rule: 'npm-module',
+    single: '.github/workflows/npm-publish.yml'
+  },
+
+  // ── js-lint ─────────────────────────────────────────────────────────────
+  { namespace: 'js_lint.package_json', policyDir: 'js_lint', rule: 'js-lint', single: 'package.json' },
+  {
+    namespace: 'js_lint.lint_js_yml',
+    policyDir: 'js_lint',
+    rule: 'js-lint',
+    single: '.github/workflows/lint-js.yml'
+  },
+
+  // ── graphql / image-compress / capacitor ────────────────────────────────
+  { namespace: 'graphql.package_json', policyDir: 'graphql', rule: 'graphql', single: 'package.json' },
+  {
+    namespace: 'image_compress.package_json',
+    policyDir: 'image_compress',
+    rule: 'image-compress',
+    single: 'package.json'
+  },
+  {
+    namespace: 'capacitor.package_json',
+    policyDir: 'capacitor',
+    rule: 'capacitor',
+    single: 'package.json'
+  },
+
+  // ── hasura ──────────────────────────────────────────────────────────────
+  {
+    namespace: 'hasura.svc_hl',
+    policyDir: 'hasura',
+    rule: 'hasura',
+    single: 'hasura/k8s/base/svc-hl.yaml'
+  },
+
+  // ── adr ─────────────────────────────────────────────────────────────────
+  { namespace: 'adr.settings_json', policyDir: 'adr', rule: 'adr', single: '.claude/settings.json' },
+  {
+    namespace: 'adr.settings_local_json',
+    policyDir: 'adr',
+    rule: 'adr',
+    single: '.claude/settings.local.json'
+  },
+
+  // ── multi-file (walk) ───────────────────────────────────────────────────
+  // Усі `package.json` у дереві (включно з workspace-пакетами).
+  {
+    namespace: 'js_mssql.package_json',
+    policyDir: 'js_mssql',
+    rule: 'js-mssql',
+    walk: { match: rel => rel.endsWith('/package.json') || rel === 'package.json' }
+  },
+  {
+    namespace: 'js_bun_db.package_json',
+    policyDir: 'js_bun_db',
+    rule: 'js-bun-db',
+    walk: { match: rel => rel.endsWith('/package.json') || rel === 'package.json' }
+  },
+  {
+    namespace: 'js_run.package_json',
+    policyDir: 'js_run',
+    rule: 'js-run',
+    walk: { match: rel => rel.endsWith('/package.json') || rel === 'package.json' }
+  },
+  {
+    namespace: 'vue.package_json',
+    policyDir: 'vue',
+    rule: 'vue',
+    walk: { match: rel => rel.endsWith('/package.json') || rel === 'package.json' }
+  },
+
+  // ConfigMap у `…/k8s/base/configmap.yaml` будь-де у дереві.
+  {
+    namespace: 'js_run.configmap',
+    policyDir: 'js_run',
+    rule: 'js-run',
+    walk: { match: rel => /(^|\/)k8s\/[^/]+\/configmap\.yaml$/.test(rel) }
+  },
+
+  // Усі YAML у дереві з сегментом `k8s` — пер-документні структурні правила.
+  {
+    namespace: 'k8s.manifest',
+    policyDir: 'k8s',
+    rule: 'k8s',
+    walk: { match: rel => /(^|\/)k8s\//.test(rel) && (rel.endsWith('.yaml') || rel.endsWith('.yml')) }
+  },
+
+  // abie HealthCheckPolicy: `hc.yaml` у дереві k8s.
+  {
+    namespace: 'abie.health_check_policy',
+    policyDir: 'abie',
+    rule: 'abie',
+    walk: { match: rel => /(^|\/)k8s\/.+\/hc\.yaml$/.test(rel) }
+  },
+
+  // abie HTTPRoute у `base/`.
+  {
+    namespace: 'abie.http_route_base',
+    policyDir: 'abie',
+    rule: 'abie',
+    walk: { match: rel => /(^|\/)k8s\/.*base\/.*hr\.yaml$/.test(rel) }
+  }
+]
+
+/**
+ * Рекурсивно збирає відносні (posix) шляхи від cwd, які матчаться предикатом.
+ * Глибокі ігнори — `SKIP_DIR_NAMES`. Не йде у симлінки, помилки stat — мовчки skip.
+ * @param {string} root абсолютний корінь обходу
+ * @param {(relPosix: string) => boolean} match предикат на відносний posix-шлях
+ * @returns {string[]} список відносних posix-шляхів
+ */
+function collectFiles(root, match) {
+  /** @type {string[]} */
+  const out = []
+  /** @param {string} dirAbs */
+  function visit(dirAbs) {
+    /** @type {import('node:fs').Dirent[]} */
+    let entries
+    try {
+      entries = readdirSync(dirAbs, { withFileTypes: true })
+    } catch {
+      return
+    }
+    for (const e of entries) {
+      if (e.isSymbolicLink()) continue
+      const abs = join(dirAbs, e.name)
+      if (e.isDirectory()) {
+        if (SKIP_DIR_NAMES.has(e.name)) continue
+        visit(abs)
+        continue
+      }
+      if (!e.isFile()) continue
+      const rel = abs.slice(root.length + 1).split(sep).join('/')
+      if (match(rel)) out.push(rel)
+    }
+  }
+  visit(root)
+  return out
+}
+
+/**
+ * Розвʼязує файлові цілі для одного таргета щодо cwd.
+ * @param {ConftestTarget} target опис таргета
+ * @param {string} cwd корінь репозиторію
+ * @returns {string[]} список абсолютних / відносних шляхів
+ */
+function resolveTargetFiles(target, cwd) {
+  if (target.single) {
+    return existsSync(join(cwd, target.single)) ? [target.single] : []
+  }
+  if (target.walk) {
+    return collectFiles(cwd, target.walk.match)
+  }
+  return []
+}
+
+/**
+ * Запускає conftest на одному таргеті. Повертає exit-код (0 — OK, 1+ — помилки).
+ *
+ * При відсутніх цільових файлах — мовчки повертає 0 (правило неактуальне для repo).
+ * Логує заголовок з namespace і кількістю файлів, як `lint-ga.mjs`.
+ * @param {string} conftestBin абсолютний шлях до бінарника conftest
+ * @param {ConftestTarget} target опис таргета
+ * @param {string[]} files список файлів для перевірки (відносні до cwd)
+ * @returns {number} exit-код
+ */
+function runConftestForTarget(conftestBin, target, files) {
+  const policyAbs = join(POLICY_DIR, target.policyDir)
+  if (!existsSync(policyAbs)) {
+    return 0
+  }
+  console.log(`\n▶ conftest (${target.namespace} — ${files.length} файл(ів))`)
+  const r = spawnSync(
+    conftestBin,
+    ['test', ...files, '-p', policyAbs, '--namespace', target.namespace, '--no-color'],
+    { stdio: 'inherit', env: process.env }
+  )
+  if (r.error) {
+    console.error(`❌ Не вдалося запустити conftest: ${r.error.message}`)
+    return 1
+  }
+  return r.status ?? 1
+}
+
+/**
+ * Запускає `conftest test` по всіх таргетах із `TARGETS`. Перший ненульовий exit-код
+ * запамʼятовується, але цикл йде до кінця, щоб користувач побачив усі порушення.
+ *
+ * Якщо `conftest` не знайдено в PATH — друкує `ℹ` повідомлення і повертає 0
+ * (структурні перевірки в `check-*.mjs` лишаються паралельно).
+ * @returns {number} 0 — все OK або skip; інакше — перший ненульовий exit-код
+ */
+export function runLintConftestCli() {
+  const conftestBin = resolveCmd('conftest')
+  if (!conftestBin) {
+    console.log(
+      'ℹ conftest не знайдено в PATH — пропускаю Rego-перевірки.\n' +
+        '  Встанови, щоб запустити локально: brew install conftest (macOS) або https://www.conftest.dev/install/'
+    )
+    return 0
+  }
+  if (!existsSync(POLICY_DIR)) {
+    console.log(`ℹ Каталог Rego-полісі не знайдено (${POLICY_DIR}) — пропускаю conftest.`)
+    return 0
+  }
+
+  const cwd = process.cwd()
+  const activeRules = loadActiveCursorRules(cwd)
+  let firstFailureCode = 0
+  for (const target of TARGETS) {
+    if (target.rule && activeRules && !activeRules.has(target.rule)) continue
+    const files = resolveTargetFiles(target, cwd)
+    if (files.length === 0) continue
+    const code = runConftestForTarget(conftestBin, target, files)
+    if (code !== 0 && firstFailureCode === 0) {
+      firstFailureCode = code
+    }
+  }
+  return firstFailureCode
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  process.exit(runLintConftestCli())
+}

package/scripts/lint-ga.mjs

@@ -7,6 +7,13 @@
  * повідомлення й продовжуємо з кодом 0. Структурні перевірки тих самих workflow паралельно живуть у
  * `npm/scripts/check-ga.mjs`, тож відсутність conftest не пропускає порушення мовчки.
  *
+ * Conftest проганяється у двох режимах:
+ * 1) per-workflow polysi (`ga.<name>`) — для канонічних `clean-ga-workflows`, `clean-merged-branch`,
+ *    `lint-ga`, `git-ai`, що мають фіксовані поля (cron, ім'я кроку тощо);
+ * 2) `ga.workflow_common` — універсальні правила (concurrency, заборонені setup-bun/cache/install у
+ *    кроках, shell line-continuation у `run:`, checkout перед локальним setup-bun-deps), які
+ *    застосовуються до **кожного** `.github/workflows/*.yml`.
+ *
  * Без preflight `actionlint` (через `bunx github-actionlint`) мовчки пропускає shell-перевірки в
  * `run:` блоках, коли `shellcheck` відсутній у PATH; локально `bun lint-ga` лишається зеленим, а CI
  * на ubuntu-latest (де shellcheck передвстановлений) падає. Preflight робить цю різницю явною.
@@ -16,7 +23,7 @@
  *
  * Експортовано окремо `runLintGaCli` — використовується з `bin/n-cursor.js` як підкоманда `lint-ga`.
  */
-import { existsSync } from 'node:fs'
+import { existsSync, readdirSync } from 'node:fs'
 import { spawnSync } from 'node:child_process'
 import { dirname, join } from 'node:path'
 import { platform } from 'node:process'
@@ -244,5 +251,35 @@ function runConftestStep() {
     ])
     if (code !== 0) return code
   }
-  return 0
+
+  return runConftestWorkflowCommon(conftestBin)
+}
+
+/**
+ * Прогоняє `ga.workflow_common` на кожному `.github/workflows/*.yml` — універсальні перевірки
+ * (concurrency, заборонені setup-bun/cache/install, shell line-continuation, checkout перед
+ * локальним setup-bun-deps). Якщо директорії немає або файлів немає — мовчки skip.
+ *
+ * Викликаємо conftest на всіх файлах одним прогоном (`conftest test <files...>`) — швидше, ніж
+ * по одному, і summary-лог зрозуміліший. Перший ненульовий exit-код повертаємо як результат.
+ * @param {string} conftestBin абсолютний шлях до бінарника conftest
+ * @returns {number} 0 — OK, інакше exit-код conftest
+ */
+function runConftestWorkflowCommon(conftestBin) {
+  const wfDir = '.github/workflows'
+  if (!existsSync(wfDir)) return 0
+  const ymlFiles = readdirSync(wfDir)
+    .filter(f => f.endsWith('.yml'))
+    .map(f => join(wfDir, f))
+  if (ymlFiles.length === 0) return 0
+
+  return runStep('conftest (workflow_common — усі workflow)', conftestBin, [
+    'test',
+    ...ymlFiles,
+    '-p',
+    GA_POLICY_DIR,
+    '--namespace',
+    'ga.workflow_common',
+    '--no-color'
+  ])
 }

package/scripts/run-shellcheck-text.mjs

@@ -80,14 +80,14 @@ export function listShellScriptPaths(cwd) {
       return []
     }
     const files = ls.stdout.split('\0').filter(Boolean)
-    return [...new Set(files)].sort()
+    return new Set(files).toSorted()
   }
 
   const fromGlob = globSync('**/*.sh', {
     cwd,
     exclude: p => p.includes('node_modules') || p.startsWith(`node_modules/`) || p.split('/').includes('node_modules')
   })
-  return [...new Set(fromGlob.map(p => p.replaceAll('\\', '/')))].sort()
+  return new Set(fromGlob.map(p => p.replaceAll('\\', '/'))).toSorted()
 }
 
 /**

package/scripts/utils/conn-file-rules.mjs

@@ -0,0 +1,170 @@
+/**
+ * Перевірки для файлів-підключень у каталозі `#conn` (js-run.mdc → «Нейминг файлів у `src/conn/`»
+ * та «Експорти у файлах `src/conn/`»).
+ *
+ * Канонічна назва файла:
+ *  - GraphQL: `ql-<id>.{js|mjs|cjs|ts|mts|cts}` (id — kebab-case ідентифікатор endpoint);
+ *  - PostgreSQL: `pg-{read|write}.{ext}` або `pg-{read|write}-<id>.{ext}` (id — для multi-БД);
+ *  - MySQL/MSSQL: `mysql-{read|write}.{ext}` або `mysql-{read|write}-<id>.{ext}`.
+ *
+ * Канонічний експорт — іменований, без `export default`. Імʼя константи має дорівнювати
+ * camelCase від basename файла (`pg-write-contract` → `pgWriteContract`).
+ *
+ * Парсимо через oxc-parser; коли файл не парситься — повертаємо порожні результати, щоб
+ * не змішувати помилки синтаксису з порушеннями цього правила.
+ */
+import { parseProgramOrNull } from './ast-scan-utils.mjs'
+
+const SOURCE_FILE_RE = /\.([cm]?[jt]sx?)$/u
+
+/**
+ * Канонічний шаблон імені файла в каталозі conn.
+ *  - `ql-<id>` для GraphQL;
+ *  - `(pg|mysql)-(read|write)(-<id>)?` для БД.
+ * `<id>` — починається з [a-z0-9], далі [a-z0-9-]*.
+ */
+const CONN_FILENAME_RE =
+  /^(?:ql-[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|(?:pg|mysql)-(?:read|write)(?:-[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)?)\.([cm]?[jt]sx?)$/u
+
+/**
+ * Чи це файл, який сканується правилом «conn-file» (JS/TS-сімʼя, без `.d.ts`).
+ * @param {string} relativePathPosix відносний posix-шлях
+ * @returns {boolean} true, якщо потрібно перевіряти
+ */
+export function isConnFileRulesSourceFile(relativePathPosix) {
+  return SOURCE_FILE_RE.test(relativePathPosix) && !relativePathPosix.endsWith('.d.ts')
+}
+
+/**
+ * Витягує basename файла без розширення.
+ * @param {string} relativePathPosix відносний шлях у posix-форматі
+ * @returns {string} basename без розширення (наприклад, `pg-write-contract`)
+ */
+function basenameNoExt(relativePathPosix) {
+  const last = relativePathPosix.lastIndexOf('/')
+  const base = last >= 0 ? relativePathPosix.slice(last + 1) : relativePathPosix
+  const dot = base.lastIndexOf('.')
+  return dot > 0 ? base.slice(0, dot) : base
+}
+
+/**
+ * Перетворює kebab-case ідентифікатор у camelCase.
+ * @param {string} kebab kebab-case рядок (`pg-write-contract`)
+ * @returns {string} camelCase (`pgWriteContract`)
+ */
+export function kebabToCamel(kebab) {
+  return kebab.replaceAll(/-([a-z0-9])/gu, (_m, c) => c.toUpperCase())
+}
+
+/**
+ * Чи відповідає назва файла канонічному шаблону для каталогу conn.
+ * @param {string} relativePathPosix відносний posix-шлях файла
+ * @returns {boolean} true, якщо basename + ext збігається зі схемою
+ */
+export function isConnFileNameValid(relativePathPosix) {
+  const last = relativePathPosix.lastIndexOf('/')
+  const base = last >= 0 ? relativePathPosix.slice(last + 1) : relativePathPosix
+  return CONN_FILENAME_RE.test(base)
+}
+
+/**
+ * Збирає всі імена named-експортів у програмі.
+ *
+ * Покриває: `export const/let/var X`, `export function X`, `export class X`,
+ * `export { X }`, `export { X as Y }` (повертає `Y`). `export *` ігнорується
+ * (немає конкретного імені для звірки), `export default` обробляється окремо.
+ * @param {unknown} program AST root
+ * @returns {string[]} список експортованих імен
+ */
+function collectNamedExportNames(program) {
+  /** @type {string[]} */
+  const out = []
+  if (!program || typeof program !== 'object') return out
+  const body = /** @type {Record<string, unknown>} */ (program).body
+  if (!Array.isArray(body)) return out
+  for (const node of body) {
+    if (!node || typeof node !== 'object') continue
+    const rec = /** @type {Record<string, unknown>} */ (node)
+    if (rec.type !== 'ExportNamedDeclaration') continue
+    const decl = /** @type {Record<string, unknown> | null} */ (rec.declaration ?? null)
+    if (decl) {
+      // export const X = ... / export let / export var
+      if (decl.type === 'VariableDeclaration' && Array.isArray(decl.declarations)) {
+        for (const d of decl.declarations) {
+          const id = /** @type {Record<string, unknown> | null} */ (d?.id ?? null)
+          if (id && id.type === 'Identifier' && typeof id.name === 'string') out.push(id.name)
+        }
+      }
+      // export function X / export class X
+      if (
+        (decl.type === 'FunctionDeclaration' || decl.type === 'ClassDeclaration') &&
+        decl.id &&
+        typeof decl.id === 'object' &&
+        typeof /** @type {Record<string, unknown>} */ (decl.id).name === 'string'
+      ) {
+        out.push(/** @type {string} */ (/** @type {Record<string, unknown>} */ (decl.id).name))
+      }
+    } else if (Array.isArray(rec.specifiers)) {
+      // export { X } / export { X as Y }
+      for (const s of rec.specifiers) {
+        const exported = /** @type {Record<string, unknown> | null} */ (s?.exported ?? null)
+        if (!exported) continue
+        // ESTree: Identifier (name) або Literal (value), залежно від спеки
+        if (exported.type === 'Identifier' && typeof exported.name === 'string') out.push(exported.name)
+        else if (typeof exported.value === 'string') out.push(exported.value)
+      }
+    }
+  }
+  return out
+}
+
+/**
+ * Чи є в програмі `export default ...`.
+ * @param {unknown} program AST root
+ * @returns {boolean} true, якщо знайдено будь-який ExportDefaultDeclaration
+ */
+function hasDefaultExport(program) {
+  if (!program || typeof program !== 'object') return false
+  const body = /** @type {Record<string, unknown>} */ (program).body
+  if (!Array.isArray(body)) return false
+  for (const node of body) {
+    if (node && typeof node === 'object' && /** @type {Record<string, unknown>} */ (node).type === 'ExportDefaultDeclaration') {
+      return true
+    }
+  }
+  return false
+}
+
+/**
+ * Знаходить порушення правил для одного файла з каталогу conn.
+ *
+ * Якщо AST не парситься — повертає порожній масив (синтаксис падає в інших перевірках,
+ * не дублюємо).
+ * @param {string} content вихідний код файла
+ * @param {string} relativePathPosix відносний posix-шлях файла (від кореня пакета)
+ * @returns {{ kind: 'name' | 'default-export' | 'export-name', expectedName?: string, foundNames?: string[] }[]} список порушень
+ */
+export function findConnFileRuleViolations(content, relativePathPosix) {
+  /** @type {{ kind: 'name' | 'default-export' | 'export-name', expectedName?: string, foundNames?: string[] }[]} */
+  const out = []
+  if (!isConnFileNameValid(relativePathPosix)) {
+    out.push({ kind: 'name' })
+    // якщо назва нестандартна — далі звірку імені експорту не робимо (camelCase двозначний)
+  }
+
+  const program = parseProgramOrNull(content, relativePathPosix)
+  if (!program) return out
+
+  if (hasDefaultExport(program)) {
+    out.push({ kind: 'default-export' })
+  }
+
+  if (out.some(v => v.kind === 'name')) return out
+
+  const expected = kebabToCamel(basenameNoExt(relativePathPosix.slice(relativePathPosix.lastIndexOf('/') + 1)))
+  const names = collectNamedExportNames(program)
+  if (!names.includes(expected)) {
+    out.push({ kind: 'export-name', expectedName: expected, foundNames: names })
+  }
+  return out
+}