@7n/rules 1.27.0 → 1.28.1

package/rules/bun/package_json/package_json.rego

@@ -1,64 +0,0 @@
-# Перевірка кореневого `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

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

package/rules/js/check/check.mdc

@@ -1,26 +0,0 @@
-## `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

@@ -1,19 +0,0 @@
-{
-  "$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

@@ -1,56 +0,0 @@
----
-type: JS Module
-title: eslint-config.mjs
-resource: npm/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

@@ -1,48 +0,0 @@
----
-type: JS Module
-title: fix-check.mjs
-resource: npm/rules/js/check/fix-check.mjs
-docgen:
-  crc: 48182147
-  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

@@ -1,13 +0,0 @@
----
-type: Directory Index
-title: npm/rules/js/check
-resource: npm/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

@@ -1,48 +0,0 @@
----
-type: JS Module
-title: main.mjs
-resource: npm/rules/js/check/main.mjs
-docgen:
-  crc: 128c6700
-  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-ом, не друкуються.

package/rules/js/check/eslint-config.mjs

@@ -1,262 +0,0 @@
-/** @see ./docs/eslint-config.md */
-
-/**
- * Детекція воркспейс-типів (node vs vue) і чистий планувальник scaffold/merge
- * для `eslint.config.js` consumer-репо. Використовується двома споживачами:
- *   - detector `main.mjs` (read-only): перевірка, що кожен vue-воркспейс
- *     присутній у `vue: [...]` аргументах getConfig — інакше .vue файли не
- *     парсяться eslint-ом;
- *   - T0 `fix-check.mjs`: детермінований scaffold відсутнього конфігу або
- *     хірургічний merge наявного (додати vue-воркспейси, прибрати їх із
- *     node-списку, доставити ignores) — БЕЗ повного перезапису файлу.
- *
- * Merge fail-safe: якщо структура конфігу не розпізнається regex-ами
- * (немає `getConfig({`), планувальник повертає null і файл не чіпається.
- */
-import { existsSync } from 'node:fs'
-import { readFile } from 'node:fs/promises'
-import { join } from 'node:path'
-
-import { globby } from 'globby'
-
-/** Відсутній eslint.config.{js,mjs} — T0 скаффолдить із детектованих типів. */
-export const ESLINT_CONFIG_MISSING = 'eslint-config-missing'
-/** У ignores немає `**\/auto-imports.d.ts` — T0 дописує в наявний масив. */
-export const ESLINT_CONFIG_IGNORES = 'eslint-config-ignores'
-/** Vue-воркспейс відсутній у `vue: [...]` getConfig — .vue файли не парсяться. */
-export const ESLINT_CONFIG_VUE_WORKSPACE = 'eslint-config-vue-workspace'
-
-export const AUTO_IMPORTS_IGNORE = '**/auto-imports.d.ts'
-
-const VUE_LIST_RE = /\bvue\s*:\s*\[([^\]]*)\]/u
-const NODE_LIST_RE = /\bnode\s*:\s*\[([^\]]*)\]/u
-const GET_CONFIG_OBJ_RE = /getConfig\(\s*\{/u
-const IGNORES_OPEN_RE = /\bignores\s*:\s*\[/u
-const STRING_ENTRY_RE = /'([^']*)'|"([^"]*)"/gu
-
-/**
- * @param {string} p шлях воркспейсу з package.json або запис зі списку getConfig
- * @returns {string} канонічна форма без `./` на початку і `/` в кінці
- */
-function normalizeWs(p) {
-  let s = p.startsWith('./') ? p.slice(2) : p
-  while (s.endsWith('/')) s = s.slice(0, -1)
-  return s || '.'
-}
-
-/**
- * @param {string} abs абсолютний шлях до JSON-файлу
- * @returns {Promise<object|null>} розпарсений об'єкт або null (немає/битий)
- */
-async function readJsonOrNull(abs) {
-  try {
-    return JSON.parse(await readFile(abs, 'utf8'))
-  } catch {
-    return null
-  }
-}
-
-/**
- * Розгортає записи `workspaces` root package.json у список наявних директорій
- * (glob-записи типу `packages/*` — через globby onlyDirectories).
- * @param {string} cwd корінь репозиторію
- * @param {unknown[]} patterns поле workspaces
- * @returns {Promise<string[]>} posix-relative директорії воркспейсів, що існують
- */
-async function expandWorkspaces(cwd, patterns) {
-  const dirs = []
-  for (const p of patterns) {
-    if (typeof p !== 'string' || p.length === 0) continue
-    const norm = normalizeWs(p)
-    if (norm.includes('*')) {
-      dirs.push(...(await globby(norm, { cwd, onlyDirectories: true, gitignore: false })))
-    } else if (existsSync(join(cwd, norm))) {
-      dirs.push(norm)
-    }
-  }
-  return [...new Set(dirs.map(d => normalizeWs(d)))]
-}
-
-/**
- * Чи є директорія Vue-кодом: `vue`/`nuxt` у deps її package.json (дешева
- * перевірка першою) або наявність бодай одного `.vue` файлу.
- * @param {string} cwd корінь репозиторію
- * @param {string} ws posix-relative директорія воркспейсу (або `.` для кореня)
- * @returns {Promise<boolean>} true — vue-воркспейс
- */
-async function isVueWorkspace(cwd, ws) {
-  const dir = ws === '.' ? cwd : join(cwd, ws)
-  const pkg = await readJsonOrNull(join(dir, 'package.json'))
-  const deps = { ...pkg?.dependencies, ...pkg?.devDependencies }
-  if ('vue' in deps || 'nuxt' in deps) return true
-  const vueFiles = await globby('**/*.vue', {
-    cwd: dir,
-    gitignore: false,
-    ignore: ['**/node_modules/**', '**/dist/**'],
-    deep: 8
-  })
-  return vueFiles.length > 0
-}
-
-/**
- * Класифікує репозиторій за воркспейс-типами для аргументів getConfig.
- * Монорепо (workspaces у root package.json) — кожен воркспейс окремо;
- * без workspaces — сам корінь як `.`.
- * @param {string} cwd корінь репозиторію
- * @returns {Promise<{ node: string[], vue: string[] }>} директорії за типами
- */
-export async function detectWorkspaceTypes(cwd) {
-  const pkg = await readJsonOrNull(join(cwd, 'package.json'))
-  const wsField = Array.isArray(pkg?.workspaces) ? pkg.workspaces : []
-  const dirs = await expandWorkspaces(cwd, wsField)
-
-  if (dirs.length === 0) {
-    const rootIsVue = await isVueWorkspace(cwd, '.')
-    return rootIsVue ? { node: [], vue: ['.'] } : { node: ['.'], vue: [] }
-  }
-
-  /** @type {{ node: string[], vue: string[] }} */
-  const types = { node: [], vue: [] }
-  for (const ws of dirs) {
-    if (await isVueWorkspace(cwd, ws)) {
-      types.vue.push(ws)
-    } else {
-      types.node.push(ws)
-    }
-  }
-  return types
-}
-
-/**
- * Записи string-літералів усередині вмісту списку (`vue: [...]`/`node: [...]`).
- * @param {string|undefined} inner текст між дужками списку
- * @returns {string[]} нормалізовані записи списку
- */
-function listEntries(inner) {
-  if (inner === undefined) return []
-  return inner
-    .matchAll(STRING_ENTRY_RE)
-    .map(m => normalizeWs(m[1] ?? m[2]))
-    .toArray()
-}
-
-/**
- * Vue-записи з тексту конфігу — для перевірки detector-ом.
- * @param {string} raw вміст eslint.config
- * @returns {string[]} нормалізовані записи `vue: [...]`
- */
-export function parseVueList(raw) {
-  return listEntries(raw.match(VUE_LIST_RE)?.[1])
-}
-
-/**
- * @param {string} ws запис для вставки у список
- * @returns {string} одинарно-квотований літерал
- */
-function quote(ws) {
-  return `'${ws}'`
-}
-
-/**
- * Повний шаблон eslint.config.js для scaffold (файл відсутній). Включає лише
- * непорожні типи; порядок ключів — node, vue (стиль власного конфігу репо).
- * @param {{ node: string[], vue: string[] }} types детектовані воркспейс-типи
- * @returns {string} вміст файлу
- */
-export function renderEslintConfigScaffold(types) {
-  const args = []
-  if (types.node.length > 0) args.push(`    node: [${types.node.map(w => quote(w)).join(', ')}]`)
-  if (types.vue.length > 0) args.push(`    vue: [${types.vue.map(w => quote(w)).join(', ')}]`)
-  return [
-    "import { getConfig } from '@nitra/eslint-config'",
-    '',
-    'export default [',
-    '  {',
-    `    ignores: ['${AUTO_IMPORTS_IGNORE}']`,
-    '  },',
-    '  ...getConfig({',
-    args.join(',\n'),
-    '  })',
-    ']',
-    ''
-  ].join('\n')
-}
-
-/**
- * Хірургічний merge наявного конфігу під детектовані типи:
- *   1) відсутній `**\/auto-imports.d.ts` → вставка в перший `ignores: [`;
- *   2) vue-воркспейси поза `vue: [...]` → вставка у список (або нова властивість
- *      одразу після `getConfig({`);
- *   3) ті самі воркспейси у `node: [...]` → вилучення звідти.
- * Решта файлу (кастомні ignores, overrides, коментарі) — недоторкана.
- * @param {string} raw вміст eslint.config
- * @param {{ node: string[], vue: string[] }} types детектовані воркспейс-типи
- * @returns {string} новий вміст (=== raw, якщо merge неможливий/не потрібен)
- */
-export function mergeEslintConfig(raw, types) {
-  let out = raw
-
-  if (!out.includes(AUTO_IMPORTS_IGNORE) && IGNORES_OPEN_RE.test(out)) {
-    out = out.replace(IGNORES_OPEN_RE, m => `${m}'${AUTO_IMPORTS_IGNORE}', `)
-  }
-
-  const missingVue = types.vue.filter(ws => !parseVueList(out).includes(ws))
-  if (missingVue.length > 0) {
-    const inserted = missingVue.map(w => quote(w)).join(', ')
-    const vueMatch = out.match(VUE_LIST_RE)
-    if (vueMatch) {
-      const rest = vueMatch[1].trim().length > 0 ? `, ${vueMatch[1]}` : vueMatch[1]
-      out = out.replace(VUE_LIST_RE, () => `vue: [${inserted}${rest}]`)
-    } else if (GET_CONFIG_OBJ_RE.test(out)) {
-      out = out.replace(GET_CONFIG_OBJ_RE, m => `${m}\n    vue: [${inserted}],`)
-    }
-    // без getConfig({ — merge неможливий, лишаємо як є (fail-safe)
-  }
-
-  const nodeMatch = out.match(NODE_LIST_RE)
-  if (nodeMatch) {
-    const entries = listEntries(nodeMatch[1])
-    const kept = entries.filter(e => !types.vue.includes(e))
-    if (kept.length !== entries.length) {
-      out = out.replace(NODE_LIST_RE, () => `node: [${kept.map(w => quote(w)).join(', ')}]`)
-    }
-  }
-
-  return out
-}
-
-/**
- * План детермінованого фіксу eslint.config для T0: scaffold відсутнього файлу
- * або merge наявного. Ідемпотентний — повторний виклик на виправленому дереві
- * повертає null.
- * @param {string} cwd корінь репозиторію
- * @returns {Promise<{ path: string, content: string, message: string }|null>} запис для виконання або null
- */
-export async function planEslintConfigFix(cwd) {
-  const types = await detectWorkspaceTypes(cwd)
-
-  const existing = ['eslint.config.js', 'eslint.config.mjs'].find(f => existsSync(join(cwd, f)))
-  if (!existing) {
-    const summary = [
-      types.node.length > 0 ? `node: [${types.node.join(', ')}]` : '',
-      types.vue.length > 0 ? `vue: [${types.vue.join(', ')}]` : ''
-    ]
-      .filter(Boolean)
-      .join(', ')
-    return {
-      path: join(cwd, 'eslint.config.js'),
-      content: renderEslintConfigScaffold(types),
-      message: `створено eslint.config.js (${summary})`
-    }
-  }
-
-  const abs = join(cwd, existing)
-  const raw = await readFile(abs, 'utf8')
-  const merged = mergeEslintConfig(raw, types)
-  if (merged === raw) return null
-  return {
-    path: abs,
-    content: merged,
-    message: `${existing}: merge під воркспейс-типи (vue: [${types.vue.join(', ')}])`
-  }
-}

package/rules/js/check/fix-check.mjs

@@ -1,82 +0,0 @@
-/** @see ./docs/fix-check.md */
-
-/**
- * T0-autofix для `js/check` — детермінований scaffold/merge `eslint.config.js`
- * і `.oxlintrc.json`. Раніше обидва йшли у LLM-ладдер, який переписував конфіги
- * цілком: для eslint.config.js це вгадувало воркспейс-типи (інцидент: у
- * vue-монорепо записано `getConfig({ node: ['npm'] })` — eslint перестав
- * обробляти .vue файли), а для .oxlintrc.json — 15 КБ канону, який дешевій
- * моделі не відтворити byte-perfect (verify fail), а дорожчій — не встигнути
- * за один rung-таймаут.
- *
- * Джерело правди для eslint.config.js — `planEslintConfigFix` (детекція типів
- * із workspaces root package.json + vue-залежність/.vue-файли), наявний конфіг
- * оновлюється точковим merge хірургічно, без повного перезапису.
- *
- * Джерело правди для .oxlintrc.json — `planOxlintrcFix`, що дзеркалить
- * `verifyOxlintRcAgainstCanonical`: відсутній файл копіює канон, наявний —
- * доповнюється до канону без втрати project-specific розширень (зайві
- * `rules`-ключі й `ignorePatterns` зберігаються).
- *
- * Решта порушень js/check (engines, workflows) — поза цим T0, стандартний шлях
- * (ladder/manual).
- */
-import { existsSync } from 'node:fs'
-import { readFile, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
-
-import {
-  ESLINT_CONFIG_IGNORES,
-  ESLINT_CONFIG_MISSING,
-  ESLINT_CONFIG_VUE_WORKSPACE,
-  planEslintConfigFix
-} from './eslint-config.mjs'
-import { OXLINT_CANONICAL_JSON_PATH, OXLINTRC_DRIFT, OXLINTRC_MISSING, planOxlintrcFix } from '../tooling/main.mjs'
-
-const ESLINT_CONFIG_REASONS = new Set([ESLINT_CONFIG_MISSING, ESLINT_CONFIG_IGNORES, ESLINT_CONFIG_VUE_WORKSPACE])
-const OXLINTRC_REASONS = new Set([OXLINTRC_MISSING, OXLINTRC_DRIFT])
-
-/**
- * Читає `.oxlintrc.json`, якщо є й валідний JSON; інакше `null` (трактується
- * як відсутній файл — `planOxlintrcFix` будує з канону).
- * @param {string} oxPath абсолютний шлях до `.oxlintrc.json`
- * @returns {Promise<unknown>} розпарсений вміст або `null`
- */
-async function readOxlintrcOrNull(oxPath) {
-  if (!existsSync(oxPath)) return null
-  try {
-    return JSON.parse(await readFile(oxPath, 'utf8'))
-  } catch {
-    return null
-  }
-}
-
-/** @type {import('../../../scripts/lib/lint-surface/types.mjs').T0Pattern[]} */
-export const patterns = [
-  {
-    id: 'js-check-eslint-config',
-    test: violations => violations.some(v => ESLINT_CONFIG_REASONS.has(v.reason)),
-    apply: async (violations, ctx) => {
-      const plan = await planEslintConfigFix(ctx.cwd)
-      if (plan === null) return { touchedFiles: [] }
-      ctx.recordWrite?.(plan.path)
-      await writeFile(plan.path, plan.content, 'utf8')
-      return { touchedFiles: [plan.path], message: plan.message }
-    }
-  },
-  {
-    id: 'js-check-oxlintrc',
-    test: violations => violations.some(v => OXLINTRC_REASONS.has(v.reason)),
-    apply: async (violations, ctx) => {
-      const oxPath = join(ctx.cwd, '.oxlintrc.json')
-      const [actual, canonicalRaw] = await Promise.all([
-        readOxlintrcOrNull(oxPath),
-        readFile(OXLINT_CANONICAL_JSON_PATH, 'utf8')
-      ])
-      const merged = planOxlintrcFix(actual, JSON.parse(canonicalRaw))
-      ctx.recordWrite?.(oxPath)
-      await writeFile(oxPath, `${JSON.stringify(merged, null, 2)}\n`, 'utf8')
-      return { touchedFiles: [oxPath], message: '.oxlintrc.json: T0 merge до канону oxlint (@7n/rules)' }
-    }
-  }
-]