@7n/rules 1.0.0

package/rules/release/release.mjs

@@ -0,0 +1,220 @@
+/**
+ * `n-rules release` — агрегує per-workspace change-файли у version-bump + CHANGELOG,
+ * комітить, ставить тег `<name>@<version>`, видаляє use-up change-файли. Запускається
+ * у CI на `main` (n-rules-release-design, варіант A). Сам нічого не публікує.
+ */
+import { existsSync } from 'node:fs'
+import { readFile, rm, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { env } from 'node:process'
+
+import { getMonorepoProjectRootDirs, readPackageManifest } from '../changelog/lib/package-manifest.mjs'
+import { aggregateWorkspace, prependChangelogSection } from './lib/aggregate.mjs'
+import { CHANGES_DIR, readChangeFiles } from './lib/change-file.mjs'
+import { defaultRunGit, synthesizeChangeFromCommits } from './lib/fallback.mjs'
+
+const SEMVER_LINE_RE = /("version"\s*:\s*")[^"]*(")/
+const PY_VERSION_LINE_RE = /^(version\s*=\s*")[^"]*(")/m
+
+/**
+ * Записує нову version у маніфест, зберігаючи форматування файлу.
+ * @param {string} cwd корінь
+ * @param {import('../changelog/lib/package-manifest.mjs').PackageManifest} manifest маніфест
+ * @param {string} newVersion нова версія
+ * @returns {Promise<void>} результат
+ */
+async function writeManifestVersion(cwd, manifest, newVersion) {
+  const path = join(cwd, manifest.ws === '.' ? manifest.manifestRel : `${manifest.ws}/${manifest.manifestRel}`)
+  const text = await readFile(path, 'utf8')
+  const re = manifest.kind === 'npm' ? SEMVER_LINE_RE : PY_VERSION_LINE_RE
+  const replaced = text.replace(re, (_match, p1, p2) => `${p1}${newVersion}${p2}`)
+  if (replaced === text) {
+    throw new Error(
+      `release: не вдалося оновити version у ${manifest.ws}/${manifest.manifestRel} — патерн version не знайдено`
+    )
+  }
+  await writeFile(path, replaced)
+}
+
+/**
+ * @param {string} cwd корінь
+ * @param {string} ws workspace
+ * @param {string} sectionBlock новий блок CHANGELOG
+ * @returns {Promise<void>} результат
+ */
+async function prependWorkspaceChangelog(cwd, ws, sectionBlock) {
+  const path = join(cwd, ws, 'CHANGELOG.md')
+  const existing = existsSync(path) ? await readFile(path, 'utf8') : ''
+  await writeFile(path, prependChangelogSection(existing, sectionBlock))
+}
+
+/**
+ * Зібрати change-файли workspace (явні + fallback-синтез, якщо явних нема, але є коміти).
+ * @param {string} cwd корінь
+ * @param {import('../changelog/lib/package-manifest.mjs').PackageManifest} manifest маніфест
+ * @param {(args: string[]) => Promise<string | null>} runGit git-раннер
+ * @returns {Promise<Array<{ file: string | null, entry: { bump: string, section: string, description: string } }>>} change-файли
+ */
+async function collectChangeFiles(cwd, manifest, runGit) {
+  const explicit = await readChangeFiles(manifest.ws, cwd)
+  if (explicit.length > 0) return explicit
+  if (!manifest.name) return []
+  const synthesized = await synthesizeChangeFromCommits(manifest.name, manifest.ws, { runGit })
+  if (!synthesized) return []
+  console.warn(`⚠️  ${manifest.ws}: немає change-файлів — синтезовано запис із комітів (fallback)`)
+  return [{ file: null, entry: synthesized }]
+}
+
+/**
+ * Пушить release-коміт (із тегами) у апстрім, переживаючи паралельні push у ту саму гілку.
+ * `runGit` — ТИХИЙ раннер (повертає null при помилці), тож non-fast-forward push не кидає, а
+ * повертає null; цей хелпер ЯВНО перевіряє результат, щоб реліз не «вдався» без приземленого
+ * commit-back (саме така мовчазна поразка лишала npm попереду git). За відмовою push:
+ * fetch + rebase release-коміту на свіжий апстрім, пересунути теги на новий HEAD і повторити
+ * (до `attempts` разів). Без апстріму або при rebase-конфлікті — кидаємо, а не маскуємо.
+ * @param {(args: string[]) => Promise<string | null>} runGit git-раннер
+ * @param {string[]} tags теги релізу (вже створені на поточному HEAD)
+ * @param {number} [attempts] максимум спроб push
+ * @returns {Promise<void>} результат; кидає, якщо push так і не приземлився
+ */
+async function pushReleaseWithRetry(runGit, tags, attempts = 5) {
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    const pushed = await runGit(['push', '--follow-tags'])
+    if (pushed !== null) return
+    if (attempt === attempts) break
+    // push відхилено (найімовірніше non-fast-forward — апстрім пішов уперед) → інтегруємо й пробуємо ще
+    const upstreamRaw = await runGit(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'])
+    const upstream = upstreamRaw?.trim()
+    if (!upstream) {
+      throw new Error('release: git push відхилено, а upstream для rebase немає — commit-back не приземлився')
+    }
+    const remote = upstream.includes('/') ? upstream.slice(0, upstream.indexOf('/')) : 'origin'
+    await runGit(['fetch', remote])
+    const rebased = await runGit(['rebase', upstream])
+    if (rebased === null) {
+      await runGit(['rebase', '--abort'])
+      throw new Error(`release: push відхилено і rebase на ${upstream} дав конфлікт — розв'яжи вручну`)
+    }
+    // після rebase хеш release-коміту змінився → пересуваємо АНОТОВАНІ теги на новий HEAD
+    // (force + annotated, бо --follow-tags несе лише анотовані теги, а HEAD уже інший)
+    for (const tag of tags) {
+      await runGit(['tag', '-f', '-a', tag, '-m', tag])
+    }
+  }
+  throw new Error(
+    `release: git push не вдався після ${attempts} спроб (non-fast-forward?) — commit-back не приземлився, реліз неуспішний`
+  )
+}
+
+/**
+ * Обробляє один workspace: агрегує зміни, бампає версію, дописує changelog, прибирає
+ * consumed-файли. Повертає запис релізу + tag (або null, якщо релізити нічого).
+ * @param {string} ws шлях workspace відносно cwd
+ * @param {string} cwd корінь монорепо
+ * @param {string} date `YYYY-MM-DD`
+ * @param {(args: string[]) => Promise<string | null>} runGit git-раннер
+ * @returns {Promise<{ entry: { ws: string, name: string | null, newVersion: string }, tag: string | null } | null>} результат або null
+ */
+async function processReleaseWorkspace(ws, cwd, date, runGit) {
+  const manifest = await readPackageManifest(ws, cwd)
+  if (!manifest || !manifest.version) return null
+
+  const changeFiles = await collectChangeFiles(cwd, manifest, runGit)
+  const agg = aggregateWorkspace({ currentVersion: manifest.version, changeFiles, date })
+  if (!agg) return null
+
+  await writeManifestVersion(cwd, manifest, agg.newVersion)
+  await prependWorkspaceChangelog(cwd, ws, agg.sectionBlock)
+  for (const file of agg.consumedFiles) {
+    if (!file) continue
+    await rm(join(cwd, ws, CHANGES_DIR, file))
+  }
+  return {
+    entry: { ws, name: manifest.name, newVersion: agg.newVersion },
+    tag: manifest.name ? `${manifest.name}@${agg.newVersion}` : null
+  }
+}
+
+/**
+ * Commit-back + анотовані теги + (опційно) push з ретраями для зрелізованих пакетів.
+ * @param {Array<{ ws: string, name: string | null, newVersion: string }>} released зрелізовані пакети
+ * @param {string[]} tags анотовані теги для push
+ * @param {(args: string[]) => Promise<string | null>} runGit git-раннер
+ * @param {boolean} push якщо `false` — лише commit+tag локально, без push (CI пушить сам після успішного publish)
+ * @returns {Promise<void>} завершення після (опційного) push
+ */
+async function commitAndPushRelease(released, tags, runGit, push) {
+  const subject = tags.length > 0 ? tags.join(', ') : released.map(r => `${r.ws}@${r.newVersion}`).join(', ')
+  await runGit(['add', '-A'])
+  const committed = await runGit(['commit', '-m', `release: ${subject}`])
+  if (committed === null) {
+    throw new Error('release: git commit не вдався — теги та push скасовано')
+  }
+  // АНОТОВАНІ теги (`-a -m`), бо `git push --follow-tags` доправляє на remote лише
+  // анотовані теги; легкі (`git tag <name>`) лишалися б локальними. `-m` обов'язкове
+  // в non-interactive CI, інакше git відкрив би редактор; повідомлення — сам `<name>@<version>`.
+  for (const tag of tags) {
+    await runGit(['tag', '-a', tag, '-m', tag])
+  }
+  if (push) await pushReleaseWithRetry(runGit, tags)
+}
+
+/**
+ * @param {object} [opts] опції
+ * @param {string} [opts.cwd] корінь
+ * @param {string} [opts.date] `YYYY-MM-DD` (за замовчуванням сьогодні)
+ * @param {(args: string[]) => Promise<string | null>} [opts.runGit] git-раннер
+ * @param {boolean} [opts.push] `false` — лише commit+tag локально, без push (типово `true`)
+ * @returns {Promise<Array<{ ws: string, name: string | null, newVersion: string }>>} зрелізовані пакети
+ */
+export async function release(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd()
+  const date = opts.date ?? new Date().toISOString().slice(0, 10)
+  const runGit = opts.runGit ?? defaultRunGit(cwd)
+  const push = opts.push ?? true
+
+  const workspaces = await getMonorepoProjectRootDirs(cwd)
+  const subWorkspaces = workspaces.filter(w => w !== '.')
+  const isMonorepoRoot = subWorkspaces.length > 0
+
+  /** @type {Array<{ ws: string, name: string | null, newVersion: string }>} */
+  const released = []
+  const tags = []
+
+  for (const ws of workspaces) {
+    if (ws === '.' && isMonorepoRoot) continue
+    const result = await processReleaseWorkspace(ws, cwd, date, runGit)
+    if (!result) continue
+    released.push(result.entry)
+    if (result.tag) tags.push(result.tag)
+  }
+
+  if (released.length > 0) {
+    await commitAndPushRelease(released, tags, runGit, push)
+  }
+  return released
+}
+
+/**
+ * @param {string[]} _args аргументи CLI (наразі без опцій)
+ * @param {import('./release.mjs').ReleaseOpts} [opts] опції для тестів (cwd, date, runGit, push)
+ * @returns {Promise<number>} exit-код
+ */
+export async function runReleaseCli(_args, opts = {}) {
+  try {
+    // env, не CLI-флаг: канонічний крок workflow `run: bunx n-rules release` (npm-module.mdc
+    // template-policy звіряє точний текст) лишається незмінним; deferred-push вмикається лише
+    // через `env:` на кроці — поле, якого немає в канонічному сніпеті, тож subset-перевірка не ламається.
+    const push = opts.push ?? (env.N_RULES_RELEASE_PUSH ?? env.N_CURSOR_RELEASE_PUSH) !== '0'
+    const released = await release({ ...opts, push })
+    if (released.length === 0) {
+      console.log('release: немає змін для релізу')
+    } else {
+      for (const r of released) console.log(`✅ ${r.name ?? r.ws}@${r.newVersion}`)
+    }
+    return 0
+  } catch (error) {
+    console.error(`❌ ${error instanceof Error ? error.message : String(error)}`)
+    return 1
+  }
+}

package/rules/rust/applies/concern.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json",
+  "lint": { "scope": "full", "glob": ["**/Cargo.toml"] }
+}

package/rules/rust/applies/docs/index.md

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

package/rules/rust/applies/docs/main.md

@@ -0,0 +1,30 @@
+---
+type: JS Module
+title: main.mjs
+resource: npm/rules/rust/applies/main.mjs
+docgen:
+  crc: 2d2dcbac
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  score: 100
+  issues: judge:inaccurate:0.97
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Функціональність визначає, чи підходить даний каталог для застосування правил. Публічна функція `applies` здійснює цей аналіз, тоді як функція `main` ініціює процес повної перевірки, звітуючи про результати застосування правил до каталогу. Сканування каталогу ігнорує системні та залежностні каталоги, такі як `.git` та `node_modules`, а також конфігураційний файл `Cargo.toml`.
+
+## Поведінка
+
+Поведінка:
+applies визначає, чи є правило застосовним до поточного каталогу, перевіряючи наявність файлу Cargo.toml або його присутності у підкаталогах, і свідомо ігнорує каталоги .git, node_modules та .next.
+main виконує логіку перевірки, ініціалізує репортер та інформує про застосування правил Rust, повертаючи код завершення.
+
+## Публічний API
+
+Будь ласка, надайте код або список елементів коду, які потрібно задокументувати.
+
+## Гарантії поведінки
+
+- Read-only: не виконує операцій запису (ФС/БД).
+- Свідомо пропускає шляхи: `.git`, `node_modules`.

package/rules/rust/applies/main.mjs

@@ -0,0 +1,28 @@
+/** @see ./docs/applies.md */
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { createViolationReporter } from '../../../scripts/lib/lint-surface/violation-reporter.mjs'
+
+import { hasCargoTomlInTree } from '../lib/has-cargo-toml.mjs'
+
+const IGNORED_DIR_NAMES = new Set(['node_modules', '.git', '.next', '.turbo'])
+
+/**
+ * @param {string} [cwd] корінь репозиторію
+ * @returns {Promise<boolean>} `true` — правило застосовне; `false` — пропустити
+ */
+export function applies(cwd = process.cwd()) {
+  if (existsSync(join(cwd, 'Cargo.toml'))) return Promise.resolve(true)
+  return Promise.resolve(hasCargoTomlInTree(cwd, IGNORED_DIR_NAMES))
+}
+
+/**
+ * @param {import('../../../scripts/lib/lint-surface/types.mjs').LintContext} ctx контекст лінту.
+ * @returns {Promise<import('../../../scripts/lib/lint-surface/types.mjs').LintResult>} результат context-pass
+ */
+export function lint(ctx) {
+  const reporter = createViolationReporter(ctx)
+  reporter.pass('Знайдено Cargo.toml — застосовуємо правила rust.mdc')
+  return Promise.resolve(reporter.result())
+}

package/rules/rust/check/concern.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json",
+  "lint": {
+    "scope": "full",
+    "glob": ["**/*.rs", "Cargo.toml", "Cargo.lock"]
+  }
+}

package/rules/rust/check/docs/fix-check.md

@@ -0,0 +1,30 @@
+---
+type: JS Module
+title: fix-check.mjs
+resource: npm/rules/rust/check/fix-check.mjs
+docgen:
+  crc: 02793a78
+---
+
+## Огляд
+
+T0-autofix для `rust/check`: детермінований `cargo fmt --all` (детектор ганяє його лише з
+`--check`) і канонічна генерація `deny.toml` через `cargo deny init`. Форматує Rust-код перед
+LLM-ладдером. clippy не автофіксимо (його `--fix` потенційно небезпечний) — ці порушення й
+далі йдуть у LLM-ladder. Запис незворотний. Відсутній `cargo`/`cargo-deny` → no-op.
+
+## Поведінка
+
+- Перелічує tracked \*.rs через git, застосовує `cargo fmt --all`. До списку змінених — лише
+  файли з фактичною зміною.
+- За наявності порушення `deny-config-missing` і встановленого `cargo-deny` викликає
+  `cargo deny init`, що створює канонічний `deny.toml` у корені проєкту.
+
+## Публічний API
+
+- `patterns` — `rust-cargo-fmt` спрацьовує на reason `cargo-fmt-violation`;
+  `rust-cargo-deny-init` спрацьовує на reason `deny-config-missing`.
+
+## Гарантії поведінки
+
+- Записуються лише фактично змінені/створені файли; кожен реєструється через `recordWrite`.

package/rules/rust/check/docs/index.md

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

package/rules/rust/check/docs/main.md

@@ -0,0 +1,37 @@
+---
+type: JS Module
+title: main.mjs
+resource: npm/rules/rust/check/main.mjs
+docgen:
+  crc: bdf1c005
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  score: 100
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Файл реалізує lint-поверхню для Rust, використовуючи команди `cargo fmt`, `clippy` та `deny` для автоматизованої перевірки та форматування коду в робочому каталозі. Поведінка супроводжується повідомленнями, описаними в `rust.mdc`.
+
+## Поведінка
+
+Поведінка:
+
+1. Якщо в робочому каталозі відсутній файл `Cargo.toml`, операція лінту для Rust пропускається.
+2. Якщо інструмент `cargo` не знайдено в системному PATH, операція лінту завершується з помилкою.
+3. Виконується форматування коду за допомогою `cargo fmt`. Якщо режим `readOnly` активовано, перевіряється лише відповідність формату; інакше, застосовується форматування.
+4. Якщо режим `readOnly` не активовано, запускається автоматичне виправлення стильових проблем за допомогою `cargo clippy --fix`.
+5. Після виправлення стилів, виконується перевірка на наявність попереджень за допомогою `cargo clippy -D warnings`.
+6. Перевіряється наявність файлу `deny.toml`.
+7. Якщо `deny.toml` відсутній і режим `readOnly` активовано, фіксується помилка, вказуючи на необхідність ручного запуску для його генерації (rust.mdc).
+8. Якщо `deny.toml` відсутній і режим `readOnly` не активовано, він створюється з дефолтним списком дозволених ліцензій.
+9. Якщо `deny.toml` присутній і інструмент `cargo deny` встановлений, виконується перевірка ліцензій за допомогою `cargo deny check licenses`.
+10. Якщо інструмент `cargo deny` не встановлений, перевірка ліцензій пропускається.
+
+## Публічний API
+
+lint — забезпечує відповідність коду специфічним стандартам поверхні Rust.
+
+## Гарантії поведінки
+
+- (специфічних машинно-виведених гарантій немає)

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

@@ -0,0 +1,79 @@
+/** @see ./docs/fix-check.md */
+
+/**
+ * T0-autofix для `rust/check` — детермінований `cargo fmt --all`, що його read-only детектор
+ * виконує лише з `--check`, плюс канонічна генерація `deny.toml` через `cargo deny init`
+ * (`deny-config-missing`). clippy не автофіксимо (його `--fix` потенційно небезпечний) — ці
+ * порушення й далі йдуть у LLM-ladder. Запис permanent. Відсутній `cargo`/`cargo-deny` → no-op.
+ */
+import { spawnSync } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+
+import { resolveCmd } from '../../../scripts/utils/resolve-cmd.mjs'
+
+/**
+ * Вміст файлу або null, якщо не читається.
+ * @param {string} abs абсолютний шлях
+ * @returns {string|null} вміст або null
+ */
+function readOrNull(abs) {
+  try {
+    return readFileSync(abs, 'utf8')
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Tracked *.rs файли проєкту (через git).
+ * @param {string} cwd корінь
+ * @returns {string[]} posix-relative шляхи
+ */
+function listRsFiles(cwd) {
+  const r = spawnSync('git', ['ls-files', '-z', '--', '*.rs'], { cwd, encoding: 'utf8' })
+  if (r.status !== 0) return []
+  return (r.stdout ?? '').split('\0').filter(Boolean)
+}
+
+/** @type {import('../../../scripts/lib/lint-surface/types.mjs').T0Pattern[]} */
+export const patterns = [
+  {
+    id: 'rust-cargo-fmt',
+    standalone: true, // §8 Phase 2: apply самостійно перелічує *.rs (git ls-files), cargo fmt сам ре-аналізує
+    test: violations => violations.some(v => v.reason === 'cargo-fmt-violation'),
+    apply: (violations, ctx) => {
+      const cargo = resolveCmd('cargo')
+      if (!cargo) return { touchedFiles: [] }
+      const files = listRsFiles(ctx.cwd)
+      if (files.length === 0) return { touchedFiles: [] }
+
+      const abs = files.map(f => resolve(ctx.cwd, f))
+      const before = new Map(abs.map(a => [a, readOrNull(a)]))
+      spawnSync(cargo, ['fmt', '--all'], { cwd: ctx.cwd, encoding: 'utf8', shell: false })
+
+      const touchedFiles = abs.filter(a => readOrNull(a) !== before.get(a))
+      for (const a of touchedFiles) ctx.recordWrite?.(a)
+      return touchedFiles.length > 0
+        ? { touchedFiles, message: `cargo fmt: ${touchedFiles.length} файл(ів)` }
+        : { touchedFiles: [] }
+    }
+  },
+  {
+    id: 'rust-cargo-deny-init',
+    test: violations => violations.some(v => v.reason === 'deny-config-missing'),
+    apply: (violations, ctx) => {
+      const cargo = resolveCmd('cargo')
+      if (!cargo) return { touchedFiles: [] }
+      const hasDeny = spawnSync(cargo, ['deny', '--version'], { stdio: 'ignore', shell: false }).status === 0
+      if (!hasDeny) return { touchedFiles: [] }
+
+      const denyConfigPath = join(ctx.cwd, 'deny.toml')
+      spawnSync(cargo, ['deny', 'init'], { cwd: ctx.cwd, encoding: 'utf8', shell: false })
+      if (!existsSync(denyConfigPath)) return { touchedFiles: [] }
+
+      ctx.recordWrite?.(denyConfigPath)
+      return { touchedFiles: [denyConfigPath], message: 'cargo deny init: deny.toml' }
+    }
+  }
+]

package/rules/rust/check/main.mjs

@@ -0,0 +1,81 @@
+/**
+ * lint-поверхня rust: read-only detector (cargo fmt --check + clippy -D warnings +
+ * cargo deny check licenses). Генерація deny.toml — окремий T0-fix, не в detector-і.
+ */
+import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { createViolationReporter } from '../../../scripts/lib/lint-surface/violation-reporter.mjs'
+import { resolveCmd } from '../../../scripts/utils/resolve-cmd.mjs'
+
+/**
+ * @param {string} label назва кроку.
+ * @param {string} cargo шлях до бінарника cargo.
+ * @param {string[]} args аргументи cargo.
+ * @param {string} cwd робочий каталог.
+ * @param {(msg: string, reason: string) => void} fail колбек реєстрації порушення.
+ * @param {string} reason машиночитна причина порушення.
+ * @returns {boolean} true якщо OK
+ */
+function runCargo(label, cargo, args, cwd, fail, reason) {
+  const r = spawnSync(cargo, args, { cwd, encoding: 'utf8', shell: false })
+  if (r.status === 0) return true
+  const code = typeof r.status === 'number' ? r.status : 1
+  const out = `${r.stdout ?? ''}${r.stderr ?? ''}`.trim().slice(0, 2000)
+  const outTail = out ? `\n${out}` : ''
+  fail(`lint-rust: ${label} — помилка (код ${code}, rust.mdc)${outTail}`, reason)
+  return false
+}
+
+/**
+ * Detector rust/check (read-only).
+ * @param {import('../../../scripts/lib/lint-surface/types.mjs').LintContext} ctx контекст лінту.
+ * @returns {import('../../../scripts/lib/lint-surface/types.mjs').LintResult} результат із порушеннями
+ */
+export function lint(ctx) {
+  const reporter = createViolationReporter(ctx)
+  const { fail } = reporter
+  const cwd = ctx.cwd
+
+  if (!existsSync(join(cwd, 'Cargo.toml'))) {
+    // немає Cargo.toml → кроки Rust пропущено
+    return reporter.result()
+  }
+
+  const cargo = resolveCmd('cargo')
+  if (!cargo) {
+    fail('lint-rust: `cargo` не знайдено в PATH (Rust toolchain через rustup, rust.mdc)', 'cargo-missing')
+    return reporter.result()
+  }
+
+  if (!runCargo('cargo fmt --check', cargo, ['fmt', '--all', '--', '--check'], cwd, fail, 'cargo-fmt-violation')) {
+    return reporter.result()
+  }
+
+  runCargo(
+    'cargo clippy -D warnings',
+    cargo,
+    ['clippy', '--all-targets', '--all-features', '--', '-D', 'warnings'],
+    cwd,
+    fail,
+    'cargo-clippy-violation'
+  )
+
+  const denyConfigPath = join(cwd, 'deny.toml')
+  if (!existsSync(denyConfigPath)) {
+    fail(
+      'lint-rust: cargo deny — немає deny.toml; запустіть `npx @7n/rules fix rust` локально для генерації (rust.mdc)',
+      'deny-config-missing'
+    )
+    return reporter.result()
+  }
+
+  const hasDeny = spawnSync(cargo, ['deny', '--version'], { stdio: 'ignore', shell: false }).status === 0
+  if (hasDeny) {
+    runCargo('cargo deny check licenses', cargo, ['deny', 'check', 'licenses'], cwd, fail, 'cargo-deny-violation')
+  }
+  // cargo-deny не встановлено → перевірку ліцензій пропущено (старий код — pass)
+
+  return reporter.result()
+}

package/rules/rust/coverage/coverage.mdc

@@ -0,0 +1,28 @@
+## Покриття + мутаційне тестування Rust
+
+Покриття + мутаційне тестування Rust постачаються через `@7n/test coverage` (правило `test.mdc`). Реалізація провайдера — у `npm/rules/rust/coverage/coverage.mjs`: `cargo llvm-cov --json --summary-only` + `cargo mutants --jobs N`.
+
+Бінарники: `cargo install cargo-llvm-cov && cargo install cargo-mutants`.
+
+### Паралелізм cargo-mutants
+
+Паралельні воркери: дефолт `min(4, cpus/2)`; override через env **`CARGO_MUTANTS_JOBS`**. Прапорець `--in-place` відсутній — cargo-mutants створює власну sandbox-копію в `target/mutants.<i>/`, що сумісне з `--jobs > 1`.
+
+### Incremental mutation через `--in-diff`
+
+cargo-mutants **не** має persistent-кешу вердиктів між прогонами (на відміну від Stryker `incremental.json`). Штатний аналог «не передивляйся незмінений код» — scoping за git-diff. Вмикається env-змінною **`CARGO_MUTANTS_BASE_REF`**:
+
+- **не задано** (дефолт, типово для `main`) — повний прогін усіх мутантів;
+- задано (напр. `origin/main`, типово для feature-гілки в CI) — мутуються лише рядки, змінені у `<baseRef>...HEAD`. Провайдер бере `git diff --relative <baseRef>...HEAD` з каталогу crate, пише diff у sandbox і передає cargo-mutants `--in-diff`.
+
+Краєві випадки: порожній diff (немає змін під crate) → mutation `0/0` без запуску cargo-mutants; невідомий ref / не git-репо → попередження у stderr і fallback до повного прогону.
+
+### Пропуск baseline через `CARGO_MUTANTS_BASELINE=skip`
+
+cargo-mutants спершу ганяє немутований baseline (повний build+test), щоб переконатися, що suite зелений. **`CARGO_MUTANTS_BASELINE=skip`** прибирає цей крок (`--baseline skip`), економлячи один повний `cargo test`.
+
+Безпечно **лише** коли тести вже зелені у попередньому CI-степі (типовий порядок: `cargo test` → потім `@7n/test coverage` зі `skip`). Без цієї гарантії всі вердикти стають сміттєвими — дефолт: baseline-прогін. Найкорисніше в парі з `--in-diff`.
+
+### CI-кеш `target/` — множник
+
+`--in-diff` ріже **кількість** мутантів, кеш `target/` — **вартість кожної** компіляції; вони множаться. Без кешу холодний CI щоразу перебудовує всі залежності, і baseline-build (для Tauri — хвилини) затьмарює економію від меншої кількості мутантів. У workflow, що викликає `@7n/test coverage` для Rust, став `Swatinem/rust-cache@v2` після `dtolnay/rust-toolchain@stable` — вимога й автофікс тепер перевіряються загально (будь-який job, будь-який workflow) concern-ом `rust/toolchain_cache`.

package/rules/rust/docs/index.md

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