@rt-tools/agent-kit 0.2.0 → 0.4.0

package/assets/checks/check-board.github.mjs

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+/**
+ * Сверка очереди работ с тем, что закон о поставке требует от задачи и её отчёта.
+ *
+ * Гард поставки отбивает промах в момент, когда его совершают, но действует только
+ * на команды агента: тикет, заведённый мимо него, и PR, открытый руками, он не
+ * видит. Эта сверка отвечает на другой вопрос — «а вся ли очередь в порядке
+ * сейчас», — и потому смотрит на состояние, а не на команду.
+ *
+ * Судит только открытое. Закрытые задачи и влитые PR — это история: из сорока
+ * последних влитых PR тридцать шесть пришли с веток, за которыми задачи не стояло,
+ * и красная навсегда проверка ничем не отличалась бы от её отсутствия.
+ *
+ * Имя ветки не судит. У открытого PR его не переименовать — это новая ветка и новый
+ * PR, — а проверка, требующая невыполнимого, обходится, а не исполняется. Имя ветки
+ * стережёт гард в момент `git checkout -b` и `gh pr create`.
+ *
+ * Колонку задачи судит по её отчёту: открытый PR означает разбор, отсутствие — нет.
+ * Момент, когда задачу берут в работу, отсюда не виден вовсе — ветки на борде нет, —
+ * и «In progress» здесь не требуется ни от кого.
+ *
+ * Нет сети или нет токена — код возврата ноль: проверка, падающая в самолёте,
+ * перестаёт что-либо значить.
+ *
+ * Ненулевой код возврата и перечень расхождений.
+ */
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+
+import {
+    IN_REVIEW_STATUS,
+    OfflineError,
+    STATUS_OPTIONS,
+    TASK_KEY,
+    botToken,
+    fetchBoard,
+    fetchIssues,
+    fetchOpenPulls,
+    numberFromTitle,
+} from './board.mjs';
+import { CONFIG, ROOT } from './rt-kit-checks.config.mjs';
+
+const IN_REVIEW = STATUS_OPTIONS[IN_REVIEW_STATUS].name;
+const TASKS_DIR = join(ROOT, CONFIG.tasksDir);
+/** Возраст брошенного черновика, после которого он перестаёт выглядеть начатым сегодня. */
+const DRAFT_DAYS = 7;
+
+const problems = [];
+const report = (message) => problems.push(message);
+
+function taskDirs() {
+    if (!existsSync(TASKS_DIR)) {
+        return [];
+    }
+    return readdirSync(TASKS_DIR, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && entry.name !== '_template')
+        .map((entry) => entry.name);
+}
+
+/**
+ * Разбор просьбы владельца идёт до заведения задачи и лежит в `_draft-<slug>`. Заглохший на
+ * середине, он остаётся на диске вне истории и выглядит так же, как начатый сегодня: второй
+ * заход берётся за то же самое заново. Возраст здесь — единственный доступный признак:
+ * задачи за черновиком ещё нет, и спросить о нём некого.
+ */
+function checkDrafts() {
+    const now = Date.now();
+    for (const name of taskDirs()) {
+        if (!name.startsWith('_draft-')) {
+            continue;
+        }
+        const age = Math.floor((now - statSync(join(TASKS_DIR, name)).mtimeMs) / 86400000);
+        if (age >= DRAFT_DAYS) {
+            report(`docs/tasks/${name}/: разбор брошен ${age} дн. назад — заведи задачу или удали папку`);
+        }
+    }
+}
+
+function closesNumbers(body) {
+    return [...String(body ?? '').matchAll(/\bCloses\s+#(\d+)\b/gi)].map((match) => Number(match[1]));
+}
+
+let checked = { issues: 0, pulls: 0 };
+
+// Черновики судятся по диску и потому проверяются всегда: связи для этого не нужно.
+checkDrafts();
+
+let offline = false;
+try {
+    const options = { token: botToken() ?? undefined };
+    const board = fetchBoard(options);
+    const issues = fetchIssues('all', options);
+    const open = issues.filter((issue) => issue.state === 'OPEN');
+    const pulls = fetchOpenPulls(options);
+    checked = { issues: issues.length, pulls: pulls.length };
+
+    for (const item of board.foreign) {
+        report(`борда: ${item} — на борде стоят задачи, а не отчёты о них`);
+    }
+    // Борду проверяем только у открытых задач. Закрытая ушла из очереди мержем, и колонки под
+    // неё у борды нет: строку о ней нечем закрыть. Шесть таких строк висели в каждом прогоне и
+    // заглушали собой настоящую задачу, которая на борду не попала.
+    for (const issue of open) {
+        if (!board.issues.has(issue.number)) {
+            report(`#${issue.number}: задачи нет на борде — за ней никто не следит`);
+        }
+        if (numberFromTitle(issue.title) !== issue.number) {
+            report(`#${issue.number}: заголовок не начинается с [${TASK_KEY}-${issue.number}] — «${issue.title}»`);
+        }
+        if (issue.assignees.length === 0) {
+            report(`#${issue.number}: у задачи нет исполнителя — по очереди работ не видно, кто её взял`);
+        }
+    }
+
+    const openNumbers = new Set(open.map((issue) => issue.number));
+    const claimed = new Map();
+    for (const pull of pulls) {
+        const titleNumber = numberFromTitle(pull.title);
+        if (titleNumber === null) {
+            report(`PR #${pull.number}: заголовок не начинается с [${TASK_KEY}-<номер>] — «${pull.title}»`);
+            continue;
+        }
+        if (!closesNumbers(pull.body).includes(titleNumber)) {
+            report(`PR #${pull.number}: в теле нет строки «Closes #${titleNumber}» — на борде он не прикрепится к задаче`);
+        }
+        if (!openNumbers.has(titleNumber)) {
+            report(`PR #${pull.number}: задачи #${titleNumber} нет среди открытых — у задачи одна ветка`);
+        }
+        if (claimed.has(titleNumber)) {
+            report(`PR #${pull.number}: задачу #${titleNumber} уже закрывает PR #${claimed.get(titleNumber)} — у задачи одна ветка`);
+        } else {
+            claimed.set(titleNumber, pull.number);
+        }
+    }
+
+    // Колонка задачи и её отчёт сверяются в обе стороны: открытый PR при задаче в «Backlog»
+    // читается как работа, к которой не приступали, а «In review» без открытого PR — как
+    // разбор, которого никто не ждёт.
+    for (const issue of open) {
+        const status = board.items.get(issue.number)?.status ?? null;
+        const pull = claimed.get(issue.number);
+        if (pull !== undefined && status !== IN_REVIEW) {
+            report(
+                `#${issue.number}: отчёт PR #${pull} открыт, а задача стоит «${status ?? 'вне колонок'}» — npm run task:move -- ${issue.number} ${IN_REVIEW_STATUS}`
+            );
+        }
+        if (pull === undefined && status === IN_REVIEW) {
+            report(`#${issue.number}: задача ждёт разбора, но открытого PR за ней нет — колонка отстала от работы`);
+        }
+    }
+
+    // Папка задачи умирает вместе с задачей: то, что объясняет состоявшееся решение, уезжает
+    // в `docs/archive/`, остальное удаляется. Оставленная рядом с текущими, она читается как
+    // текущая — тем убедительнее, чем старше.
+    for (const name of taskDirs()) {
+        const number = Number(new RegExp(`^${TASK_KEY}-(\\d+)-`).exec(name)?.[1]);
+        if (!Number.isInteger(number) || openNumbers.has(number)) {
+            continue;
+        }
+        if (issues.some((issue) => issue.number === number)) {
+            report(`docs/tasks/${name}/: задача #${number} закрыта, а папка лежит среди текущих — разбери её`);
+        }
+    }
+} catch (error) {
+    if (error instanceof OfflineError) {
+        // Очередь работ без связи не проверить, а папки на диске — проверить: молчать про
+        // них значило бы терять единственное, что здесь ещё можно сказать.
+        console.log(`check-board: очередь работ пропущена, проверять нечем — ${error.message}`);
+        offline = true;
+    } else {
+        console.error(`check-board: ${String(error.message ?? error)}`);
+        process.exit(1);
+    }
+}
+
+if (problems.length > 0) {
+    console.error(`check-board: расхождений ${problems.length}\n`);
+    problems.forEach((problem) => console.error(`  ${problem}`));
+    console.error('\nЗадача заводится командой npm run task:new — она делает все четыре шага сразу.');
+    console.error('Папка задачи и её разбор — скил task-flow.');
+    process.exit(1);
+}
+
+if (offline) {
+    process.exit(0);
+}
+
+console.log(`check-board: задач ${checked.issues}, открытых PR ${checked.pulls}, расхождений нет`);

package/assets/checks/check-doc-paths.mjs

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+/**
+ * Проверка того, что пути, названные в документации, существуют.
+ *
+ * Документ, ссылающийся на исчезнувший файл, хуже отсутствующего: он выглядит
+ * действующей справкой и уводит читателя в каталог, которого нет. Накапливается
+ * это молча — перекладка дерева правит код и ломает текст, а текст никто не
+ * собирает. К моменту заведения проверки из 159 путей, названных в `docs/`,
+ * не существовало 80.
+ *
+ * Считаются только пути в обратных кавычках и вне блоков кода: в блоках лежат
+ * команды и вывод, где `dist/apps/api/main.js` — результат сборки, а не файл
+ * репозитория. Шаблоны (`*`, `<…>`, `{…}`) пропускаются: это форма пути, а не путь.
+ *
+ * Документы, которые по устройству говорят о несуществующем — планы будущего и
+ * архив, — перечислены в tools/doc-paths-allowlist.json.
+ *
+ * Ненулевой код возврата и перечень расхождений.
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { allowlistOf, CONFIG, ROOT } from './rt-kit-checks.config.mjs';
+
+const ALLOWLIST = allowlistOf('doc-paths');
+// `worktrees` — копии репозитория под `.claude/`: их документы описывают раскладку своей
+// ветки, а проверка ищет пути в дереве текущей. Одна брошенная копия дала 73 расхождения и
+// красный сквозной прогон на ветке, которая её не заводила.
+const SKIPPED_DIRS = CONFIG.skippedDirs;
+/**
+ * Архив описывает раскладку, бывшую на момент записи. Править в нём пути — значит
+ * переписывать историю задним числом, поэтому он выведен из проверки целиком.
+ */
+const ARCHIVE_DIR = CONFIG.archiveDir;
+/** Расширения, по которым строка в кавычках считается путём, а не именем сущности */
+const EXTENSIONS = 'ts|mts|cts|js|mjs|cjs|json|jsonc|scss|css|html|proto|conf|ya?ml|sh|md|sql|txt|xml|svg|webp|png|ico|env|Dockerfile|lock';
+const PATH_IN_BACKTICKS = new RegExp(`\`([^\`\\n]+?\\.(?:${EXTENSIONS}))\``, 'g');
+
+const problems = [];
+const report = (doc, line, path) => problems.push(`${doc}:${line}: нет файла \`${path}\``);
+
+function readAllowlist() {
+    const path = join(ROOT, ALLOWLIST);
+    if (!existsSync(path)) {
+        return { files: [], paths: [] };
+    }
+
+    const raw = JSON.parse(readFileSync(path, 'utf8'));
+
+    return { files: raw.files ?? [], paths: raw.paths ?? [] };
+}
+
+function collectDocs(dir = '.') {
+    const entries = readdirSync(join(ROOT, dir), { withFileTypes: true });
+    const found = [];
+
+    for (const entry of entries) {
+        const relativePath = dir === '.' ? entry.name : `${dir}/${entry.name}`;
+        if (entry.isDirectory()) {
+            if (!SKIPPED_DIRS.includes(entry.name)) {
+                found.push(...collectDocs(relativePath));
+            }
+        } else if (entry.name.endsWith('.md')) {
+            found.push(relativePath);
+        }
+    }
+
+    return found.sort();
+}
+
+/**
+ * Документы, которые в репозиторий не попадут: личный черновик, лежащий в дереве и
+ * закрытый `.gitignore` или `.git/info/exclude`. Проверка судит репозиторий, а не рабочий
+ * стол того, кто её запустил: мёртвая ссылка в чужом черновике держала гейт пуша, хотя ни
+ * в одну ветку этот файл не едет.
+ */
+function droppedByGit(docs) {
+    if (docs.length === 0) {
+        return new Set();
+    }
+
+    // `--stdin` вместо аргументов: список длиннее ограничения командной строки
+    const ignored = spawnSync('git', ['check-ignore', '--stdin'], {
+        cwd: ROOT,
+        encoding: 'utf8',
+        input: docs.join('\n'),
+    });
+
+    // Нет git — судить нечем, и проверка остаётся строже нужного
+    return new Set((ignored.stdout ?? '').split('\n').filter(Boolean));
+}
+
+/**
+ * Верхний уровень дерева. Проверяются только адреса, укоренённые в нём: `src/index.ts`
+ * в правиле означает «любой файл такого вида», а `services/theme/theme.service.ts` —
+ * обрывок чужого пути. Ни то, ни другое адресом не является, и требовать их
+ * существования значит ловить форму записи вместо ссылки.
+ */
+const ROOTED_IN = new Set(
+    readdirSync(ROOT, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && !SKIPPED_DIRS.includes(entry.name))
+        .map((entry) => entry.name)
+);
+
+/**
+ * Путь ли это вообще. Отсекается всё, что описывает форму, а не адрес: шаблоны,
+ * URL и пакеты npm.
+ */
+function looksLikePath(candidate) {
+    if (/[*<>{}$|\s]|\.\.\.|…/.test(candidate)) {
+        return false;
+    }
+    if (/^(https?:|@|~|\/)/.test(candidate)) {
+        return false;
+    }
+
+    return ROOTED_IN.has(candidate.split('/')[0]);
+}
+
+function checkDoc(doc, allowed) {
+    const lines = readFileSync(join(ROOT, doc), 'utf8').split('\n');
+    let insideFence = false;
+
+    lines.forEach((line, index) => {
+        if (/^\s*(```|~~~)/.test(line)) {
+            insideFence = !insideFence;
+
+            return;
+        }
+        if (insideFence) {
+            return;
+        }
+
+        for (const [, candidate] of line.matchAll(PATH_IN_BACKTICKS)) {
+            if (!looksLikePath(candidate) || allowed.has(candidate)) {
+                continue;
+            }
+            if (!existsSync(join(ROOT, candidate))) {
+                report(doc, index + 1, candidate);
+            }
+        }
+    });
+}
+
+const allowlist = readAllowlist();
+const allowedPaths = new Set(allowlist.paths);
+const collected = collectDocs().filter((doc) => !allowlist.files.includes(doc) && !doc.startsWith(ARCHIVE_DIR));
+const dropped = droppedByGit(collected);
+const docs = collected.filter((doc) => !dropped.has(doc));
+
+docs.forEach((doc) => checkDoc(doc, allowedPaths));
+
+if (problems.length > 0) {
+    console.error(`check-doc-paths: расхождений ${problems.length}\n`);
+    problems.forEach((problem) => console.error(`  ${problem}`));
+    console.error(
+        `\nЛибо путь устарел и его надо поправить, либо документ описывает ещё не созданное —\nтогда он вносится в ${ALLOWLIST}.`
+    );
+    process.exit(1);
+}
+
+console.log(`check-doc-paths: проверено документов ${docs.length}, расхождений нет`);

package/assets/checks/check-dupes.mjs

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+/**
+ * Проверка того, что образец не написан второй раз.
+ *
+ * Повтор заводится молча: домен пишет своё перечисление статусов, потому что
+ * чужое лежит в либе, которая ему не видна, — и дальше два набора расходятся
+ * по одному значению за раз. Ни линт, ни сборка, ни тесты этого не видят:
+ * каждая копия сама по себе исправна.
+ *
+ * Ловится двумя признаками:
+ *
+ *   1. Одно имя экспортировано из двух разных либ. Имя совпадает не случайно —
+ *      его выбирали под одно и то же понятие.
+ *   2. Два перечисления с одинаковым набором членов под разными именами.
+ *      Имя разошлось, а понятие осталось одно.
+ *   3. Настройка под одним именем объявлена в двух либах. Экспорта у неё нет,
+ *      поэтому первый признак её не видел: `DEFAULT_PAGE_SIZE` разошёлся на
+ *      шесть объявлений, и одно из них успело стать `25` против `20` у
+ *      остальных. Считаются только имена вида `SCREAMING_SNAKE_CASE` — форма,
+ *      которой в этом коде записывают настройки, а не местные переменные.
+ *   4. Перечисление, повторяющее набор из внешнего пакета. Наборы `@rt-tools/utils`
+ *      читаются из его `.d.ts` наравне с либами: копия оператора условия и
+ *      направления порядка лежала на бэкенде дословно, а признак 2 сравнивал
+ *      только либы между собой и до `node_modules` не доходил.
+ *
+ * Сравнение членов идёт по нижнему регистру без подчёркиваний, поэтому
+ * `NOT_EQUALS` контракта и `NotEquals` приложения считаются одним членом.
+ *
+ * Ключ повтора несёт и список либ: без него третья копия уже известного имени
+ * проходила молча — состав менялся, а ключ оставался прежним.
+ *
+ * Накопленное к моменту заведения проверки лежит в tools/dupes-allowlist.json
+ * и отказом не считается: гейт падает на НОВОМ повторе, а старое остаётся
+ * видимым числом в сводке. Разбор долга идёт отдельными задачами — иначе
+ * проверку пришлось бы заводить вместе с правкой сорока мест.
+ *
+ * Ненулевой код возврата и перечень расхождений.
+ */
+import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { allowlistOf, CONFIG, ROOT } from './rt-kit-checks.config.mjs';
+
+const ALLOWLIST = allowlistOf('dupes');
+/**
+ * Где ищутся повторы. Корни берутся из настройки: зашитое имя молча не находило ни одного файла
+ * у дерева, которое держит код иначе, и проверка зеленела на пустом обходе.
+ */
+const SOURCE_ROOTS = CONFIG.sourceRoots;
+/**
+ * `gen` и `generated` — контракт и клиент Prisma: их объявления и есть источник, с
+ * которым сверяются остальные. Считать их копией значит требовать правки того, что
+ * пересобирается генератором.
+ */
+const SKIPPED_DIRS = CONFIG.skippedDirs;
+/** Минимум членов, при котором совпадение набора перечислений о чём-то говорит */
+const MIN_ENUM_MEMBERS = 2;
+
+const allowlist = JSON.parse(readFileSync(join(ROOT, ALLOWLIST), 'utf8'));
+const known = new Set([...(allowlist.accepted ?? []), ...(allowlist.debt ?? [])]);
+const debt = new Set(allowlist.debt ?? []);
+
+function collectFiles(dir) {
+    const files = [];
+    for (const entry of readdirSync(join(ROOT, dir), { withFileTypes: true })) {
+        if (SKIPPED_DIRS.includes(entry.name)) {
+            continue;
+        }
+        const path = `${dir}/${entry.name}`;
+        if (entry.isDirectory()) {
+            files.push(...collectFiles(path));
+        } else if (entry.name.endsWith('.ts') && !entry.name.endsWith('.spec.ts')) {
+            files.push(path);
+        }
+    }
+    return files;
+}
+
+/** Корень либы: путь до каталога `src`. Повтор внутри одной либы повтором не считается */
+function libOf(path) {
+    const parts = path.split('/');
+    const at = parts.indexOf('src');
+    return at === -1 ? path : parts.slice(0, at).join('/');
+}
+
+const EXPORT_RE = /^export (?:const|function|interface|enum|type|class|abstract class) (\w+)/gm;
+const ENUM_RE = /export (?:declare )?enum (\w+)\s*\{([^}]*)\}/g;
+const MEMBER_RE = /(\w+)\s*=/g;
+/**
+ * Настройка-число: имя в верхнем регистре и значение из одних чисел — предел,
+ * размер, длительность. Строки и таблицы соответствий сюда не подпадают
+ * намеренно: `LOG_CONTEXT` объявлен в восьми либах, и у каждой он свой по смыслу,
+ * а совпадение имени числа означает совпадение понятия.
+ */
+const SETTING_RE = /^(?:export )?const ([A-Z][A-Z0-9_]*)\s*(?::\s*number\s*)?=\s*\d[\d\s*+\-/_.]*;/gm;
+/**
+ * Настройка-строка и настройка-список. Сверяются по значению, а не по имени: одно имя
+ * значит здесь разное — `BEM_BLOCK` объявлен в тридцати шести либах, `LOG_CONTEXT` в
+ * десяти, и у каждой либы своё. Одинаковое значение под разными именами — наоборот,
+ * почти всегда одно понятие, записанное дважды: имя события правки, код отказа о повторе,
+ * набор принимаемых типов вложений.
+ */
+const STRING_SETTING_RE =
+    /^(?:export )?const ([A-Z][A-Z0-9_]*)\s*(?::[^=]*)?=\s*('[^']*'|"[^"]*"|`[^`]*`|\[[^\]]*\])\s*(?:as const\s*)?;/gm;
+/** Таблица соответствий: перевод статуса в контракт, колонки в поля сортировки, ключи подписей */
+const TABLE_RE = /^(?:export )?const ([A-Z][A-Z0-9_]*)\s*(?::[^=]*)?=\s*\{([^}]*?)\}\s*(?:as const\s*)?;/gms;
+const PAIR_RE = /([\w'"[\].]+)\s*:\s*([^,\n]+)/g;
+/**
+ * Значение короче этого о совпадении понятий не говорит: пустая строка, дефис и `id`
+ * совпадают у всех подряд.
+ */
+const MIN_VALUE_LENGTH = 4;
+/** Минимум пар, при котором совпадение таблиц о чём-то говорит */
+const MIN_TABLE_PAIRS = 2;
+
+/**
+ * Пакеты, чьи наборы считаются наравне с либами. Своё перечисление под уже
+ * объявленный там набор — такая же копия, как и между двумя либами.
+ */
+const EXTERNAL_ENUM_SOURCES = ['node_modules/@rt-tools/utils/esm/lib/interfaces'];
+
+const exportsByName = new Map();
+const settingsByName = new Map();
+const enums = [];
+/** Строковые настройки и списки под ключом значения: `значение → [{ имя, либа }]` */
+const namesByValue = new Map();
+/** Таблицы соответствий: набор пар под ключом, имя и либа рядом */
+const tables = [];
+
+/** Значение без кавычек и пробелов; список — отсортированным набором членов */
+function valueOf(raw) {
+    if (raw.startsWith('[')) {
+        const items = [...raw.matchAll(/'([^']*)'|"([^"]*)"|`([^`]*)`/g)].map((item) => item[1] ?? item[2] ?? item[3]);
+
+        return items.length > 0 ? `[${[...items].sort().join('|')}]` : '';
+    }
+
+    return raw.slice(1, -1).trim();
+}
+
+function collectEnums(text, lib) {
+    for (const match of text.matchAll(ENUM_RE)) {
+        const members = [...match[2].matchAll(MEMBER_RE)].map((member) => member[1].toLowerCase().replaceAll('_', ''));
+        enums.push({ name: match[1], lib, members: new Set(members) });
+    }
+}
+
+for (const path of SOURCE_ROOTS.flatMap((root) => collectFiles(root))) {
+    const text = readFileSync(join(ROOT, path), 'utf8');
+    const lib = libOf(path);
+
+    for (const match of text.matchAll(EXPORT_RE)) {
+        const name = match[1];
+        if (!exportsByName.has(name)) {
+            exportsByName.set(name, new Set());
+        }
+        exportsByName.get(name).add(lib);
+    }
+
+    for (const match of text.matchAll(SETTING_RE)) {
+        const name = match[1];
+        if (!settingsByName.has(name)) {
+            settingsByName.set(name, new Set());
+        }
+        settingsByName.get(name).add(lib);
+    }
+
+    for (const [, name, raw] of text.matchAll(STRING_SETTING_RE)) {
+        const value = valueOf(raw);
+        if (value.length < MIN_VALUE_LENGTH) {
+            continue;
+        }
+        if (!namesByValue.has(value)) {
+            namesByValue.set(value, []);
+        }
+        namesByValue.get(value).push({ name, lib });
+    }
+
+    for (const [, name, body] of text.matchAll(TABLE_RE)) {
+        const pairs = [...body.matchAll(PAIR_RE)].map(
+            ([, key, value]) => `${key.replaceAll(/['"[\]]/g, '')}:${value.trim().replace(/,$/, '')}`
+        );
+        if (pairs.length >= MIN_TABLE_PAIRS) {
+            tables.push({ name, lib, pairs: [...pairs].sort().join('|') });
+        }
+    }
+
+    collectEnums(text, lib);
+}
+
+for (const dir of EXTERNAL_ENUM_SOURCES) {
+    for (const entry of readdirSync(join(ROOT, dir), { withFileTypes: true })) {
+        if (entry.isFile() && entry.name.endsWith('.d.ts')) {
+            collectEnums(readFileSync(join(ROOT, dir, entry.name), 'utf8'), dir.replace('node_modules/', ''));
+        }
+    }
+}
+
+const findings = [];
+
+for (const [name, libs] of [...exportsByName.entries()].sort()) {
+    if (libs.size < 2) {
+        continue;
+    }
+    const where = [...libs].sort().join(', ');
+    findings.push({ key: `export ${name} @ ${where}`, text: `${name} экспортируется из ${libs.size} либ: ${where}` });
+}
+
+for (const [name, libs] of [...settingsByName.entries()].sort()) {
+    if (libs.size < 2) {
+        continue;
+    }
+    const where = [...libs].sort().join(', ');
+    findings.push({ key: `setting ${name} @ ${where}`, text: `${name} объявлена в ${libs.size} либах: ${where}` });
+}
+
+for (const [value, places] of [...namesByValue.entries()].sort()) {
+    const libs = new Set(places.map((place) => place.lib));
+    if (libs.size < 2) {
+        continue;
+    }
+    const where = places
+        .map((place) => `${place.name} @ ${place.lib}`)
+        .sort()
+        .join(' ~ ');
+    findings.push({ key: `value ${value} @ ${where}`, text: `значение ${value} объявлено в ${libs.size} либах: ${where}` });
+}
+
+for (let i = 0; i < tables.length; i++) {
+    for (let j = i + 1; j < tables.length; j++) {
+        const [first, second] = [tables[i], tables[j]];
+        if (first.lib === second.lib || first.pairs !== second.pairs) {
+            continue;
+        }
+        const key = `table ${[`${first.name} @ ${first.lib}`, `${second.name} @ ${second.lib}`].sort().join(' ~ ')}`;
+        findings.push({ key, text: `${first.name} (${first.lib}) и ${second.name} (${second.lib}) — одна таблица соответствий` });
+    }
+}
+
+const sameMembers = (first, second) =>
+    first.size === second.size && first.size >= MIN_ENUM_MEMBERS && [...first].every((member) => second.has(member));
+
+for (let i = 0; i < enums.length; i++) {
+    for (let j = i + 1; j < enums.length; j++) {
+        const [first, second] = [enums[i], enums[j]];
+        if (first.lib === second.lib || first.name === second.name || !sameMembers(first.members, second.members)) {
+            continue;
+        }
+        const key = `enum ${[`${first.name} @ ${first.lib}`, `${second.name} @ ${second.lib}`].sort().join(' ~ ')}`;
+        findings.push({
+            key,
+            text: `${first.name} (${first.lib}) и ${second.name} (${second.lib}) — один набор членов: ${[...first.members].sort().join(', ')}`,
+        });
+    }
+}
+
+const fresh = findings.filter((finding) => !known.has(finding.key));
+const staleKeys = [...known].filter((key) => !findings.some((finding) => finding.key === key));
+
+if (process.argv.includes('--baseline')) {
+    const keys = findings.map((finding) => finding.key).sort();
+    console.log(JSON.stringify({ ...allowlist, debt: keys }, null, 4));
+    process.exit(0);
+}
+
+const problems = [
+    ...fresh.map((finding) => finding.text),
+    ...staleKeys.map((key) => `${key}: значится в ${ALLOWLIST}, но повтора больше нет — строку убрать`),
+];
+
+if (problems.length > 0) {
+    console.error(`check-dupes: расхождений ${problems.length}\n`);
+    problems.forEach((problem) => console.error(`  ${problem}`));
+    process.exit(1);
+}
+
+console.log(`check-dupes: повторов ${findings.length}, из них принято ${findings.length - debt.size}, долг ${debt.size} — новых нет`);