@7n/rules 1.0.0

package/rules/doc-files/docgen-scan/main.mjs

@@ -0,0 +1,231 @@
+/** @see ./docs/docgen-scan.md */
+import { join, dirname, basename, extname, relative, resolve, sep, posix } from 'node:path'
+import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import { execFileSync } from 'node:child_process'
+
+import { isDocgenIgnored } from '../docgen-ignore/main.mjs'
+import { parseDocFrontmatter, readDocCrc, staleness } from '../docgen-crc/main.mjs'
+
+/** Кодові розширення, для яких генеруємо документацію. */
+const SOURCE_EXTENSIONS = new Set(['.js', '.mjs', '.ts', '.vue', '.py', '.rs'])
+
+/** `*.test.*`, `*.spec.*` — тести, документувати не треба. */
+const TEST_FILE_RE = /\.(?:test|spec)\.[^.]+$/u
+
+/**
+ * Чи корінь має system-wide docs layout.
+ * Такий корінь зарезервований під репозиторні docs/adr, docs/explanation тощо,
+ * тому file-level docs у нього не пишемо.
+ * @param {string} root абсолютний корінь обходу
+ * @returns {boolean} true — корінь system-wide docs
+ */
+function isSystemWideDocsRoot(root) {
+  return existsSync(join(root, 'docs', 'adr')) || existsSync(join(root, 'docs', 'explanation'))
+}
+
+/**
+ * Чи є файл кодовим джерелом для документування.
+ * @param {string} fileName базове ім'я файлу
+ * @returns {boolean} true — документуємо; false — пропускаємо
+ */
+export function isSourceFile(fileName) {
+  if (fileName.endsWith('.d.ts')) return false
+  if (TEST_FILE_RE.test(fileName)) return false
+  return SOURCE_EXTENSIONS.has(extname(fileName))
+}
+
+/**
+ * Обчислює шлях md-документа для кодового файлу: тека `docs/` поряд із джерелом.
+ * Якщо `sourcePath` відносний, `docPath` теж відносний; якщо абсолютний — абсолютний.
+ * @param {string} sourcePath шлях до джерела (відносний або абсолютний)
+ * @returns {string} шлях до `<dir>/docs/<stem>.md` у тому ж просторі шляхів
+ */
+export function docPathForSource(sourcePath) {
+  const dir = dirname(sourcePath)
+  const stem = basename(sourcePath, extname(sourcePath))
+  return join(dir, 'docs', `${stem}.md`)
+}
+
+/**
+ * Чи кодовий файл `relPath` (posix, від кореня) підлягає документуванню:
+ * правильне розширення, не тест, не в ignore-дереві, не кореневий system-wide docs.
+ * @param {string} root абсолютний корінь
+ * @param {string} relPath posix-шлях файлу від кореня
+ * @returns {boolean} true — кандидат на доку
+ */
+export function isDocCandidate(root, relPath) {
+  const fileName = posix.basename(relPath)
+  if (!isSourceFile(fileName)) return false
+  if (isSystemWideDocsRoot(root) && posix.dirname(relPath) === '.') return false
+  return !isDocgenIgnored(relPath)
+}
+
+/**
+ * Описує один кодовий файл: шлях джерела, шлях доки, стан застарілості за CRC.
+ *
+ * `foreign: true` — docPath існує, але БЕЗ `docgen:`-CRC у frontmatter: рукописна
+ * (людська) дока. Така дока вважається чинною документацією файлу (`stale: false`) —
+ * генерація її мовчки не перезаписує (перезапис лише explicit `--overwrite`, який
+ * бере всі цілі без фільтра). Живий кейс: `npm/docs/index.md` — людський зміст модуля
+ * у проєкті-споживачі; сканер бачив його як `missing` і затирав чат-філером моделі.
+ * @param {string} root абсолютний корінь
+ * @param {string} sourcePath posix-шлях джерела від кореня
+ * @returns {{sourcePath:string, docPath:string, stale:boolean, reason:'missing'|'crc-mismatch'|null, foreign:boolean}} опис файлу
+ */
+export function describeFile(root, sourcePath) {
+  const docPath = docPathForSource(sourcePath)
+  const docAbsPath = join(root, docPath)
+  if (existsSync(docAbsPath) && readDocCrc(docAbsPath) === null) {
+    return { sourcePath, docPath, stale: false, reason: null, foreign: true }
+  }
+  const { stale, reason } = staleness(join(root, sourcePath), docAbsPath)
+  return { sourcePath, docPath, stale, reason, foreign: false }
+}
+
+/**
+ * Знаходить "сирітські" доки: `docs/<stem>.md` із `resource:` + `docgen.crc` у frontmatter,
+ * у яких відповідний source-файл (resource:) вже не існує. Перевіряє лише файли,
+ * згенеровані `fix-doc-files` (наявність `docgen.crc` у frontmatter). Directory Index
+ * (resource із `/` на кінці) та ручні доки без `resource:` або без CRC — ігноруються.
+ * @param {string} root абсолютний корінь обходу
+ * @returns {string[]} posix-шляхи сирітських doc-файлів від кореня
+ */
+export function scanOrphanedDocs(root) {
+  const orphans = []
+
+  /** @param {string} docsAbsDir абсолютний шлях docs/-директорії */
+  function scanDocsDir(docsAbsDir) {
+    let entries
+    try {
+      entries = readdirSync(docsAbsDir, { withFileTypes: true })
+    } catch {
+      return
+    }
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith('.md')) continue
+      const fullPath = join(docsAbsDir, entry.name)
+      let content
+      try {
+        content = readFileSync(fullPath, 'utf8')
+      } catch {
+        continue
+      }
+      const { data } = parseDocFrontmatter(content)
+      // Пропускаємо: Directory Index (resource з `/`), ручні доки (немає resource або CRC)
+      if (!data?.source || data.source.endsWith('/') || !data.crc) continue
+      if (!existsSync(join(root, data.source))) {
+        orphans.push(relative(root, fullPath).split(sep).join('/'))
+      }
+    }
+  }
+
+  /**
+   * Обходить дерево, шукаючи docs/-директорії для orphan-перевірки.
+   *  docs/ — входимо завжди (батьківська пройшла ignore-перевірку);
+   *  інші — перевіряємо через isDocgenIgnored.
+   * @param {string} dir абсолютний шлях директорії для обходу.
+   */
+  function walk(dir) {
+    let entries
+    try {
+      entries = readdirSync(dir, { withFileTypes: true })
+    } catch {
+      return
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+      const fullPath = join(dir, entry.name)
+      if (entry.name === 'docs') {
+        scanDocsDir(fullPath)
+      } else {
+        const relPath = relative(root, fullPath).split(sep).join('/')
+        if (isDocgenIgnored(relPath, 'dir')) continue
+        walk(fullPath)
+      }
+    }
+  }
+
+  walk(root)
+  return orphans
+}
+
+/**
+ * Підмножина шляхів, які git вважає ігнорованими (`.gitignore` + global excludes).
+ * Один батч-виклик `git check-ignore --stdin`. Tracked-файли git не репортить як
+ * ігноровані (тож `euscp.js` лишається кандидатом). Поза git-репо / коли жоден не
+ * ігнорується — порожній набір (graceful: фільтр просто не застосовується).
+ * @param {string} root абсолютний корінь (cwd для git)
+ * @param {string[]} relPaths posix-шляхи від кореня
+ * @returns {Set<string>} підмножина ігнорованих relPaths
+ */
+function gitIgnoredPaths(root, relPaths) {
+  if (relPaths.length === 0) return new Set()
+  try {
+    const out = execFileSync('git', ['check-ignore', '--stdin'], {
+      cwd: root,
+      input: relPaths.join('\n'),
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'ignore'] // git пише «not a git repository» у stderr — глушимо
+    })
+    return new Set(
+      out
+        .split('\n')
+        .map(s => s.trim())
+        .filter(Boolean)
+    )
+  } catch {
+    // exit 1 (жоден не ігнорується) і 128 (не git-репо) → execFileSync кидає; обидва = «не фільтруємо».
+    return new Set()
+  }
+}
+
+/**
+ * Рекурсивно обходить дерево від `root`, повертає кодові файли зі станом застарілості.
+ * Синхронний `readdirSync` — детермінований порядок без гонок; обсяг дерева це дозволяє.
+ * Поверх `DOCGEN_IGNORE_GLOBS` відсіює ще й те, що в `.gitignore` (через git check-ignore).
+ * @param {string} root абсолютний корінь обходу
+ * @returns {Array<{sourcePath:string, docPath:string, stale:boolean, reason:'missing'|'crc-mismatch'|null}>} кандидати з відносними шляхами
+ */
+export function scanForDocFiles(root) {
+  const results = []
+
+  /** @param {string} dir поточний каталог обходу */
+  function walk(dir) {
+    let entries
+    try {
+      entries = readdirSync(dir, { withFileTypes: true })
+    } catch {
+      return
+    }
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name)
+      const relPath = relative(root, fullPath)
+      if (entry.isDirectory()) {
+        if (isDocgenIgnored(relPath, 'dir')) continue
+        walk(fullPath)
+      } else if (entry.isFile() && isSourceFile(entry.name)) {
+        if (isSystemWideDocsRoot(root) && dirname(relPath) === '.') continue
+        const sourcePath = relPath.split(sep).join('/')
+        if (isDocgenIgnored(sourcePath)) continue
+        results.push(describeFile(root, sourcePath))
+      }
+    }
+  }
+
+  walk(root)
+  const ignored = gitIgnoredPaths(
+    root,
+    results.map(r => r.sourcePath)
+  )
+  return ignored.size ? results.filter(r => !ignored.has(r.sourcePath)) : results
+}
+
+/**
+ * Парсить `--root <dir>` з argv; default — cwd.
+ * @param {string[]} argv аргументи після підкоманди
+ * @returns {string} абсолютний корінь
+ */
+export function resolveRoot(argv) {
+  const i = argv.indexOf('--root')
+  return i !== -1 && argv[i + 1] ? resolve(argv[i + 1]) : process.cwd()
+}

package/rules/doc-files/docs/index.md

@@ -0,0 +1,11 @@
+---
+type: Directory Index
+title: npm/rules/doc-files
+resource: npm/rules/doc-files/
+---
+
+# npm/rules/doc-files
+
+| Файл                | Тип       |
+| ------------------- | --------- |
+| [main.mjs](main.md) | JS Module |

package/rules/doc-files/main.json

@@ -0,0 +1 @@
+{ "auto": "завжди" }

package/rules/doc-files/main.mdc

@@ -0,0 +1,49 @@
+---
+description: Файлова документація — обовʼязковий крок задачі (як lint); unified lint surface, concern doc-files/check — детект застарілості за CRC джерела + fix-by-default генерація local-only конвеєром (omlx)
+globs: "**/*.{js,mjs,ts,vue,py,rs},**/docs/**"
+alwaysApply: true
+version: '2.0'
+---
+
+Кожен кодовий файл (`.js .mjs .ts .vue .py .rs`, крім тестів і `.d.ts`) має **актуальну**
+файлову доку поряд: `<dir>/docs/<stem>.md`. Це **обовʼязковий крок кожної задачі**, нарівні
+з lint. Актуальність детермінується за **CRC** джерела, записаним у frontmatter доки.
+
+## Одна команда — unified lint surface
+
+Як і решта правил проєкту (`.cursor/rules/scripts.mdc`, секція «Діагностика»), doc-files —
+concern `doc-files/check` у unified lint surface: **одна** команда, fix-by-default.
+
+- **`npx @7n/rules lint doc-files`** — детект **і одразу fix**: T0 (детермінований
+  CRC-stamp для `crc-mismatch`) → LLM-worker (генерація для `missing`/degraded, local-only
+  конвеєр omlx) → purge сирітських док.
+- **`npx @7n/rules lint doc-files --no-fix`** — лише детект, **0 викликів LLM**, без
+  мутацій. Це форма для CI-гейта й hook'ів.
+
+Окремих команд `lint-doc-files` / `fix-doc-files` **немає** — вони існували до міграції на
+unified lint surface (spec `docs/specs/2026-06-29-unified-lint-surface.md`) і видалені.
+
+## Stale = `missing` ∪ `crc-mismatch`
+
+Дока застаріла, якщо її **немає** (`missing`) або `crc(джерело) ≠ crc` у frontmatter
+(`crc-mismatch`). Це і є `violations`, які повертає `lint(ctx)` концерну.
+
+Алгоритм детекту (кандидати, ignore-дерево, CRC, реверс-мапінг доки→джерело) — у
+`docgen-scan/main.mjs` / `docgen-crc/main.mjs` / `docgen-ignore/main.mjs`, детектор — у
+`check/main.mjs` (`lint(ctx)`), fix — у `check/fix-check.mjs` (T0) і `check/fix-worker.mjs`
+(LLM); тут — лише людинозрозумілий контракт, без дублювання логіки.
+
+## Hook'и
+
+PostToolUse (`hook --post-tool-use` → `detectAll` для зміненого файлу) **сигналить** про
+дрейф одразу після правки кодового файлу; Stop-гейт (`hook --stop` → `detectAll` по `git diff`
+HEAD) **блокує завершення** задачі за наявності застарілих док. Обидва — read-only детект,
+без fix. Ручна регенерація — `npx @7n/rules lint doc-files` (fix-by-default) або скіл
+`/n-doc-files`. Агрегуюча дока (module-summary, доменні) — окремий скіл `/doc-aggregate`.
+
+## Серіалізація
+
+Як і решта unified lint surface — через спільний `withGlobalLintLock`/`ProgressReporter`
+(`.cursor/rules/scripts.mdc`, секції «Серіалізація важких CLI-команд» і «Прогрес довгих
+lint/fix-прогонів»). Окремого локу для doc-files немає — це один concern серед інших, що
+проходять через `npx @7n/rules lint`.

package/rules/doc-files/units/concern.json

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

package/rules/doc-files/units/docs/main.md

@@ -0,0 +1,32 @@
+---
+type: JS Module
+title: main.mjs
+resource: npm/rules/doc-files/units/main.mjs
+docgen:
+  crc: b304d152
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  tier: local-min
+  score: 100
+  issues: judge:inaccurate:0.98
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Цей файл забезпечує аналіз вмісту файлів різного мовного формату для вилучення інформації про юніти. Він обробляє вміст, визначаючи відповідний метод вилучення для JavaScript-подібних або Rust-файлів. Публічна функція `extractUnits` виконує механізм вилучення юнітних даних з коду.
+
+## Поведінка
+
+1. Метод `extractUnits` приймає вміст файлу та його відносний шлях.
+2. Визначається розширення файлу за його відносним шляхом.
+3. Якщо розширення відповідає JavaScript-подібним мовам (js, mjs, ts, jsx, tsx, cts, mts), викликається відповідна функція для вилучення юнітів на основі AST.
+4. Якщо розширення 'rs', викликається відповідна функція для вилучення юнітів шляхом парсингу за допомогою регулярних виразів та підрахунку блоків.
+5. Якщо розширення не підтримується або файл не може бути проаналізований, метод повертає null.
+
+## Публічний API
+
+- extractUnits — Витягує одиниці виміру, визначаючи метод аналізу на основі розширення файлу (від AST для JS/TS до простого пошуку для Vue/Py).
+
+## Гарантії поведінки
+
+- Read-only: не виконує операцій запису (ФС/БД).

package/rules/doc-files/units/main.mjs

@@ -0,0 +1,20 @@
+/** @see ./docs/units.md */
+
+import { extractUnitsJs } from '../units-js/main.mjs'
+import { extractUnitsRs } from '../units-rs/main.mjs'
+
+const JS_EXT = new Set(['js', 'mjs', 'ts', 'jsx', 'tsx', 'cts', 'mts'])
+
+/**
+ * Мовно-агностичний фасад юніт-шару. Диспатчить за розширенням:
+ * js/mjs/ts → oxc AST; rs → regex+brace-counting; vue/py → null (whole-file шлях).
+ * @param {string} src вміст файлу
+ * @param {string} relPath шлях файлу
+ * @returns {Array<object>|null} юніти або null, якщо мова ще не підтримана / файл не парситься
+ */
+export function extractUnits(src, relPath) {
+  const ext = (relPath.split('.').pop() || '').toLowerCase()
+  if (JS_EXT.has(ext)) return extractUnitsJs(src, relPath)
+  if (ext === 'rs') return extractUnitsRs(src, relPath)
+  return null
+}

package/rules/doc-files/units-js/concern.json

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

package/rules/doc-files/units-js/docs/main.md

@@ -0,0 +1,32 @@
+---
+type: JS Module
+title: main.mjs
+resource: npm/rules/doc-files/units-js/main.mjs
+docgen:
+  crc: 395188f4
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  score: 100
+  issues: judge:inaccurate:0.99
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Будь ласка, надайте секцію «overview», яку необхідно переписати.
+
+## Поведінка
+
+1. Функція extractUnitsJs аналізує вміст файлу, щоб виявити ідентифіковані юніти (функції, класи, const-функції).
+2. Вона визначає, які юніти є експортованими та обробляє їх для включення до списку.
+3. Для кожного знайденого юніту вона витягує відповідний опис з JSDoc, що передує його оголошенню.
+4. Зібрана інформація про юніт включає його назву, тип (функція, клас, const), прапор експорту, діапазон у вихідному коді та повний вихідний код.
+5. Система виявляє всі виклики інших юнітів у тілі коду кожного юніта.
+6. В результаті повертається список об'єктів, де кожен об'єкт описує один юніт, і в якому вказано лише посилання на інші виявлені юніти.
+
+## Публічний API
+
+extractUnitsJs — знаходить та витягує на верхньому рівні логічні блоки (функції/класи/константи) з файлів JavaScript/TypeScript, які є частиною юніт-шару. Включає інформацію про експорт та взаємодії з іншими юнітами.
+
+## Гарантії поведінки
+
+- Read-only: не виконує операцій запису (ФС/БД).

package/rules/doc-files/units-js/main.mjs

@@ -0,0 +1,141 @@
+/** @see ./docs/units-js.md */
+
+import { parseProgramOrNull, walkAstWithAncestors } from '../../../scripts/utils/ast-scan-utils.mjs'
+
+// JSDoc-блок, що стоїть впритул перед позицією (лише пробіли між ними).
+const JSDOC_BEFORE_RE = /\/\*\*(?:(?!\*\/)[\s\S])*\*\/\s*$/
+const JSDOC_OPEN_RE = /^\s*\/\*\*?/
+const JSDOC_CLOSE_RE = /\*\/\s*$/
+const STAR_PREFIX_RE = /^\s*\*?\s?/
+
+/**
+ * Очищає JSDoc від обрамлення `/** *​/` і `*`-префіксів.
+ * @param {string} raw сирий блок або порожній рядок
+ * @returns {string} текст опису без тегів-обрамлення
+ */
+function cleanDoc(raw) {
+  if (!raw) return ''
+  return raw
+    .replace(JSDOC_OPEN_RE, '')
+    .replace(JSDOC_CLOSE_RE, '')
+    .split('\n')
+    .map(l => l.replace(STAR_PREFIX_RE, '').trimEnd())
+    .join('\n')
+    .trim()
+}
+
+/**
+ * JSDoc, що передує позиції `start` у джерелі (або порожній рядок).
+ * @param {string} src вміст файлу
+ * @param {number} start зміщення початку декларації
+ * @returns {string} очищений опис
+ */
+function precedingDoc(src, start) {
+  const m = src.slice(0, start).match(JSDOC_BEFORE_RE)
+  return cleanDoc(m ? m[0] : '')
+}
+
+/**
+ * Імʼя функції, що викликається (проста Identifier або `obj.method`).
+ * @param {Record<string, unknown>} node CallExpression
+ * @returns {string|null} імʼя callee або null
+ */
+function calleeName(node) {
+  const c = node.callee
+  if (!c || typeof c !== 'object') return null
+  if (c.type === 'Identifier') return c.name
+  if (c.type === 'MemberExpression' && !c.computed && c.property?.type === 'Identifier') return c.property.name
+  return null
+}
+
+/**
+ * Множина імен, що викликаються у тілі вузла (сирі callee — фільтрація на ребра
+ * call-graph робиться у `extractUnitsJs` після збору всіх імен юнітів).
+ * @param {unknown} node AST-вузол юніта
+ * @returns {Set<string>} імена викликів
+ */
+function collectCalls(node) {
+  const names = new Set()
+  walkAstWithAncestors(node, [], n => {
+    if (n.type !== 'CallExpression') {
+      return
+    }
+
+    const name = calleeName(n)
+    if (name) names.add(name)
+  })
+  return names
+}
+
+/**
+ * Будує юніт із декларації, додає у `units`. Розпізнає function/class та
+ * const-функції (`const x = () => {}` / `function expression`).
+ * @param {Record<string, unknown>} decl декларація (function/class/variable)
+ * @param {boolean} exported чи експортується
+ * @param {number} docStart зміщення для пошуку JSDoc (зовнішній export-вузол)
+ * @param {string} src вміст файлу
+ * @param {Array<object>} units акумулятор
+ * @returns {void}
+ */
+function pushUnits(decl, exported, docStart, src, units) {
+  if (!decl || typeof decl !== 'object') return
+  const doc = precedingDoc(src, docStart)
+  if (decl.type === 'FunctionDeclaration' || decl.type === 'ClassDeclaration') {
+    const name = decl.id?.name
+    if (!name) return
+    units.push({
+      name,
+      kind: decl.type === 'ClassDeclaration' ? 'class' : 'function',
+      exported,
+      span: { start: decl.start, end: decl.end },
+      body: src.slice(decl.start, decl.end),
+      calls: collectCalls(decl),
+      doc
+    })
+    return
+  }
+  if (decl.type === 'VariableDeclaration') {
+    for (const d of decl.declarations ?? []) {
+      const init = d.init
+      const isFn = init && (init.type === 'ArrowFunctionExpression' || init.type === 'FunctionExpression')
+      if (!isFn || d.id?.type !== 'Identifier') continue
+      units.push({
+        name: d.id.name,
+        kind: 'const',
+        exported,
+        span: { start: init.start, end: init.end },
+        body: src.slice(init.start, init.end),
+        calls: collectCalls(init),
+        doc
+      })
+    }
+  }
+}
+
+/**
+ * Юніт-шар для js/mjs/ts: top-level функції/класи/const-функції з тілом, JSDoc,
+ * прапором експорту і ребрами call-graph (виклики ІНШИХ юнітів у тілі).
+ * @param {string} src вміст файлу
+ * @param {string} [relPath] шлях (для вибору мови oxc)
+ * @returns {Array<{name:string, kind:string, exported:boolean, span:{start:number,end:number}, body:string, calls:string[], doc:string}>|null} юніти або null, якщо файл не парситься
+ */
+export function extractUnitsJs(src, relPath = 'scan.ts') {
+  const program = parseProgramOrNull(src, relPath)
+  if (!program || !Array.isArray(program.body)) return null
+
+  const units = []
+  for (const node of program.body) {
+    const isExport =
+      (node.type === 'ExportNamedDeclaration' || node.type === 'ExportDefaultDeclaration') && node.declaration
+    if (isExport) {
+      pushUnits(node.declaration, true, node.start, src, units)
+    } else {
+      pushUnits(node, false, node.start, src, units)
+    }
+  }
+
+  // Ребра call-graph: лишаємо тільки виклики інших внутрішніх юнітів
+  const names = new Set(units.map(u => u.name))
+  for (const u of units) u.calls = [...u.calls].filter(n => names.has(n) && n !== u.name)
+  return units
+}

package/rules/doc-files/units-rs/concern.json

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

package/rules/doc-files/units-rs/docs/main.md

@@ -0,0 +1,36 @@
+---
+type: JS Module
+title: main.mjs
+resource: npm/rules/doc-files/units-rs/main.mjs
+docgen:
+  crc: 45adb1a4
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  score: 100
+  issues: judge:inaccurate:0.98
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Огляд:
+Цей файл відповідає за аналіз коду з метою вилучення інформації про публічно доступні елементи, зокрема, про структуру та методи. Він ідентифікує відображені елементи на підставі їхніх атрибутів або публічності, збираючи повні описи та тіла їхніх декларацій. Зокрема, функція `extractUnitsRs` забезпечує можливість автоматично генерувати технічну документацію, детально описуючи призначення кожного публічного елемента.
+
+## Поведінка
+
+Поведінка:
+
+1. Функція `extractUnitsRs` аналізує вміст файлу з кодом.
+2. Функція визначає всі визначені верхнерівневі та методи в блоках `impl`.
+3. Визначення відображеності (exported) елементів відбувається на основі атрибутів, таких як `tauri::command`, або якщо функція звичайного виклику є вказана як публічна.
+4. Для кожного знайденого елемента видобувається повний текстовий опис, що йде безпосередньо перед його декларацією.
+5. Для функції, структури, перерахування, трейту або типу видобувається повний вміст тіла декларації.
+6. Визначається, до якого блоку `impl` належить елемент, якщо він не є верхнерівневим.
+7. Для вилучених елементів ідентифікуються внутрішні виклики до інших юнітів у межах того ж файлу.
+
+## Публічний API
+
+extractUnitsRs — витягує основні та реалізовані методи з файлів Rust.
+
+## Гарантії поведінки
+
+- Read-only: не виконує операцій запису (ФС/БД).