@nitra/cursor 12.3.2 → 12.4.0

package/rules/python/lint/docs/lint.md

@@ -3,324 +3,27 @@ type: JS Module
 title: lint.mjs
 resource: npm/rules/python/lint/lint.mjs
 docgen:
-  crc: 92c8f115
+  crc: 61a1e3c3
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  score: 90
+  issues: internal-name:runStandardLint,judge:inaccurate:0.99
+  judgeModel: openai-codex/gpt-5.4-mini
 ---
 
-Модуль `npm/rules/python/lint/lint.mjs` реалізує крок `lint-python` — частину
-загального лінт-пайплайну монорепозиторію. Крок виконує перевірку Python-частини
-проєкту відповідно до правила `python.mdc` і базується на пакетному менеджері
-[uv](https://docs.astral.sh/uv/).
+## Огляд
 
-Поведінкові ключові точки:
+Забезпечує виконання обов'язкових кроків для валідації Python-коду відповідно до правил, визначених у `python.mdc`, використовуючи інструменти з [uv](https://docs.astral.sh/uv/). Якщо `pyproject.toml` відсутній у корені, процес завершується з кодом 0. Якщо файл присутній, але `uv` не знайдено в PATH, це розглядається як помилка. Обов'язкові кроки включають перевірку актуальності lock-файлу (`uv lock --check`) та збірку середовища (`uv sync --frozen`). Опціональні лінтери (`ruff`, `mypy`) запускаються лише за умови їх доступності через `uv run`. Цей процес реалізує канон патерну `lint-*` (серіалізація через `runStandardLint`).
 
-- Якщо у корені, переданому як `cwd` (за замовчуванням `process.cwd()`), немає
-  файлу `pyproject.toml`, крок завершується успіхом (`exit code 0`) без запуску
-  будь-яких інструментів. Це дозволяє безпечно вмикати крок у репозиторіях
-  без Python-частини.
-- Якщо `pyproject.toml` присутній, але бінарника `uv` немає в `PATH`, крок
-  завершується помилкою. Інших пакет-менеджерів (Poetry, pip, pdm тощо) модуль
-  не підтримує — `uv` є єдиним каноном.
-- Обовʼязкові кроки `uv lock --check` і `uv sync --frozen` запускаються завжди,
-  якщо `uv` доступний.
-- Опційні лінтери (`ruff check --fix`, `ruff format`, `mypy`) запускаються
-  лише якщо вони доступні через `uv run --frozen <tool> --version`. Якщо
-  відповідного інструмента у uv-середовищі немає — крок пропускається з
-  pass-повідомленням (аналогічно «optional vendor-tools» у `php.mdc`).
-- `ruff` працює в auto-fix-режимі (`--fix`, потім `format`), тобто може
-  мутувати робоче дерево, подібно до `markdownlint-cli2 --fix` у `lint-text`
-  чи `clippy --fix` у `lint-rust`.
-- Серіалізація запусків CLI організована через `runStandardLint` (а не через
-  безпосередній `withLock`) — це відповідає канону патерну `lint-*`, описаному
-  в `.cursor/rules/scripts.mdc` (секція «Серіалізація важких CLI-команд»).
+## Поведінка
 
-Файл одночасно є:
+runLintPythonSteps виконує обов'язкові кроки для Python-лінтування за правилом python.mdc на базі [uv](https://docs.astral.sh/uv/). Якщо `pyproject.toml` відсутній, кроки пропускаються. Якщо `uv` не знайдено, виникає помилка. Виконує перевірку актуальності lock-файлу (`uv lock --check`) та збірку середовища (`uv sync --frozen`). Опціонально запускає лінтери (`ruff`, `mypy`) через `uv run`, якщо вони доступні.
+runLintPython серіалізує запуск кроків лінтування Python через механізм `runStandardLint` та повертає код виходу.
 
-1. Бібліотекою (експортує функції `runLintPythonSteps` та `runLintPython`).
-2. CLI-точкою входу — при запуску напряму (`isRunAsCli`) виконує
-   `runLintPython()` і виставляє `process.exitCode`.
+## Публічний API
 
-## Експорти / API
+runLintPythonSteps — Виконує внутрішні етапи перевірки коду Python без блокування.
+runLintPython — Виконує публічну команду перевірки коду Python, забезпечуючи унікальність виконання на основі стану Git-дерева та використовуючи механізм блокування.
 
-| Експорт              | Тип                     | Призначення                                                                                                                                               |
-| -------------------- | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `runLintPythonSteps` | `function`              | Виконує внутрішні кроки `lint-python` (без зовнішнього локу). Призначений для повторного використання з обгортки `runStandardLint` та для тестування.     |
-| `runLintPython`      | `() => Promise<number>` | Публічна CLI-форма: запускає `runLintPythonSteps` через `runStandardLint`, який бере глобальний лок `lint-python` і дедупає прогони за станом git-дерева. |
+## Гарантії поведінки
 
-Модуль не має default-export. Усі експорти — іменовані ES Module exports.
-
-Side effect модуля верхнього рівня: якщо файл запущений як CLI
-(`isRunAsCli(import.meta.url)` повертає `true`), на верхньому рівні
-виконується `await runLintPython()` і результат записується у
-`process.exitCode`.
-
-## Функції
-
-### `runTool(label, cmd, args, pass, fail)`
-
-Внутрішня (не експортується) функція-обгортка над `child_process.spawnSync`,
-яка запускає вказаний CLI-крок і репортить результат через колбеки репортера.
-
-- Сигнатура: `runTool(label: string, cmd: string, args: string[], pass: (msg: string) => void, fail: (msg: string) => void): boolean`
-- Параметри:
-  - `label` — людиночитана назва кроку, використовується у повідомленнях
-    (`lint-python: <label> — OK` / `lint-python: <label> — помилка ...`).
-  - `cmd` — абсолютний шлях до виконуваного файлу (наприклад, отриманий через
-    `resolveCmd('uv')`).
-  - `args` — масив аргументів CLI.
-  - `pass` — callback репортера для успіху.
-  - `fail` — callback репортера для невдачі.
-- Повертає: `true`, якщо процес завершився з `status === 0`, інакше `false`.
-- Спосіб запуску: `spawnSync(cmd, args, { stdio: 'inherit', shell: false })`.
-  Це означає, що stdout/stderr CLI-кроку успадковуються від батьківського
-  процесу (видно користувачу), а інтерпретація аргументів shell-ом
-  вимкнена — аргументи передаються «as is».
-- Обробка статусу: якщо `r.status` не число (наприклад, процес був убитий
-  сигналом), у повідомлення про помилку підставляється `1`.
-- Side effects: запуск зовнішнього процесу; запис у stdout/stderr батька;
-  виклик `pass` або `fail` репортера.
-
-### `uvToolAvailable(uv, tool)`
-
-Внутрішня (не експортується) перевірка наявності лінтера всередині
-uv-середовища.
-
-- Сигнатура: `uvToolAvailable(uv: string, tool: string): boolean`
-- Параметри:
-  - `uv` — абсолютний шлях до бінарника `uv`.
-  - `tool` — назва бінарника, що перевіряється (`ruff`, `mypy`, тощо).
-- Повертає: `true`, якщо `uv run --frozen <tool> --version` завершився з
-  кодом `0`, інакше `false`.
-- Спосіб запуску: `spawnSync(uv, ['run', '--frozen', tool, '--version'],
-{ stdio: 'ignore', shell: false })`. `stdio: 'ignore'` гасить весь вивід
-  пробної команди, щоб не засмічувати лог.
-- Side effects: запуск дочірнього процесу `uv run --frozen <tool> --version`.
-  Опція `--frozen` гарантує, що `uv` не намагатиметься оновлювати lock-файл
-  під час перевірки.
-
-### `runLintPythonSteps(cwd?)`
-
-Експортована функція. Виконує всю послідовність кроків `lint-python` без
-зовнішнього серіалізаційного локу.
-
-- Сигнатура: `runLintPythonSteps(cwd?: string): number`
-- Параметри:
-  - `cwd` — корінь репозиторію. За замовчуванням `process.cwd()`.
-- Повертає: код виходу — `0`, якщо всі обовʼязкові кроки пройшли успішно,
-  `1` — якщо хоча б один крок зафейлив. Кінцевий код повертається через
-  `reporter.getExitCode()` (інстансу `createCheckReporter`).
-- Алгоритм:
-  1. Створює репортер: `const reporter = createCheckReporter()`,
-     дістає колбеки `{ pass, fail }`.
-  2. Перевіряє `existsSync(join(cwd, 'pyproject.toml'))`. Якщо файла
-     немає — викликає `pass(...)` з повідомленням «кроки Python пропущено»
-     і повертає `reporter.getExitCode()`.
-  3. `const uv = resolveCmd('uv')` — резолвить абсолютний шлях до `uv`.
-     Якщо `uv` не знайдено — `fail(...)` і повернення коду.
-  4. Виконує `runTool('uv lock --check', uv, ['lock', '--check'], pass, fail)`.
-     За невдачі — повертає поточний код (далі не йде).
-  5. Виконує `runTool('uv sync --frozen', uv, ['sync', '--frozen'], pass,
-fail)`. За невдачі — повертає поточний код.
-  6. Створює локальний хелпер `runOptionalUvTool(tool, label, args)`
-     (див. нижче) і послідовно запускає:
-     - `runOptionalUvTool('ruff', 'ruff check --fix', ['check', '--fix', '.'])`
-     - `runOptionalUvTool('ruff', 'ruff format', ['format', '.'])`
-     - `runOptionalUvTool('mypy', 'mypy', ['.'])`
-       За першої ж справжньої невдачі (повертає `false`) — повернення поточного
-       коду виходу.
-  7. Повертає `reporter.getExitCode()`.
-- Side effects:
-  - Запуск зовнішніх процесів (`uv lock`, `uv sync`, `uv run ruff`,
-    `uv run mypy`).
-  - `ruff check --fix` та `ruff format` можуть **модифікувати файли
-    проєкту** (auto-fix Python-коду).
-  - `uv sync --frozen` може створювати або оновлювати `.venv` (з повним
-    дотриманням `uv.lock`).
-  - Запис у stdout/stderr через `stdio: 'inherit'`.
-
-### `runOptionalUvTool(tool, label, args)` (вкладена у `runLintPythonSteps`)
-
-Внутрішній замикач, доступний лише всередині `runLintPythonSteps`. Захоплює
-`uv`, `pass`, `fail` із зовнішньої області видимості.
-
-- Сигнатура: `runOptionalUvTool(tool: string, label: string, args: string[]): boolean`
-- Параметри:
-  - `tool` — імʼя інструмента (`ruff`, `mypy`).
-  - `label` — назва кроку для повідомлень.
-  - `args` — аргументи, які слід передати інструменту після `uv run --frozen <tool>`.
-- Повертає: `true`, якщо крок успішно завершився **або** інструмент
-  відсутній у uv-середовищі (тоді крок пропускається з pass-повідомленням).
-  `false` повертається тільки коли інструмент доступний і завершився з
-  ненульовим статусом.
-- Логіка:
-  1. `if (!uvToolAvailable(uv, tool))` → `pass(...)` з повідомленням «крок
-     пропущено» і повертає `true` (це коректне продовження пайплайну,
-     інструмент трактується як optional).
-  2. Інакше викликає `runTool(label, uv, ['run', '--frozen', tool, ...args],
-pass, fail)`.
-- Side effects: ті ж, що й у `runTool` / `uvToolAvailable` (запуск дочірніх
-  процесів, оновлення репортера).
-
-### `runLintPython`
-
-Публічна обгортка-стрілкова функція.
-
-- Сигнатура: `runLintPython(): Promise<number>`
-- Параметри: немає.
-- Повертає: `Promise<number>` — код виходу, отриманий з `runStandardLint`.
-- Реалізація: `runStandardLint(import.meta.dirname, runLintPythonSteps)`.
-  Сенс параметрів:
-  - `import.meta.dirname` — директорія самого модуля; використовується
-    `runStandardLint` як ідентифікатор для дедуплікації / стану git-дерева.
-  - `runLintPythonSteps` — функція кроків, яку `runStandardLint` викличе
-    всередині глобального локу `lint-python`.
-- Серіалізація: `runStandardLint` бере глобальний лок `lint-python` (як
-  описано в `scripts.mdc`) та дедупає прогони за станом git-дерева, тому
-  паралельні виклики `runLintPython()` не перетинатимуться по запуску
-  `uv`.
-- Side effects: ті самі, що й у `runLintPythonSteps`, плюс блокування на
-  файловому локу.
-
-## CLI-вхід (верхній рівень модуля)
-
-```js
-if (isRunAsCli(import.meta.url)) {
-  process.exitCode = await runLintPython()
-}
-```
-
-- Перевірка `isRunAsCli(import.meta.url)` встановлює, чи запущений файл
-  безпосередньо як CLI-точка входу (наприклад, `node lint.mjs` або через
-  `n-cursor`), а не імпортований як модуль.
-- Якщо так — виконується top-level `await runLintPython()`, а результат
-  кладеться у `process.exitCode`. Це означає, що Node завершиться з цим
-  кодом після того, як event loop спорожніє.
-- Якщо файл імпортовано як модуль, цей блок не виконується — викликач сам
-  вирішує, як використати експортовані функції.
-
-## Залежності
-
-### Стандартна бібліотека Node.js
-
-- `node:child_process` → `spawnSync` — синхронний запуск зовнішніх процесів
-  (`uv`, `uv run …`).
-- `node:fs` → `existsSync` — перевірка наявності `pyproject.toml`.
-- `node:path` → `join` — побудова повного шляху до `pyproject.toml` від `cwd`.
-
-### Внутрішні модулі репозиторію
-
-- `../../../scripts/cli-entry.mjs` → `isRunAsCli` — детекція CLI-режиму
-  через `import.meta.url`.
-- `../../../scripts/lib/check-reporter.mjs` → `createCheckReporter` —
-  фабрика репортера з методами `pass`, `fail`, `getExitCode`. Цей патерн
-  єдиний для всіх лінт-кроків.
-- `../../../scripts/utils/resolve-cmd.mjs` → `resolveCmd` — пошук
-  виконуваного файлу в `PATH` (повертає абсолютний шлях або `null`).
-- `../../../scripts/lib/run-standard-lint.mjs` → `runStandardLint` —
-  стандартизована обгортка над лінт-кроком (глобальний лок + дедуплікація
-  за станом git-дерева).
-
-### Зовнішні бінарники (runtime-залежності)
-
-- `uv` — обовʼязковий у `PATH`, якщо в репозиторії є `pyproject.toml`.
-- `ruff` — опційний, перевіряється через `uv run --frozen ruff --version`.
-- `mypy` — опційний, перевіряється через `uv run --frozen mypy --version`.
-
-### Артефакти у проєкті
-
-- `pyproject.toml` (у корені `cwd`) — тригер запуску Python-частини.
-- `uv.lock` — використовується `uv lock --check` та `uv sync --frozen`,
-  має бути актуальним.
-
-## Потік виконання / Використання
-
-### Сценарій 1: Python-частини немає
-
-1. `runLintPython()` → `runStandardLint(...)` → `runLintPythonSteps()`.
-2. `existsSync('<cwd>/pyproject.toml')` повертає `false`.
-3. Репортер фіксує pass-повідомлення «немає pyproject.toml у корені — кроки
-   Python пропущено».
-4. Повертається `0`.
-
-### Сценарій 2: Python є, але `uv` не встановлений
-
-1. `existsSync('pyproject.toml')` → `true`.
-2. `resolveCmd('uv')` → `null`.
-3. `fail('lint-python: `uv` не знайдено в PATH ...')`.
-4. Повертається `1`.
-
-### Сценарій 3: Повний прогон з усіма лінтерами
-
-1. `uv lock --check` — перевірка lock-файлу. За невдачі вихід `1`.
-2. `uv sync --frozen` — інсталяція середовища строго за `uv.lock`. За
-   невдачі вихід `1`.
-3. `uvToolAvailable(uv, 'ruff')` → `true` → `uv run --frozen ruff check
---fix .`. Може **змінити файли**.
-4. `uv run --frozen ruff format .`. Також може **змінити файли**.
-5. `uvToolAvailable(uv, 'mypy')` → `true` → `uv run --frozen mypy .`.
-   Лише читає, не змінює дерево.
-6. Якщо всі кроки повернули `0` — підсумок `0`. Інакше — перший
-   ненульовий код розриває послідовність і повертається.
-
-### Сценарій 4: `ruff` або `mypy` не встановлені у uv-середовищі
-
-- Для відповідного інструмента `uvToolAvailable` поверне `false`.
-- Виводиться pass-повідомлення «<tool> недоступний у uv-середовищі —
-  крок пропущено».
-- Інші кроки виконуються штатно.
-
-### Як викликати з коду
-
-```js
-import { runLintPython, runLintPythonSteps } from './lint.mjs'
-
-// Стандартний шлях: з локом, дедуплікацією, асинхронно.
-const code = await runLintPython()
-process.exit(code)
-
-// Прямий виклик без локу (наприклад, у тестах або з власною серіалізацією):
-const codeRaw = runLintPythonSteps('/path/to/repo')
-```
-
-### Як викликати з CLI
-
-Файл є виконуваною точкою входу для лінт-пайплайну. У звичайному монорепо
-він викликається через спільний раннер (`n-cursor`, `bun run lint` тощо).
-Прямий запуск:
-
-```bash
-node npm/rules/python/lint/lint.mjs
-```
-
-Кодом виходу буде число з `runLintPython()` (`0` — OK, `1` — є помилки).
-
-## Rebuild Test
-
-За цією документацією можна відтворити модуль так:
-
-1. Створити ES Module-файл, що імпортує `spawnSync` з `node:child_process`,
-   `existsSync` з `node:fs`, `join` з `node:path`, а також `isRunAsCli`,
-   `createCheckReporter`, `resolveCmd`, `runStandardLint` з відповідних
-   шляхів `../../../scripts/...`.
-2. Реалізувати приватну `runTool(label, cmd, args, pass, fail)`:
-   `spawnSync` з `stdio: 'inherit'`, `shell: false`; при `status === 0`
-   викликати `pass`, інакше `fail` з кодом (типу number або `1` при
-   неприродному завершенні); повертати `boolean`.
-3. Реалізувати `uvToolAvailable(uv, tool)`: `spawnSync(uv, ['run',
-'--frozen', tool, '--version'], { stdio: 'ignore', shell: false })` →
-   `r.status === 0`.
-4. Експортувати `runLintPythonSteps(cwd = process.cwd())`:
-   - створити репортер;
-   - якщо `pyproject.toml` відсутній → `pass(...)` і повернути код;
-   - резолвити `uv`; якщо немає → `fail(...)` і повернути;
-   - послідовно: `uv lock --check`, `uv sync --frozen` (обовʼязкові);
-   - опційні через локальну функцію-замикач `runOptionalUvTool`: `ruff
-check --fix .`, `ruff format .`, `mypy .` — кожен через
-     `uvToolAvailable` + `runTool`;
-   - повернути `reporter.getExitCode()`.
-5. Експортувати `runLintPython = () => runStandardLint(import.meta.dirname,
-runLintPythonSteps)`.
-6. На верхньому рівні: `if (isRunAsCli(import.meta.url)) process.exitCode =
-await runLintPython()`.
-
-Результат повинен поведінково збігтися з оригіналом: ті самі повідомлення,
-ті самі коди виходу, така ж серіалізація та обробка опційних інструментів.
+- Read-only: не виконує операцій запису (ФС/БД).

package/rules/python/lint/lint.mjs

@@ -63,9 +63,11 @@ function uvToolAvailable(uv, tool) {
 /**
  * Внутрішні кроки `lint-python` без локу.
  * @param {string} [cwd] корінь репозиторію
+ * @param {{ readOnly?: boolean }} [opts] readOnly → `ruff` без `--fix`, `ruff format --check` (нуль мутацій, CI/детект)
  * @returns {number} 0 — OK, 1 — є помилки
  */
-export function runLintPythonSteps(cwd = process.cwd()) {
+export function runLintPythonSteps(cwd = process.cwd(), opts = {}) {
+  const readOnly = opts.readOnly === true
   const reporter = createCheckReporter()
   const { pass, fail } = reporter
 
@@ -98,8 +100,10 @@ export function runLintPythonSteps(cwd = process.cwd()) {
     return runTool(label, uv, ['run', '--frozen', tool, ...args], pass, fail)
   }
 
-  if (!runOptionalUvTool('ruff', 'ruff check --fix', ['check', '--fix', '.'])) return reporter.getExitCode()
-  if (!runOptionalUvTool('ruff', 'ruff format', ['format', '.'])) return reporter.getExitCode()
+  const ruffCheck = readOnly ? ['check', '.'] : ['check', '--fix', '.']
+  const ruffFormat = readOnly ? ['format', '--check', '.'] : ['format', '.']
+  if (!runOptionalUvTool('ruff', readOnly ? 'ruff check' : 'ruff check --fix', ruffCheck)) return reporter.getExitCode()
+  if (!runOptionalUvTool('ruff', readOnly ? 'ruff format --check' : 'ruff format', ruffFormat)) return reporter.getExitCode()
   if (!runOptionalUvTool('mypy', 'mypy', ['.'])) return reporter.getExitCode()
 
   return reporter.getExitCode()
@@ -107,10 +111,12 @@ export function runLintPythonSteps(cwd = process.cwd()) {
 
 /**
  * Публічна CLI-форма: серіалізує через `withLock('lint-python')` + дедуп за станом git-дерева.
+ * @param {{ readOnly?: boolean }} [opts] readOnly → детект без мутацій (проброс у кроки)
  * @returns {Promise<number>} код виходу
  */
-export const runLintPython = () => runStandardLint(import.meta.dirname, runLintPythonSteps)
+export const runLintPython = (opts = {}) =>
+  runStandardLint(import.meta.dirname, () => runLintPythonSteps(process.cwd(), opts))
 
 if (isRunAsCli(import.meta.url)) {
-  process.exitCode = await runLintPython()
+  process.exitCode = await runLintPython({ readOnly: process.argv.includes('--read-only') })
 }

package/rules/python/meta.json

@@ -1 +1 @@
-{ "auto": { "glob": "pyproject.toml" } }
+{ "auto": { "glob": "pyproject.toml" }, "lint": "full" }

package/rules/python/policy/lint_python_yml/template/lint-python.yml.snippet.yml

@@ -38,4 +38,4 @@ jobs:
         run: uv sync --frozen
 
       - name: Lint Python
-        run: bun run lint-python
+        run: n-cursor lint python --read-only

package/rules/python/python.mdc

@@ -27,9 +27,7 @@ Python-проєкти ведуться **виключно** на [uv](https://do
 
 ## lint-python
 
-Інструменти uv-екосистеми не мають єдиного CLI, що сам обходить репозиторій, тому `lint-python` делегується у JS-скрипт-обгортку (як `lint-php`, `lint-docker`).
-
-- Канон `package.json#scripts.lint-python` (substring requirement): [package.json.contains.json](./policy/package_json/template/package.json.contains.json)
+Інструменти uv-екосистеми не мають єдиного CLI, що сам обходить репозиторій, тому python-лінт делегується у JS-скрипт-обгортку. Запуск — через **`n-cursor lint python`** (CI — `--read-only`); окремого `package.json`-скрипта немає.
 
 Скрипт `rules/python/lint/lint.mjs`:
 

package/rules/rego/rego.mdc

@@ -1,5 +1,5 @@
 ---
-description: Opa, Rego — інструментарій (VS Code, lint-rego)
+description: Opa, Rego — інструментарій (VS Code, opa/regal)
 version: '1.1'
 globs: "**/*.rego"
 alwaysApply: false
@@ -12,17 +12,13 @@ alwaysApply: false
 ## Перевірка
 
 ```bash
-bun run lint-rego
+n-cursor lint rego
 ```
 
 Цілі — `npm/rules/` (рекурсивно знаходить `.rego` у `<rule>/policy/<concern>/`). Інші *.rego поза деревом додай у `LINT_TARGETS` у `npm/rules/rego/lint/lint.mjs`.
 
 `opa` і `regal` — лише у `PATH`, **не** додавай у `dependencies` / `devDependencies`.
 
-### `package.json`
-
-- Канон `scripts.lint-rego`: [package.json.snippet.json](./policy/package_json/template/package.json.snippet.json)
-
 ### `.vscode/extensions.json`
 
 - Канон `recommendations` має містити `tsandall.opa` (LSP, format-on-save через `opa fmt`): [extensions.json.snippet.json](./policy/vscode_extensions/template/extensions.json.snippet.json)

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

@@ -9,3 +9,4 @@ resource: npm/rules/rust/js/
 | Файл | Тип |
 |---|---|
 | [applies.mjs](applies.md) | JS Module |
+| [lint.mjs](lint.md) | JS Module |

package/rules/rust/js/docs/lint.md

@@ -0,0 +1,21 @@
+---
+type: JS Module
+title: lint.mjs
+resource: npm/rules/rust/js/lint.mjs
+docgen:
+  crc: 5d7c4123
+  score: 100
+---
+
+Оркестраторний адаптер правила `rust` для `n-cursor lint`: rustfmt + clippy через `cargo`. Запускається на `n-cursor lint rust`. За відсутності `Cargo.toml` у корені — no-op (вихід 0). `cargo`/`rustfmt`/`clippy` резолвляться з PATH (Rust toolchain через rustup), не з npm-залежностей; якщо `cargo` відсутній за наявного `Cargo.toml` — помилка.
+
+## Поведінка
+
+1. `readOnly` (CI): `cargo fmt --all -- --check` + `cargo clippy --all-targets --all-features -- -D warnings` — детект без мутацій.
+2. fix-режим: `cargo fmt --all` + `cargo clippy --fix` + фінальний `cargo clippy … -D warnings`.
+3. Перший ненульовий cargo-крок спиняє ланцюг і повертає його код.
+
+## Гарантії поведінки
+
+- Read-only за наявності `readOnly`: cargo не мутує робоче дерево (`--check`, без `--fix`).
+- Не звертається до мережі напряму (cargo-кроки можуть тягнути crates, але це поведінка тулчейну).

package/rules/rust/js/lint.mjs

@@ -0,0 +1,67 @@
+/** @see ./docs/lint.md */
+import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { createCheckReporter } from '../../../scripts/lib/check-reporter.mjs'
+import { resolveCmd } from '../../../scripts/utils/resolve-cmd.mjs'
+
+/**
+ * Запускає cargo-крок і репортить результат.
+ * @param {string} label назва кроку
+ * @param {string} cargo абсолютний шлях до `cargo`
+ * @param {string[]} args аргументи
+ * @param {(m: string) => void} pass callback pass
+ * @param {(m: string) => void} fail callback fail
+ * @returns {boolean} true якщо крок успішний
+ */
+function runCargo(label, cargo, args, pass, fail) {
+  const r = spawnSync(cargo, args, { stdio: 'inherit', shell: false })
+  if (r.status === 0) {
+    pass(`lint-rust: ${label} — OK`)
+    return true
+  }
+  const code = typeof r.status === 'number' ? r.status : 1
+  fail(`lint-rust: ${label} — помилка (код ${code}, rust.mdc)`)
+  return false
+}
+
+/**
+ * Оркестраторний адаптер `n-cursor lint rust`: rustfmt + clippy через cargo. Без `Cargo.toml` —
+ * no-op (0). `cargo`/`rustfmt`/`clippy` — Rust toolchain (rustup), не npm-залежності.
+ * readOnly (CI): `cargo fmt --all -- --check` + `cargo clippy … -D warnings` (нуль мутацій).
+ * fix: `cargo fmt --all` + `cargo clippy --fix` + фінальний `cargo clippy … -D warnings`.
+ * @param {string[] | undefined} _files ігнорується (cargo обходить crate сам)
+ * @param {string} [cwd] корінь
+ * @param {{ readOnly?: boolean }} [opts] readOnly → без мутацій
+ * @returns {number} exit code
+ */
+export function lint(_files, cwd = process.cwd(), opts = {}) {
+  const readOnly = opts.readOnly === true
+  const reporter = createCheckReporter()
+  const { pass, fail } = reporter
+
+  if (!existsSync(join(cwd, 'Cargo.toml'))) {
+    pass('lint-rust: немає Cargo.toml — кроки Rust пропущено')
+    return reporter.getExitCode()
+  }
+
+  const cargo = resolveCmd('cargo')
+  if (!cargo) {
+    fail('lint-rust: `cargo` не знайдено в PATH (Rust toolchain через rustup, rust.mdc)')
+    return reporter.getExitCode()
+  }
+
+  const fmtArgs = readOnly ? ['fmt', '--all', '--', '--check'] : ['fmt', '--all']
+  if (!runCargo(readOnly ? 'cargo fmt --check' : 'cargo fmt', cargo, fmtArgs, pass, fail)) {
+    return reporter.getExitCode()
+  }
+
+  if (!readOnly) {
+    const fixArgs = ['clippy', '--fix', '--allow-staged', '--allow-dirty', '--all-targets', '--all-features']
+    if (!runCargo('cargo clippy --fix', cargo, fixArgs, pass, fail)) return reporter.getExitCode()
+  }
+
+  runCargo('cargo clippy -D warnings', cargo, ['clippy', '--all-targets', '--all-features', '--', '-D', 'warnings'], pass, fail)
+  return reporter.getExitCode()
+}

package/rules/rust/rust.mdc

@@ -5,12 +5,10 @@ alwaysApply: false
 version: '1.4'
 ---
 
-**rustfmt** ([rust-lang/rustfmt](https://github.com/rust-lang/rustfmt)) — форматер; **clippy** ([rust-lang/rust-clippy](https://github.com/rust-lang/rust-clippy)) — лінтер. У скрипті **`lint-rust`** локально йдуть три кроки в одному рядку: `cargo fmt --all` → `cargo clippy --fix --allow-staged --allow-dirty --all-targets --all-features` → фінальний `cargo clippy --all-targets --all-features -- -D warnings`. У CI — без `--fix`: `cargo fmt --all -- --check` і `cargo clippy ... -- -D warnings` (див. `lint-rust.yml`).
+**rustfmt** ([rust-lang/rustfmt](https://github.com/rust-lang/rustfmt)) — форматер; **clippy** ([rust-lang/rust-clippy](https://github.com/rust-lang/rust-clippy)) — лінтер. Запуск — через **`n-cursor lint rust`** (адаптер `js/lint.mjs`): локально (fix) `cargo fmt --all` → `cargo clippy --fix --allow-staged --allow-dirty --all-targets --all-features` → фінальний `cargo clippy --all-targets --all-features -- -D warnings`; у `--read-only` (детект) — `cargo fmt --all -- --check` + `cargo clippy ... -- -D warnings`. Окремого `package.json`-скрипта немає. У CI cargo викликається напряму (див. `lint-rust.yml`).
 
 `cargo`, `rustfmt`, `clippy` не додавай у `devDependencies` — це Rust toolchain, ставиться через `rustup` локально або через `dtolnay/rust-toolchain@stable` у CI.
 
-Канон `scripts.lint-rust` (substring requirement): [package.json.contains.json](./policy/package_json/template/package.json.contains.json)
-
 У `.vscode/extensions.json` `recommendations` мають містити `rust-lang.rust-analyzer` і `tamasfe.even-better-toml`: [extensions.json.snippet.json](./policy/vscode_extensions/template/extensions.json.snippet.json)
 
 Канон workflow `.github/workflows/lint-rust.yml`: [lint-rust.yml.snippet.yml](./policy/lint_rust_yml/template/lint-rust.yml.snippet.yml)
@@ -21,7 +19,7 @@ version: '1.4'
 
 Tauri-проєкт завжди має `src-tauri/Cargo.toml`, тому правило `rust` активується автоматично разом з `tauri`. Поділ обов'язків:
 
-- `rust` — `lint-rust` скрипт, `rust-analyzer`, `even-better-toml`, CI workflow.
+- `rust` — лінт через `n-cursor lint rust`, `rust-analyzer`, `even-better-toml`, CI workflow.
 - `tauri` — `tauri-apps.tauri-vscode` (див. **tauri.mdc**).
 
 Обидва правила перевіряють `.vscode/extensions.json` за `contains`-семантикою; конкурентного запису немає.

package/rules/security/policy/package_json/package_json.rego

@@ -5,14 +5,6 @@ package security.package_json
 
 import rego.v1
 
-# ── deny: кожен snippet leaf має співпадати з input ──────────────────────────
-deny contains msg if {
-	some script_name, expected in data.template.snippet.scripts
-	actual := object.get(object.get(input, "scripts", {}), script_name, "")
-	actual != expected
-	msg := sprintf("package.json: scripts.%s має бути %q (security.mdc)", [script_name, expected])
-}
-
 # ── deny: жодного ключа з deny у dependencies/devDependencies ────────────────
 deny contains msg if {
 	some pkg, reason in data.template.deny.dependencies
@@ -25,14 +17,3 @@ deny contains msg if {
 	pkg in object.keys(object.get(input, "devDependencies", {}))
 	msg := sprintf("package.json: devDependencies.%s — %s (security.mdc)", [pkg, reason])
 }
-
-# ── deny: рядкові поля з contains мають містити кожен substring ──────────────
-# Перевіряємо лише наявні поля (якщо `scripts.<name>` відсутній — поле опціональне).
-deny contains msg if {
-	some script_name, needles in data.template.contains.scripts
-	actual := object.get(object.get(input, "scripts", {}), script_name, "")
-	actual != ""
-	some needle in needles
-	not contains(actual, needle)
-	msg := sprintf("package.json: scripts.%s має містити %q (security.mdc)", [script_name, needle])
-}

package/rules/security/security.mdc

@@ -1,5 +1,5 @@
 ---
-description: Локальний та CI-секюріті-лінт через TruffleHog — скрипт `lint-security`, `.trufflehog-exclude`, інтеграція в агрегований `lint`; канонічний placeholder `sample-secret` у прикладних файлах
+description: Локальний та CI-секюріті-лінт через TruffleHog — `.trufflehog-exclude`, канонічний placeholder `sample-secret` у прикладних файлах
 globs: "**/.trufflehog-exclude,**/package.json,**/.github/workflows/**/*.yml"
 alwaysApply: false
 version: '2.1'
@@ -7,10 +7,10 @@ version: '2.1'
 
 [TruffleHog](https://github.com/trufflesecurity/trufflehog) — глобальний CLI (як `shellcheck`, `conftest`); **не** додавай до `dependencies`/`devDependencies`.
 
-## Канон `package.json#scripts`
+## Канон `package.json`
+
+Скан запускається через `n-cursor lint security` (CI — `n-cursor lint security --read-only`); окремого `lint-*` скрипта в `package.json` немає.
 
-- `lint-security` скрипт: [package.json.snippet.json](./policy/package_json/template/package.json.snippet.json)
-- `lint` агрегатор повинен містити: [package.json.contains.json](./policy/package_json/template/package.json.contains.json)
 - Заборонено `trufflehog` у `dependencies`/`devDependencies`: [package.json.deny.json](./policy/package_json/template/package.json.deny.json)
 
 **Зауваження:**
@@ -19,8 +19,7 @@ version: '2.1'
 - `--no-update` — вимикає self-update check (CI-friendly).
 - `--exclude-paths .trufflehog-exclude` — файл з regex-patterns, які треба пропускати (аналог `[allowlist].paths` із gitleaks).
 - `--results=verified,unknown` — показує лише верифіковані секрети + ті, що TruffleHog не зміг перевірити (`unverified` дублікат відсіюється).
-- `--fail` — exit-code `183` за наявності знахідок (потрібно, щоб `bun run lint` падав).
-- Позиція в `lint`: за конвенцією після інших `lint-*` і перед `oxfmt`.
+- `--fail` — exit-code `183` за наявності знахідок (щоб лінт падав).
 
 ## `.trufflehog-exclude` (рекомендована основа)
 

package/rules/style-lint/policy/lint_style_yml/template/lint-style.yml.snippet.yml

@@ -36,4 +36,4 @@ jobs:
       - uses: ./.github/actions/setup-bun-deps
 
       - name: StyleLint
-        run: npx stylelint '**/*.{css,scss,vue}'
+        run: n-cursor lint style-lint --read-only