@nitra/cursor 1.39.1 → 1.40.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [1.40.0] - 2026-05-31
+
+### Added
+
+- lint: розділення на `n-cursor lint` (quick, по змінених файлах) і `n-cursor lint-ci` (повний, по всьому репо) — data-driven за полем `meta.json.lint` (quick/ci); виконавець кроку — `js/lint.mjs` правила; jscpd+knip винесено в нове правило `js-lint-ci` (фаза ci)
+
 ## [1.39.1] - 2026-05-31
 
 ### Changed

package/bin/n-cursor.js

@@ -105,7 +105,7 @@ import { runRenameYamlExtensionsCli } from './rename-yaml-extensions.mjs'
 import { runSkillsCli } from '../scripts/skills-cli.mjs'
 import { runWorktreeCli } from '../scripts/worktree-cli.mjs'
 import { syncSetupBunDepsAction } from '../scripts/sync-setup-bun-deps-action.mjs'
-import { runLintCli } from '../scripts/lib/run-lint-cli.mjs'
+import { runLint } from '../scripts/lint-cli.mjs'
 import { formatTimingSummary } from '../scripts/lib/timing-summary.mjs'
 
 const PACKAGE_NAME = '@nitra/cursor'
@@ -1464,9 +1464,12 @@ try {
       break
     }
     case 'lint': {
-      // Оркестратор lint-ланцюжка з вимірюванням часу на кожен крок (fail-fast).
-      // Замінює раніше використовуваний агрегатор `bun run lint-ga && bun run lint-js && …` у root package.json.
-      process.exitCode = runLintCli()
+      process.exitCode = await runLint({ ci: false })
+
+      break
+    }
+    case 'lint-ci': {
+      process.exitCode = await runLint({ ci: true })
 
       break
     }
@@ -1540,7 +1543,7 @@ try {
     default: {
       console.error(`❌ Невідома команда: ${command}`)
       console.error(
-        `   Очікується: (без аргументів) синхронізація правил, check, rename-yaml-extensions, post-tool-use-fix, lint, lint-ga, lint-rego, lint-k8s, lint-docker, lint-text, coverage, change, release, skill, worktree`
+        `   Очікується: (без аргументів) синхронізація правил, check, rename-yaml-extensions, post-tool-use-fix, lint, lint-ga, lint-rego, lint-k8s, lint-docker, lint-text, coverage, change, release, skill, worktree, lint-ci`
       )
       process.exitCode = 1
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nitra/cursor",
-  "version": "1.39.1",
+  "version": "1.40.0",
   "description": "CLI для завантаження cursor-правил (префікс n-) у локальний репозиторій",
   "keywords": [
     "cli",

package/rules/ga/js/lint.mjs

@@ -0,0 +1,12 @@
+/**
+ * Ci-крок ga: делегує у наявний CLI правила (per-file режиму немає — `files` ігнорується).
+ */
+import { runLintGaCli } from '../lint/lint.mjs'
+
+/**
+ * @param {string[] | undefined} _files ігнорується (whole-repo аналіз)
+ * @returns {Promise<number>} exit code
+ */
+export async function lint(_files) {
+  return runLintGaCli()
+}

package/rules/ga/meta.json

@@ -1 +1 @@
-{ "auto": { "glob": ".github/workflows/**" } }
+{ "auto": { "glob": ".github/workflows/**" }, "lint": "ci" }

package/rules/js-lint/js/lint.mjs

@@ -0,0 +1,52 @@
+/**
+ * Quick-крок lint правила js-lint: oxlint + eslint (з автофіксом).
+ *
+ * Викликається lint-оркестратором (`n-cursor lint` / `lint-ci`):
+ *  - `files` = масив змінених файлів (quick) → лінтимо лише js-подібні з них;
+ *  - `files` = undefined (ci) → лінтимо весь проєкт.
+ * Крос-файлові jscpd/knip — окреме правило js-lint-ci (фаза ci).
+ */
+import { spawnSync } from 'node:child_process'
+
+const JS_EXT_RE = /\.(?:mjs|cjs|js|jsx|ts|tsx|vue)$/u
+
+/**
+ * Лишає лише js-подібні файли зі списку.
+ * @param {string[]} files список шляхів
+ * @returns {string[]} підмножина js-подібних
+ */
+export function filterJsFiles(files) {
+  return files.filter(f => JS_EXT_RE.test(f))
+}
+
+/**
+ * @param {string[]} args аргументи інструмента (бінар через bunx)
+ * @param {string} cwd корінь
+ * @returns {number} exit code
+ */
+function run(args, cwd) {
+  const r = spawnSync('bunx', args, { cwd, stdio: 'inherit' })
+  return typeof r.status === 'number' ? r.status : 1
+}
+
+/**
+ * Запускає oxlint+eslint з автофіксом.
+ * @param {string[] | undefined} files quick: лише ці файли; undefined: весь проєкт
+ * @param {string} [cwd] корінь репо
+ * @returns {Promise<number>} 0 — OK, ≠0 — порушення
+ */
+export function lint(files, cwd = process.cwd()) {
+  let oxArgs = ['oxlint', '--fix']
+  let esArgs = ['eslint', '--fix']
+  if (files === undefined) {
+    esArgs.push('.')
+  } else {
+    const js = filterJsFiles(files)
+    if (js.length === 0) return Promise.resolve(0)
+    oxArgs = ['oxlint', '--fix', ...js]
+    esArgs = ['eslint', '--fix', ...js]
+  }
+  const ox = run(oxArgs, cwd)
+  if (ox !== 0) return Promise.resolve(ox)
+  return Promise.resolve(run(esArgs, cwd))
+}

package/rules/js-lint/meta.json

@@ -1 +1 @@
-{ "auto": { "glob": ["**/*.mjs", "**/*.cjs", "**/*.js", "**/*.jsx", "**/*.ts", "**/*.tsx"] } }
+{ "auto": { "glob": ["**/*.mjs", "**/*.cjs", "**/*.js", "**/*.jsx", "**/*.ts", "**/*.tsx"] }, "lint": "quick" }

package/rules/js-lint-ci/fix.mjs

@@ -0,0 +1,19 @@
+import { isRunAsCli, runRuleCli } from '../../scripts/lib/run-rule-cli.mjs'
+import { runStandardRule } from '../../scripts/lib/run-standard-rule.mjs'
+
+/**
+ * Запускає правило: applies → JS-concerns → policy → mdc-refs (через runStandardRule).
+ * Library mode: викликається CLI orchestration через `import + run(ctx)`.
+ * @param {import('../../scripts/lib/run-standard-rule.mjs').RuleContext} [ctx] контекст прогону (walkCache тощо)
+ * @returns {Promise<number>} 0 — OK, 1 — порушення
+ */
+export function run(ctx) {
+  return runStandardRule(import.meta.dirname, ctx)
+}
+
+if (isRunAsCli(import.meta.url)) {
+  // Standalone: bun rules/<id>/fix.mjs — повний еквівалент `npx @nitra/cursor fix <id>`
+  // (config-loading + whitelist + summary). Дві ролі fix.mjs: library (run) + standalone (main).
+  // eslint-disable-next-line n/no-process-exit, unicorn/no-process-exit -- standalone entry-point має повертати exit-code для CI/IDE
+  process.exit(await runRuleCli(import.meta.dirname))
+}

package/rules/js-lint-ci/js/lint.mjs

@@ -0,0 +1,20 @@
+/**
+ * Ci-крок: jscpd (детектор клонів) + knip (невикористані експорти).
+ *
+ * Крос-файлові аналізатори — працюють лише по всьому репо, тож `files` ігнорується
+ * (викликається лише у `lint-ci` з undefined). Per-file режиму ці інструменти не мають.
+ */
+import { spawnSync } from 'node:child_process'
+
+/**
+ * @param {string[] | undefined} _files ігнорується (крос-файловий аналіз)
+ * @param {string} [cwd] корінь репо
+ * @returns {Promise<number>} 0 — OK, ≠0 — порушення
+ */
+export function lint(_files, cwd = process.cwd()) {
+  const jscpd = spawnSync('bunx', ['jscpd', '.'], { cwd, stdio: 'inherit' })
+  const jc = typeof jscpd.status === 'number' ? jscpd.status : 1
+  if (jc !== 0) return Promise.resolve(jc)
+  const knip = spawnSync('bunx', ['knip', '--no-config-hints'], { cwd, stdio: 'inherit' })
+  return Promise.resolve(typeof knip.status === 'number' ? knip.status : 1)
+}

package/rules/js-lint-ci/js-lint-ci.mdc

@@ -0,0 +1,12 @@
+---
+description: Крос-файловий ci-етап js-lint — jscpd (детектор клонів) і knip (невикористані експорти). Лише у lint-ci, по всьому репо.
+globs:
+alwaysApply: true
+---
+
+# js-lint-ci — крос-файловий ci-етап
+
+`jscpd` і `knip` аналізують увесь граф проєкту, тож мають сенс лише у повному прогоні
+`npx @nitra/cursor lint-ci` (не у швидкому `lint` по змінених файлах). Per-file режиму нема.
+
+Швидкий етап js-lint (oxlint/eslint) — у правилі `js-lint` (`lint: quick`).

package/rules/js-lint-ci/meta.json

@@ -0,0 +1 @@
+{ "lint": "ci" }

package/rules/npm-module/js/rule_meta.mjs

@@ -12,7 +12,7 @@ import { existsSync, readdirSync } from 'node:fs'
 import { join } from 'node:path'
 
 import { createCheckReporter } from '../../../scripts/lib/check-reporter.mjs'
-import { parseRuleAutoSpec, readRuleMetaRaw } from '../../../scripts/lib/rule-meta.mjs'
+import { parseRuleAutoSpec, parseRuleLintPhase, readRuleMetaRaw } from '../../../scripts/lib/rule-meta.mjs'
 import { RULE_PREDICATES } from '../../../scripts/lib/rule-predicates.mjs'
 
 /**
@@ -54,6 +54,15 @@ export function check(cwd = process.cwd()) {
         ruleOk = false
       }
     }
+    if (raw.lint !== undefined) {
+      if (parseRuleLintPhase(raw.lint) === null) {
+        reporter.fail(`rules/${id}: meta.json.lint нерозпізнане (очікується "quick"|"ci")`)
+        ruleOk = false
+      } else if (!existsSync(join(ruleDir, 'js', 'lint.mjs'))) {
+        reporter.fail(`rules/${id}: lint:"${raw.lint}" але немає js/lint.mjs`)
+        ruleOk = false
+      }
+    }
     if (ruleOk) {
       reporter.pass(`rules/${id}: meta.json валідний`)
     }

package/rules/rego/js/lint.mjs

@@ -0,0 +1,12 @@
+/**
+ * Ci-крок rego: делегує у наявний CLI правила (per-file режиму немає — `files` ігнорується).
+ */
+import { runLintRego } from '../lint/lint.mjs'
+
+/**
+ * @param {string[] | undefined} _files ігнорується (whole-repo аналіз)
+ * @returns {Promise<number>} exit code
+ */
+export async function lint(_files) {
+  return runLintRego()
+}

package/rules/rego/meta.json

@@ -1 +1 @@
-{ "auto": { "glob": "**/*.rego" } }
+{ "auto": { "glob": "**/*.rego" }, "lint": "ci" }

package/rules/security/js/lint.mjs

@@ -0,0 +1,18 @@
+/**
+ * Ci-крок security: trufflehog filesystem скан усього репо (per-file немає).
+ */
+import { spawnSync } from 'node:child_process'
+
+/**
+ * @param {string[] | undefined} _files ігнорується
+ * @param {string} [cwd] корінь
+ * @returns {Promise<number>} exit code
+ */
+export function lint(_files, cwd = process.cwd()) {
+  const r = spawnSync(
+    'trufflehog',
+    ['filesystem', '.', '--no-update', '--exclude-paths', '.trufflehog-exclude', '--results=verified,unknown', '--fail'],
+    { cwd, stdio: 'inherit' }
+  )
+  return Promise.resolve(typeof r.status === 'number' ? r.status : 1)
+}

package/rules/security/meta.json

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

package/rules/style-lint/js/lint.mjs

@@ -0,0 +1,34 @@
+/**
+ * Quick-крок lint правила style-lint: stylelint --fix по css/scss/vue.
+ *
+ * `files` (quick) → лише style-файли з них; undefined (ci) → весь glob `**\/*.{css,scss,vue}`.
+ */
+import { spawnSync } from 'node:child_process'
+
+const STYLE_EXT_RE = /\.(?:css|scss|vue)$/u
+
+/**
+ * @param {string[]} files список шляхів
+ * @returns {string[]} лише css/scss/vue
+ */
+export function filterStyleFiles(files) {
+  return files.filter(f => STYLE_EXT_RE.test(f))
+}
+
+/**
+ * @param {string[] | undefined} files quick: ці файли; undefined: весь проєкт
+ * @param {string} [cwd] корінь
+ * @returns {Promise<number>} exit code
+ */
+export function lint(files, cwd = process.cwd()) {
+  const args = ['stylelint', '--fix']
+  if (files === undefined) {
+    args.push('**/*.{css,scss,vue}')
+  } else {
+    const style = filterStyleFiles(files)
+    if (style.length === 0) return Promise.resolve(0)
+    args.push(...style)
+  }
+  const r = spawnSync('npx', args, { cwd, stdio: 'inherit' })
+  return Promise.resolve(typeof r.status === 'number' ? r.status : 1)
+}

package/rules/style-lint/meta.json

@@ -1 +1 @@
-{ "auto": { "glob": ["**/*.css", "**/*.vue"] } }
+{ "auto": { "glob": ["**/*.css", "**/*.vue"] }, "lint": "quick" }

package/rules/text/js/lint.mjs

@@ -0,0 +1,12 @@
+/**
+ * Ci-крок text: делегує у наявний CLI правила (per-file режиму немає — `files` ігнорується).
+ */
+import { runLintTextCli } from '../lint/lint.mjs'
+
+/**
+ * @param {string[] | undefined} _files ігнорується (whole-repo аналіз)
+ * @returns {Promise<number>} exit code
+ */
+export async function lint(_files) {
+  return runLintTextCli()
+}

package/rules/text/meta.json

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

package/schemas/rule-meta.json

@@ -6,6 +6,7 @@
   "type": "object",
   "additionalProperties": false,
   "properties": {
+    "lint": { "type": "string", "enum": ["quick", "ci"], "description": "Фаза lint-кроку: quick (по змінених, у lint і lint-ci) або ci (лише lint-ci)." },
     "auto": {
       "description": "Умова автоактивації правила: \"завжди\", масив id правил-залежностей, glob, або іменований предикат.",
       "oneOf": [

package/scripts/lib/changed-files.mjs

@@ -0,0 +1,30 @@
+/**
+ * Збір змінених файлів для quick-режиму lint-оркестратора.
+ *
+ * Quick лінтить лише те, що змінено в робочому дереві: tracked-modified + staged
+ * (`git diff HEAD`) і нові untracked (`git ls-files --others --exclude-standard`).
+ * Видалені файли не повертаються. Поза git-репо або при помилці git — порожній список.
+ */
+import { spawnSync } from 'node:child_process'
+
+/**
+ * @param {string[]} args аргументи git
+ * @param {string} cwd корінь
+ * @returns {string[]} непорожні рядки stdout або [] при помилці
+ */
+function gitLines(args, cwd) {
+  const r = spawnSync('git', args, { cwd, encoding: 'utf8' })
+  if (r.status !== 0 || r.error) return []
+  return r.stdout.split('\n').map(s => s.trim()).filter(Boolean)
+}
+
+/**
+ * Relative-posix список змінених + untracked файлів робочого дерева.
+ * @param {string} [cwd] корінь репо
+ * @returns {string[]} унікальні шляхи (без видалених)
+ */
+export function collectChangedFiles(cwd = process.cwd()) {
+  const modified = gitLines(['diff', 'HEAD', '--name-only', '--diff-filter=ACMR'], cwd)
+  const untracked = gitLines(['ls-files', '--others', '--exclude-standard'], cwd)
+  return [...new Set([...modified, ...untracked])]
+}

package/scripts/lib/rule-meta.mjs

@@ -48,6 +48,18 @@ export function parseRuleAutoSpec(value) {
   return null
 }
 
+/** Допустимі фази lint. */
+const LINT_PHASES = new Set(['quick', 'ci'])
+
+/**
+ * Нормалізує значення `meta.json.lint` у фазу lint.
+ * @param {unknown} value значення поля `lint`
+ * @returns {'quick' | 'ci' | null} фаза або `null` (відсутнє/невалідне = не lint-крок)
+ */
+export function parseRuleLintPhase(value) {
+  return typeof value === 'string' && LINT_PHASES.has(value) ? /** @type {'quick'|'ci'} */ (value) : null
+}
+
 /**
  * Читає й парсить `meta.json` одного правила.
  * @param {string} ruleDir абсолютний шлях до каталогу правила

package/scripts/lint-cli.mjs

@@ -0,0 +1,83 @@
+/**
+ * Оркестратор `n-cursor lint` (quick) / `n-cursor lint-ci` (full).
+ *
+ * Data-driven: сканує `rules/<id>/meta.json` за полем `lint` (`quick`|`ci`),
+ * послідовно (заборона паралельного eslint) викликає `rules/<id>/js/lint.mjs`:
+ *  - quick: `lint(changedFiles)` — лише змінені файли (git diff HEAD + untracked);
+ *  - ci:    `lint(undefined)` — весь проєкт.
+ * Порядок правил — алфавітний; ci-набір = quick ∪ ci. Fail-fast: перший ненульовий код спиняє.
+ */
+import { existsSync, readdirSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { cwd as processCwd } from 'node:process'
+
+import { parseRuleLintPhase, readRuleMetaRaw } from './lib/rule-meta.mjs'
+import { collectChangedFiles } from './lib/changed-files.mjs'
+
+const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)))
+const RULES_DIR = join(PACKAGE_ROOT, 'rules')
+
+/**
+ * Вибирає id правил для фази, алфавітно.
+ * @param {Record<string, {lint?: unknown}>} metaById мапа id → meta-обʼєкт
+ * @param {'quick'|'ci'} phase цільова фаза (quick → лише quick; ci → quick+ci)
+ * @returns {string[]} відсортовані id
+ */
+export function selectLintRules(metaById, phase) {
+  const out = []
+  for (const [id, raw] of Object.entries(metaById)) {
+    const p = parseRuleLintPhase(raw?.lint)
+    if (p === 'quick' || (phase === 'ci' && p === 'ci')) out.push(id)
+  }
+  return out.toSorted((a, b) => a.localeCompare(b))
+}
+
+/**
+ * Зчитує meta всіх правил пакета.
+ * @param {string} rulesDir каталог rules
+ * @returns {Record<string, Record<string, unknown>>} id → meta
+ */
+function readAllMeta(rulesDir) {
+  /** @type {Record<string, Record<string, unknown>>} */
+  const out = {}
+  if (!existsSync(rulesDir)) return out
+  for (const e of readdirSync(rulesDir, { withFileTypes: true })) {
+    if (!e.isDirectory() || e.name.startsWith('.')) continue
+    const raw = readRuleMetaRaw(join(rulesDir, e.name))
+    if (raw) out[e.name] = raw
+  }
+  return out
+}
+
+/**
+ * Запускає lint-оркестрацію.
+ * @param {{ ci?: boolean, cwd?: string, rulesDir?: string, log?: (s: string) => void }} [opts] параметри
+ * @returns {Promise<number>} exit code
+ */
+export async function runLint(opts = {}) {
+  const ci = opts.ci === true
+  const cwd = opts.cwd ?? processCwd()
+  const rulesDir = opts.rulesDir ?? RULES_DIR
+  const log = opts.log ?? (s => process.stdout.write(s))
+
+  const changed = ci ? undefined : collectChangedFiles(cwd)
+  if (!ci && changed.length === 0) {
+    log('\nℹ️  lint: немає змінених файлів — нічого перевіряти.\n')
+    return 0
+  }
+
+  const ids = selectLintRules(readAllMeta(rulesDir), ci ? 'ci' : 'quick')
+  for (const id of ids) {
+    const lintPath = join(rulesDir, id, 'js', 'lint.mjs')
+    if (!existsSync(lintPath)) {
+      log(`⚠️  lint: правило ${id} має lint-фазу, але немає js/lint.mjs — пропускаю.\n`)
+      continue
+    }
+    // eslint-disable-next-line no-unsanitized/method -- шлях з discovered rule dir
+    const mod = await import(lintPath)
+    const code = await mod.lint(changed, cwd)
+    if (code !== 0) return code
+  }
+  return 0
+}

package/scripts/lib/run-lint-cli.mjs

@@ -1,116 +0,0 @@
-/**
- * `n-cursor lint` — оркестратор лінт-ланцюжка з вимірюванням часу на кожен крок.
- *
- * Замість агрегатора `bun run lint-ga && bun run lint-js && ... && oxfmt .` у кореневому
- * `package.json` (де child-процеси анонімні і час кожного не видно), цей оркестратор:
- *
- *  - читає `scripts` з кореневого `package.json`,
- *  - бере **присутні** ключі з фіксованого списку `LINT_SCRIPTS` (відсутні мовчки пропускає),
- *  - послідовно запускає `bun run <script>`,
- *  - заміряє час кожного,
- *  - **fail-fast**: при першому ненульовому exit-коді зупиняється, друкує таблицю
- *    лише по виконаних і повертає той самий код,
- *  - друкує підсумкову таблицю `⏱ Lint timing` і повертає 0, якщо все ОК.
- *
- * Список + порядок зумисне фіксований: збігається з канонічним ланцюжком, що його раніше
- * тримав root `package.json`. Динамічний discovery (`scripts/^lint-/`) дав би непередбачуваний
- * порядок і небажану інтерпретацію власних `lint-*` користувача.
- *
- * `oxfmt` — окремий рядок поза префіксом `lint-`, ставиться в кінець (як було у `lint`).
- */
-import { spawnSync as defaultSpawnSync } from 'node:child_process'
-import { existsSync, readFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-import { formatTimingSummary } from './timing-summary.mjs'
-
-/**
- * Імена npm-скриптів, які `n-cursor lint` запускає **по черзі**, якщо вони є у root `package.json`.
- * Порядок дзеркалить попередній агрегатор `lint`: cheap-checks першими, формат — в кінці.
- */
-export const LINT_SCRIPTS = /** @type {const} */ ([
-  'lint-ga',
-  'lint-js',
-  'lint-rego',
-  'lint-style',
-  'lint-text',
-  'lint-security',
-  'oxfmt'
-])
-
-/**
- * Читає `scripts` з `package.json` у заданій теці. Повертає `null`, якщо файла немає, JSON
- * некоректний або поля `scripts` нема. Не кидає — викликач сам вирішує, що робити.
- * @param {string} root абсолютний шлях до теки з `package.json`
- * @returns {Record<string, string> | null} мапа scripts або null
- */
-function readRootScripts(root) {
-  const packageJsonPath = join(root, 'package.json')
-  if (!existsSync(packageJsonPath)) {
-    return null
-  }
-  try {
-    const parsed = JSON.parse(readFileSync(packageJsonPath, 'utf8'))
-    const scripts = parsed?.scripts
-    if (!scripts || typeof scripts !== 'object') {
-      return null
-    }
-    return /** @type {Record<string, string>} */ (scripts)
-  } catch {
-    return null
-  }
-}
-
-/**
- * @typedef {{
- *   cwd?: string,
- *   spawnSyncFn?: typeof defaultSpawnSync,
- *   now?: () => number,
- *   log?: (text: string) => void,
- *   logError?: (text: string) => void
- * }} RunLintCliOptions
- */
-
-/**
- * Виконує лінт-ланцюжок з вимірюванням часу. Повертає exit-код, не кидає винятків (для прямого
- * присвоєння у `process.exitCode`).
- * @param {RunLintCliOptions} [options] DI для тестів (підміняємо spawn / fs / clock)
- * @returns {number} 0 = успіх, ненульовий = code першого впалого скрипта, або 1 при структурних проблемах
- */
-export function runLintCli(options = {}) {
-  const root = options.cwd ?? process.cwd()
-  const spawnSync = options.spawnSyncFn ?? defaultSpawnSync
-  const now = options.now ?? Date.now
-  const log = options.log ?? (text => process.stdout.write(text))
-  const logError = options.logError ?? (text => process.stderr.write(text))
-
-  const scripts = readRootScripts(root)
-  if (scripts === null) {
-    logError(`❌ n-cursor lint: не знайдено package.json або поля "scripts" у ${root}\n`)
-    return 1
-  }
-
-  const present = LINT_SCRIPTS.filter(name => typeof scripts[name] === 'string' && scripts[name].length > 0)
-  if (present.length === 0) {
-    log('\nℹ️  n-cursor lint: у package.json немає жодного з lint-* / oxfmt скриптів — нічого запускати.\n')
-    return 0
-  }
-
-  /** @type {{ id: string, ms: number, ok: boolean }[]} */
-  const timings = []
-  let failedCode = 0
-  for (const name of present) {
-    const startedAt = now()
-    const result = spawnSync('bun', ['run', name], { stdio: 'inherit', cwd: root })
-    const code = typeof result.status === 'number' ? result.status : 1
-    const ok = code === 0
-    timings.push({ id: name, ms: now() - startedAt, ok })
-    if (!ok) {
-      failedCode = code === 0 ? 1 : code
-      break
-    }
-  }
-
-  log(formatTimingSummary('Lint timing', timings))
-  return failedCode
-}