@nitra/cursor 1.8.144 → 1.8.147

package/scripts/check-vue.mjs

@@ -69,6 +69,42 @@ function isEsbuildScanFile(relPosix) {
   )
 }
 
+/**
+ * Збирає `esbuild`-матчі по рядках одного файлу, поки буфер не досягне ліміту.
+ * @param {string} rel relative path
+ * @param {string} content вміст файлу
+ * @param {{ rel: string; line: number; snippet: string }[]} matches буфер для збору матчів
+ * @param {number} maxMatches максимум елементів у буфері
+ */
+function appendEsbuildLineMatches(rel, content, matches, maxMatches) {
+  const lines = content.split('\n')
+  for (const [i, line] of lines.entries()) {
+    if (matches.length >= maxMatches) return
+    if (ESBUILD_RE.test(line)) {
+      matches.push({ rel, line: i + 1, snippet: line.trim() })
+    }
+  }
+}
+
+/**
+ * Перебирає вибрані файли пакета і збирає до `maxMatches` згадок `esbuild`.
+ * @param {string} absPackageRoot абсолютний шлях до кореня пакета
+ * @param {{ rel: string }[]} files перелік відносних шляхів
+ * @param {number} maxMatches максимум знайдених матчів
+ * @returns {Promise<{ rel: string; line: number; snippet: string }[]>} зібрані матчі
+ */
+async function collectEsbuildMatchesInFiles(absPackageRoot, files, maxMatches) {
+  /** @type {{ rel: string; line: number; snippet: string }[]} */
+  const matches = []
+  for (const { rel } of files) {
+    if (matches.length >= maxMatches) break
+    const content = await readFile(join(absPackageRoot, rel), 'utf8')
+    if (!ESBUILD_RE.test(content)) continue
+    appendEsbuildLineMatches(rel, content, matches, maxMatches)
+  }
+  return matches
+}
+
 /**
  * Сканує дерево пакета на згадки `esbuild` і підказує заміну на `rolldown`.
  * @param {string} rootDir відносний шлях до пакета
@@ -78,31 +114,16 @@ function isEsbuildScanFile(relPosix) {
  * @param {(msg: string) => void} fail callback при помилці
  */
 async function checkEsbuildMentions(rootDir, absPackageRoot, prefix, passFn, fail) {
-  /** @type {{ rel: string; line: number; snippet: string }[]} */
-  const hits = []
-
+  /** @type {{ rel: string }[]} */
+  const candidates = []
   await walkDir(absPackageRoot, absPath => {
     const rel = relative(absPackageRoot, absPath).split('\\').join('/')
     if (!isEsbuildScanFile(rel)) return
-    hits.push({ rel, line: 0, snippet: '' })
+    candidates.push({ rel })
   })
 
-  // ми використали hits як буфер шляхів; зараз перетворимо на реальні співпадіння
-  /** @type {{ rel: string; line: number; snippet: string }[]} */
-  const matches = []
-  for (const { rel } of hits) {
-    const content = await readFile(join(absPackageRoot, rel), 'utf8')
-    if (!ESBUILD_RE.test(content)) continue
-
-    const lines = content.split('\n')
-    for (let i = 0; i < lines.length; i++) {
-      if (ESBUILD_RE.test(lines[i])) {
-        matches.push({ rel, line: i + 1, snippet: lines[i].trim() })
-        if (matches.length >= 30) break
-      }
-    }
-    if (matches.length >= 30) break
-  }
+  const maxMatches = 30
+  const matches = await collectEsbuildMatchesInFiles(absPackageRoot, candidates, maxMatches)
 
   if (matches.length === 0) {
     passFn(`${prefix}немає згадок 'esbuild' у джерелах пакета (очікується rolldown)`)
@@ -112,8 +133,8 @@ async function checkEsbuildMentions(rootDir, absPackageRoot, prefix, passFn, fai
   for (const m of matches) {
     fail(`${prefix}${m.rel}:${m.line} — знайдено 'esbuild'. Замінити на 'rolldown'. Фрагмент: ${m.snippet}`)
   }
-  if (matches.length >= 30) {
-    fail(`${prefix}показано перші 30 збігів 'esbuild' (замінити на 'rolldown')`)
+  if (matches.length >= maxMatches) {
+    fail(`${prefix}показано перші ${maxMatches} збігів 'esbuild' (замінити на 'rolldown')`)
   }
 }
 
@@ -308,44 +329,60 @@ async function checkVuePackage(rootDir, fail, passFn) {
 }
 
 /**
- * Перевіряє відповідність проєкту правилам vue.mdc (корінь і всі workspace-пакети з `vue` у dependencies).
- * @returns {Promise<number>} 0 — все OK, 1 — є проблеми
+ * Збирає корені пакетів, у яких у `dependencies` є `vue`.
+ * @param {string[]} roots усі корені пакетів monorepo
+ * @returns {Promise<string[]>} перелік пакетів з vue у dependencies
  */
-export async function check() {
-  const reporter = createCheckReporter()
-  const { pass, fail } = reporter
-
-  const roots = await getMonorepoPackageRootDirs()
+async function collectVueRoots(roots) {
   /** @type {string[]} */
   const vueRoots = []
   for (const r of roots) {
     const p = join(r, 'package.json')
-    if (existsSync(p)) {
-      const pkg = JSON.parse(await readFile(p, 'utf8'))
-      if (pkg.dependencies?.vue) vueRoots.push(r)
-    }
+    if (!existsSync(p)) continue
+    const pkg = JSON.parse(await readFile(p, 'utf8'))
+    if (pkg.dependencies?.vue) vueRoots.push(r)
   }
+  return vueRoots
+}
 
-  if (vueRoots.length > 0) {
-    if (existsSync('.vscode/extensions.json')) {
-      const ext = JSON.parse(await readFile('.vscode/extensions.json', 'utf8'))
-      if (ext.recommendations?.includes('Vue.volar')) {
-        pass('extensions.json містить Vue.volar')
-      } else {
-        fail('extensions.json не містить Vue.volar — додай до recommendations')
-      }
-    } else {
-      fail('.vscode/extensions.json не існує (для Vue-проєкту потрібна рекомендація Vue.volar)')
-    }
+/**
+ * Перевіряє наявність рекомендації `Vue.volar` у `.vscode/extensions.json`.
+ * @param {(msg: string) => void} pass pass callback
+ * @param {(msg: string) => void} fail fail callback
+ * @returns {Promise<void>}
+ */
+async function checkVueVolarRecommendation(pass, fail) {
+  if (!existsSync('.vscode/extensions.json')) {
+    fail('.vscode/extensions.json не існує (для Vue-проєкту потрібна рекомендація Vue.volar)')
+    return
+  }
+  const ext = JSON.parse(await readFile('.vscode/extensions.json', 'utf8'))
+  if (ext.recommendations?.includes('Vue.volar')) {
+    pass('extensions.json містить Vue.volar')
   } else {
-    pass('Vue.volar: пропущено (у repo немає пакетів з vue у dependencies)')
+    fail('extensions.json не містить Vue.volar — додай до recommendations')
   }
+}
+
+/**
+ * Перевіряє відповідність проєкту правилам vue.mdc (корінь і всі workspace-пакети з `vue` у dependencies).
+ * @returns {Promise<number>} 0 — все OK, 1 — є проблеми
+ */
+export async function check() {
+  const reporter = createCheckReporter()
+  const { pass, fail } = reporter
+
+  const roots = await getMonorepoPackageRootDirs()
+  const vueRoots = await collectVueRoots(roots)
 
   if (vueRoots.length === 0) {
+    pass('Vue.volar: пропущено (у repo немає пакетів з vue у dependencies)')
     pass('vue не знайдено в dependencies жодного пакета (перевірка vue пропущена)')
     return reporter.getExitCode()
   }
 
+  await checkVueVolarRecommendation(pass, fail)
+
   for (const r of vueRoots) {
     await checkVuePackage(r, fail, pass)
   }

package/scripts/cli-entry.mjs

@@ -1,8 +1,8 @@
 /**
  * Визначення, чи виконується поточний ESM-модуль як точка входу CLI, а не як import у тестах чи інших модулях.
  *
- * У Bun використовується `import.meta.main`; у Node — порівняння `import.meta.url` з `process.argv[1]`
- * після `resolve`, щоб `bun path/to/script.mjs` і `node path/to/script.mjs` коректно вважалися прямим запуском.
+ * Порівняння `import.meta.url` з `process.argv[1]` після `resolve`, щоб `bun path/to/script.mjs`
+ * і `node path/to/script.mjs` коректно вважалися прямим запуском.
  */
 import { resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -12,9 +12,6 @@ import { fileURLToPath } from 'node:url'
  * @returns {boolean} `true`, якщо файл запущено напряму; інакше `false`.
  */
 export function isRunAsCli() {
-  if (import.meta.main === true) {
-    return true
-  }
   try {
     const entry = process.argv[1]
     if (!entry) {

package/scripts/upgrade-nitra-cursor-and-install.mjs

@@ -108,7 +108,7 @@ async function runBunInstall(projectRoot) {
   } catch (error) {
     const exitCode = typeof error?.code === 'number' ? error.code : null
     if (exitCode !== null && exitCode !== 0) {
-      throw new Error(`bun i завершився з кодом ${exitCode}`)
+      throw new Error(`bun i завершився з кодом ${exitCode}`, { cause: error })
     }
     throw error
   }

package/scripts/utils/bun-sql-scan.mjs

@@ -0,0 +1,294 @@
+/**
+ * AST-сканер небезпечних патернів Bun SQL (`import { sql, SQL } from 'bun'`).
+ *
+ * Знаходить:
+ * - `new SQL(...)` всередині функції — пул має бути singleton на рівні модуля,
+ *   а не на кожен виклик handler-а.
+ * - Виклик `sql.unsafe(\`...${expr}...\`)` з даними у TemplateLiteral —
+ *   `sql.unsafe` приймає лише статичний SQL (плюс масив параметрів); інтерполяція
+ *   у текст руйнує параметризацію і відкриває SQL injection.
+ * - Динамічні SQL-списки у tagged template `sql\`... IN (${arr.join(',')}) ...\``:
+ *   навіть «через tagged template» у запит потрапляє готовий шматок SQL замість
+ *   параметризованих значень — треба `sql([...])`.
+ *
+ * Семантика — через **oxc-parser**, без regex по тексту коду.
+ * Якщо файл не парситься / містить синтаксичні помилки — повертаємо порожній
+ * результат: спочатку треба полагодити синтаксис, потім перезапустити перевірку.
+ */
+import { parseSync } from 'oxc-parser'
+
+const SOURCE_FILE_RE = /\.([cm]?[jt]sx?)$/u
+const SQL_LIST_CONTEXT_RE = /\b(in|values)\b\s*\(/iu
+const BUN_SQL_IMPORT_RE = /\bimport\s*\{[\s\S]*?\b(sql|SQL)\b[\s\S]*?\}\s*from\s*["']bun["']/u
+
+/**
+ * Мова для 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 байтове зміщення початку фрагмента
+ * @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+/gu, ' ').trim().slice(0, 180)
+}
+
+/**
+ * Чи є вузол функцією.
+ * @param {unknown} node AST node
+ * @returns {boolean} true, якщо це будь-який вузол-функція
+ */
+function isFunctionNode(node) {
+  return (
+    !!node &&
+    typeof node === 'object' &&
+    typeof node.type === 'string' &&
+    (node.type === 'FunctionDeclaration' ||
+      node.type === 'FunctionExpression' ||
+      node.type === 'ArrowFunctionExpression')
+  )
+}
+
+/**
+ * Рекурсивний обхід AST з предками, щоб визначати контекст (всередині функції чи ні).
+ * @param {unknown} node поточний вузол
+ * @param {unknown[]} ancestors масив предків від кореня до parent
+ * @param {(n: Record<string, unknown>, ancestors: unknown[]) => void} visit відвідувач для вузлів з `type`
+ * @returns {void}
+ */
+function walkAstWithAncestors(node, ancestors, visit) {
+  if (!node || typeof node !== 'object') return
+  if (Array.isArray(node)) {
+    for (const item of node) walkAstWithAncestors(item, ancestors, visit)
+    return
+  }
+
+  const rec = /** @type {Record<string, unknown>} */ (node)
+  if (typeof rec.type === 'string') {
+    visit(rec, ancestors)
+    ancestors = [...ancestors, rec]
+  }
+
+  for (const key of Object.keys(node)) {
+    if (key === 'parent') continue
+    const v = rec[key]
+    if (v && typeof v === 'object') {
+      walkAstWithAncestors(v, ancestors, visit)
+    }
+  }
+}
+
+/**
+ * Парсить файл та повертає program або null, якщо є синтаксичні помилки.
+ * @param {string} content вихідний код
+ * @param {string} virtualPath шлях для вибору `lang`
+ * @returns {unknown | null} `result.program` або null
+ */
+function parseProgramOrNull(content, virtualPath) {
+  const lang = langFromPath(virtualPath || 'scan.ts')
+  let result
+  try {
+    result = parseSync(virtualPath || 'scan.ts', content, { lang, sourceType: 'module' })
+  } catch {
+    return null
+  }
+  if (result.errors?.length) return null
+  return result.program
+}
+
+/**
+ * Чи це `new SQL(...)` (Identifier callee з імʼям `SQL`).
+ * @param {unknown} node AST node
+ * @returns {boolean} true, якщо це `new SQL(...)`
+ */
+function isNewSqlConstructor(node) {
+  if (!node || node.type !== 'NewExpression') return false
+  const callee = node.callee
+  return !!callee && callee.type === 'Identifier' && callee.name === 'SQL'
+}
+
+/**
+ * Чи це виклик `<obj>.unsafe(...)` з TemplateLiteral як першим аргументом і expressions усередині нього.
+ * Допустимий лише `sql.unsafe('static text', [params])`; з `${...}` у TemplateLiteral — небезпечно.
+ * @param {unknown} node AST node
+ * @returns {boolean} true для небезпечного `sql.unsafe(\`... ${x} ...\`)`
+ */
+function isUnsafeCallWithInterpolatedTemplate(node) {
+  if (!node || node.type !== 'CallExpression') return false
+  const callee = node.callee
+  if (!callee || callee.type !== 'MemberExpression' || callee.computed) return false
+  const prop = callee.property
+  if (!prop || prop.type !== 'Identifier' || prop.name !== 'unsafe') return false
+  const args = node.arguments
+  if (!Array.isArray(args) || args.length === 0) return false
+  const first = args[0]
+  if (!first || first.type !== 'TemplateLiteral') return false
+  const expressions = first.expressions
+  return Array.isArray(expressions) && expressions.length > 0
+}
+
+/**
+ * Чи це `.join(...)` виклик (типово для динамічних списків у SQL).
+ * @param {unknown} node AST node
+ * @returns {boolean} true, якщо це CallExpression `*.join(...)`
+ */
+function isJoinCall(node) {
+  if (!node || node.type !== 'CallExpression') return false
+  const callee = node.callee
+  if (!callee || callee.type !== 'MemberExpression' || callee.computed) return false
+  const prop = callee.property
+  return !!prop && prop.type === 'Identifier' && prop.name === 'join'
+}
+
+/**
+ * Текст quasis у TemplateLiteral (без expressions).
+ * @param {unknown} template TemplateLiteral
+ * @returns {string} обʼєднаний raw-текст
+ */
+function templateQuasisText(template) {
+  if (!template || template.type !== 'TemplateLiteral') return ''
+  const quasis = template.quasis
+  if (!Array.isArray(quasis) || quasis.length === 0) return ''
+  let out = ''
+  for (const q of quasis) {
+    if (!q || typeof q !== 'object') continue
+    const value = q.value
+    if (!value || typeof value !== 'object') continue
+    if (typeof value.raw === 'string') out += value.raw
+  }
+  return out
+}
+
+/**
+ * Чи виглядає TemplateLiteral як SQL-контекст зі списком (IN/VALUES (...)).
+ * @param {unknown} template TemplateLiteral
+ * @returns {boolean} true, якщо текст містить `IN (` або `VALUES (`
+ */
+function isSqlListContextTemplate(template) {
+  return SQL_LIST_CONTEXT_RE.test(templateQuasisText(template))
+}
+
+/**
+ * Знаходить `new SQL(...)` всередині функцій (handler на кожен запит замість singleton).
+ * @param {string} content вихідний код
+ * @param {string} [virtualPath] шлях для вибору `lang`
+ * @returns {{ line: number, snippet: string }[]} список порушень
+ */
+export function findBunSqlPerRequestConnectionInText(content, virtualPath = 'scan.ts') {
+  const program = parseProgramOrNull(content, virtualPath)
+  if (!program) return []
+
+  /** @type {{ line: number, snippet: string }[]} */
+  const out = []
+  walkAstWithAncestors(program, [], (node, ancestors) => {
+    if (!isNewSqlConstructor(node)) return
+    const insideFunction = ancestors.some(n => isFunctionNode(n))
+    if (!insideFunction) return
+    out.push({
+      line: offsetToLine(content, node.start),
+      snippet: normalizeSnippet(content.slice(node.start, node.end))
+    })
+  })
+  return out
+}
+
+/**
+ * Знаходить виклики `sql.unsafe(\`...${...}...\`)` (TemplateLiteral з expressions).
+ * @param {string} content вихідний код
+ * @param {string} [virtualPath] шлях для вибору `lang`
+ * @returns {{ line: number, snippet: string }[]} список порушень
+ */
+export function findUnsafeBunSqlUnsafeCallInText(content, virtualPath = 'scan.ts') {
+  const program = parseProgramOrNull(content, virtualPath)
+  if (!program) return []
+
+  /** @type {{ line: number, snippet: string }[]} */
+  const out = []
+  walkAstWithAncestors(program, [], node => {
+    if (!isUnsafeCallWithInterpolatedTemplate(node)) return
+    out.push({
+      line: offsetToLine(content, node.start),
+      snippet: normalizeSnippet(content.slice(node.start, node.end))
+    })
+  })
+  return out
+}
+
+/**
+ * Знаходить динамічні SQL-списки у TaggedTemplateExpression / TemplateLiteral в контексті
+ * `IN (...)` або `VALUES (...)`, де серед expressions є виклик `.join(...)`.
+ * @param {string} content вихідний код
+ * @param {string} [virtualPath] шлях для вибору `lang`
+ * @returns {{ line: number, snippet: string }[]} список порушень
+ */
+export function findUnsafeBunSqlDynamicSqlListInText(content, virtualPath = 'scan.ts') {
+  const program = parseProgramOrNull(content, virtualPath)
+  if (!program) return []
+
+  /** @type {{ line: number, snippet: string }[]} */
+  const out = []
+  walkAstWithAncestors(program, [], node => {
+    /** @type {unknown} */
+    let template = null
+    if (node.type === 'TemplateLiteral') {
+      template = node
+    } else if (node.type === 'TaggedTemplateExpression') {
+      template = node.quasi
+    }
+    if (!template || typeof template !== 'object' || template.type !== 'TemplateLiteral') return
+    if (!isSqlListContextTemplate(template)) return
+    const expressions = template.expressions
+    if (!Array.isArray(expressions) || expressions.length === 0) return
+    if (!expressions.some(expr => isJoinCall(expr))) return
+    out.push({
+      line: offsetToLine(content, template.start),
+      snippet: normalizeSnippet(content.slice(template.start, template.end))
+    })
+  })
+  return out
+}
+
+/**
+ * Чи містить текст джерела імпорт імені `sql` або `SQL` з `"bun"`.
+ * Скан по сирому тексту — без AST, щоб бути дешевим: викликається на кожному
+ * JS/TS-файлі при зборі ознак для авто-детекту правил.
+ * @param {string} content вміст файлу
+ * @returns {boolean} true, якщо є імпорт sql або SQL з модуля bun
+ */
+export function textHasBunSqlImport(content) {
+  return BUN_SQL_IMPORT_RE.test(content)
+}
+
+/**
+ * Чи сканувати цей файл за розширенням (JS/TS-сімʼя, без `.d.ts`).
+ * @param {string} relativePathPosix відносний шлях (posix)
+ * @returns {boolean} true, якщо розширення підходить для AST-скану
+ */
+export function isBunSqlScanSourceFile(relativePathPosix) {
+  return SOURCE_FILE_RE.test(relativePathPosix) && !relativePathPosix.endsWith('.d.ts')
+}