@nitra/cursor 1.8.147 → 1.8.151

package/scripts/utils/mssql-pool-scan.mjs

@@ -22,93 +22,125 @@
  */
 import { parseSync } from 'oxc-parser'
 
+import {
+  isFunctionNode,
+  isJoinCall,
+  isSqlListContextTemplate,
+  langFromPath,
+  normalizeSnippet,
+  offsetToLine,
+  walkAstWithAncestors
+} from './ast-scan-utils.mjs'
+
 const SOURCE_FILE_RE = /\.([cm]?[jt]sx?)$/
-const SQL_LIST_CONTEXT_RE = /\b(in|values)\b\s*\(/iu
 const IN_PLACEHOLDER_END_RE = /\bin\s*\(\s*$/iu
 const NUMERIC_PARSE_FN_NAMES = new Set(['parseInt', 'parseFloat', 'Number', 'BigInt'])
 
 /**
- * Мова для Oxc за шляхом файлу (розширення).
- * @param {string} filePath віртуальний або реальний шлях до файлу
- * @returns {'js' | 'jsx' | 'ts' | 'tsx'} значення опції `lang` для `parseSync`
+ * Чи містить тест if-умови перевірку “список порожній”.
+ * Підтримує базові форми:
+ * - `if (!ids.length) ...`
+ * - `if (ids.length === 0) ...` / `<= 0` / `< 1`
+ *
+ * @param {unknown} test IfStatement.test
+ * @param {string} name імʼя змінної списку
+ * @returns {boolean}
  */
-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'
-}
+function isEmptyListTest(test, name) {
+  if (!test || typeof test !== 'object') return false
+
+  if (test.type === 'UnaryExpression' && test.operator === '!') {
+    const arg = test.argument
+    if (!arg || typeof arg !== 'object') return false
+    if (arg.type === 'MemberExpression' && !arg.computed) {
+      const obj = arg.object
+      const prop = arg.property
+      return !!obj && obj.type === 'Identifier' && obj.name === name && !!prop && prop.type === 'Identifier' && prop.name === 'length'
+    }
+  }
 
-/**
- * Номер рядка (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++
+  if (test.type === 'BinaryExpression') {
+    const { left, right, operator } = test
+    const isLen = node =>
+      !!node &&
+      typeof node === 'object' &&
+      node.type === 'MemberExpression' &&
+      !node.computed &&
+      node.object &&
+      node.object.type === 'Identifier' &&
+      node.object.name === name &&
+      node.property &&
+      node.property.type === 'Identifier' &&
+      node.property.name === 'length'
+    const isZero = node =>
+      !!node &&
+      typeof node === 'object' &&
+      ((node.type === 'NumericLiteral' && node.value === 0) || (node.type === 'Literal' && node.value === 0))
+
+    if (!['===', '==', '<=', '<'].includes(operator)) return false
+    if (isLen(left) && isZero(right)) return true
+    // допускаємо `0 === ids.length` теж
+    if (isZero(left) && isLen(right) && (operator === '===' || operator === '==')) return true
   }
-  return line
+
+  return false
 }
 
 /**
- * Стискає пробіли для повідомлення про порушення.
- * @param {string} s фрагмент коду
- * @returns {string} скорочений однорядковий рядок
+ * Чи є в consequent (або в його BlockStatement) ThrowStatement.
+ * @param {unknown} consequent IfStatement.consequent
+ * @returns {boolean}
  */
-function normalizeSnippet(s) {
-  return s.replaceAll(/\s+/g, ' ').trim().slice(0, 180)
+function consequentHasThrow(consequent) {
+  if (!consequent || typeof consequent !== 'object') return false
+  if (consequent.type === 'ThrowStatement') return true
+  if (consequent.type === 'BlockStatement' && Array.isArray(consequent.body)) {
+    return consequent.body.some(s => s && typeof s === 'object' && s.type === 'ThrowStatement')
+  }
+  return false
 }
 
 /**
- * Чи є вузол функцією.
- * @param {unknown} node AST node
- * @returns {boolean} true, якщо це будь-який вузол-функція
+ * Шукає “guard” `if (empty) throw` перед statementIndex у межах того ж BlockStatement.
+ * @param {unknown} block BlockStatement
+ * @param {number} statementIndex індекс statement, перед яким шукаємо guard
+ * @param {string} name імʼя змінної списку
+ * @returns {boolean}
  */
-function isFunctionNode(node) {
-  return (
-    !!node &&
-    typeof node === 'object' &&
-    typeof node.type === 'string' &&
-    (node.type === 'FunctionDeclaration' ||
-      node.type === 'FunctionExpression' ||
-      node.type === 'ArrowFunctionExpression')
-  )
+function hasEmptyGuardBefore(block, statementIndex, name) {
+  if (!block || typeof block !== 'object' || block.type !== 'BlockStatement') return false
+  const body = block.body
+  if (!Array.isArray(body)) return false
+  for (let i = 0; i < statementIndex; i++) {
+    const st = body[i]
+    if (!st || typeof st !== 'object') continue
+    if (st.type !== 'IfStatement') continue
+    if (!isEmptyListTest(st.test, name)) continue
+    if (!consequentHasThrow(st.consequent)) continue
+    return true
+  }
+  return false
 }
 
 /**
- * Рекурсивний обхід AST з предками, щоб визначати контекст (всередині функції чи ні).
- * @param {unknown} node поточний вузол
- * @param {unknown[]} ancestors масив предків від кореня до parent
- * @param {(n: Record<string, unknown>, ancestors: unknown[]) => void} visit відвідувач для вузлів з `type`
- * @returns {void}
+ * Знаходить найближчий enclosing BlockStatement і statement всередині нього.
+ * @param {unknown[]} ancestors ancestors масив з walkAstWithAncestors
+ * @returns {{ block: unknown, index: number } | null}
  */
-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)
-    }
+function findEnclosingBlockAndStatementIndex(ancestors) {
+  if (!Array.isArray(ancestors) || ancestors.length === 0) return null
+
+  // statement — перший зверху вузол, який лежить у block.body
+  // шукаємо пару (block, statement), де statement ∈ block.body
+  for (let i = ancestors.length - 1; i >= 1; i--) {
+    const maybeStatement = ancestors[i]
+    const maybeBlock = ancestors[i - 1]
+    if (!maybeBlock || typeof maybeBlock !== 'object' || maybeBlock.type !== 'BlockStatement') continue
+    if (!Array.isArray(maybeBlock.body)) continue
+    const idx = maybeBlock.body.indexOf(maybeStatement)
+    if (idx !== -1) return { block: maybeBlock, index: idx }
   }
+  return null
 }
 
 /**
@@ -160,48 +192,6 @@ function isRequestFactoryCall(node) {
   return !!prop && prop.type === 'Identifier' && prop.name === 'request'
 }
 
-/**
- * Чи це `.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') return false
-  if (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} обʼєднаний текст
- */
-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))
-}
-
 /**
  * Знаходить створення `ConnectionPool` всередині функцій.
  * @param {string} content вихідний код
@@ -449,13 +439,7 @@ function isInListExpressionParsed(expr, declarators, seen = new Set()) {
     const inits = declarators
       .filter(d => {
         const id = d.id
-        return (
-          !!id &&
-          typeof id === 'object' &&
-          id.type === 'Identifier' &&
-          id.name === expr.name &&
-          !!d.init
-        )
+        return !!id && typeof id === 'object' && id.type === 'Identifier' && id.name === expr.name && !!d.init
       })
       .map(d => d.init)
     if (inits.length === 0) return false
@@ -504,6 +488,47 @@ function collectInListUnparsedFromTemplate(node, content, declarators, out) {
   }
 }
 
+/**
+ * Збирає порушення для одного TemplateLiteral: якщо у `IN (${...})`:
+ * - `${...}` не є Identifier (значення не винесені у змінну);
+ * - або це Identifier, але перед запитом немає guard `if (empty) throw`.
+ *
+ * @param {Record<string, unknown>} node TemplateLiteral
+ * @param {unknown[]} ancestors ancestors від walkAstWithAncestors
+ * @param {string} content вихідний код
+ * @param {{ line: number, snippet: string, reason: 'not_var' | 'missing_guard', name?: string }[]} out буфер результатів
+ */
+function collectInListMissingEmptyGuardFromTemplate(node, ancestors, content, out) {
+  if (node.type !== 'TemplateLiteral') return
+  const quasis = node.quasis
+  const expressions = node.expressions
+  if (!Array.isArray(quasis) || !Array.isArray(expressions) || expressions.length === 0) return
+
+  for (const [i, expr] of expressions.entries()) {
+    if (!IN_PLACEHOLDER_END_RE.test(quasiRawText(quasis[i]))) continue
+    if (!expr || typeof expr !== 'object') continue
+
+    if (expr.type !== 'Identifier' || typeof expr.name !== 'string') {
+      out.push({
+        line: offsetToLine(content, node.start),
+        snippet: normalizeSnippet(content.slice(node.start, node.end)),
+        reason: 'not_var'
+      })
+      continue
+    }
+
+    const place = findEnclosingBlockAndStatementIndex(ancestors)
+    if (!place || !hasEmptyGuardBefore(place.block, place.index, expr.name)) {
+      out.push({
+        line: offsetToLine(content, node.start),
+        snippet: normalizeSnippet(content.slice(node.start, node.end)),
+        reason: 'missing_guard',
+        name: expr.name
+      })
+    }
+  }
+}
+
 /**
  * Знаходить підстановки IN (вираз) у TemplateLiteral, де вираз не пройшов числовий парсер.
  *
@@ -533,6 +558,33 @@ export function findUnsafeMssqlInListUnparsedInText(content, virtualPath = 'scan
   return out
 }
 
+/**
+ * Знаходить підстановки списків у `IN (${...})`, які:
+ * - не винесені в окрему змінну (в `${...}` стоїть не Identifier);
+ * - або винесені, але перед запитом немає перевірки на пустоту з `throw`.
+ *
+ * @param {string} content вихідний код
+ * @param {string} [virtualPath] шлях для вибору мови парсера (lang)
+ * @returns {{ line: number, snippet: string, reason: 'not_var' | 'missing_guard', name?: string }[]} список порушень
+ */
+export function findUnsafeMssqlInListMissingEmptyGuardInText(content, virtualPath = 'scan.ts') {
+  const lang = langFromPath(virtualPath || 'scan.ts')
+  let result
+  try {
+    result = parseSync(virtualPath, content, { lang, sourceType: 'module' })
+  } catch {
+    return []
+  }
+  if (result.errors?.length) return []
+
+  /** @type {{ line: number, snippet: string, reason: 'not_var' | 'missing_guard', name?: string }[]} */
+  const out = []
+  walkAstWithAncestors(result.program, [], (node, ancestors) =>
+    collectInListMissingEmptyGuardFromTemplate(node, ancestors, content, out)
+  )
+  return out
+}
+
 /**
  * Чи сканувати цей файл за розширенням (JS/TS-сім'я).
  * @param {string} relativePathPosix відносний шлях (posix)
@@ -541,4 +593,3 @@ export function findUnsafeMssqlInListUnparsedInText(content, virtualPath = 'scan
 export function isMssqlScanSourceFile(relativePathPosix) {
   return SOURCE_FILE_RE.test(relativePathPosix) && !relativePathPosix.endsWith('.d.ts')
 }
-

package/skills/lint/SKILL.md

@@ -53,7 +53,7 @@ bun run lint
 
 **Чому взагалі кілька `eslint`:** оркестратор (Claude Code, Cursor тощо) може **розпаралелити** роботу: кілька **субагентів** / **паралельних Bash-задач** / **фонових shell**, і кожен **сам** виконує **`/n-lint`** або запускає **`eslint`**. Тоді навантаження **множиться**: не один прогон лінту, а **N прогонів** одночасно.
 
-**Що робити агенту під час виконання цього скілу (обов’язково)**
+### Що робити агенту під час виконання цього скілу (обов’язково)
 
 1. **Один** запуск **`bun run lint`** (або всі кроки **`lint`**, як у **`package.json`**) — у **одному** foreground shell, **без** `run_in_background` / фонових копій тієї ж команди.
 2. **Не** викликати **паралельні субагенти** (subagent, Task, «розбий на N паралельних завдань») лише заради лінту в одному репозиторії. Лінт не потребує шардінгу: один процес, послідовно.