@7n/rules 1.27.0 → 1.28.1

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

@@ -1,160 +0,0 @@
-/** @see ./docs/fix-eslint.md */
-
-/**
- * T0-autofix для `js/eslint` — детермінований прогін лінтерів у fix-режимі
- * (`oxlint --fix` + `eslint --fix`) на файлах, де детектор знайшов порушення.
- * Виправляє лише авто-fixable правила; решта лишається детектору на re-check
- * (далі — LLM-ладдер). Запис permanent (поза rollback).
- *
- * Межа CI: цей модуль — частина fix-фази (`lint` без `--no-fix`); сам по собі
- * detector-шлях його не вантажить. У CI (`--no-fix`) fix не запускається —
- * узгоджено із забороною `oxlint --fix`/`eslint --fix` у CI (js.mdc / lint_js_yml).
- */
-import { spawnSync } from 'node:child_process'
-import { readFileSync, writeFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-
-import { ESLint } from 'eslint'
-
-import { filterJsFiles } from './main.mjs'
-
-/**
- * Вміст файлу або null, якщо не читається (видалений/недоступний).
- * @param {string} abs абсолютний шлях
- * @returns {string|null} вміст або null
- */
-function readOrNull(abs) {
-  try {
-    return readFileSync(abs, 'utf8')
-  } catch {
-    return null
-  }
-}
-
-/**
- * Прогін `oxlint --fix` + `eslint --fix` по списку js-файлів. Повертає абсолютні
- * шляхи фактично змінених файлів (порівняння до/після).
- * @param {string[]} jsFiles posix-relative js-файли
- * @param {string} cwd корінь проєкту
- * @returns {Promise<string[]>} абсолютні шляхи змінених файлів
- */
-async function runLinterFix(jsFiles, cwd) {
-  const abs = jsFiles.map(f => resolve(cwd, f))
-  const before = new Map(abs.map(a => [a, readOrNull(a)]))
-
-  // oxlint --fix (CLI): авто-fixable oxc-правила.
-  spawnSync('bunx', ['oxlint', '--fix', ...jsFiles], { cwd, encoding: 'utf8' })
-
-  // eslint --fix (API): outputFixes пише виправлені файли на диск.
-  const eslint = new ESLint({ cwd, fix: true })
-  const results = await eslint.lintFiles(abs)
-  await ESLint.outputFixes(results)
-
-  /** @type {string[]} */
-  const touched = []
-  for (const a of abs) {
-    if (readOrNull(a) !== before.get(a)) touched.push(a)
-  }
-  return touched
-}
-
-/**
- * Реєстр "механічних" правил `js/eslint`: `oxlint --fix`/`eslint --fix` (T0
- * `js-eslint-autofix` вище) їх НЕ покриває (suggestion-only у власній реалізації
- * інструментів — перевірено емпірично: лишаються порушеними після `--fix` на
- * реальних прогонах), але текстуальна заміна на позначеному рядку однозначна й
- * безпечна без повного AST-парсингу — проста заміна ідентифікатора/API-виклику.
- * `reasons` — обидва формати `reason` з `main.mjs` (`f.rule`): eslint (`ruleId`,
- * `"plugin/rule"`) і oxlint (`d.code`, `"plugin(rule)"`) — те саме правило різні
- * тули віддають по-різному.
- * @type {Array<{ reasons: string[], replace: (line: string) => string|null }>}
- */
-const MECHANICAL_TEXT_FIXES = [
-  {
-    // Number.isInteger(x) не ловить x поза Number.MIN/MAX_SAFE_INTEGER — сама заміна
-    // імені методу семантично точна для рядка, що ЛИШЕ так і викликає isInteger.
-    reasons: ['unicorn/prefer-number-is-safe-integer', 'unicorn(prefer-number-is-safe-integer)'],
-    replace: line =>
-      line.includes('Number.isInteger') ? line.replaceAll('Number.isInteger', 'Number.isSafeInteger') : null
-  }
-]
-
-/**
- * Знаходить механічний фікс для reason-у порушення (обидва формати tool-у).
- * @param {string} reason `violation.reason`
- * @returns {((line: string) => string|null)|null} replace-функція або null
- */
-function mechanicalFixFor(reason) {
-  return MECHANICAL_TEXT_FIXES.find(f => f.reasons.includes(reason))?.replace ?? null
-}
-
-/**
- * Застосовує механічні текстові заміни по конкретних рядках (`data.line`, 1-indexed)
- * файлу. Рядок без збігу очікуваного шаблону (файл змінився з моменту detect-у) —
- * пропускається, не гадаємо.
- * @param {string} content вміст файлу
- * @param {Array<{ line: number, replace: (line: string) => string|null }>} targets рядки й replace-функції
- * @returns {string|null} новий вміст або null, якщо жоден рядок не змінився
- */
-function applyMechanicalLineFixes(content, targets) {
-  const lines = content.split('\n')
-  let changed = false
-  for (const { line, replace } of targets) {
-    const idx = line - 1
-    if (idx < 0 || idx >= lines.length) continue
-    const next = replace(lines[idx])
-    if (next !== null && next !== lines[idx]) {
-      lines[idx] = next
-      changed = true
-    }
-  }
-  return changed ? lines.join('\n') : null
-}
-
-/** @type {import('../../../scripts/lib/lint-surface/types.mjs').T0Pattern[]} */
-export const patterns = [
-  {
-    id: 'js-eslint-autofix',
-    test: violations => violations.some(v => v.file),
-    apply: async (violations, ctx) => {
-      const files = [...new Set(violations.map(v => v.file).filter(Boolean))]
-      const jsFiles = filterJsFiles(files)
-      if (jsFiles.length === 0) return { touchedFiles: [] }
-      const touchedFiles = await runLinterFix(jsFiles, ctx.cwd)
-      for (const a of touchedFiles) ctx.recordWrite?.(a)
-      return touchedFiles.length > 0
-        ? { touchedFiles, message: `oxlint/eslint --fix: ${touchedFiles.length} файл(ів)` }
-        : { touchedFiles: [] }
-    }
-  },
-  {
-    id: 'js-eslint-mechanical-text-fix',
-    test: violations => violations.some(v => v.file && v.data?.line && mechanicalFixFor(v.reason)),
-    apply: (violations, ctx) => {
-      /** @type {Map<string, Array<{ line: number, replace: (line: string) => string|null }>>} */
-      const byFile = new Map()
-      for (const v of violations) {
-        const replace = v.file && v.data?.line ? mechanicalFixFor(v.reason) : null
-        if (!replace) continue
-        const arr = byFile.get(v.file)
-        const target = { line: v.data.line, replace }
-        if (arr) arr.push(target)
-        else byFile.set(v.file, [target])
-      }
-      const touchedFiles = []
-      for (const [rel, targets] of byFile) {
-        const abs = resolve(ctx.cwd, rel)
-        const content = readOrNull(abs)
-        if (content === null) continue
-        const next = applyMechanicalLineFixes(content, targets)
-        if (next === null) continue
-        ctx.recordWrite?.(abs)
-        writeFileSync(abs, next)
-        touchedFiles.push(abs)
-      }
-      return touchedFiles.length > 0
-        ? { touchedFiles, message: `механічні текстові заміни: ${touchedFiles.length} файл(ів)` }
-        : { touchedFiles: [] }
-    }
-  }
-]

package/rules/js/eslint/fix-worker.mjs

@@ -1,139 +0,0 @@
-/**
- * fix-worker для `js/eslint`: окрема агентна сесія НА ФАЙЛ замість одного великого промпту
- * на всі файли concern-а одразу. Дефолтний worker (`default-worker.mjs`) шле ВСІ порушення
- * з УСІХ файлів в один `runAgentFix`-виклик — на реальних lint-прогонах (tauri-components)
- * це давало 100% timeout на всіх 4 rung-ах драбини (local-min→cloud-avg), навіть коли
- * порушень було лише 20-90 у 1-3 файлах: одна сесія жонглює кількома файлами одразу і не
- * встигає в rung-таймаут.
- *
- * Файли обробляються ПАРАЛЕЛЬНО (обмежений пул, `MAX_PARALLEL_FILES`), не послідовно —
- * ADR docs/adr/260718-0754-js-eslint-fix-worker-per-session-overhead.md. Профайлінг
- * реального прогону (2026-07-18, trace `runAgentFix`) спростував гіпотезу про фіксовані
- * bootstrap-витрати сесії: `dispatch.test.js` (2 порушення) — 9 раундів моделі, 29.4с;
- * тривіальний фікс так само вимагав багато tool-раундів, а не одноразової плати за bootstrap.
- * Оскільки домінує саме кількість/довжина turn-раундів, а не старт сесії, паралелізм
- * (кілька файлів одночасно замість черги) дає пряме пришвидшення незалежно від причини —
- * секвенційна версія витрачала весь бюджет rung-а на 1 файл, лишаючи іншим 0 шансів
- * навіть стартувати.
- *
- * Rollback-контракт незмінний: `recordWrite` (не durable) на кожен файл — правки наявного
- * стороннього коду. Якщо після worker-а `runRung`-ів canonical re-detect (whole-concern)
- * знайде хоч одне порушення будь-де, увесь rung однаково відкотиться (S1) — той самий
- * контракт, що й у дефолтного worker-а; паралелізм підвищує ймовірність, що ЦЕЙ rung
- * дійде до 0 порушень, а не замінює rollback-семантику. `snapshot.record`/`recordWrite` —
- * синхронні Map-операції без `await` усередині, тож конкурентні виклики безпечні (Node
- * event loop не перериває синхронний блок).
- *
- * Дедлайн (`DEADLINE_FRACTION` від `ctx.timeoutMs`, той самий підхід, що й
- * `doc-files/check/fix-worker.mjs`) гейтить лише СТАРТ нового файлу з черги — не
- * скасовує вже запущені. При files.length ≤ MAX_PARALLEL_FILES усі стартують майже
- * одночасно й отримують практично весь бюджет незалежно один від одного (справжній
- * паралелізм); при більшій кількості — черга природно звужує бюджет пізніших хвиль
- * (`callTimeoutMs` рахується в момент старту, не наперед), не даючи перевищити
- * backstop ×1.25 runner-а.
- * @typedef {import('../../../scripts/lib/lint-surface/types.mjs').FixWorkerFn} FixWorkerFn
- */
-import { resolve } from 'node:path'
-
-import { anchoredEnabled } from '../../../scripts/lib/lint-surface/default-worker.mjs'
-import { renderViolations } from '../../../scripts/lib/lint-surface/render.mjs'
-import { lint } from './main.mjs'
-
-/** Частка ctx.timeoutMs, після якої черга не стартує новий файл (запас до backstop ×1.25). */
-const DEADLINE_FRACTION = 0.8
-
-/** Максимум файлів, що обробляються одночасно (без необмеженого burst на великих concern-ах). */
-const MAX_PARALLEL_FILES = 4
-
-/**
- * Item-scoped (один файл) canonical re-detect для evidence-гейта `runAgentFix` —
- * НЕ те саме, що whole-concern `ctx.verify` з `runRung` (той перевірив би ВСІ файли
- * concern-а й дав би хибний "не готово" навіть коли саме ЦЕЙ файл уже чистий).
- * @param {string} cwd абсолютний корінь проєкту
- * @param {string} ruleId id правила
- * @param {string} concernId id concern-а
- * @param {string} file posix-relative шлях файлу, що перевіряється
- * @returns {Promise<{ ok: boolean, output: string }>} вердикт verify-петлі
- */
-async function verifyFile(cwd, ruleId, concernId, file) {
-  const { violations: after } = await lint({ cwd, ruleId, concernId, files: [file] })
-  const stamped = after.map(v => ({ ...v, ruleId, concernId }))
-  return { ok: stamped.length === 0, output: renderViolations(stamped) }
-}
-
-/**
- * Обробляє `items` обмеженим пулом воркерів (не більше `MAX_PARALLEL_FILES` одночасно) —
- * власна черга замість `Promise.all(items.map(...))`, щоб великий concern не відкрив
- * необмежену кількість конкурентних агентних сесій одразу.
- * @param {string[]} items елементи черги (шляхи файлів)
- * @param {(item: string) => Promise<void>} worker обробник одного елемента; винятки ловить сам
- * @returns {Promise<void>}
- */
-async function runPooled(items, worker) {
-  const queue = [...items]
-  const runnerCount = Math.min(MAX_PARALLEL_FILES, items.length)
-  await Promise.all(
-    Array.from({ length: runnerCount }, async () => {
-      let item
-      while ((item = queue.shift())) {
-        await worker(item)
-      }
-    })
-  )
-}
-
-/** @type {FixWorkerFn} */
-export async function fixWorker(violations, ctx) {
-  // lazy import — тримає detect-шлях вільним від pi/oxc (read-only --no-fix не вантажить їх).
-  const [{ runAgentFix }, { isLocalModel }, { extractContext }] = await Promise.all([
-    import('@7n/llm-lib/agent-fix'),
-    import('@7n/llm-lib/model-tiers'),
-    import('../../../scripts/utils/ast-extract.mjs')
-  ])
-
-  /** @type {Map<string, import('../../../scripts/lib/lint-surface/types.mjs').LintViolation[]>} */
-  const byFile = new Map()
-  for (const v of violations) {
-    if (!v.file) continue
-    const arr = byFile.get(v.file)
-    if (arr) arr.push(v)
-    else byFile.set(v.file, [v])
-  }
-  const files = byFile.keys().toArray()
-  if (files.length === 0) return { touchedFiles: [] }
-
-  const deadlineAt = ctx.timeoutMs ? Date.now() + Math.round(ctx.timeoutMs * DEADLINE_FRACTION) : null
-  const anchoredEdits = anchoredEnabled(ctx.model, isLocalModel)
-
-  const touchedFiles = []
-  await runPooled(files, async file => {
-    if (deadlineAt && Date.now() >= deadlineAt) return
-    const callTimeoutMs = deadlineAt ? Math.max(1000, deadlineAt - Date.now()) : ctx.timeoutMs
-
-    let res
-    try {
-      res = await runAgentFix(ctx.ruleId, renderViolations(byFile.get(file)), ctx.cwd, {
-        model: ctx.model,
-        tier: ctx.tier,
-        timeoutMs: callTimeoutMs,
-        feedback: ctx.feedback ?? null,
-        caller: `fix:${ctx.ruleId}/${ctx.concernId}:${ctx.tier}:${file}`,
-        recordWrite: ctx.recordWrite,
-        chain: ctx.chain ?? null,
-        targetFiles: [file],
-        verify: () => verifyFile(ctx.cwd, ctx.ruleId, ctx.concernId, file),
-        verifyMax: ctx.verifyMax,
-        anchoredEdits,
-        deps: { astContext: p => extractContext(resolve(ctx.cwd, p)) }
-      })
-    } catch {
-      // Один файл впав винятком — не валимо решту паралельних воркерів у пулі; whole-concern
-      // canonical re-detect runner-а (не цей worker) визначить, чи rung закрито.
-      return
-    }
-
-    if (!res.error) touchedFiles.push(...(res.touchedFiles ?? []))
-  })
-
-  return { touchedFiles }
-}

package/rules/js/eslint/main.mjs

@@ -1,115 +0,0 @@
-/**
- * lint-поверхня js/eslint: read-only detector (oxlint + eslint). Fix (oxlint --fix /
- * eslint --fix) — окремий T0 `fix-eslint.mjs` (детермінований), не в detector-і.
- */
-import { resolve, relative } from 'node:path'
-
-import { ESLint } from 'eslint'
-
-import { addedLinesByFile } from '../../../scripts/lib/diff-added-lines.mjs'
-import { spawnAsync } from '../../../scripts/utils/spawn-async.mjs'
-import { WORKTREE_CHECKOUT_GLOBS } from '../../../scripts/utils/walkDir.mjs'
-import { classifyFindings, eslintResultsToFindings, parseOxlint } from '../lint-findings/main.mjs'
-
-const JS_EXT_RE = /\.(?:mjs|cjs|js|jsx|ts|tsx|vue)$/u
-
-/**
- * @param {string[]} files список шляхів
- * @returns {string[]} лише JS-подібні файли
- */
-export function filterJsFiles(files) {
-  return files.filter(f => JS_EXT_RE.test(f))
-}
-
-/**
- * Async (не блокує event loop) — детектор може виконуватись у parallel lane `detectAll()`
- * (ADR 260716-1354).
- * @param {string[]} args аргументи запуску oxlint
- * @param {string} cwd робочий каталог
- * @returns {Promise<{ status: number, stdout: string, stderr: string }>} код завершення, stdout і stderr процесу
- */
-async function runOxlintJson(args, cwd) {
-  const r = await spawnAsync('bunx', args, { cwd })
-  return { status: typeof r.exitCode === 'number' ? r.exitCode : 1, stdout: r.stdout ?? '', stderr: r.stderr ?? '' }
-}
-
-/**
- * Finding → LintViolation.
- * @param {{ file: string, line: number, rule: string, message: string, tool: string }} f знахідка лінтера
- * @param {string} cwd робочий каталог
- * @param {'error'|'warn'} severity рівень порушення
- * @returns {import('../../../scripts/lib/lint-surface/types.mjs').LintViolation} нормалізоване порушення
- */
-function toViolation(f, cwd, severity) {
-  return /** @type {import('../../../scripts/lib/lint-surface/types.mjs').LintViolation} */ ({
-    reason: f.rule || `${f.tool}-error`,
-    message: `${f.message} (${f.tool})`,
-    file: relative(cwd, f.file).split('\\').join('/'),
-    severity,
-    data: { line: f.line, tool: f.tool }
-  })
-}
-
-/**
- * Збирає findings (oxlint json + eslint read-only) по заданих файлах або всьому проєкту.
- * @param {string[]|null} js null → весь проєкт
- * @param {string} cwd робочий каталог
- * @returns {Promise<Array<{ file: string, line: number, rule: string, message: string, tool: string }>>} зібрані знахідки oxlint+eslint
- */
-async function collectFindings(js, cwd) {
-  // warnIgnored:false — файли з delta, що матчать ignore-патерни конфігу, не є порушеннями.
-  // overrideConfig лише з ignores → global ignores: worktree-чекаути (.worktrees/,
-  // .claude/worktrees/) — копії репо, споживацький eslint-конфіг їх не виключає.
-  const eslint = new ESLint({ cwd, warnIgnored: false, overrideConfig: { ignores: WORKTREE_CHECKOUT_GLOBS } })
-  const esResults = await eslint.lintFiles(js === null ? [cwd] : js.map(f => resolve(cwd, f)))
-  const es = eslintResultsToFindings(esResults)
-
-  const worktreeIgnoreArgs = WORKTREE_CHECKOUT_GLOBS.map(g => `--ignore-pattern=${g}`)
-  const oxArgs =
-    js === null
-      ? ['oxlint', '--format=json', ...worktreeIgnoreArgs]
-      : ['oxlint', '--format=json', ...worktreeIgnoreArgs, ...js]
-  const oxRes = await runOxlintJson(oxArgs, cwd)
-  const ox = parseOxlint(oxRes.stdout)
-  if (ox === null && oxRes.status !== 0) {
-    // Хвости stdout/stderr — інакше на CI причина крашу (OOM, конфіг, версія) невидима.
-    const tail = [oxRes.stderr, oxRes.stdout]
-      .map(t => t.trim().slice(-500))
-      .filter(t => t !== '')
-      .join('\n--- stdout: ')
-    const suffix = tail === '' ? '' : `\n${tail}`
-    throw new Error(
-      `oxlint завершився з помилкою (exit ${oxRes.status}, не lint-порушення) — json не розпарсено${suffix}`
-    )
-  }
-  return [...(ox ?? []), ...es]
-}
-
-/**
- * Detector js/eslint: per-file (classify introduced/pre-existing) або full-project.
- * @param {import('../../../scripts/lib/lint-surface/types.mjs').LintContext} ctx контекст лінту
- * @returns {Promise<import('../../../scripts/lib/lint-surface/types.mjs').LintResult>} перелік порушень
- */
-export async function lint(ctx) {
-  const { cwd, files } = ctx
-
-  if (files === undefined) {
-    const findings = await collectFindings(null, cwd)
-    return { violations: findings.map(f => toViolation(f, cwd, 'error')) }
-  }
-
-  const js = filterJsFiles(files)
-  if (js.length === 0) return { violations: [] }
-
-  const findings = await collectFindings(js, cwd)
-  if (findings.length === 0) return { violations: [] }
-
-  // introduced (на доданих рядках) → error; pre-existing → warn.
-  const classified = classifyFindings(findings, addedLinesByFile(js, cwd), cwd)
-  return {
-    violations: [
-      ...classified.introduced.map(f => toViolation(f, cwd, 'error')),
-      ...classified.preExisting.map(f => toViolation(f, cwd, 'warn'))
-    ]
-  }
-}

package/rules/js/file-extensions/concern.json

@@ -1,3 +0,0 @@
-{
-  "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json"
-}

package/rules/js/file-extensions/file-extensions.mdc

@@ -1,12 +0,0 @@
-## Розширення нових файлів — `.mjs` / `.cjs`, не `.js`
-
-**Нові** JS-файли створюй з явним розширенням модуля:
-
-- **`.mjs`** — для ESM (типовий випадок);
-- **`.cjs`** — для CommonJS, де він справді потрібен.
-
-Голий **`.js`** для нового файлу **заборонено**. Розширення `.js` інтерпретується як ESM чи CJS лише за полем `package.json#type`, тож той самий файл читається по-різному залежно від пакета. Явне `.mjs`/`.cjs` робить тип модуля однозначним **без читання `package.json`** — навіть якщо `type` зміниться або файл перемістять в інший пакет. Це доповнює вимогу `"type": "module"` у [package_json.mdc](../package_json/package_json.mdc): `type` лишається каноном для всього дерева, а розширення нового файлу прибирає залежність від нього.
-
-Стосується **backend і frontend** — будь-який новий вихідний файл: `src/`, тести `*.test.*`, `scripts/`, `src/conn/` тощо.
-
-**Існуючі `.js` лишаються як є** — масово перейменовувати не треба; це конвенція для нового коду. Автоматичної перевірки тут немає: stateless-скан не відрізнить новий файл від існуючого, тож `.js` нікого не фейлить.

package/rules/js/jscpd_config/concern.json

@@ -1,11 +0,0 @@
-{
-  "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json",
-  "fixability": "config",
-  "policy": {
-    "files": {
-      "single": ".jscpd.json",
-      "required": true
-    },
-    "missingMessage": ".jscpd.json не існує — створи з полями згідно js.mdc"
-  }
-}

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

@@ -1,26 +0,0 @@
----
-type: JS Module
-title: fix-jscpd_config.mjs
-resource: npm/rules/js/jscpd_config/fix-jscpd_config.mjs
-docgen:
-  crc: 93258f26
-  model: openai-codex/gpt-5.4-mini
-  tier: cloud-min
-  score: 100
-  judgeModel: openai-codex/gpt-5.4-mini
----
-
-## Огляд
-
-`patterns` визначає узгоджені з правилами проєкту зміни для `.jscpd.json` і слугує централізованим орієнтиром для того, що саме має бути виправлено в цьому конфігу.
-
-## Поведінка
-
-1. `patterns` формує перелік правил для уніфікації шаблонного конфіга проєкту.
-2. Кожне правило орієнтується на конфіг `.jscpd.json`, щоб тримати його в узгодженому, очікуваному форматі.
-3. `patterns` потрібен для централізованого опису того, що саме має бути виправлено в `.jscpd.json`, без ручного втручання в інші файли чи артефакти.
-4. `patterns` не змінює файлову систему або базу даних і працює лише як опис набору правок для цього конфіга.
-
-## Гарантії поведінки
-
-- Read-only: не виконує операцій запису (ФС/БД).

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

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

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

@@ -1,3 +0,0 @@
-import { createTemplateFixPattern } from '../../../scripts/lib/fix/template-deep-merge.mjs'
-
-export const patterns = [createTemplateFixPattern({ id: 'js-jscpd_config-template', targetPath: '.jscpd.json' })]

package/rules/js/jscpd_config/jscpd_config.mdc

@@ -1,42 +0,0 @@
-## Rego-gate `.jscpd.json`
-
-Rego-пакет: `js_lint.jscpd`
-
-Цільовий файл: `.jscpd.json` у корені проєкту.
-
-Що перевіряється:
-
-- `gitignore` — точна відповідність (`true`)
-- `exitCode` — точна відповідність (`1`)
-- `reporters` — subset-of: масив має містити всі елементи з канону (`["console"]`)
-- `minLines` — число, значення >= канонічного порогу (`25`); більше дозволено
-
-Канон-snippet: [.jscpd.json.snippet.json](./template/.jscpd.json.snippet.json)
-
-### Ігнорування `.claude/worktrees/`
-
-Каталог `.claude/worktrees/` (робочі копії, які Claude Code створює через **superpowers:using-git-worktrees**) має ігноруватися:
-
-- додай `.claude/worktrees/` у кореневий `.gitignore` (штатне місце для не-комітних робочих копій);
-- у `.jscpd.json` додай `.claude/worktrees/**` у `ignore` як страховку на випадок запуску без `gitignore: true`.
-
-Без цього jscpd сканує паралельну копію репо в worktree і фіксує самозбіги між дзеркальними файлами.
-
-```text title=".gitignore (фрагмент)"
-.claude/worktrees/
-```
-
-### Ігнорування `**/CHANGELOG.md`
-
-`**/CHANGELOG.md` у каноні `ignore`: release-журнали різних пакетів структурно повторюються (заголовки `## [x.y.z] - YYYY-MM-DD`, секції `### Added / Changed / Fixed` за Keep a Changelog), і `jscpd` за `minLines: 25` фіксує їх як клон — це false positive. Без цього в монорепо легко зловити критичний `bun run lint` на парі CHANGELOG-ів довжиною від ~25 рядків.
-
-### Рефакторинг vs конфіг
-
-Коли **jscpd** знаходить клони, спочатку зменшуй дублювання кодом, а не конфігом.
-
-- **Рефакторинг:** винеси спільні фрагменти в функції, модулі, утиліти, composables/hooks, спільні компоненти або базові типи — залежно від контексту.
-- **Структура:** якщо одна й та сама логіка розмазана між файлами чи пакетами, запропонуй зміну структури (наприклад, спільний модуль, `shared/`, внутрішній пакет у monorepo), щоб була **одна канонічна реалізація** і повторні місця лише викликали її.
-
-Розширення `ignore` чи завищення `minLines` лише щоб прибрати звіт — не заміна рефакторингу для справжніх клонів. Якщо збіг **семантично випадковий** (генерований код, формальні шаблони без спільної логіки), після оцінки допустимо точковий `ignore` або зміна порогу — з коротким обґрунтуванням.
-
-Перед рефакторингом перевір чи є тести на блоки які підлягають зміні (Bun.test для js, playwright для vue). Якщо тестів немає або вони не покривають — спочатку створи їх, перевір що вони відпрацьовують коректно, потім роби рефакторинг і ще раз запускай тести.

package/rules/js/jscpd_config/jscpd_config.rego

@@ -1,44 +0,0 @@
-# Перевірка `.jscpd.json` (js.mdc).
-#
-# Канон надходить через --data: { "template": { "snippet": ... } }
-# Структура --data сформована з template/.jscpd.json.snippet.json.
-# Особливості:
-#  - `reporters` — subset-of (масив string)
-#  - `minLines` — >= expected (semantic: дозволяється більше, не менше)
-#  - `gitignore`/`exitCode` — exact match
-package js.jscpd_config
-
-import rego.v1
-
-# Top-level scalar leafs (exact match) для gitignore + exitCode.
-deny contains msg if {
-	some key, expected_value in data.template.snippet
-	key != "minLines"
-	not is_array(expected_value)
-	actual := object.get(input, key, null)
-	actual != expected_value
-	msg := sprintf(".jscpd.json має містити \"%s\": %v (js.mdc)", [key, expected_value])
-}
-
-# Array subset-of для reporters.
-deny contains msg if {
-	some field, expected_values in data.template.snippet
-	is_array(expected_values)
-	actual_set := {v | some v in object.get(input, field, [])}
-	some required in expected_values
-	not required in actual_set
-	msg := sprintf(".jscpd.json має містити \"%s\": [\"%s\"] (js.mdc)", [field, required])
-}
-
-# minLines: must be number and >= expected.
-deny contains msg if {
-	expected := data.template.snippet.minLines
-	actual := object.get(input, "minLines", null)
-	not is_valid_min_lines(actual, expected)
-	msg := sprintf(".jscpd.json має містити \"minLines\" як число >= %d (js.mdc)", [expected])
-}
-
-is_valid_min_lines(actual, expected) if {
-	is_number(actual)
-	actual >= expected
-}

package/rules/js/jscpd_config/template/.jscpd.json.snippet.json

@@ -1,7 +0,0 @@
-{
-  "gitignore": true,
-  "exitCode": 1,
-  "reporters": ["console"],
-  "minLines": 25,
-  "ignore": [".claude/worktrees/**", "**/dist/**", "**/CHANGELOG.md"]
-}

package/rules/js/jscpd_duplicates/concern.json

@@ -1,7 +0,0 @@
-{
-  "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json",
-  "fixability": "structural",
-  "lint": {
-    "scope": "full"
-  }
-}

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

@@ -1,29 +0,0 @@
----
-type: JS Module
-title: main.mjs
-resource: npm/rules/js/jscpd_duplicates/main.mjs
-docgen:
-  crc: 8839c5e9
-  model: omlx/gemma-4-e4b-it-OptiQ-4bit
-  score: 100
-  issues: judge:inaccurate:0.99
-  judgeModel: openai-codex/gpt-5.4-mini
----
-
-## Огляд
-
-Публічна функція `lint` аналізує вихідний код у вказаному кореневому каталозі, використовуючи `jscpd`, щоб виявляти дублікати та інші порушення стилю і логіки коду. Функція повертає код виходу, який інформує про успішне завершення аналізу чи виявлення проблем.
-
-## Поведінка
-
-1. Викликається функція `lint`, яка ініціює перевірку коду у вказаному кореневому каталозі з метою виявлення дублікатів.
-2. Процес аналізу виконується за допомогою `jscpd` у середовищі `bunx`.
-3. Функція повертає код завершення процесу: 0 у разі успішного виконання (без знайдених проблем) або інше число, що вказує на помилки.
-
-## Публічний API
-
-lint — виявляє дублікати коду за допомогою `bunx jscpd` у файлах JavaScript/JSCPD.
-
-## Гарантії поведінки
-
-- Read-only: не виконує операцій запису (ФС/БД).