@7n/rules 1.0.0

package/rules/rust/lib/docs/has-cargo-toml.md

@@ -0,0 +1,134 @@
+---
+type: JS Module
+title: has-cargo-toml.mjs
+resource: npm/rules/rust/lib/has-cargo-toml.mjs
+docgen:
+  crc: f55fc57e
+---
+
+Модуль `has-cargo-toml.mjs` — rule-local утиліта для правил Rust, що визначає наявність маніфесту Cargo (`Cargo.toml`) у дереві файлової системи, починаючи з заданого кореневого каталогу. Використовується як applies-walker на рівні правила: дозволяє правилу Rust динамічно вирішувати, чи варто застосовуватися до конкретного workspace/cwd, шукаючи `Cargo.toml` у поточному каталозі або в будь-якому з підкаталогів.
+
+Реалізація — синхронний рекурсивний обхід каталогів з раннім поверненням (`early return`) при першому ж знайденому `Cargo.toml`, без читання вмісту файлів. Імена директорій, у які заходити не треба (наприклад, `node_modules`, `.git`, `.next`, `.turbo`), передаються ззовні через `Set<string>` — модуль свідомо не містить власного списку, щоб список ігнорувань був єдиним з тим, що в `npm/scripts/auto-rules.mjs` (на рівні виклику).
+
+Утиліта навмисно тримається rule-local (у каталозі правила `rust/lib/`), оскільки на момент написання її єдиний споживач — правило `rust`. У документуючому коментарі модуля зазначено: якщо з'явиться другий споживач — утиліту слід підняти у спільний `npm/scripts/lib/`.
+
+## Експорти / API
+
+Модуль експортує одну іменовану функцію:
+
+- `hasCargoTomlInTree(root, ignoredDirNames)` — `function`, named export.
+
+Інших експортів (default, типів, констант) у модулі немає.
+
+## Функції
+
+### `hasCargoTomlInTree(root, ignoredDirNames)`
+
+**Сигнатура:**
+
+```js
+export function hasCargoTomlInTree(root: string, ignoredDirNames: Set<string>): boolean
+```
+
+**Параметри:**
+
+- `root` — `string`. Абсолютний шлях до кореневого каталогу, з якого починається пошук. Передається у внутрішню функцію `walk` як стартова точка обходу.
+- `ignoredDirNames` — `Set<string>`. Множина імен директорій (саме базових імен — не шляхів), у які НЕ слід заходити під час обходу. Перевірка виконується через `ignoredDirNames.has(entry.name)`. Типові значення, які формує викликова сторона: `'node_modules'`, `'.git'`, `'.next'`, `'.turbo'`.
+
+**Повертає:**
+
+- `boolean` — `true`, якщо в піддереві з коренем `root` (включно з самим `root`) знайдено хоча б один файл з ім'ям `Cargo.toml`. `false` — якщо такого файла немає, або якщо корінь недоступний для читання.
+
+**Алгоритм:**
+
+1. Викликається внутрішня функція `walk(root)`.
+2. Усередині `walk(dir)` робиться спроба отримати вміст каталогу через `readdirSync(dir, { withFileTypes: true })`, що повертає масив об'єктів `Dirent`.
+3. Якщо `readdirSync` кидає виключення (наприклад, `EACCES`, `ENOENT`, `ENOTDIR`) — воно мовчки ловиться `catch {}` і функція повертає `false` для цього каталогу (обхід продовжується для інших гілок, якщо вони є).
+4. Виконується ітерація по `entries`:
+   - Якщо запис — це файл і його ім'я дорівнює рівно `'Cargo.toml'`, негайно повертається `true` (early return).
+   - Якщо запис — це каталог і його ім'я не входить у `ignoredDirNames`, рекурсивно викликається `walk(join(dir, entry.name))`; при `true` від рекурсії — негайно повертається `true`.
+5. Якщо жоден запис не дав `true`, повертається `false`.
+
+Порядок обходу — детерміністичний у межах одного запуску і визначається порядком, який повертає `readdirSync` (як правило, залежить від ФС/ОС). Це означає, що логічний результат (boolean) детерміністичний, але швидкість виявлення `Cargo.toml` залежить від порядку записів.
+
+Алгоритм має властивість «depth-first з раннім return»: знайшовши `Cargo.toml` у першій же підгілці, функція не обходить решту дерева.
+
+**Side effects:**
+
+- Виключно синхронні I/O-операції читання вмісту директорій через `readdirSync` із Node.js `fs`. Не читає вміст файлів, не пише на диск, не звертається до мережі, не змінює глобальний стан.
+- При помилках доступу до окремого каталогу не пробрасує виключення назовні — глушить їх через `try/catch` і повертає `false` лише для проблемної гілки.
+- Блокує event loop на час обходу (синхронне API). Для дуже великих дерев це може бути помітним; ризик частково мітигує ранній return і список `ignoredDirNames`, що відсікає типові важкі директорії на кшталт `node_modules`.
+
+**Внутрішня функція `walk(dir)`:**
+
+- `dir` — `string`, абсолютний шлях каталогу для обходу.
+- Повертає `boolean` — `true`, якщо в піддереві `dir` є `Cargo.toml`.
+- Замикається на параметр `ignoredDirNames` зовнішньої функції (тобто множина передається один раз і використовується на всіх рівнях рекурсії без повторної параметризації).
+
+## Залежності
+
+Зовнішні npm-залежності — відсутні. Модуль працює виключно на стандартній бібліотеці Node.js:
+
+- `node:fs` — імпортується `readdirSync` для синхронного читання вмісту каталогу з опцією `withFileTypes: true`, що повертає `Dirent[]` (для уникнення додаткових `statSync` на кожен запис).
+- `node:path` — імпортується `join` для безпечного склеювання шляхів `dir + entry.name` із врахуванням розділювача ОС.
+
+Імпорти використовують префікс `node:` (`node:fs`, `node:path`) — це канонічна форма посилання на вбудовані модулі Node.js, що відрізняє їх від npm-пакунків.
+
+Модуль написаний як ES Module (`.mjs`): використовуються `import` та `export`.
+
+Внутрішніх залежностей від інших файлів проєкту немає — модуль повністю самодостатній.
+
+## Потік виконання / Використання
+
+### Контекст застосування
+
+Функція проектована як applies-walker для правил Rust: правило викликає її, щоб дізнатися, чи має воно сенс у поточному репозиторії/workspace. Якщо `Cargo.toml` ніде не знайдено — правило застосовувати не треба.
+
+### Типовий виклик
+
+```js
+import { hasCargoTomlInTree } from './lib/has-cargo-toml.mjs'
+
+const IGNORED = new Set(['node_modules', '.git', '.next', '.turbo'])
+
+if (hasCargoTomlInTree(process.cwd(), IGNORED)) {
+  // правило Rust застосовується: десь у дереві є Cargo.toml
+} else {
+  // Rust-проєкту не виявлено — правило пропускається
+}
+```
+
+Список ігнорованих директорій формується викликовою стороною й має співпадати зі списком, який використовує `npm/scripts/auto-rules.mjs` (це вимога з заголовного коментаря модуля — щоб поведінка обходу була узгоджена між скриптом авто-правил і rule-local утилітою).
+
+### Розгортання потоку виконання
+
+1. Споживач (правило Rust) формує `Set<string>` ігнорованих імен директорій.
+2. Споживач викликає `hasCargoTomlInTree(root, ignoredDirNames)` із кореневим шляхом (зазвичай — поточний workspace або репозиторій).
+3. Усередині функції стартує `walk(root)`:
+   - Якщо `root` сам містить `Cargo.toml` як файл першого рівня — повертається `true` без рекурсії далі по цьому ж рівню (інші записи не перевіряються після першого ж `Cargo.toml`).
+   - Якщо `Cargo.toml` на першому рівні немає — обхід заглиблюється у кожен підкаталог, якого немає в `ignoredDirNames`.
+   - Перший же `true` із рекурсії припиняє обхід і пробрасує `true` нагору.
+4. Якщо все дерево пройдене без знахідки — повертається `false`.
+5. Споживач використовує boolean-результат для прийняття рішення про застосування правила.
+
+### Граничні випадки
+
+- **Порожній `ignoredDirNames`** (`new Set()`): функція обходить геть усе дерево, включно з `node_modules` тощо — це коректно, але повільно.
+- **Неіснуючий `root`**: `readdirSync` кидає `ENOENT`, помилка ловиться, функція повертає `false`.
+- **`root` не є директорією** (наприклад, шлях до файлу): `readdirSync` кидає `ENOTDIR`, ловиться `catch`, повертається `false`.
+- **Cargo.toml як директорія**: пропускається, бо перевірка йде через `entry.isFile() && entry.name === 'Cargo.toml'` — потрібен саме файл.
+- **Симлінки**: `withFileTypes: true` повертає `Dirent` з власними методами; `entry.isFile()` для симлінка поверне `false`, `entry.isDirectory()` — теж `false` (метод `isSymbolicLink()` тут не перевіряється), тож симлінки фактично не переходяться. Це свідомий вибір — захист від циклів через симлінки.
+- **Cargo.toml у самому корені**: знаходиться на першому ж рівні без рекурсії.
+- **Cargo.toml виключно всередині `node_modules`** (за умови, що `node_modules` у `ignoredDirNames`): не знаходиться, функція повертає `false`. Це навмисна поведінка: ні правила, ні авто-обхід не повинні «бачити» вендоровані Rust-маніфести з npm-залежностей.
+
+### Контекст у проєкті
+
+Згідно з заголовним коментарем файлу:
+
+- Утиліта живе у `npm/rules/rust/lib/` як rule-local — лише `rust`-правило її використовує.
+- Список ігнорованих директорій має узгоджуватися зі списком у `npm/scripts/auto-rules.mjs`.
+- Інваріант масштабування: при появі другого споживача — підняти модуль у спільний `npm/scripts/lib/`.
+
+## Rebuild Test
+
+За цією документацією модуль можна відтворити: один ES-модуль з імпортами `readdirSync` із `node:fs` та `join` із `node:path`, що експортує іменовану функцію `hasCargoTomlInTree(root, ignoredDirNames)`. Усередині — внутрішня рекурсивна функція `walk(dir)` із синхронним `readdirSync(dir, { withFileTypes: true })`, обгорнутим у `try/catch`, ітерацією по `Dirent`-записах, перевіркою `isFile() && name === 'Cargo.toml'` для негайного `true`, та рекурсією у підкаталоги через `join(dir, entry.name)` за умови `isDirectory() && !ignoredDirNames.has(name)`. Поведінкові інваріанти: ранній return при знахідці; повернення `false` при помилці читання каталогу; пропуск ігнорованих директорій; обхід не йде у симлінки (бо `isDirectory()` для симлінка повертає `false`); жодних побічних ефектів окрім читання структури директорій. Сигнатура: `(string, Set<string>) => boolean`.

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

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

package/rules/rust/lib/has-cargo-toml.mjs

@@ -0,0 +1,37 @@
+/**
+ * Rule-level applies-walker правила rust: рекурсивно шукає Cargo.toml у
+ * cwd або будь-якому workspace-підкаталозі. Пропускає `node_modules`, `.git`,
+ * `.next`, `.turbo` за тим самим списком, що `npm/scripts/auto-rules.mjs`.
+ *
+ * Утиліта rule-local, бо лише `rust` потребує "знайти Cargo.toml у дереві";
+ * якщо з'явиться другий споживач — підняти у `npm/scripts/lib/`.
+ */
+import { readdirSync } from 'node:fs'
+import { join } from 'node:path'
+
+/**
+ * Чи присутній хоч один Cargo.toml у дереві `root` (синхронно, з раннім return).
+ * @param {string} root абсолютний шлях кореня
+ * @param {Set<string>} ignoredDirNames імена директорій, в які НЕ заходимо
+ * @returns {boolean} true, якщо знайдено Cargo.toml
+ */
+export function hasCargoTomlInTree(root, ignoredDirNames) {
+  /**
+   * @param {string} dir абсолютний шлях каталогу для обходу
+   * @returns {boolean} true якщо в піддереві є Cargo.toml
+   */
+  function walk(dir) {
+    let entries
+    try {
+      entries = readdirSync(dir, { withFileTypes: true })
+    } catch {
+      return false
+    }
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name === 'Cargo.toml') return true
+      if (entry.isDirectory() && !ignoredDirNames.has(entry.name) && walk(join(dir, entry.name))) return true
+    }
+    return false
+  }
+  return walk(root)
+}

package/rules/rust/lint_rust_yml/concern.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json",
+  "fixability": "config",
+  "policy": {
+    "files": {
+      "single": ".github/workflows/lint-rust.yml",
+      "required": true
+    },
+    "missingMessage": ".github/workflows/lint-rust.yml не існує — створи з канонічним вмістом (rust.mdc)"
+  }
+}

package/rules/rust/lint_rust_yml/lint_rust_yml.mdc

@@ -0,0 +1,17 @@
+## Перевірка `.github/workflows/lint-rust.yml`
+
+Rego-пакет: `rust.lint_rust_yml`
+
+Цільовий файл: `.github/workflows/lint-rust.yml`
+
+Перевіряє:
+
+- кожен `uses`-крок з канону присутній у workflow (підмножина): `actions/checkout@v6`, `dtolnay/rust-toolchain@stable`, `Swatinem/rust-cache@v2`
+- кожен `run`-крок з канону присутній як підрядок серед усіх `run`-кроків: `cargo fmt --all -- --check`, `cargo clippy --all-targets --all-features -- -D warnings`
+- канон завантажується через `--data` з template-сніпету — drift-safe: зміна шаблону автоматично рухає перевірку
+
+Канонічний template: [lint-rust.yml.snippet.yml](./template/lint-rust.yml.snippet.yml)
+
+Вимога `Swatinem/rust-cache@v2` після `dtolnay/rust-toolchain@…` тут перевіряється лише для цього конкретного файлу (як частина канону). Та сама вимога для **будь-якого** іншого workflow (coverage, release/build через `tauri-apps/tauri-action`, кастомні) — concern `rust/toolchain_cache`.
+
+Tauri-проєкти (`src-tauri/Cargo.toml`) додатково потребують у цьому файлі apt-кроку системних залежностей Linux перед Clippy — concern `tauri/linux_deps` (tauri.mdc), не частина канону тут.

package/rules/rust/lint_rust_yml/lint_rust_yml.rego

@@ -0,0 +1,79 @@
+# Перевірка `.github/workflows/lint-rust.yml` для правила rust (rust.mdc).
+#
+# Канон надходить через --data: { "template": { "snippet": ... } }
+# Структура --data сформована з template/lint-rust.yml.snippet.yml.
+# Перевіряємо:
+#   - кожен `uses` з template (підмножина): actions/checkout@v6,
+#     dtolnay/rust-toolchain@stable, Swatinem/rust-cache@v2;
+#   - кожен `run` з template має бути присутнім (як substring) серед
+#     run-кроків input'а — drift-safe: зміна template одразу рухає перевірку.
+# Універсальні workflow-перевірки (name, concurrency, branches) — у `ga.workflow_common`.
+package rust.lint_rust_yml
+
+import rego.v1
+
+# Усі `uses` з канону workflow.
+expected_uses contains u if {
+	some step in data.template.snippet.jobs.lint.steps
+	u := object.get(step, "uses", "")
+	u != ""
+}
+
+# Усі `uses` з input workflow.
+actual_uses contains u if {
+	some job in object.get(input, "jobs", {})
+	some step in object.get(job, "steps", [])
+	u := object.get(step, "uses", "")
+	u != ""
+}
+
+# Конкатенація всіх `run`-кроків з input workflow.
+all_run_text := concat("\n", [run_text |
+	some job in object.get(input, "jobs", {})
+	some step in object.get(job, "steps", [])
+	run_text := step_run_to_text(step)
+])
+
+# Крок dtolnay/rust-toolchain@stable має мати with.components з rustfmt і clippy.
+toolchain_step(step) if {
+	uses := object.get(step, "uses", "")
+	startswith(uses, "dtolnay/rust-toolchain@")
+}
+
+deny contains msg if {
+	some required_use in expected_uses
+	not required_use in actual_uses
+	msg := sprintf("lint-rust.yml: відсутній step з `uses: %s` (rust.mdc)", [required_use])
+}
+
+deny contains msg if {
+	some step in data.template.snippet.jobs.lint.steps
+	expected_run := object.get(step, "run", "")
+	expected_run != ""
+	not contains(all_run_text, expected_run)
+	msg := sprintf("lint-rust.yml: жоден крок run не містить %q (rust.mdc)", [expected_run])
+}
+
+deny contains msg if {
+	msg := "lint-rust.yml: dtolnay/rust-toolchain step потребує with.components: rustfmt, clippy (rust.mdc)"
+	some job in object.get(input, "jobs", {})
+	some step in object.get(job, "steps", [])
+	toolchain_step(step)
+	components := object.get(object.get(step, "with", {}), "components", "")
+	not contains(components, "rustfmt")
+}
+
+deny contains msg if {
+	msg := "lint-rust.yml: dtolnay/rust-toolchain step потребує with.components: rustfmt, clippy (rust.mdc)"
+	some job in object.get(input, "jobs", {})
+	some step in object.get(job, "steps", [])
+	toolchain_step(step)
+	components := object.get(object.get(step, "with", {}), "components", "")
+	not contains(components, "clippy")
+}
+
+step_run_to_text(step) := step.run if is_string(step.run)
+
+else := concat("\n", [s | some s in step.run]) if is_array(step.run)
+
+else := ""

package/rules/rust/lint_rust_yml/template/lint-rust.yml.snippet.yml

@@ -0,0 +1,44 @@
+name: Lint Rust
+
+on:
+  push:
+    branches:
+      - dev
+      - main
+    paths:
+      - '**/*.rs'
+      - '**/Cargo.toml'
+      - '**/Cargo.lock'
+      - '**/rustfmt.toml'
+      - '**/clippy.toml'
+
+  pull_request:
+    branches:
+      - dev
+      - main
+
+concurrency:
+  group: ${{ github.ref }}-${{ github.workflow }}
+  cancel-in-progress: true
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+
+      - uses: Swatinem/rust-cache@v2
+
+      - name: Rustfmt
+        run: cargo fmt --all -- --check
+
+      - name: Clippy
+        run: cargo clippy --all-targets --all-features -- -D warnings

package/rules/rust/main.json

@@ -0,0 +1 @@
+{ "auto": { "glob": ["**/Cargo.toml", "deny.toml"] } }

package/rules/rust/main.mdc

@@ -0,0 +1,8 @@
+---
+description: Перевірка Rust коду
+globs: "**/{Cargo.toml,Cargo.lock,rustfmt.toml,clippy.toml,.vscode/extensions.json,package.json},**/*.rs"
+alwaysApply: false
+version: '1.4'
+---
+
+Правило забезпечує форматування (rustfmt), лінт (clippy), CI workflow та покриття для Rust-проєктів.

package/rules/rust/package_json/concern.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json",
+  "fixability": "config",
+  "policy": {
+    "files": {
+      "single": "package.json",
+      "required": false
+    }
+  }
+}

package/rules/rust/package_json/package_json.mdc

@@ -0,0 +1,12 @@
+## Rego-gate: `cargo`, `rustfmt`, `clippy` заборонені у `package.json`
+
+Rego-пакет: `rust.package_json`
+
+Цільовий файл: `package.json`
+
+`cargo`, `rustfmt` і `clippy` — це частина **Rust toolchain**, а не npm-пакети. Вони **не додаються** у `dependencies`, `devDependencies` або `peerDependencies`. Встановлення:
+
+- **локально** — через `rustup` (`rustup component add rustfmt clippy`);
+- **у CI** — через крок `dtolnay/rust-toolchain@stable` із `with.components: rustfmt, clippy`.
+
+Gate видає deny, якщо `cargo`, `rustfmt` або `clippy` з'являється у будь-якій секції залежностей `package.json`.

package/rules/rust/package_json/package_json.rego

@@ -0,0 +1,20 @@
+# Перевірка `package.json` для Rust-проєктів (rust.mdc / lint.mdc).
+#
+# `cargo`, `rustfmt`, `clippy` — частина Rust toolchain (rustup), не npm-залежностей.
+# Вони мають бути у PATH через `rustup` локально або `dtolnay/rust-toolchain@stable` у CI.
+package rust.package_json
+
+import rego.v1
+
+banned_rust_tools := {"cargo", "rustfmt", "clippy"}
+
+deny contains msg if {
+	some field in {"dependencies", "devDependencies", "peerDependencies"}
+	deps := object.get(input, field, {})
+	some name, _ in deps
+	name in banned_rust_tools
+	msg := sprintf(
+		"package.json: %s.%s заборонений — Rust toolchain встановлюється через rustup / dtolnay/rust-toolchain@stable, не через npm (rust.mdc)",
+		[field, name],
+	)
+}

package/rules/rust/toolchain_cache/concern.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json",
+  "fixability": "config",
+  "lint": { "scope": "full", "glob": [".github/workflows/*.yml", ".github/workflows/*.yaml"] }
+}

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

@@ -0,0 +1,35 @@
+---
+type: JS Module
+title: fix-toolchain_cache.mjs
+resource: npm/rules/rust/toolchain_cache/fix-toolchain_cache.mjs
+docgen:
+  crc: ad42b3a8
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  score: 100
+  issues: judge:inaccurate:0.97
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Управляє логікою кешування `Swatinem/rust-cache@v2` у системі. Додає необхідні кроки кешування до робочих процесів через `insertRustCache` та `addCacheWorkspaces`. Визначає шаблони для застосування трансформерів до файлів з конфігураційними порушеннями, використовуючи `patterns`. Забезпечує механізм fail-safe, перехоплюючи помилки без викиду винятків.
+
+## Поведінка
+
+Поведінка:
+insertRustCache вставляє відсутній крок кешування `Swatinem/rust-cache@v2` після кроків, що використовують `dtolnay/rust-toolchain`, у робочих процесах, якщо це можливо.
+addCacheWorkspaces дописує конфігурацію `with: workspaces: <dir>` до існуючих кроків кешування `Swatinem/rust-cache@v2` у робочих процесах Tauri, якщо вони не містять цієї інформації.
+patterns надає визначення для автоматичного застосування трансформерів до файлів, що містять порушення конфігурації кешування, використовуючи логіку, визначену у файлі.
+
+## Публічний API
+
+insertRustCache — вставляє інструмент для кешування Rust-засобів одразу після кроку з інструментарієм Rust, якщо в цьому ж завдання немає кроку кешування.
+
+addCacheWorkspaces — додає вказування робочих просторів до кожного кроку кешування Tauri-завдання, де ця інформація відсутня.
+
+patterns — визначає шаблони, за якими застосовується логіка.
+
+## Гарантії поведінки
+
+- Перехоплює помилки і не пропускає винятків назовні (fail-safe).
+- Кешує результати в межах одного прогону.

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

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

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

@@ -0,0 +1,57 @@
+---
+type: JS Module
+title: main.mjs
+resource: npm/rules/rust/toolchain_cache/main.mjs
+docgen:
+  crc: bcb01136
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  score: 100
+  issues: judge:inaccurate:0.99
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Огляд
+Конструкція забезпечує перевірку у `.github/workflows/*.yml` того, що кожен job, що використовує `dtolnay/rust-toolchain@stable` для встановлення Rust toolchain, має подальший крок із кешуванням Rust за допомогою `Swatinem/rust-cache@v2`. Якщо job також виконує `tauri-apps/tauri-action` і `Cargo.toml` лежить у `src-tauri/`, кеш-крок повинен мати `with.workspaces` на цей каталог. Ця логіка контролюється згідно з принципами, описаними у (rust.mdc), використовуючи константи `MISSING_RUST_CACHE` та `MISSING_RUST_CACHE_WORKSPACES` для маркування відхилень.
+
+Поведінка
+MISSING_RUST_CACHE — константа-рядок, яка позначає відсутність необхідного кешування Rust toolchain.
+MISSING_RUST_CACHE_WORKSPACES — константа-рядок, що інформує про неправильну конфігурацію кешування для робочих просторів Rust.
+TOOLCHAIN_RE — визначення для ідентифікації кроків встановлення Rust toolchain.
+CACHE_RE — визначення для ідентифікації кроків, що використовують кешування Rust.
+scanToolchainSteps — аналізує вміст YAML-файлу workflow, виявляючи кроки встановлення toolchain та інформацію про кешування в межах одного job-а.
+tauriWorkspaceDir — визначає шлях до робочого простору Tauri, коли `Cargo.toml` не знаходиться в корені репозиторію.
+lint — сканує всі `.yml` та `.yaml` файли у каталозі `.github/workflows`, перевіряючи відповідність вимогам кешування.
+Інструмент працює лише з читанням конфігурацій (Read-only) та здійснює кешування інформації в межах поточного прогону.
+
+## Поведінка
+
+**Поведінка**
+MISSING_RUST_CACHE — константа, що позначає відсутність необхідного кешування Rust toolchain.
+MISSING_RUST_CACHE_WORKSPACES — константа, що позначає неправильну конфігурацію кешування для робочих просторів Rust.
+TOOLCHAIN_RE — регулярний вираз для ідентифікації кроків, що встановлюють Rust toolchain.
+CACHE_RE — регулярний вираз для ідентифікації кроків, що використовують кешування Rust.
+scanToolchainSteps — аналізує вміст YAML-файлу workflow, виявляючи кроки встановлення toolchain та інформацію про кешування в межах одного job-а.
+tauriWorkspaceDir — визначає шлях до робочого простору Tauri, якщо файл `Cargo.toml` не розташований у корені проєкту.
+lint — сканує всі `.yml` та `.yaml` файли в каталозі `.github/workflows`, перевіряючи, чи присутні необхідні кешування для кроків Rust toolchain, і повідомляє про відхилення. При цьому ігнорує каталоги .github та .git.
+
+## Публічний API
+
+Understood. As a technical writer adhering to the specified constraints, I will transform the provided list into concise, action-oriented behavioral documentation in Ukrainian, using only bulleted markers ("name — what it does"). I will avoid all introductory/concluding remarks, code blocks, signatures, types, parameters, stdlib mentions, regex descriptions, and internal private names.
+
+Here is the rewritten list:
+
+*   MISSING_RUST_CACHE — Ідентифікатор, що позначає відсутність кешу Rust.
+*   MISSING_RUST_CACHE_WORKSPACES — Ідентифікатор, що позначає відсутність кешу для Rust-робочих просторів.
+*   TOOLCHAIN_RE — Маркер, що вказує на інструментарій.
+*   CACHE_RE — Маркер, що стосується механізму кешування.
+*   scanToolchainSteps — Виявляє всі етапи використання `dtolnay/rust-toolchain@…` у workflow-файлі, надаючи деталі про кешування та дії Tauri у відповідних завданнях.
+*   tauriWorkspaceDir — Вказує на шлях до Rust-робочого простору для кешування, якщо `Cargo.toml` знаходиться в `src-tauri/`, інакше — не визначений.
+*   lint — Здійснює перевірку коду на відповідність встановленим стандартам.
+
+## Гарантії поведінки
+
+- Read-only: не виконує операцій запису (ФС/БД).
+- Кешує результати в межах одного прогону.
+- Свідомо пропускає шляхи: `.github`, `.git`.

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

@@ -0,0 +1,117 @@
+/** @see ./docs/fix-toolchain_cache.md */
+
+/**
+ * T0-autofix для `rust/toolchain_cache` — детерміновано вставляє
+ * `Swatinem/rust-cache@v2` одразу після кожного `dtolnay/rust-toolchain@…` кроку,
+ * якому його бракує у своєму job-і, і дописує `with.workspaces` у Tauri-job-ах,
+ * де Cargo.toml не в корені репо. Текстові splice-и (як `ga/workflows/fix-workflows.mjs`) —
+ * зберігають коментарі/формат, мінімальний diff. Ідемпотентно: `scanToolchainSteps`
+ * заново перевіряє стан файла на кожному прогоні.
+ */
+import { applyToFiles } from '../../../scripts/utils/apply-to-files.mjs'
+
+import { MISSING_RUST_CACHE, MISSING_RUST_CACHE_WORKSPACES, scanToolchainSteps } from './main.mjs'
+
+/**
+ * Індекс першого рядка після step-блоку, що починається на `stepLine`
+ * (dash-колонка `dashCol`) — перший рядок з відступом не більшим за `dashCol`
+ * (сусідній крок того самого рівня або dedent), або EOF.
+ * @param {string[]} lines усі рядки
+ * @param {number} stepLine індекс рядка кроку (`- uses: …`)
+ * @param {number} dashCol колонка dash-а кроку
+ * @returns {number} індекс вставки (кінець блоку кроку)
+ */
+function stepBlockEnd(lines, stepLine, dashCol) {
+  let j = stepLine + 1
+  while (j < lines.length) {
+    const line = lines[j]
+    if (line.trim() !== '' && line.length - line.trimStart().length <= dashCol) break
+    j++
+  }
+  return j
+}
+
+/**
+ * Вставляє `Swatinem/rust-cache@v2` (з опційним `with.workspaces`) одразу після
+ * кожного `dtolnay/rust-toolchain@…` кроку без cache-кроку в тому самому job-і.
+ * @param {string} content вміст workflow-файла
+ * @param {string} [workspaceDir] відносний шлях workspace-а для `with.workspaces` (опційно)
+ * @returns {string|null} новий вміст або null, якщо нічого не змінилось
+ */
+export function insertRustCache(content, workspaceDir) {
+  const lines = content.split('\n')
+  const missing = scanToolchainSteps(content).filter(s => !s.hasCache)
+  if (missing.length === 0) return null
+
+  /** @type {Array<{ at: number, text: string[] }>} */
+  const inserts = []
+  for (const step of missing) {
+    const at = stepBlockEnd(lines, step.line, step.dashCol)
+    const ind = ' '.repeat(step.dashCol)
+    const text = [`${ind}- uses: Swatinem/rust-cache@v2`]
+    if (workspaceDir && step.jobHasTauriAction) {
+      text.push(`${ind}  with:`, `${ind}    workspaces: ${workspaceDir}`)
+    }
+    inserts.push({ at, text })
+  }
+  inserts.sort((a, b) => b.at - a.at) // згори вниз — індекси не зсуваються під час splice
+  for (const ins of inserts) lines.splice(ins.at, 0, ...ins.text)
+  return lines.join('\n')
+}
+
+/**
+ * Дописує `with: workspaces: <dir>` у кожен уже наявний `Swatinem/rust-cache@…`
+ * крок Tauri-job-а (`tauri-apps/tauri-action`), якому бракує `workspaces`.
+ * @param {string} content вміст workflow-файла
+ * @param {string} workspaceDir відносний шлях workspace-а
+ * @returns {string|null} новий вміст або null, якщо нічого не змінилось
+ */
+export function addCacheWorkspaces(content, workspaceDir) {
+  const lines = content.split('\n')
+  const targets = scanToolchainSteps(content).filter(s => s.hasCache && s.jobHasTauriAction && !s.cacheHasWorkspaces)
+  if (targets.length === 0) return null
+
+  /** @type {Array<{ at: number, text: string[] }>} */
+  const inserts = []
+  for (const step of targets) {
+    const cacheLine = lines[step.cacheLine]
+    const usesCol = cacheLine.indexOf('uses:')
+    const ind = ' '.repeat(usesCol)
+    const at = stepBlockEnd(lines, step.cacheLine, usesCol - 2)
+    inserts.push({ at, text: [`${ind}with:`, `${ind}  workspaces: ${workspaceDir}`] })
+  }
+  inserts.sort((a, b) => b.at - a.at)
+  for (const ins of inserts) lines.splice(ins.at, 0, ...ins.text)
+  return lines.join('\n')
+}
+
+/** @type {import('../../../scripts/lib/lint-surface/types.mjs').T0Pattern[]} */
+export const patterns = [
+  {
+    id: 'rust-toolchain-cache-insert',
+    test: violations => violations.some(v => v.data?.kind === MISSING_RUST_CACHE && v.file),
+    apply: (violations, ctx) => {
+      const targets = violations.filter(v => v.data?.kind === MISSING_RUST_CACHE && v.file)
+      const wsTargets = violations.filter(v => v.data?.kind === MISSING_RUST_CACHE_WORKSPACES)
+      const workspaceDir = wsTargets.find(v => typeof v.data?.workspaceDir === 'string')?.data?.workspaceDir
+      const touchedFiles = applyToFiles(targets, ctx, () => content => insertRustCache(content, workspaceDir))
+      return touchedFiles.length > 0
+        ? { touchedFiles, message: `Swatinem/rust-cache@v2 → ${touchedFiles.length} workflow(s)` }
+        : { touchedFiles: [] }
+    }
+  },
+  {
+    id: 'rust-toolchain-cache-workspaces',
+    test: violations => violations.some(v => v.data?.kind === MISSING_RUST_CACHE_WORKSPACES && v.file),
+    apply: (violations, ctx) => {
+      const targets = violations.filter(v => v.data?.kind === MISSING_RUST_CACHE_WORKSPACES && v.file)
+      const touchedFiles = applyToFiles(targets, ctx, () => content => {
+        const workspaceDir = targets.find(v => typeof v.data?.workspaceDir === 'string')?.data?.workspaceDir
+        return workspaceDir ? addCacheWorkspaces(content, workspaceDir) : null
+      })
+      return touchedFiles.length > 0
+        ? { touchedFiles, message: `with.workspaces → ${touchedFiles.length} workflow(s)` }
+        : { touchedFiles: [] }
+    }
+  }
+]