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

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

@@ -0,0 +1,262 @@
+/** @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

@@ -0,0 +1,82 @@
+/** @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('@7n/rules/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)' }
+    }
+  }
+]

package/rules/js/check/main.mjs

@@ -0,0 +1,310 @@
+/** @see ./docs/tooling.md */
+import { existsSync } from 'node:fs'
+import { copyFile, readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+import { createViolationReporter } from '@7n/rules/scripts/lib/lint-surface/violation-reporter.mjs'
+
+import {
+  KNIP_CANONICAL_JSON_PATH,
+  OXLINT_CANONICAL_JSON_PATH,
+  OXLINTRC_DRIFT,
+  OXLINTRC_MISSING,
+  verifyOxlintRcAgainstCanonical
+} from '../tooling/main.mjs'
+
+import {
+  AUTO_IMPORTS_IGNORE,
+  ESLINT_CONFIG_IGNORES,
+  ESLINT_CONFIG_MISSING,
+  ESLINT_CONFIG_VUE_WORKSPACE,
+  detectWorkspaceTypes,
+  parseVueList
+} from './eslint-config.mjs'
+
+const NON_DIGITS_RE = /\D+/u
+
+/**
+ * Перевіряє ESLint flat config файл.
+ * @param {(msg: string) => void} passFn callback при успішній перевірці
+ * @param {(msg: string) => void} failFn callback при помилці
+ * @param {string} cwd корінь репозиторію
+ */
+async function checkEslintConfig(passFn, failFn, cwd) {
+  let eslintPath
+  if (existsSync(join(cwd, 'eslint.config.js'))) {
+    eslintPath = 'eslint.config.js'
+    passFn('eslint.config.js існує')
+  } else if (existsSync(join(cwd, 'eslint.config.mjs'))) {
+    eslintPath = 'eslint.config.mjs'
+    passFn('eslint.config.mjs існує')
+  } else {
+    failFn('Відсутній eslint.config.js або eslint.config.mjs — flat config з getConfig (js.mdc)', ESLINT_CONFIG_MISSING)
+    return
+  }
+  const eslintRaw = await readFile(join(cwd, eslintPath), 'utf8')
+  const checks = [
+    {
+      needle: 'getConfig',
+      ok: `${eslintPath}: містить getConfig`,
+      err: `${eslintPath}: потрібен виклик getConfig (js.mdc)`
+    },
+    {
+      needle: '@nitra/eslint-config',
+      ok: `${eslintPath}: імпорт @nitra/eslint-config`,
+      err: `${eslintPath}: імпортуй getConfig з @nitra/eslint-config`
+    },
+    {
+      needle: AUTO_IMPORTS_IGNORE,
+      ok: `${eslintPath}: ignores містить ${AUTO_IMPORTS_IGNORE}`,
+      err: `${eslintPath}: додай у ignores запис ${AUTO_IMPORTS_IGNORE} (js.mdc)`,
+      reason: ESLINT_CONFIG_IGNORES
+    }
+  ]
+  for (const { needle, ok, err, reason } of checks) {
+    if (eslintRaw.includes(needle)) {
+      passFn(ok)
+    } else {
+      failFn(err, reason)
+    }
+  }
+  await checkEslintWorkspaceTypes(eslintRaw, eslintPath, passFn, failFn, cwd)
+}
+
+/**
+ * Кожен vue-воркспейс (детекція: `workspaces` root package.json + vue-залежність
+ * або `.vue` файли) має бути у `vue: [...]` аргументах getConfig — інакше eslint
+ * не підключає vue-parser і всі `.vue` файли воркспейсу не парсяться. Ловить
+ * хибний scaffold типу `getConfig({ node: ['npm'] })` у vue-монорепо.
+ * @param {string} eslintRaw вміст eslint.config
+ * @param {string} eslintPath ім'я файлу конфігу для повідомлень
+ * @param {(msg: string) => void} passFn callback при успішній перевірці
+ * @param {(msg: string, reason?: string) => void} failFn callback при помилці
+ * @param {string} cwd корінь репозиторію
+ */
+async function checkEslintWorkspaceTypes(eslintRaw, eslintPath, passFn, failFn, cwd) {
+  const types = await detectWorkspaceTypes(cwd)
+  if (types.vue.length === 0) return
+  const vueEntries = parseVueList(eslintRaw)
+  for (const ws of types.vue) {
+    if (vueEntries.includes(ws)) {
+      passFn(`${eslintPath}: vue-воркспейс '${ws}' у vue: [...]`)
+    } else {
+      failFn(
+        `${eslintPath}: воркспейс '${ws}' містить Vue-код, але відсутній у vue: [...] getConfig — ` +
+          '.vue файли не парсяться (js.mdc)',
+        ESLINT_CONFIG_VUE_WORKSPACE
+      )
+    }
+  }
+}
+
+// Перевірки `prettier` / `@nitra/prettier-config` у залежностях (text.mdc) і
+// `@nitra/eslint-config ≥ 3.10.0` тепер у Rego: відповідно
+// `npm/policy/text/package_json/` і `npm/policy/js_lint/package_json/`. Тут
+// лишилася лише workspace-ітерація для `type: "module"` і engines, бо js_lint
+// Rego запускається лише на кореневому `package.json`.
+
+/**
+ * Перевіряє, що package.json має `"type": "module"`.
+ * @param {string} label шлях або назва пакета для повідомлень
+ * @param {{ type?: string }} pkg parsed package.json
+ * @param {(msg: string) => void} passFn callback при успішній перевірці
+ * @param {(msg: string) => void} failFn callback при помилці
+ */
+function checkPackageJsonTypeModule(label, pkg, passFn, failFn) {
+  if (pkg.type === 'module') {
+    passFn(`${label}: "type": "module"`)
+  } else {
+    failFn(`${label}: має містити "type": "module" (js.mdc)`)
+  }
+}
+
+/**
+ * `"type": "module"`, `engines.node >= 24` і `engines.bun >= 1.3` у кожному workspace `package.json`.
+ * @param {unknown[]} workspaces поле workspaces з package.json
+ * @param {(msg: string) => void} passFn callback при успішній перевірці
+ * @param {(msg: string) => void} failFn callback при помилці
+ * @param {string} cwd корінь репозиторію
+ */
+async function checkWorkspacePackages(workspaces, passFn, failFn, cwd) {
+  for (const ws of workspaces) {
+    const wsPkgRel = `${ws}/package.json`
+    const wsPkgAbs = join(cwd, wsPkgRel)
+    if (existsSync(wsPkgAbs)) {
+      const wsPkg = JSON.parse(await readFile(wsPkgAbs, 'utf8'))
+      checkPackageJsonTypeModule(wsPkgRel, wsPkg, passFn, failFn)
+      checkEnginesNode(wsPkgRel, wsPkg, passFn, failFn)
+      checkEnginesBun(wsPkgRel, wsPkg, passFn, failFn)
+    }
+  }
+}
+
+/**
+ * engines.node >= 24.
+ * @param {string} label шлях або назва пакета для повідомлень
+ * @param {{ engines?: { node?: string } }} pkg розпарсений package.json
+ * @param {(msg: string) => void} passFn callback при успішній перевірці
+ * @param {(msg: string) => void} failFn callback при помилці
+ */
+function checkEnginesNode(label, pkg, passFn, failFn) {
+  const nodeEngine = pkg.engines?.node
+  if (nodeEngine) {
+    const firstNumeric = String(nodeEngine).split(NON_DIGITS_RE).find(Boolean)
+    if (firstNumeric && Number(firstNumeric) >= 24) {
+      passFn(`${label}: engines.node "${nodeEngine}"`)
+    } else {
+      failFn(`${label}: engines.node "${nodeEngine}" — має бути >=24`)
+    }
+  } else {
+    failFn(`${label} не містить engines.node — додай: "engines": { "node": ">=24" }`)
+  }
+}
+
+/**
+ * engines.bun >= 1.3.
+ * @param {string} label шлях або назва пакета для повідомлень
+ * @param {{ engines?: { bun?: string } }} pkg розпарсений package.json
+ * @param {(msg: string) => void} passFn callback при успішній перевірці
+ * @param {(msg: string) => void} failFn callback при помилці
+ */
+function checkEnginesBun(label, pkg, passFn, failFn) {
+  const bunEngine = pkg.engines?.bun
+  if (bunEngine) {
+    const [major, minor] = String(bunEngine).split(NON_DIGITS_RE).filter(Boolean).map(Number)
+    if (Number.isFinite(major) && Number.isFinite(minor) && (major > 1 || (major === 1 && minor >= 3))) {
+      passFn(`${label}: engines.bun "${bunEngine}"`)
+    } else {
+      failFn(`${label}: engines.bun "${bunEngine}" — має бути >=1.3`)
+    }
+  } else {
+    failFn(`${label} не містить engines.bun — додай: "engines": { "bun": ">=1.3" }`)
+  }
+}
+
+/**
+ * Workspace-ітерація: для кожного workspace `package.json` перевіряємо
+ * `type: "module"` і `engines.{node,bun}`. Кореневий `package.json` ці поля
+ * валідує `npm/policy/js_lint/package_json/`; lint-js скрипт і `@nitra/eslint-config`
+ * — теж у Rego.
+ * @param {(msg: string) => void} passFn callback при успішній перевірці
+ * @param {(msg: string) => void} failFn callback при помилці
+ * @param {string} cwd корінь репозиторію
+ */
+async function checkPackageJsonJsLint(passFn, failFn, cwd) {
+  const pkgPath = join(cwd, 'package.json')
+  if (!existsSync(pkgPath)) return
+  const pkg = JSON.parse(await readFile(pkgPath, 'utf8'))
+  const workspaces = Array.isArray(pkg.workspaces) ? pkg.workspaces : []
+  await checkWorkspacePackages(workspaces, passFn, failFn, cwd)
+}
+
+/**
+ * Перевіряє .oxlintrc.json.
+ * @param {(msg: string) => void} passFn callback при успішній перевірці
+ * @param {(msg: string) => void} failFn callback при помилці
+ * @param {string} cwd корінь репозиторію
+ */
+async function checkOxlintRc(passFn, failFn, cwd) {
+  const oxPath = join(cwd, '.oxlintrc.json')
+  if (!existsSync(oxPath)) {
+    failFn('.oxlintrc.json не існує — додай конфіг oxlint (js.mdc)', OXLINTRC_MISSING)
+    return
+  }
+  let oxCfg
+  try {
+    oxCfg = JSON.parse(await readFile(oxPath, 'utf8'))
+  } catch {
+    failFn('.oxlintrc.json не є валідним JSON')
+    return
+  }
+  passFn('.oxlintrc.json існує')
+  let canonical
+  try {
+    canonical = JSON.parse(await readFile(OXLINT_CANONICAL_JSON_PATH, 'utf8'))
+  } catch {
+    failFn('внутрішня помилка: не вдалося прочитати канон oxlint з пакета @7n/rules')
+    return
+  }
+  const oxV = verifyOxlintRcAgainstCanonical(oxCfg, canonical)
+  if (oxV.ok) {
+    passFn('.oxlintrc.json збігається з каноном oxlint (@7n/rules)')
+  } else {
+    for (const msg of oxV.failures) {
+      failFn(msg, OXLINTRC_DRIFT)
+    }
+  }
+}
+
+/**
+ * Cross-file перевірка: `lint.yml` (якщо існує) не дублює лінт JS-кроки з `lint-js.yml`.
+ * Existence і структуру `lint-js.yml` валідує mixin-концерн `js/lint_js_yml`
+ * плагіна `@7n/rules-ci-github` (провайдер-специфіка — поза ядром).
+ * @param {(msg: string) => void} passFn callback при успішній перевірці
+ * @param {(msg: string) => void} failFn callback при помилці
+ * @param {string} cwd корінь репозиторію
+ */
+async function checkLintJsWorkflows(passFn, failFn, cwd) {
+  // Existence/структуру lint-js.yml вимагає провайдер-плагін @7n/rules-ci-github
+  // (mixin js/lint_js_yml, policy required) — ядро провайдер-агностичне і тут
+  // перевіряє лише крос-файловий дубляж, коли GitHub-workflow уже існують.
+  const lintYmlPath = join(cwd, '.github/workflows/lint.yml')
+  if (existsSync(lintYmlPath)) {
+    const lintYml = await readFile(lintYmlPath, 'utf8')
+    if (lintYml.includes('bunx oxlint') && lintYml.includes('bunx eslint') && lintYml.includes('jscpd')) {
+      failFn('.github/workflows/lint.yml дублює кроки lint-js.yml — залиш один workflow на лінт JS (js.mdc)')
+    } else {
+      passFn('.github/workflows/lint.yml не дублює oxlint/eslint/jscpd з lint-js.yml')
+    }
+  }
+}
+
+/**
+ * Перевіряє наявність `knip.json` у корені проєкту. Якщо файл відсутній —
+ * копіює канонічний `knip-canonical.json` з пакета `@7n/rules` як стартовий
+ * baseline; зміст подальших модифікацій локально не валідується (`entry` /
+ * `project` / `ignore` / `ignoreDependencies` / `ignoreBinaries` дозволені
+ * будь-які; це side effect — описано у js.mdc).
+ * @param {(msg: string) => void} passFn callback при успішній перевірці
+ * @param {(msg: string) => void} failFn callback при помилці
+ * @param {string} cwd корінь репозиторію
+ */
+async function checkKnipConfig(passFn, failFn, cwd) {
+  const knipPath = join(cwd, 'knip.json')
+  if (existsSync(knipPath)) {
+    passFn('knip.json існує')
+    return
+  }
+  if (!existsSync(KNIP_CANONICAL_JSON_PATH)) {
+    failFn(
+      `knip.json відсутній, і канонічний шаблон у пакеті не знайдено (${KNIP_CANONICAL_JSON_PATH}) — ` +
+        'перевстанови @7n/rules'
+    )
+    return
+  }
+  await copyFile(KNIP_CANONICAL_JSON_PATH, knipPath)
+  passFn('knip.json створено з канонічного npm/rules/js/tooling/data/tooling/knip-canonical.json (js.mdc)')
+}
+
+/**
+ * Перевіряє відповідність проєкту правилам js.mdc
+ * @param {import('@7n/rules/scripts/lib/lint-surface/types.mjs').LintContext} ctx контекст лінту
+ * @returns {Promise<import('@7n/rules/scripts/lib/lint-surface/types.mjs').LintResult>} перелік порушень
+ */
+export async function lint(ctx) {
+  const cwd = ctx.cwd
+  const reporter = createViolationReporter(ctx)
+  const { pass, fail } = reporter
+
+  await checkEslintConfig(pass, fail, cwd)
+  await checkPackageJsonJsLint(pass, fail, cwd)
+  await checkOxlintRc(pass, fail, cwd)
+  await checkLintJsWorkflows(pass, fail, cwd)
+  await checkKnipConfig(pass, fail, cwd)
+
+  for (const dup of ['.eslintrc', '.eslintrc.js', '.eslintrc.json', '.eslintrc.yml']) {
+    if (existsSync(join(cwd, dup))) fail(`Знайдено застарілий конфіг ESLint: ${dup} — видали, використовуй flat config`)
+  }
+
+  return reporter.result()
+}

package/rules/js/dep-policy/concern.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json",
+  "lint": { "scope": "full", "glob": ["**/*.{js,mjs,cjs,jsx,ts,mts,cts,tsx}"] }
+}