@nitra/cursor 1.8.24 → 1.8.29

package/mdc/vue.mdc

@@ -217,10 +217,10 @@ export default defineConfig({
 
 Потрібно використовувати Vite версії 8 та вище для frontend проекту на Vue.
 
-Потрібно використовувати unplugin-auto-import для автоматичного імпортування компонентів, composables, utils та інших функцій і прибирати з Vue sfc імпорти які їх дублюють.
+Потрібно використовувати unplugin-auto-import для автоматичного імпортування компонентів, composables, utils та інших функцій і прибирати з файлів усередині Vite проектів відповідні ручні імпорти, зокрема рядки виду `import { … } from 'vue'` — API Vue (`ref`, `computed`, `watch` тощо) мають підставлятися через auto-import, а не дублюватися явним імпортом з модуля `vue`.
 
 Потрібно використовувати vite-plugin-vue-layouts-next для автоматичного імпортування layout компонентів.
 
 ## Перевірка
 
-`npx @nitra/cursor check vue`
+`npx @nitra/cursor check vue` — перевіряє залежності, `vite.config`, а також обходить джерела Vue-пакета (`.vue`, `.ts`, `.js` тощо) на заборонені value-імпорти з модуля `vue`; дозволені лише type-only та side-effect `import 'vue'`. Імпорти аналізуються через **oxc-parser** (`module.staticImports`); для `.vue` вміст `<script>` витягується з SFC, далі той самий парсер (логіка в `npm/scripts/utils/vue-forbidden-imports.mjs`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nitra/cursor",
-  "version": "1.8.24",
+  "version": "1.8.29",
   "description": "CLI для завантаження cursor-правил (префікс n-) у локальний репозиторій",
   "keywords": [
     "cli",
@@ -36,6 +36,7 @@
     "test": "bun test tests"
   },
   "dependencies": {
+    "oxc-parser": "^0.124.0",
     "yaml": "^2.8.3"
   },
   "engines": {

package/scripts/check-ga.mjs

@@ -7,13 +7,22 @@
  * перед `uses: ./…/setup-bun-deps` у workflow — `actions/checkout` (runner інакше не бачить локальний action).
  *
  * Заборонено дублювати кроки встановлення Bun та кешування безпосередньо у workflow файлах
- * (oven-sh/setup-bun, actions/cache, bun install).
+ * (oven-sh/setup-bun, actions/cache, bun install). Перевірки `uses`/`run` виконуються після **YAML parse**
+ * (`yaml`), щоб не спрацьовувати на випадкові збіги в коментарях або поза кроками.
  */
 import { existsSync } from 'node:fs'
 import { readdir, readFile } from 'node:fs/promises'
 import { join } from 'node:path'
 
 import { pass } from './utils/pass.mjs'
+import {
+  anyRunStepIncludes,
+  eventPathsIncludeExact,
+  findForbiddenUsesOrRunPatterns,
+  hasAnyStepUsesContaining,
+  hasCheckoutBeforeLocalSetupBunDeps,
+  parseWorkflowYaml
+} from './utils/gha-workflow.mjs'
 
 /** Шаблони наявності MegaLinter у вмісті workflow */
 const MEGALINTER_USE_PATTERNS = [/oxsecurity\/megalinter-action/i, /megalinter\/megalinter/i]
@@ -21,8 +30,19 @@ const MEGALINTER_USE_PATTERNS = [/oxsecurity\/megalinter-action/i, /megalinter\/
 /** Типові конфіги MegaLinter у корені репо */
 const MEGALINTER_CONFIG_NAMES = ['.mega-linter.yml', '.megalinter.yaml', '.mega-linter.yaml']
 
+/** Локальні composite setup-bun-deps (ga.mdc). */
+const SETUP_BUN_PATTERNS = ['./.github/actions/setup-bun-deps', './npm/github-actions/setup-bun-deps']
+
+/** Заборонені підрядки лише в кроках uses/run. */
+const FORBIDDEN_BUN_PATTERNS = [
+  { pattern: 'oven-sh/setup-bun', msg: 'використовуй .github/actions/setup-bun-deps замість oven-sh/setup-bun' },
+  { pattern: 'actions/cache', msg: 'використовуй .github/actions/setup-bun-deps замість actions/cache' },
+  { pattern: 'bun install', msg: 'використовуй .github/actions/setup-bun-deps замість bun install' }
+]
+
 /**
  * Якщо workflow викликає локальний setup-bun-deps, раніше у файлі має бути `actions/checkout@v…` (ga.mdc).
+ * Fallback: сирий текст, якщо YAML не вдається розібрати.
  * @param {string} relPath шлях для повідомлень
  * @param {string} content вміст YAML
  * @param {(msg: string) => void} failFn реєструє порушення (exit 1)
@@ -30,9 +50,22 @@ const MEGALINTER_CONFIG_NAMES = ['.mega-linter.yml', '.megalinter.yaml', '.mega-
  * @returns {void}
  */
 function verifyCheckoutBeforeLocalSetupBunDeps(relPath, content, failFn, passFn) {
-  const patterns = ['./.github/actions/setup-bun-deps', './npm/github-actions/setup-bun-deps']
+  const root = parseWorkflowYaml(content)
+  if (root) {
+    if (!hasAnyStepUsesContaining(root, SETUP_BUN_PATTERNS)) {
+      return
+    }
+    if (!hasCheckoutBeforeLocalSetupBunDeps(root, SETUP_BUN_PATTERNS)) {
+      failFn(
+        `${relPath}: перед локальним setup-bun-deps потрібен крок actions/checkout@v6 — інакше runner не знайде action.yml (ga.mdc)`
+      )
+      return
+    }
+    passFn(`${relPath}: перед setup-bun-deps є checkout`)
+    return
+  }
   let idxSetup = -1
-  for (const p of patterns) {
+  for (const p of SETUP_BUN_PATTERNS) {
     const i = content.indexOf(p)
     if (i !== -1 && (idxSetup === -1 || i < idxSetup)) {
       idxSetup = i
@@ -52,27 +85,33 @@ function verifyCheckoutBeforeLocalSetupBunDeps(relPath, content, failFn, passFn)
 }
 
 /**
- * Перевіряє, чи не використовуються oven-sh/setup-bun або actions/cache безпосередньо у workflow.
+ * Перевіряє заборонені кроки Bun/cache/install у `uses` та `run`.
  * @param {string} relPath шлях для повідомлень
  * @param {string} content вміст YAML
  * @param {(msg: string) => void} failFn реєструє порушення (exit 1)
  * @param {(msg: string) => void} passFn реєструє успішну перевірку
+ * @returns {void}
  */
 function verifyNoDirectBunOrCache(relPath, content, failFn, passFn) {
-  const forbidden = [
-    { pattern: 'oven-sh/setup-bun', msg: 'використовуй .github/actions/setup-bun-deps замість oven-sh/setup-bun' },
-    { pattern: 'actions/cache', msg: 'використовуй .github/actions/setup-bun-deps замість actions/cache' },
-    { pattern: 'bun install', msg: 'використовуй .github/actions/setup-bun-deps замість bun install' }
-  ]
-
+  const root = parseWorkflowYaml(content)
+  if (root) {
+    const hits = findForbiddenUsesOrRunPatterns(root, FORBIDDEN_BUN_PATTERNS)
+    if (hits.length === 0) {
+      passFn(`${relPath}: не містить заборонених кроків setup-bun/cache/install`)
+    } else {
+      for (const h of hits) {
+        failFn(`${relPath}: ${h.msg} (ga.mdc)`)
+      }
+    }
+    return
+  }
   let foundForbidden = false
-  for (const { pattern, msg } of forbidden) {
+  for (const { pattern, msg } of FORBIDDEN_BUN_PATTERNS) {
     if (content.includes(pattern)) {
       failFn(`${relPath}: ${msg} (ga.mdc)`)
       foundForbidden = true
     }
   }
-
   if (!foundForbidden) {
     passFn(`${relPath}: не містить заборонених кроків setup-bun/cache/install`)
   }
@@ -109,7 +148,9 @@ export async function check() {
 
   const yamlFiles = files.filter(f => f.endsWith('.yaml'))
   if (yamlFiles.length > 0) {
-    for (const f of yamlFiles) fail(`Workflow з розширенням .yaml: ${wfDir}/${f} — перейменуй на .yml`)
+    for (const f of yamlFiles) {
+      fail(`Workflow з розширенням .yaml: ${wfDir}/${f} — перейменуй на .yml`)
+    }
   } else {
     pass('Всі workflows мають розширення .yml')
   }
@@ -124,7 +165,10 @@ export async function check() {
 
   if (files.includes('apply-k8s.yml')) {
     const content = await readFile(`${wfDir}/apply-k8s.yml`, 'utf8')
-    if (content.includes('**/k8s/**/*.yaml')) {
+    const root = parseWorkflowYaml(content)
+    const ok =
+      root && eventPathsIncludeExact(root, 'push', '**/k8s/**/*.yaml') ? true : content.includes('**/k8s/**/*.yaml')
+    if (ok) {
       pass('apply-k8s.yml має правильний paths trigger')
     } else {
       fail('apply-k8s.yml не містить paths: **/k8s/**/*.yaml')
@@ -133,7 +177,10 @@ export async function check() {
 
   if (files.includes('apply-nats-consumer.yml')) {
     const content = await readFile(`${wfDir}/apply-nats-consumer.yml`, 'utf8')
-    if (content.includes('**/consumer.yaml')) {
+    const root = parseWorkflowYaml(content)
+    const ok =
+      root && eventPathsIncludeExact(root, 'push', '**/consumer.yaml') ? true : content.includes('**/consumer.yaml')
+    if (ok) {
       pass('apply-nats-consumer.yml має правильний paths trigger')
     } else {
       fail('apply-nats-consumer.yml не містить paths: **/consumer.yaml')
@@ -216,15 +263,30 @@ export async function check() {
   const lintGaWf = join(wfDir, 'lint-ga.yml')
   if (existsSync(lintGaWf)) {
     const lgContent = await readFile(lintGaWf, 'utf8')
-    if (lgContent.includes('bun run lint-ga')) {
-      pass('lint-ga.yml викликає bun run lint-ga')
-    } else {
-      fail('lint-ga.yml: крок має містити bun run lint-ga')
-    }
-    if (lgContent.includes('astral-sh/setup-uv')) {
-      pass('lint-ga.yml містить astral-sh/setup-uv')
+    const root = parseWorkflowYaml(lgContent)
+    if (root) {
+      if (anyRunStepIncludes(root, 'bun run lint-ga')) {
+        pass('lint-ga.yml викликає bun run lint-ga')
+      } else {
+        fail('lint-ga.yml: крок має містити bun run lint-ga')
+      }
+      const usesFlat = hasAnyStepUsesContaining(root, ['astral-sh/setup-uv'])
+      if (usesFlat || lgContent.includes('astral-sh/setup-uv')) {
+        pass('lint-ga.yml містить astral-sh/setup-uv')
+      } else {
+        fail('lint-ga.yml: додай astral-sh/setup-uv для uvx zizmor (ga.mdc)')
+      }
     } else {
-      fail('lint-ga.yml: додай astral-sh/setup-uv для uvx zizmor (ga.mdc)')
+      if (lgContent.includes('bun run lint-ga')) {
+        pass('lint-ga.yml викликає bun run lint-ga')
+      } else {
+        fail('lint-ga.yml: крок має містити bun run lint-ga')
+      }
+      if (lgContent.includes('astral-sh/setup-uv')) {
+        pass('lint-ga.yml містить astral-sh/setup-uv')
+      } else {
+        fail('lint-ga.yml: додай astral-sh/setup-uv для uvx zizmor (ga.mdc)')
+      }
     }
   }
 

package/scripts/check-js-lint.mjs

@@ -10,6 +10,7 @@ import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 
 import { pass } from './utils/pass.mjs'
+import { parseWorkflowYaml, verifyLintJsWorkflowStructure } from './utils/gha-workflow.mjs'
 
 /** Очікуваний локальний скрипт (oxlint без bunx; eslint/jscpd через bunx). */
 export const CANONICAL_LINT_JS = 'oxlint --fix && bunx eslint --fix . && bunx jscpd .'
@@ -154,26 +155,38 @@ export async function check() {
   if (existsSync('.github/workflows/lint-js.yml')) {
     const content = await readFile('.github/workflows/lint-js.yml', 'utf8')
     pass('lint-js.yml існує')
-    const checks = [
-      ['actions/checkout@v6', 'lint-js.yml: потрібен крок actions/checkout@v6 (ga.mdc)'],
-      ['persist-credentials: false', 'lint-js.yml: checkout з persist-credentials: false'],
-      ['./.github/actions/setup-bun-deps', 'lint-js.yml: потрібен uses: ./.github/actions/setup-bun-deps'],
-      ['bunx oxlint', 'lint-js.yml: у run має бути bunx oxlint'],
-      ['bunx eslint .', 'lint-js.yml: у run має бути bunx eslint . (без --fix у CI)'],
-      ['bunx jscpd .', 'lint-js.yml: у run має бути bunx jscpd .']
-    ]
-    for (const [needle, errMsg] of checks) {
-      if (content.includes(needle)) {
-        pass(`lint-js.yml містить: ${needle}`)
+    const root = parseWorkflowYaml(content)
+    if (root) {
+      const v = verifyLintJsWorkflowStructure(root)
+      if (v.ok) {
+        pass('lint-js.yml: кроки checkout, setup-bun-deps, oxlint/eslint/jscpd (YAML + кроки)')
       } else {
-        fail(errMsg)
+        for (const msg of v.failures) {
+          fail(`lint-js.yml: ${msg}`)
+        }
+      }
+    } else {
+      const checks = [
+        ['actions/checkout@v6', 'lint-js.yml: потрібен крок actions/checkout@v6 (ga.mdc)'],
+        ['persist-credentials: false', 'lint-js.yml: checkout з persist-credentials: false'],
+        ['./.github/actions/setup-bun-deps', 'lint-js.yml: потрібен uses: ./.github/actions/setup-bun-deps'],
+        ['bunx oxlint', 'lint-js.yml: у run має бути bunx oxlint'],
+        ['bunx eslint .', 'lint-js.yml: у run має бути bunx eslint . (без --fix у CI)'],
+        ['bunx jscpd .', 'lint-js.yml: у run має бути bunx jscpd .']
+      ]
+      for (const [needle, errMsg] of checks) {
+        if (content.includes(needle)) {
+          pass(`lint-js.yml містить: ${needle}`)
+        } else {
+          fail(errMsg)
+        }
+      }
+      if (content.includes('bunx oxlint') && /bunx\s+oxlint[^\n]*--fix/u.test(content)) {
+        fail('lint-js.yml: у CI не використовуй oxlint --fix (лише bunx oxlint)')
+      }
+      if (content.includes('eslint --fix')) {
+        fail('lint-js.yml: у CI не використовуй eslint --fix (лише bunx eslint .)')
       }
-    }
-    if (content.includes('bunx oxlint') && /bunx\s+oxlint[^\n]*--fix/u.test(content)) {
-      fail('lint-js.yml: у CI не використовуй oxlint --fix (лише bunx oxlint)')
-    }
-    if (content.includes('eslint --fix')) {
-      fail('lint-js.yml: у CI не використовуй eslint --fix (лише bunx eslint .)')
     }
   } else {
     fail('.github/workflows/lint-js.yml не існує — створи його (див. check-js-lint.mjs / js-lint.mdc)')

package/scripts/check-npm-module.mjs

@@ -2,11 +2,19 @@
  * Перевіряє структуру npm-модуля в монорепо за правилом npm-module.mdc.
  *
  * Workspace `npm/`, `npm/package.json`, workflow `npm-publish.yml` з OIDC, `on.push.paths` з glob для каталогу npm (див. npm-module.mdc).
+ * Поля workflow перевіряються після **YAML parse**, щоб не плутати з коментарями.
  */
 import { existsSync } from 'node:fs'
 import { readFile, stat } from 'node:fs/promises'
 
 import { pass } from './utils/pass.mjs'
+import {
+  hasIdTokenWritePermission,
+  hasNpmPublishStepWithPackage,
+  parseWorkflowYaml,
+  pushHasMainBranch,
+  pushPathsIncludeNpmGlob
+} from './utils/gha-workflow.mjs'
 
 /**
  * Перевіряє відповідність проєкту правилам npm-module.mdc
@@ -62,19 +70,44 @@ export async function check() {
   if (existsSync(publishWf)) {
     pass(`${publishWf} існує`)
     const pub = await readFile(publishWf, 'utf8')
-    const need = [
-      { sub: 'npm/**', msg: `${publishWf}: у on.push.paths має бути npm/**` },
-      { sub: 'branches:', msg: `${publishWf}: очікується on.push.branches` },
-      { sub: 'main', msg: `${publishWf}: очікується branch main` },
-      { sub: 'id-token: write', msg: `${publishWf}: permissions має містити id-token: write (OIDC)` },
-      { sub: 'JS-DevTools/npm-publish', msg: `${publishWf}: очікується uses: JS-DevTools/npm-publish` },
-      { sub: 'package: npm/package.json', msg: `${publishWf}: with.package має бути npm/package.json` }
-    ]
-    for (const { sub, msg } of need) {
-      if (pub.includes(sub)) {
-        pass(`${publishWf} містить «${sub}»`)
+    const root = parseWorkflowYaml(pub)
+
+    if (root) {
+      if (pushPathsIncludeNpmGlob(root)) {
+        pass(`${publishWf}: on.push.paths містить npm/**`)
+      } else {
+        fail(`${publishWf}: у on.push.paths має бути npm/**`)
+      }
+      if (pushHasMainBranch(root)) {
+        pass(`${publishWf}: очікується branch main`)
+      } else {
+        fail(`${publishWf}: очікується branch main`)
+      }
+      if (hasIdTokenWritePermission(root)) {
+        pass(`${publishWf}: permissions містить id-token: write (OIDC)`)
       } else {
-        fail(msg)
+        fail(`${publishWf}: permissions має містити id-token: write (OIDC)`)
+      }
+      if (hasNpmPublishStepWithPackage(root)) {
+        pass(`${publishWf}: uses JS-DevTools/npm-publish та with.package npm/package.json`)
+      } else {
+        fail(`${publishWf}: очікується uses: JS-DevTools/npm-publish та with.package: npm/package.json`)
+      }
+    } else {
+      const need = [
+        { sub: 'npm/**', msg: `${publishWf}: у on.push.paths має бути npm/**` },
+        { sub: 'branches:', msg: `${publishWf}: очікується on.push.branches` },
+        { sub: 'main', msg: `${publishWf}: очікується branch main` },
+        { sub: 'id-token: write', msg: `${publishWf}: permissions має містити id-token: write (OIDC)` },
+        { sub: 'JS-DevTools/npm-publish', msg: `${publishWf}: очікується uses: JS-DevTools/npm-publish` },
+        { sub: 'package: npm/package.json', msg: `${publishWf}: with.package має бути npm/package.json` }
+      ]
+      for (const { sub, msg } of need) {
+        if (pub.includes(sub)) {
+          pass(`${publishWf} містить «${sub}»`)
+        } else {
+          fail(msg)
+        }
       }
     }
   } else {

package/scripts/check-style-lint.mjs

@@ -8,6 +8,7 @@ import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 
 import { pass } from './utils/pass.mjs'
+import { anyRunStepIncludesStylelint, parseWorkflowYaml } from './utils/gha-workflow.mjs'
 
 /**
  * Перевіряє відповідність проєкту правилам style-lint.mdc
@@ -54,8 +55,10 @@ export async function check() {
   if (existsSync('.github/workflows/lint-style.yml')) {
     const content = await readFile('.github/workflows/lint-style.yml', 'utf8')
     pass('lint-style.yml існує')
-    if (content.includes('stylelint')) {
-      pass('lint-style.yml містить stylelint')
+    const root = parseWorkflowYaml(content)
+    const ok = root ? anyRunStepIncludesStylelint(root) : content.includes('stylelint')
+    if (ok) {
+      pass('lint-style.yml містить stylelint у кроці run')
     } else {
       fail('lint-style.yml не містить виклик stylelint')
     }

package/scripts/check-text.mjs

@@ -13,6 +13,7 @@ import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 
 import { pass } from './utils/pass.mjs'
+import { anyRunStepIncludes, parseWorkflowYaml } from './utils/gha-workflow.mjs'
 
 /** Заголовок абзацу про апостроф у text.mdc / n-text.mdc. */
 const UK_APOSTROPHE_HEADING = '**Український апостроф:**'
@@ -194,7 +195,9 @@ export async function check() {
 
     if (existsSync('.github/workflows/lint-text.yml')) {
       const wf = await readFile('.github/workflows/lint-text.yml', 'utf8')
-      if (wf.includes('bun run lint-text')) {
+      const root = parseWorkflowYaml(wf)
+      const ok = root ? anyRunStepIncludes(root, 'bun run lint-text') : wf.includes('bun run lint-text')
+      if (ok) {
         pass('lint-text.yml викликає bun run lint-text')
       } else {
         fail('lint-text.yml має містити крок bun run lint-text')

package/scripts/check-vue.mjs

@@ -3,12 +3,21 @@
  *
  * Версії Vite та плагінів, vue-macros, auto-import, layouts, вміст `vite.config`;
  * у репозиторії — рекомендацію розширення Vue.volar.
+ *
+ * Заборонені явні value-імпорти з `vue` у джерелах пакета — сканування `.vue`/`.ts`/`.js` тощо
+ * через **oxc-parser** (`module.staticImports`; див. `utils/vue-forbidden-imports.mjs`); дозволені лише type-only та side-effect `import 'vue'`.
  */
 import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
-import { join } from 'node:path'
+import { join, relative } from 'node:path'
 
 import { pass } from './utils/pass.mjs'
+import {
+  findForbiddenVueImportsInSourceFile,
+  isVueImportScanSourceFile,
+  shouldSkipFileForVueImportScan
+} from './utils/vue-forbidden-imports.mjs'
+import { walkDir } from './utils/walkDir.mjs'
 import { getMonorepoPackageRootDirs } from './utils/workspaces.mjs'
 
 /**
@@ -20,11 +29,31 @@ function packageLabel(rootDir) {
   return rootDir === '.' ? 'корінь' : rootDir
 }
 
+/**
+ * Текст кількості файлів українською (1 файл, 2 файли, 5 файлів, 11 файлів).
+ * @param {number} n невід’ємна кількість
+ * @returns {string} фраза виду «N файл» / «N файли» / «N файлів»
+ */
+function ukFilesCountPhrase(n) {
+  const m100 = n % 100
+  if (m100 >= 11 && m100 <= 14) {
+    return `${n} файлів`
+  }
+  const m10 = n % 10
+  if (m10 === 1) {
+    return `${n} файл`
+  }
+  if (m10 >= 2 && m10 <= 4) {
+    return `${n} файли`
+  }
+  return `${n} файлів`
+}
+
 /**
  * Перевіряє залежності та vite.config одного Vue-пакета.
  * @param {string} rootDir відносний шлях до пакета
  * @param {(msg: string) => void} fail функція зворотного виклику для реєстрації помилки перевірки
- * @returns {Promise<void>} завершується після перевірок залежностей і Vite
+ * @returns {Promise<void>} завершується після перевірок залежностей, `vite.config` і сканування джерел на імпорти з `vue`
  */
 async function checkVuePackage(rootDir, fail) {
   const label = packageLabel(rootDir)
@@ -95,6 +124,33 @@ async function checkVuePackage(rootDir, fail) {
   } else {
     fail(`${prefix}немає vite.config.js|ts|mjs у каталозі пакета`)
   }
+
+  const absPackageRoot = join(process.cwd(), rootDir)
+  /** @type {string[]} */
+  const sourcePaths = []
+  await walkDir(absPackageRoot, absPath => {
+    const rel = relative(absPackageRoot, absPath).split('\\').join('/')
+    if (shouldSkipFileForVueImportScan(rel) || !isVueImportScanSourceFile(rel)) {
+      return
+    }
+    sourcePaths.push(absPath)
+  })
+
+  let importViolations = 0
+  for (const absPath of sourcePaths) {
+    const rel = relative(absPackageRoot, absPath).split('\\').join('/')
+    const content = await readFile(absPath, 'utf8')
+    const hits = findForbiddenVueImportsInSourceFile(content, rel)
+    for (const v of hits) {
+      importViolations++
+      fail(`${prefix}${rel}:${v.line} — прибери явний value-імпорт з 'vue' (unplugin-auto-import): ${v.snippet}`)
+    }
+  }
+  if (importViolations === 0) {
+    pass(
+      `${prefix}немає заборонених value-імпортів з 'vue' у джерелах (проскановано ${ukFilesCountPhrase(sourcePaths.length)})`
+    )
+  }
 }
 
 /**

package/scripts/utils/gha-workflow.mjs

@@ -0,0 +1,350 @@
+/**
+ * Допоміжні функції для аналізу GitHub Actions workflow (`.yml`) після структурного розбору YAML.
+ *
+ * Використовується в check-ga, check-js-lint, check-text, check-style-lint, check-npm-module замість
+ * пошуку підрядків у сирому тексті там, де важливі лише значення `uses:` та `run:` кроків.
+ */
+import { parse } from 'yaml'
+
+/**
+ * Парсить workflow YAML у звичайний об’єкт; при синтаксичній помилці — `null`.
+ * @param {string} content вміст файлу
+ * @returns {Record<string, unknown> | null} корінь документа або `null`
+ */
+export function parseWorkflowYaml(content) {
+  try {
+    const root = parse(content)
+    return root && typeof root === 'object' ? /** @type {Record<string, unknown>} */ (root) : null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Збирає всі кроки з усіх jobs.
+ * @param {Record<string, unknown>} root корінь workflow
+ * @returns {{ jobId: string, stepIndex: number, step: Record<string, unknown> }[]} плоский список кроків з метаданими
+ */
+export function flattenWorkflowSteps(root) {
+  const jobs = root?.jobs
+  if (!jobs || typeof jobs !== 'object') {
+    return []
+  }
+  /** @type {{ jobId: string, stepIndex: number, step: Record<string, unknown> }[]} */
+  const out = []
+  for (const [jobId, job] of Object.entries(jobs)) {
+    if (job && typeof job === 'object') {
+      const steps = /** @type {{ steps?: unknown }} */ (job).steps
+      if (Array.isArray(steps)) {
+        for (const [stepIndex, step] of steps.entries()) {
+          if (step && typeof step === 'object') {
+            out.push({
+              jobId,
+              stepIndex,
+              step: /** @type {Record<string, unknown>} */ (step)
+            })
+          }
+        }
+      }
+    }
+  }
+  return out
+}
+
+/**
+ * Значення `uses:` кроку.
+ * @param {Record<string, unknown>} step об’єкт одного елемента `steps`
+ * @returns {string} рядок `uses` або порожній рядок
+ */
+export function getStepUses(step) {
+  return typeof step.uses === 'string' ? step.uses : ''
+}
+
+/**
+ * Значення `run:` кроку (багаторядковий рядок або масив рядків у YAML).
+ * @param {Record<string, unknown>} step об’єкт одного елемента `steps`
+ * @returns {string} текст команди
+ */
+export function getStepRun(step) {
+  const r = step.run
+  if (typeof r === 'string') {
+    return r
+  }
+  if (Array.isArray(r)) {
+    return r.map(String).join('\n')
+  }
+  return ''
+}
+
+/**
+ * Чи є крок, у якого `uses` містить будь-який з підрядків.
+ * @param {Record<string, unknown>} root корінь workflow
+ * @param {string[]} substrings підрядки для пошуку в `uses`
+ * @returns {boolean} `true`, якщо знайдено хоча б один збіг
+ */
+export function hasAnyStepUsesContaining(root, substrings) {
+  for (const { step } of flattenWorkflowSteps(root)) {
+    const uses = getStepUses(step)
+    if (substrings.some(s => uses.includes(s))) {
+      return true
+    }
+  }
+  return false
+}
+
+/**
+ * Чи перед першим кроком з локальним `setup-bun-deps` у кожному job є `actions/checkout@`.
+ * Якщо `setup-bun-deps` у файлі немає — `true`.
+ * @param {Record<string, unknown>} root корінь workflow
+ * @param {string[]} setupPathSubstrings підрядки `uses`, що означають локальний composite (наприклад `./.github/actions/setup-bun-deps`)
+ * @returns {boolean} `false`, якщо є setup без попереднього checkout
+ */
+export function hasCheckoutBeforeLocalSetupBunDeps(root, setupPathSubstrings) {
+  const jobs = root?.jobs
+  if (!jobs || typeof jobs !== 'object') {
+    return true
+  }
+  for (const job of Object.values(jobs)) {
+    if (job && typeof job === 'object') {
+      const steps = /** @type {{ steps?: unknown }} */ (job).steps
+      if (Array.isArray(steps)) {
+        for (let i = 0; i < steps.length; i++) {
+          const step = steps[i]
+          if (step && typeof step === 'object') {
+            const uses = getStepUses(/** @type {Record<string, unknown>} */ (step))
+            const isSetup = setupPathSubstrings.some(s => uses.includes(s))
+            if (isSetup) {
+              let foundCheckout = false
+              for (let j = 0; j < i; j++) {
+                const prev = steps[j]
+                if (prev && typeof prev === 'object') {
+                  const u = getStepUses(/** @type {Record<string, unknown>} */ (prev))
+                  if (u.includes('actions/checkout@')) {
+                    foundCheckout = true
+                    break
+                  }
+                }
+              }
+              if (!foundCheckout) {
+                return false
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return true
+}
+
+/**
+ * Шукає заборонені підрядки лише в `uses` та `run` кроків (не в коментарях YAML поза кроками).
+ * @param {Record<string, unknown>} root корінь workflow
+ * @param {{ pattern: string, msg: string }[]} forbidden список заборонених фрагментів і повідомлень
+ * @returns {{ jobId: string, stepIndex: number, pattern: string, msg: string }[]} знайдені збіги
+ */
+export function findForbiddenUsesOrRunPatterns(root, forbidden) {
+  /** @type {{ jobId: string, stepIndex: number, pattern: string, msg: string }[]} */
+  const hits = []
+  for (const { jobId, stepIndex, step } of flattenWorkflowSteps(root)) {
+    const uses = getStepUses(step)
+    const run = getStepRun(step)
+    const blob = `${uses}\n${run}`
+    for (const { pattern, msg } of forbidden) {
+      if (blob.includes(pattern)) {
+        hits.push({ jobId, stepIndex, pattern, msg })
+      }
+    }
+  }
+  return hits
+}
+
+/**
+ * Чи є в `on.push.paths` (або `on.pull_request.paths`) елемент з точним значенням.
+ * @param {Record<string, unknown>} root корінь workflow
+ * @param {'push' | 'pull_request'} event ім’я ключа в `on`
+ * @param {string} exact очікуваний glob
+ * @returns {boolean} `true`, якщо шлях присутній у масиві `paths`
+ */
+export function eventPathsIncludeExact(root, event, exact) {
+  const on = root?.on
+  if (!on || typeof on !== 'object') {
+    return false
+  }
+  const ev = /** @type {Record<string, unknown>} */ (on)[event]
+  if (!ev || typeof ev !== 'object') {
+    return false
+  }
+  const paths = /** @type {Record<string, unknown>} */ (ev).paths
+  if (!Array.isArray(paths)) {
+    return false
+  }
+  return paths.includes(exact)
+}
+
+/**
+ * Чи містить `on.push.paths` підрядок `npm/**` (npm-module).
+ * @param {Record<string, unknown>} root корінь workflow
+ * @returns {boolean} `true`, якщо серед `paths` є рядок з `npm/**`
+ */
+export function pushPathsIncludeNpmGlob(root) {
+  const on = root?.on
+  if (!on || typeof on !== 'object') {
+    return false
+  }
+  const push = /** @type {Record<string, unknown>} */ (on).push
+  if (!push || typeof push !== 'object') {
+    return false
+  }
+  const paths = push.paths
+  if (!Array.isArray(paths)) {
+    return false
+  }
+  return paths.some(p => typeof p === 'string' && p.includes('npm/**'))
+}
+
+/**
+ * Перевіряє наявність `branches` з `main` у `on.push`.
+ * @param {Record<string, unknown>} root корінь workflow
+ * @returns {boolean} `true`, якщо `main` є в `on.push.branches`
+ */
+export function pushHasMainBranch(root) {
+  const on = root?.on
+  if (!on || typeof on !== 'object') {
+    return false
+  }
+  const push = /** @type {Record<string, unknown>} */ (on).push
+  if (!push || typeof push !== 'object') {
+    return false
+  }
+  const branches = push.branches
+  if (!Array.isArray(branches)) {
+    return false
+  }
+  return branches.includes('main')
+}
+
+/**
+ * Чи є крок з `uses: JS-DevTools/npm-publish` та `with.package` для npm-пакета.
+ * @param {Record<string, unknown>} root корінь workflow
+ * @returns {boolean} `true`, якщо знайдено крок publish з `package: npm/package.json`
+ */
+export function hasNpmPublishStepWithPackage(root) {
+  for (const { step } of flattenWorkflowSteps(root)) {
+    const uses = getStepUses(step)
+    if (uses.includes('JS-DevTools/npm-publish')) {
+      const w = step.with
+      if (w && typeof w === 'object' && /** @type {Record<string, unknown>} */ (w).package === 'npm/package.json') {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+/**
+ * Чи є у job `permissions.id-token: write`.
+ * @param {Record<string, unknown>} root корінь workflow
+ * @returns {boolean} `true`, якщо OIDC-дозвіл для npm publish налаштований
+ */
+export function hasIdTokenWritePermission(root) {
+  const jobs = root?.jobs
+  if (!jobs || typeof jobs !== 'object') {
+    return false
+  }
+  for (const job of Object.values(jobs)) {
+    if (job && typeof job === 'object') {
+      const perm = /** @type {Record<string, unknown>} */ (job).permissions
+      if (perm && typeof perm === 'object' && /** @type {Record<string, unknown>} */ (perm)['id-token'] === 'write') {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+/**
+ * Перевірки для `lint-js.yml`: checkout@v6, persist-credentials, setup-bun-deps, run-команди.
+ * @param {Record<string, unknown> | null} root корінь workflow або `null` якщо parse не вдався
+ * @returns {{ ok: boolean, failures: string[] }} результат перевірки та список причин відмови
+ */
+export function verifyLintJsWorkflowStructure(root) {
+  /** @type {string[]} */
+  const failures = []
+  if (!root) {
+    return { ok: false, failures: ['YAML не вдалося розібрати — перевір синтаксис workflow'] }
+  }
+
+  const steps = flattenWorkflowSteps(root)
+  const usesList = steps.map(s => getStepUses(s.step))
+  const runBlob = steps.map(s => getStepRun(s.step)).join('\n')
+
+  if (!usesList.some(u => u.includes('actions/checkout@v6'))) {
+    failures.push('немає кроку uses: actions/checkout@v6')
+  }
+
+  let checkoutOk = false
+  for (const { step } of steps) {
+    const u = getStepUses(step)
+    if (u.includes('actions/checkout@v6')) {
+      const w = step.with
+      if (w && typeof w === 'object' && /** @type {Record<string, unknown>} */ (w)['persist-credentials'] === false) {
+        checkoutOk = true
+        break
+      }
+    }
+  }
+  if (!checkoutOk) {
+    failures.push('checkout@v6 без with.persist-credentials: false')
+  }
+
+  if (!usesList.some(u => u.includes('./.github/actions/setup-bun-deps'))) {
+    failures.push('немає uses: ./.github/actions/setup-bun-deps')
+  }
+
+  if (!runBlob.includes('bunx oxlint')) {
+    failures.push('у run немає bunx oxlint')
+  }
+  if (!runBlob.includes('bunx eslint .')) {
+    failures.push('у run немає bunx eslint .')
+  }
+  if (!runBlob.includes('bunx jscpd .')) {
+    failures.push('у run немає bunx jscpd .')
+  }
+
+  for (const { step } of steps) {
+    const run = getStepRun(step)
+    if (/bunx\s+oxlint[^\n]*--fix/u.test(run)) {
+      failures.push('у run є oxlint з --fix (у CI заборонено)')
+    }
+    if (run.includes('eslint --fix')) {
+      failures.push('у run є eslint --fix (у CI заборонено)')
+    }
+  }
+
+  return failures.length === 0 ? { ok: true, failures: [] } : { ok: false, failures }
+}
+
+/**
+ * Чи є в будь-якому `run` кроку підрядок (наприклад `bun run lint-text`).
+ * @param {Record<string, unknown>} root корінь workflow
+ * @param {string} needle підрядок для пошуку
+ * @returns {boolean} `true`, якщо хоча б один `run` містить `needle`
+ */
+export function anyRunStepIncludes(root, needle) {
+  for (const { step } of flattenWorkflowSteps(root)) {
+    if (getStepRun(step).includes(needle)) {
+      return true
+    }
+  }
+  return false
+}
+
+/**
+ * Чи є в будь-якому `run` підрядок `stylelint`.
+ * @param {Record<string, unknown>} root корінь workflow
+ * @returns {boolean} `true`, якщо stylelint згадано в команді
+ */
+export function anyRunStepIncludesStylelint(root) {
+  return anyRunStepIncludes(root, 'stylelint')
+}

package/scripts/utils/vue-forbidden-imports.mjs

@@ -0,0 +1,178 @@
+/**
+ * Визначає явні імпорти з модуля `vue`, які суперечать vue.mdc (має працювати unplugin-auto-import).
+ *
+ * Аналіз import виконується через **oxc-parser** (`parseSync`, поле `module.staticImports`) — ESTree-сумісний
+ * розбір без евристик по рядках. Дозволені лише side-effect `import 'vue'`, повністю type-only імпорти
+ * та `import { type A, type B } from 'vue'` (перевірка `entries[].isType`).
+ *
+ * Для `.vue` з шаблону витягуються лише теги `<script>` / `<script setup>` (регулярний вираз); далі той самий Oxc-парсинг
+ * вмісту скрипта з віртуальним ім’ям `*.ts` для режиму TypeScript.
+ */
+import { parseSync } from 'oxc-parser'
+
+/**
+ * Мова для Oxc за шляхом файлу (розширення).
+ * @param {string} filePath віртуальний або реальний шлях до файлу
+ * @returns {'js' | 'jsx' | 'ts' | 'tsx'} значення опції `lang` для `parseSync`
+ */
+function langFromPath(filePath) {
+  const lower = filePath.toLowerCase()
+  if (lower.endsWith('.tsx')) {
+    return 'tsx'
+  }
+  if (lower.endsWith('.ts') || lower.endsWith('.mts') || lower.endsWith('.cts')) {
+    return 'ts'
+  }
+  if (lower.endsWith('.jsx')) {
+    return 'jsx'
+  }
+  return 'js'
+}
+
+/**
+ * Номер рядка (1-based) за зміщенням у буфері.
+ * @param {string} content повний текст файлу
+ * @param {number} offset байтове зміщення початку import
+ * @returns {number} номер рядка від 1
+ */
+function offsetToLine(content, offset) {
+  let line = 1
+  const n = Math.min(offset, content.length)
+  for (let i = 0; i < n; i++) {
+    if (content.codePointAt(i) === 10) {
+      line++
+    }
+  }
+  return line
+}
+
+/**
+ * Стискає пробіли для повідомлення про порушення.
+ * @param {string} s фрагмент коду
+ * @returns {string} скорочений однорядковий рядок
+ */
+function normalizeSnippet(s) {
+  return s.replaceAll(/\s+/g, ' ').trim().slice(0, 160)
+}
+
+/**
+ * Чи цей static import з `vue` дозволено правилом (усі записи type-only або порожній side-effect).
+ * @param {{ moduleRequest: { value: string }, entries: { isType: boolean }[] }} imp запис з `module.staticImports`
+ * @returns {boolean} `true`, якщо імпорт дозволено (type-only або `import 'vue'`)
+ */
+function isAllowedVueStaticImport(imp) {
+  if (imp.entries.length === 0) {
+    return true
+  }
+  return imp.entries.every(e => e.isType)
+}
+
+/**
+ * Віртуальний шлях для парсера: вміст з `<script>` у `.vue` розбираємо як TypeScript.
+ * @param {string} relativePath шлях до файлу в пакеті
+ * @returns {string} той самий шлях або з `.vue` заміненим на `.ts`
+ */
+function virtualPathForParse(relativePath) {
+  if (relativePath.endsWith('.vue')) {
+    return relativePath.replace(/\.vue$/u, '.ts')
+  }
+  return relativePath
+}
+
+/**
+ * Витягує з SFC лише код усередині `<script>`, щоб не чіпати шаблон.
+ * @param {string} sfc вміст .vue файлу
+ * @returns {string} текст усередині тегів `<script>` (усі блоки поспіль)
+ */
+export function extractVueScriptBlocks(sfc) {
+  const chunks = []
+  const re = /<script\b[^>]*>([\s\S]*?)<\/script>/gi
+  let m = re.exec(sfc)
+  while (m) {
+    chunks.push(m[1])
+    m = re.exec(sfc)
+  }
+  return chunks.join('\n\n')
+}
+
+/**
+ * Підбирає текст для сканування: для .vue — лише script-блоки, інакше — увесь вміст.
+ * @param {string} content сирий вміст файлу
+ * @param {string} filePath відносний шлях (для вибору режиму)
+ * @returns {string} текст для `parseSync`
+ */
+export function contentForVueImportScan(content, filePath) {
+  if (filePath.endsWith('.vue')) {
+    return extractVueScriptBlocks(content)
+  }
+  return content
+}
+
+/**
+ * Знаходить заборонені static import з `vue` у вже підготовленому тексті (без `<template>`).
+ * Використовує **oxc-parser**; при синтаксичних помилках повертає порожній масив (спочатку виправ синтаксис).
+ * @param {string} content вихідний код
+ * @param {string} [virtualPath] шлях для вибору `lang` (наприклад `app/src/foo.ts` або віртуальний після `.vue` → `.ts`)
+ * @returns {{ line: number, snippet: string }[]} список порушень з номером рядка початку import
+ */
+export function findForbiddenVueImportsInText(content, virtualPath = 'scan.ts') {
+  const pathForLang = virtualPath || 'scan.ts'
+  const lang = langFromPath(pathForLang)
+  let result
+  try {
+    result = parseSync(pathForLang, content, { lang, sourceType: 'module' })
+  } catch {
+    return []
+  }
+  if (result.errors?.length) {
+    return []
+  }
+  /** @type {{ line: number, snippet: string }[]} */
+  const out = []
+  for (const imp of result.module.staticImports) {
+    if (imp.moduleRequest.value === 'vue' && !isAllowedVueStaticImport(imp)) {
+      out.push({
+        line: offsetToLine(content, imp.start),
+        snippet: normalizeSnippet(content.slice(imp.start, imp.end))
+      })
+    }
+  }
+  return out
+}
+
+/**
+ * Чи слід пропустити файл під час обходу пакета (генерація, типи).
+ * @param {string} relativePosix шлях з posix-слешами
+ * @returns {boolean} `true`, якщо файл не сканувати (`.d.ts`, згенеровані імена)
+ */
+export function shouldSkipFileForVueImportScan(relativePosix) {
+  const base = relativePosix.split('/').pop() || ''
+  if (base === 'auto-imports.d.ts' || base === 'components.d.ts') {
+    return true
+  }
+  if (relativePosix.endsWith('.d.ts')) {
+    return true
+  }
+  return false
+}
+
+/**
+ * Чи сканувати цей файл за розширенням.
+ * @param {string} relativePath відносний шлях до файлу
+ * @returns {boolean} `true`, якщо розширення підходить для пошуку import
+ */
+export function isVueImportScanSourceFile(relativePath) {
+  return /\.(vue|[cm]?[jt]sx?)$/.test(relativePath)
+}
+
+/**
+ * Знаходить порушення в одному файлі (з урахуванням .vue script extraction).
+ * @param {string} content сирий вміст файлу
+ * @param {string} relativePath шлях відносно кореня пакета або репо
+ * @returns {{ line: number, snippet: string }[]} список порушень для цього файлу
+ */
+export function findForbiddenVueImportsInSourceFile(content, relativePath) {
+  const scan = contentForVueImportScan(content, relativePath)
+  const virtualPath = virtualPathForParse(relativePath)
+  return findForbiddenVueImportsInText(scan, virtualPath)
+}