@7n/rules-lang-js 0.3.1 → 0.4.0

package/rules/bun/package_json/docs/fix-package_json.md

@@ -0,0 +1,28 @@
+---
+type: JS Module
+title: fix-package_json.mjs
+resource: plugins/lang-js/rules/bun/package_json/fix-package_json.mjs
+docgen:
+  crc: cf834366
+  model: openai-codex/gpt-5.4-mini
+  score: 100
+  issues: judge:inaccurate:0.97
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Файл знаходить `package.json` із порушеннями policy `bun/package_json` серед заборонених top-level полів і `scripts.lint` / `scripts.lint-*` та запускає T0-autofix для цих випадків. Він видаляє top-level поля за каноном `template/package.json.deny.json` і `package.json.deny.json`, а lint-скрипти переписує на канонічний `bunx n-rules lint ...` лише після репо-wide пошуку всіх їхніх викликів; нерозпізнані виклики лишаються без змін, і в такому разі скрипт не видаляється. Помилки обробляє fail-safe і не кидає назовні.
+
+## Поведінка
+
+1. `patterns` знаходить package.json, у яких є порушення policy для `bun/package_json`, і запускає T0-autofix лише для них.
+2. Для кожного такого package.json вона орієнтується на канон deny-списку з `template/package.json.deny.json` і прибирає заборонені top-level поля.
+3. Якщо в `package.json` є `scripts.lint` або `scripts.lint-*`, вона спершу шукає їхні виклики в репозиторії та переписує їх на канонічний `bunx n-rules lint ...`, щоб не зламати споживачів цих скриптів.
+4. Власні скрипти цього ж `package.json` теж оновлюються до канонічного запуску, якщо вони посилаються на lint-скрипти, що плануються до видалення.
+5. Скрипт видаляє `scripts.lint*` лише тоді, коли для них не лишається нерозпізнаних викликів; якщо десь є незрозумілий спосіб запуску, він лишає скрипт на місці й лише повідомляє про це.
+6. Після змін вона записує оновлений `package.json` і повертає перелік зачеплених файлів та короткий підсумок змін; назовні помилки не пробиваються.
+
+## Гарантії поведінки
+
+- Перехоплює помилки і не пропускає винятків назовні (fail-safe).

package/rules/bun/package_json/docs/index.md

@@ -0,0 +1,9 @@
+---
+type: Directory Index
+title: npm/rules/bun/package_json
+resource: plugins/lang-js/rules/bun/package_json/
+---
+
+| Файл                                        | Тип       |
+| ------------------------------------------- | --------- |
+| [fix-package_json.mjs](fix-package_json.md) | JS Module |

package/rules/bun/package_json/fix-package_json.mjs

@@ -0,0 +1,311 @@
+/**
+ * T0-autofix для policy-concern-а `bun/package_json`: видаляє заборонені top-level поля
+ * (канон — `template/package.json.deny.json`, той самий `data.template.deny`, що бачить rego)
+ * і `scripts.lint` / `scripts.lint-*` (bun.mdc — лінт лише через `n-rules lint`, не npm-скрипти).
+ *
+ * Просте видалення `scripts.lint*` небезпечне: якщо десь у репо (workflow yml, інший
+ * npm-скрипт) є виклик `bun run lint-js` тощо, видалення ключа зламає цей виклик.
+ * Тому перед видаленням шукаємо всі виклики кожного lint-скрипта репо-вайд і переписуємо
+ * їх на прямий `bunx n-rules lint <surface>` (canonical — той самий, що вимагають
+ * lint_js_yml/lint_style_yml). Скрипт видаляється лише якщо ВСІ його виклики вдалось
+ * переписати (файли, де виклик не розпізнано — залишаємо як є, скрипт теж лишається,
+ * щоб не зламати консьюмера мовчки).
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { walkDir } from '@7n/rules/scripts/utils/walkDir.mjs'
+import { loadCursorIgnorePaths } from '@7n/rules/scripts/lib/load-cursor-config.mjs'
+
+const LINT_SCRIPT_RE = /^lint(-.*)?$/u
+const WORKFLOW_YML_RE = /^\.github\/workflows\/.*\.ya?ml$/u
+const LOCKFILE_RE = /(^|\/)(bun\.lockb?|package-lock\.json|yarn\.lock|pnpm-lock\.yaml)$/u
+const PACKAGE_MANAGER_SCRIPT_PREFIX_RE = /\b(?:(?:bun|yarn|pnpm)(?:\s+run)?|npm\s+run)\s+/gu
+const SCRIPT_NAME_CONTINUATION_RE = /[\w-]/u
+
+// `lint-<suffix>` → rule-id канонічного `n-rules lint <rule-id>`; bare `lint` → без rule-id.
+const SURFACE_MAP = { image: 'image-compress' }
+
+/**
+ * @param {string} scriptName напр. `lint-js`, `lint`
+ * @returns {string} суфікс аргументу для `n-rules lint` (порожній рядок для bare `lint`)
+ */
+function surfaceArgFor(scriptName) {
+  const suffix = scriptName.slice('lint'.length)
+  if (suffix.length === 0) return ''
+  const normalized = suffix.startsWith('-') ? suffix.slice(1) : suffix
+  return ` ${SURFACE_MAP[normalized] ?? normalized}`
+}
+
+/**
+ * Знаходить діапазони виклику package-manager-ом заданого npm-скрипта: `bun[ run] X`,
+ * `yarn[ run] X`, `pnpm[ run] X`, `npm run X` (голий `npm X` — не валідний npm-синтаксис,
+ * окрім start/test). Right-boundary — НЕ `\b` (hyphen — non-word char, тож `lint\b`
+ * матчить всередині `lint-js`), а перевірка проти `[\w-]`, щоб `lint` не «зжирав»
+ * префікс `lint-js`.
+ * @param {string} content вміст для пошуку
+ * @param {string} scriptName ім'я npm-скрипта
+ * @returns {Array<[number, number]>} діапазони повного виклику в content
+ */
+function invocationRanges(content, scriptName) {
+  /** @type {Array<[number, number]>} */
+  const ranges = []
+  PACKAGE_MANAGER_SCRIPT_PREFIX_RE.lastIndex = 0
+  let match
+  while ((match = PACKAGE_MANAGER_SCRIPT_PREFIX_RE.exec(content))) {
+    const scriptStart = PACKAGE_MANAGER_SCRIPT_PREFIX_RE.lastIndex
+    if (!content.startsWith(scriptName, scriptStart)) continue
+    const scriptEnd = scriptStart + scriptName.length
+    if (SCRIPT_NAME_CONTINUATION_RE.test(content[scriptEnd] ?? '')) continue
+    ranges.push([match.index, scriptEnd])
+  }
+  return ranges
+}
+
+/**
+ * Читає JSON-файл template-а з deny-полями концерну; відсутній/невалідний → {}.
+ * @param {string} path абсолютний шлях
+ * @returns {Record<string, string>} мапа `field -> reason`
+ */
+function readDenyTemplate(path) {
+  if (!existsSync(path)) return {}
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'))
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * `workflow`/`package-json` — відомий, безпечно переписуваний формат; `other` — будь-який
+ * інший текстовий файл (Makefile, README, shell-скрипт…), де ми ЛИШЕ детектуємо виклик,
+ * але не переписуємо (немає надійного canonical-заміщення для довільного формату).
+ * @typedef {'workflow'|'package-json'|'other'} FileKind
+ */
+
+/**
+ * @param {string} rel posix-відносний шлях від кореня репо
+ * @param {string} abs абсолютний шлях
+ * @param {string} rootPkgAbs абсолютний шлях кореневого package.json (сам він — не кандидат)
+ * @returns {FileKind|null} категорія файлу, або null якщо файл взагалі не кандидат (лок-файли)
+ */
+function classifyCandidate(rel, abs, rootPkgAbs) {
+  if (LOCKFILE_RE.test(rel)) return null
+  if (WORKFLOW_YML_RE.test(rel)) return 'workflow'
+  if (rel.endsWith('package.json')) return abs === rootPkgAbs ? null : 'package-json'
+  return 'other'
+}
+
+/**
+ * Знаходить УСІ файли репозиторію (крім кореневого package.json і лок-файлів) як кандидатів
+ * на пошук викликів npm-скриптів — виклик може бути де завгодно (Makefile, README, CI,
+ * інший package.json), не лише у відомих форматах.
+ * @param {string} cwd абсолютний корінь репозиторію
+ * @param {string} rootPkgAbs абсолютний шлях кореневого package.json (виключити)
+ * @returns {Promise<Array<{ abs: string, kind: FileKind }>>} кандидати з категорією
+ */
+async function findUsageCandidateFiles(cwd, rootPkgAbs) {
+  const ignorePaths = await loadCursorIgnorePaths(cwd)
+  /** @type {Array<{ abs: string, kind: FileKind }>} */
+  const out = []
+  await walkDir(
+    cwd,
+    abs => {
+      const rel = abs
+        .slice(cwd.length + 1)
+        .split('\\')
+        .join('/')
+      const kind = classifyCandidate(rel, abs, rootPkgAbs)
+      if (kind) out.push({ abs, kind })
+    },
+    ignorePaths
+  )
+  return out
+}
+
+/**
+ * Переписує один файл-кандидат: кожен знайдений виклик `scriptName` замінюється на
+ * канонічний `bunx n-rules lint<surface>` (workflow yml — з `--no-fix`, package.json
+ * scripts-чейни — без, дев-контекст хоче autofix).
+ * @param {string} content вміст файлу
+ * @param {string} scriptName ім'я lint-скрипта
+ * @param {boolean} isWorkflow чи це workflow yml (інакше — package.json)
+ * @returns {{ content: string, matched: boolean }} новий вміст і чи був матч
+ */
+function rewriteUsages(content, scriptName, isWorkflow) {
+  const ranges = invocationRanges(content, scriptName)
+  if (ranges.length === 0) return { content, matched: false }
+  const canonical = `bunx n-rules lint${surfaceArgFor(scriptName)}${isWorkflow ? ' --no-fix' : ''}`
+  let next = ''
+  let lastIndex = 0
+  for (const [start, end] of ranges) {
+    next += content.slice(lastIndex, start) + canonical
+    lastIndex = end
+  }
+  next += content.slice(lastIndex)
+  return { content: next, matched: true }
+}
+
+/**
+ * Для кожного lint-скрипта шукає й переписує його виклики по всіх кандидатах.
+ * `workflow`/`package-json` — переписуємо на канонічний `bunx n-rules lint`; `other`
+ * (Makefile, README, довільний shell) — лише детектуємо, без canonical-заміщення для
+ * довільного формату скрипт НЕ видаляємо (блокуючий, а не мовчки проігнорований, збіг).
+ * @param {string[]} scriptNames кандидати на видалення (`lint`, `lint-js`, …)
+ * @param {Array<{ abs: string, kind: FileKind }>} candidateFiles файли-кандидати з категорією
+ * @param {(absPath: string) => void} recordWrite реєстрація запису для rollback
+ * @returns {{ safeToRemove: Set<string>, touchedFiles: string[] }} скрипти без залишкових
+ *   викликів (безпечно видалити) і список фактично змінених файлів
+ */
+function adaptUsages(scriptNames, candidateFiles, recordWrite) {
+  const unresolved = new Set()
+  const touchedFiles = []
+  const sortedNames = scriptNames.toSorted((a, b) => b.length - a.length)
+
+  for (const { abs, kind } of candidateFiles) {
+    if (kind === 'other') continue
+    const isWorkflow = kind === 'workflow'
+    let content
+    try {
+      content = readFileSync(abs, 'utf8')
+    } catch {
+      continue
+    }
+    let next = content
+    // Найдовші імена першими (defense-in-depth поряд із right-boundary lookahead) —
+    // `lint-js` перепишеться до того, як коротший `lint` встигне зачепити його префікс.
+    for (const name of sortedNames) next = rewriteUsages(next, name, isWorkflow).content
+    if (next === content) continue
+    recordWrite?.(abs)
+    writeFileSync(abs, next)
+    touchedFiles.push(abs)
+  }
+
+  // Другий прохід (після переписів) — чи лишився десь виклик, який ми не розпізнали
+  // (`other`-формат або невідомий package-manager-синтаксис); такий скрипт НЕ видаляємо.
+  for (const { abs } of candidateFiles) {
+    let content
+    try {
+      content = readFileSync(abs, 'utf8')
+    } catch {
+      continue
+    }
+    for (const name of scriptNames) {
+      if (invocationRanges(content, name).length > 0) unresolved.add(name)
+    }
+  }
+
+  return { safeToRemove: new Set(scriptNames.filter(n => !unresolved.has(n))), touchedFiles }
+}
+
+/**
+ * Адаптує виклики lint-скриптів в ІНШИХ скриптах ТОГО Ж package.json (напр. `precommit`:
+ * `bun run lint-js && bun test`) — цей файл не потрапляє у зовнішній `findUsageCandidateFiles`,
+ * бо він же ціль видалення. Мутує `pkg.scripts` на місці.
+ * @param {object} pkg розпарсений package.json (мутується)
+ * @param {string[]} scriptNames кандидати на видалення
+ * @returns {Set<string>} імена, для яких лишився нерозпізнаний виклик у власних скриптах
+ */
+function adaptOwnScripts(pkg, scriptNames) {
+  const unresolved = new Set()
+  if (!pkg.scripts || typeof pkg.scripts !== 'object') return unresolved
+
+  const sorted = scriptNames.toSorted((a, b) => b.length - a.length)
+  const otherEntries = Object.entries(pkg.scripts).filter(
+    ([key, value]) => !scriptNames.includes(key) && typeof value === 'string'
+  )
+
+  for (const [key, value] of otherEntries) {
+    let next = value
+    for (const name of sorted) next = rewriteUsages(next, name, false).content
+    if (next !== value) pkg.scripts[key] = next
+  }
+  // Пере-перевірка після мутації: чи лишився десь нерозпізнаний виклик.
+  for (const [key] of otherEntries) {
+    const current = pkg.scripts[key]
+    if (typeof current !== 'string') continue
+    for (const name of scriptNames) {
+      if (invocationRanges(current, name).length > 0) unresolved.add(name)
+    }
+  }
+  return unresolved
+}
+
+/**
+ * Видаляє заборонені top-level поля й `scripts.lint*` (лише ті, чиї виклики вже адаптовано)
+ * з `package.json`.
+ * @param {object} pkg розпарсений package.json
+ * @param {Record<string, string>} denyFields канон заборонених top-level полів
+ * @param {Set<string>} safeToRemove скрипти без залишкових зовнішніх викликів
+ * @returns {string[]} список видалених ключів (для message)
+ */
+function stripDenied(pkg, denyFields, safeToRemove) {
+  const removed = []
+  for (const field of Object.keys(denyFields)) {
+    if (!Object.hasOwn(pkg, field)) continue
+    delete pkg[field]
+    removed.push(field)
+  }
+  if (pkg.scripts && typeof pkg.scripts === 'object') {
+    for (const name of Object.keys(pkg.scripts)) {
+      if (!LINT_SCRIPT_RE.test(name) || !safeToRemove.has(name)) continue
+      delete pkg.scripts[name]
+      removed.push(`scripts.${name}`)
+    }
+  }
+  return removed
+}
+
+/** @type {import('@7n/rules/scripts/lib/lint-surface/types.mjs').T0Pattern[]} */
+export const patterns = [
+  {
+    id: 'bun-package_json-strip-denied',
+    test: violations => violations.some(v => v.reason === 'policy-deny' && v.file),
+    apply: async (violations, ctx) => {
+      const denyFields = readDenyTemplate(join(ctx.concernDir ?? '', 'template', 'package.json.deny.json'))
+      const files = [...new Set(violations.filter(v => v.file).map(v => v.file))]
+      const touchedFiles = []
+      const messages = []
+
+      for (const rel of files) {
+        const abs = join(ctx.cwd, rel)
+        let pkg
+        try {
+          pkg = JSON.parse(readFileSync(abs, 'utf8'))
+        } catch {
+          continue
+        }
+
+        const lintScriptNames =
+          pkg.scripts && typeof pkg.scripts === 'object'
+            ? Object.keys(pkg.scripts).filter(n => LINT_SCRIPT_RE.test(n))
+            : []
+
+        let safeToRemove = new Set(lintScriptNames)
+        if (lintScriptNames.length > 0) {
+          const ownUnresolved = adaptOwnScripts(pkg, lintScriptNames)
+          const candidateFiles = await findUsageCandidateFiles(ctx.cwd, abs)
+          const adapted = adaptUsages(lintScriptNames, candidateFiles, ctx.recordWrite)
+          safeToRemove = new Set([...adapted.safeToRemove].filter(n => !ownUnresolved.has(n)))
+          touchedFiles.push(...adapted.touchedFiles)
+          const skipped = lintScriptNames.filter(n => !safeToRemove.has(n))
+          if (skipped.length > 0) {
+            messages.push(
+              `${rel}: не видаляю scripts.${skipped.join(', scripts.')} — знайдено нерозпізнаний виклик деінде`
+            )
+          }
+        }
+
+        const removed = stripDenied(pkg, denyFields, safeToRemove)
+        if (removed.length === 0) continue
+
+        ctx.recordWrite?.(abs)
+        writeFileSync(abs, `${JSON.stringify(pkg, null, 2)}\n`)
+        touchedFiles.push(abs)
+        messages.push(`${rel}: -${removed.join(', -')}`)
+      }
+
+      return touchedFiles.length > 0 ? { touchedFiles, message: messages.join('; ') } : { touchedFiles: [] }
+    }
+  }
+]

package/rules/bun/package_json/package_json.mdc

@@ -0,0 +1,14 @@
+## Rego-gate: заборонені поля та devDependencies у кореневому package.json
+
+Rego-пакет: `bun.package_json`
+
+Цільовий файл: кореневий `package.json`.
+
+Список заборонених top-level полів (template-driven): [package.json.deny.json](./template/package.json.deny.json)
+
+Gate виносить два класи deny:
+
+1. **Заборонені top-level поля** — будь-яке поле з `package.json.deny.json` присутнє у файлі (навіть із порожнім значенням `{}`).
+2. **devDependencies не з білого списку** — дозволені лише `@nitra/*`/`@7n/*` та root-only тестові peer/tools (`vitest`, `@vitest/coverage-v8`, `@stryker-mutator/vitest-runner`, `@playwright/test`). Будь-який інший пакет → deny. CLI-тули, які `n-rules lint` спавнить через `bunx` (oxlint, jscpd, v8r, github-actionlint тощо), у root не пінуються — вони приїжджають як `dependencies` пакета `@7n/rules` (npm-module.mdc).
+
+Перевірки, що потребують FS або cross-file контексту (наприклад наявність `yarn.lock`), лишаються у JS-шарі.

package/rules/bun/package_json/package_json.rego

@@ -0,0 +1,64 @@
+# Перевірка кореневого `package.json` для bun (bun.mdc).
+#
+# Канон надходить через --data: { "template": { "deny": ... } }
+# Структура --data сформована з template/package.json.deny.json
+# (top-level fields заборонені у root).
+#
+# Логіка, що ЛИШАЄТЬСЯ у rego (inverse-patterns, не виносяться у template):
+#  - `devDependencies` лише `@nitra/*` + root-only тестові peer/tools для `@7n/test coverage`
+#    (правило `test` enabled завжди — див. `test/auto.md`; published workspace-и не мають
+#     `devDependencies` за `npm-module.mdc`)
+#
+# Перевірки, які потребують FS / cross-file контексту, лишаються у JS.
+package bun.package_json
+
+import rego.v1
+
+# ── deny: заборонені top-level поля (template-driven) ─────────────────────
+
+# Сентинельний value відрізняє «поле відсутнє» від «поле є з будь-яким значенням»
+# (наприклад `dependencies: {}` — присутнє але порожнє → теж заборонено).
+deny contains msg if {
+	some field, reason in data.template.deny
+	object.get(input, field, "__bun_missing__") != "__bun_missing__"
+	msg := sprintf("package.json: поле %s — %s", [field, reason])
+}
+
+# ── deny: scripts.lint / scripts.lint-* заборонені (bun.mdc lint) ────────
+
+deny contains msg if {
+	is_object(input.scripts)
+	some script_name, _ in input.scripts
+	regex.match(`^lint(-.*)?$`, script_name)
+	msg := sprintf(
+		"package.json: scripts.%s заборонений — лінт запускається через n-rules lint, не через package.json-скрипти (bun.mdc)",
+		[script_name],
+	)
+}
+
+# ── deny: devDependencies — лише `@nitra/*`/`@7n/*` + root-only тестові peer/tools ─
+
+deny contains msg if {
+	is_object(input.devDependencies)
+	some name, _ in input.devDependencies
+	not allowed_root_dev_dependency(name)
+	msg := sprintf("Кореневі devDependencies: дозволені лише @nitra/*/@7n/* або root-only test peers — прибери або перенеси: %s (bun.mdc)", [name])
+}
+
+# ── helpers ────────────────────────────────────────────────────────────────
+
+# @stryker-mutator/core — обов'язковий exact-pin peer vitest-runner@9+ (раніше тягнувся транзитивно)
+# @7n/test — оркестратор `coverage` (npx @7n/test coverage); devDependency, щоб npx резолвив
+# локально без мережевого fetch щоразу.
+allowed_root_test_deps := {"vitest", "@vitest/coverage-v8", "@stryker-mutator/vitest-runner", "@stryker-mutator/core", "@playwright/test", "@7n/test"}
+
+allowed_root_dev_dependency(name) if {
+	startswith(name, "@nitra/")
+} else if {
+	startswith(name, "@7n/")
+} else if {
+	# Vitest/Stryker peer/tools + @7n/test (`coverage`) для `@7n/test coverage` живуть у корені
+	# будь-якого монорепо-споживача: правило `test` enabled завжди, а published workspace-и
+	# не мають `devDependencies` (`npm-module.mdc`).
+	name in allowed_root_test_deps
+}

package/rules/bun/package_json/template/package.json.deny.json

@@ -0,0 +1,4 @@
+{
+  "packageManager": "видали поле — Bun не потребує packageManager (bun.mdc)",
+  "dependencies": "кореневий package.json не повинен містити dependencies — додай у workspace-пакети (bun.mdc)"
+}

package/rules/js/check/check.mdc

@@ -0,0 +1,26 @@
+## `for...in` заборонено — рефакторити на `for...of`
+
+Конструкція `for (const k in obj)` обходить успадковані ключі прототипу, тому майже завжди тягне `Object.hasOwn(obj, k)`-guard. Заборонена у `@nitra/eslint-config` через `no-restricted-syntax` для `ForInStatement` (з версії **3.8.0**). У каноні oxlint (`guard-for-in: "deny"` у [oxlint-canonical.json](../tooling/data/tooling/oxlint-canonical.json)) лишається `guard-for-in` як часткова страховка (oxlint не підтримує `no-restricted-syntax`) — `checkOxlintRc` у `check/main.mjs` звіряє `.oxlintrc.json` проєкту з цим каноном.
+
+Замість цього обходь масив напряму, а об'єкт — через `Object.entries` / `Object.keys` / `Object.values`. У такому коді guard за `Object.hasOwn` стає непотрібним і має зникнути разом із `for...in`.
+
+```javascript title="❌ до"
+for (const k in obj) {
+  if (!Object.hasOwn(obj, k)) continue
+  use(k, obj[k])
+}
+
+for (const i in arr) {
+  use(arr[i])
+}
+```
+
+```javascript title="✅ після"
+for (const [k, v] of Object.entries(obj)) {
+  use(k, v)
+}
+
+for (const item of arr) {
+  use(item)
+}
+```

package/rules/js/check/concern.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json",
+  "lint": {
+    "scope": "full",
+    "glob": [
+      "eslint.config.js",
+      "eslint.config.mjs",
+      "**/package.json",
+      ".oxlintrc.json",
+      ".github/workflows/lint-js.yml",
+      ".github/workflows/lint.yml",
+      "knip.json",
+      ".eslintrc",
+      ".eslintrc.js",
+      ".eslintrc.json",
+      ".eslintrc.yml"
+    ]
+  }
+}

package/rules/js/check/docs/eslint-config.md

@@ -0,0 +1,56 @@
+---
+type: JS Module
+title: eslint-config.mjs
+resource: plugins/lang-js/rules/js/check/eslint-config.mjs
+docgen:
+  crc: 6626a862
+  model: manual
+---
+
+## Огляд
+
+Детекція воркспейс-типів (node/vue) репозиторію і чистий (read-only) планувальник
+scaffold/merge для `eslint.config.js` consumer-репо. Спільне джерело правди для
+detector-а `main.mjs` (перевірка, що кожен vue-воркспейс присутній у `vue: [...]`
+аргументах `getConfig`) і T0-фіксера `fix-check.mjs` (детерміноване створення або
+хірургічне оновлення конфігу — без повного перезапису файлу).
+
+## Поведінка
+
+- Тип воркспейсу визначається за root `package.json`: записи `workspaces`
+  (glob-и типу `packages/*` розгортаються у наявні директорії); воркспейс — vue,
+  якщо його `package.json` має `vue`/`nuxt` у deps або в ньому є хоч один `.vue`
+  файл (`node_modules`/`dist` ігноруються). Без `workspaces` класифікується сам
+  корінь як `.`.
+- Merge наявного конфігу — хірургічний: додає відсутній `**/auto-imports.d.ts`
+  у перший `ignores: [...]`, вставляє відсутні vue-воркспейси у `vue: [...]`
+  (або нову властивість одразу після `getConfig({`), вилучає ці ж воркспейси з
+  `node: [...]`. Кастомні ignores, overrides і коментарі не змінюються.
+- Fail-safe: якщо структура конфігу не розпізнається (немає `getConfig({`),
+  файл не чіпається — порушення лишається для ручного розгляду.
+
+## Публічний API
+
+- `detectWorkspaceTypes(cwd)` → `{ node: string[], vue: string[] }` — директорії
+  за типами.
+- `parseVueList(raw)` → нормалізовані записи `vue: [...]` з тексту конфігу.
+- `renderEslintConfigScaffold(types)` → повний шаблон `eslint.config.js`
+  (лише непорожні типи).
+- `mergeEslintConfig(raw, types)` → новий вміст (`=== raw`, якщо merge
+  неможливий чи не потрібен).
+- `planEslintConfigFix(cwd)` → `{ path, content, message } | null` — ідемпотентний
+  план для T0 (`null` на виправленому дереві).
+- Константи reason-ів: `ESLINT_CONFIG_MISSING`, `ESLINT_CONFIG_IGNORES`,
+  `ESLINT_CONFIG_VUE_WORKSPACE`; `AUTO_IMPORTS_IGNORE`.
+
+## Де використовується
+
+- `npm/rules/js/check/main.mjs` — detector (reason-и порушень, перевірка
+  vue-воркспейсів).
+- `npm/rules/js/check/fix-check.mjs` — T0-фіксер (виконання плану).
+
+## Гарантії поведінки
+
+- Read-only: модуль лише читає ФС і повертає план; запис виконує викликач.
+- Ідемпотентність: повторний `planEslintConfigFix` на виправленому дереві → `null`.
+- Биті/відсутні JSON-файли не кидають виняток (повертається `null`-об'єкт).

package/rules/js/check/docs/fix-check.md

@@ -0,0 +1,48 @@
+---
+type: JS Module
+title: fix-check.mjs
+resource: plugins/lang-js/rules/js/check/fix-check.mjs
+docgen:
+  crc: d4e460e8
+  model: manual
+---
+
+## Огляд
+
+T0-autofix для `js/check`: два детерміновані патерни, обидва без LLM.
+
+- `js-check-eslint-config` — scaffold/merge `eslint.config.js` за планом
+  `planEslintConfigFix` (детекція воркспейс-типів node/vue). Раніше ці
+  порушення йшли у LLM-ладдер, який переписував конфіг цілком і вгадував типи
+  (інцидент: у vue-монорепо записано `getConfig({ node: ['npm'] })` — eslint
+  перестав обробляти .vue файли).
+- `js-check-oxlintrc` — scaffold/merge `.oxlintrc.json` за планом
+  `planOxlintrcFix` (`../tooling/main.mjs`). Раніше ці порушення теж йшли у
+  LLM-ладдер: 15 КБ канону дешева модель не відтворює byte-perfect (verify
+  fail), а дорожча не встигає за один rung-таймаут.
+
+## Поведінка
+
+- `js-check-eslint-config` тригериться на reason-и `eslint-config-missing` /
+  `eslint-config-ignores` / `eslint-config-vue-workspace`. `apply` перераховує
+  план із поточного стану диска (ідемпотентно): відсутній конфіг —
+  створюється з детектованими типами; наявний — зазнає хірургічного merge, без
+  повного перезапису. Якщо план порожній (`null`) — жодних змін
+  (`touchedFiles: []`).
+- `js-check-oxlintrc` тригериться на reason-и `oxlintrc-missing` /
+  `oxlintrc-drift` (`OXLINTRC_MISSING` / `OXLINTRC_DRIFT` з `../tooling/main.mjs`).
+  `apply` читає наявний `.oxlintrc.json` (`null`, якщо відсутній або невалідний
+  JSON) і канон, будує злитий обʼєкт через `planOxlintrcFix` і перезаписує
+  файл цілком (JSON, 2-space, з кінцевим переносом рядка).
+- Решта порушень `js/check` (engines, workflows) — поза цим T0, стандартний
+  шлях (ladder/manual).
+- Обидва патерни викликають `ctx.recordWrite` перед записом (pre-image для
+  central rollback).
+
+## Гарантії поведінки
+
+- `js-check-eslint-config` записує лише `eslint.config.js`/`eslint.config.mjs`
+  у корені репо; наявний конфіг ніколи не перезаписується цілком — тільки
+  точкові вставки/заміни.
+- `js-check-oxlintrc` записує лише `.oxlintrc.json` у корені репо; результат
+  завжди проходить `verifyOxlintRcAgainstCanonical` без ручного втручання.

package/rules/js/check/docs/index.md

@@ -0,0 +1,13 @@
+---
+type: Directory Index
+title: npm/rules/js/check
+resource: plugins/lang-js/rules/js/check/
+---
+
+# npm/rules/js/check
+
+| Файл                                  | Тип       |
+| ------------------------------------- | --------- |
+| [eslint-config.mjs](eslint-config.md) | JS Module |
+| [fix-check.mjs](fix-check.md)         | JS Module |
+| [main.mjs](main.md)                   | JS Module |

package/rules/js/check/docs/main.md

@@ -0,0 +1,48 @@
+---
+type: JS Module
+title: main.mjs
+resource: plugins/lang-js/rules/js/check/main.mjs
+docgen:
+  crc: 1da6a724
+  model: manual
+---
+
+## Огляд
+
+Detector concern-а `js/check`: read-only перевірка відповідності проєкту правилам
+`js.mdc`. Накопичує порушення через violation-reporter і повертає їх runner-у;
+нічого не друкує і (за одним винятком — baseline `knip.json`) нічого не пише.
+
+## Поведінка
+
+- `eslint.config.js`/`eslint.config.mjs`: файл існує (інакше reason
+  `eslint-config-missing`), містить `getConfig` та імпорт `@nitra/eslint-config`,
+  в ignores є `**/auto-imports.d.ts` (reason `eslint-config-ignores`).
+- Воркспейс-типи: кожен vue-воркспейс (детекція з `eslint-config.mjs` — root
+  `workspaces` + vue/nuxt-залежність або `.vue` файли) має бути у `vue: [...]`
+  аргументах `getConfig`, інакше reason `eslint-config-vue-workspace` — без
+  цього eslint не парсить `.vue` файли воркспейсу. Ці три reason-и детерміновано
+  виправляє T0 `fix-check.mjs`.
+- Кожен workspace `package.json`: `"type": "module"`, `engines.node >= 24`,
+  `engines.bun >= 1.3` (кореневий `package.json` валідує Rego
+  `npm/policy/js_lint/package_json/`).
+- `.oxlintrc.json`: існує, валідний JSON, збігається з каноном oxlint із пакета
+  `@7n/rules` (`verifyOxlintRcAgainstCanonical` з `../tooling/main.mjs`).
+  Відсутність — reason `oxlintrc-missing`, розходження з каноном — reason
+  `oxlintrc-drift` (константи `OXLINTRC_MISSING`/`OXLINTRC_DRIFT`); обидва
+  детерміновано виправляє T0 `fix-check.mjs` (патерн `js-check-oxlintrc`).
+- `.github/workflows/lint-js.yml`: існує; `lint.yml` (якщо є) не дублює
+  oxlint/eslint/jscpd кроки.
+- `knip.json`: якщо відсутній — копіюється канонічний baseline із пакета
+  (side effect, описаний у js.mdc); подальший вміст локально не валідується.
+- Застарілі конфіги ESLint (`.eslintrc`, `.eslintrc.js`, `.eslintrc.json`,
+  `.eslintrc.yml`) — порушення: лише flat config.
+
+## Публічний API
+
+- `lint(ctx)` → `LintResult` — перелік порушень concern-а.
+
+## Гарантії поведінки
+
+- Read-only, крім єдиного side effect — створення `knip.json` з канону.
+- Порушення повертаються reporter-ом, не друкуються.