@7n/rules 1.0.0

package/rules/js-mssql/package_json/package_json.rego

@@ -0,0 +1,57 @@
+# Порт перевірки версії `mssql` з `npm/scripts/rules/js-mssql/fix.mjs` (js-mssql.mdc).
+#
+# Запуск (локально, для будь-якого `package.json`):
+#   conftest test path/to/package.json -p npm/policy/js_mssql \
+#     --namespace js_mssql.package_json
+#
+# Перевіряє: якщо `dependencies.mssql` присутній, версія має бути >= 12.5.0.
+# Підтримує `^12.5.0`, `>=12.5.0`, `12.5.0`, `workspace:*` (трактується як OK).
+#
+# AST-скан коду на per-request `new sql.ConnectionPool(...)` всередині функцій
+# (потребує парсингу `.js` / `.ts` через oxc-parser), а також full-semver
+# (`major.minor.patch` triple-compare у `rules/js-mssql/fix.mjs`) лишаються у JS:
+# JS-перевірка authoritative, ця Rego — швидкий gate для одиничного `package.json`.
+#
+# Структура каталогу збігається зі шляхом пакету (regal: directory-package-mismatch).
+# Конвенція проєкту — `import rego.v1` + multi-value `deny contains msg if { … }`
+# (.cursor/rules/conftest.mdc). Лінт — `bun run lint-rego` (regal).
+package js_mssql.package_json
+
+import rego.v1
+
+deny contains msg if {
+	range := object.get(object.get(input, "dependencies", {}), "mssql", "")
+	range != ""
+	not mssql_version_meets_min(range)
+	msg := sprintf("dependencies.mssql має бути >= 12.5.0 (зараз %q) (js-mssql.mdc)", [range])
+}
+
+# Мінімум — 12.5.0 (js-mssql.mdc). `workspace:*` трактуємо як OK (узгоджено з JS).
+mssql_version_meets_min(range) if startswith(trim_space(range), "workspace:")
+
+mssql_version_meets_min(range) if {
+	parts := split_to_numbers(range)
+	count(parts) >= 3
+	parts[0] > 12
+}
+
+mssql_version_meets_min(range) if {
+	parts := split_to_numbers(range)
+	count(parts) >= 3
+	parts[0] == 12
+	parts[1] > 5
+}
+
+mssql_version_meets_min(range) if {
+	parts := split_to_numbers(range)
+	count(parts) >= 3
+	parts[0] == 12
+	parts[1] == 5
+	parts[2] >= 0
+}
+
+split_to_numbers(spec) := nums if {
+	tokens := regex.split(`\D+`, spec)
+	non_empty := [t | some t in tokens; t != ""]
+	nums := [n | some t in non_empty; n := to_number(t)]
+}

package/rules/js-run/configmap/concern.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json",
+  "fixability": "config",
+  "policy": {
+    "files": {
+      "walkGlob": "**/k8s/*/configmap.yaml"
+    }
+  }
+}

package/rules/js-run/configmap/configmap.mdc

@@ -0,0 +1,31 @@
+## Rego-gate: OTEL ConfigMap (k8s)
+
+Rego-пакет: `js-run.configmap`
+
+**Цільові файли:** `k8s/base/configmap.yaml` (і будь-які ConfigMap у kustomize-оверлеях)
+
+**Умова спрацювання:** `input.kind == "ConfigMap"`
+
+Перевіряє, що поле `data.OTEL_RESOURCE_ATTRIBUTES` містить усі обовʼязкові substring-маркери, визначені у template:
+
+- `service.name=`
+- `service.namespace=`
+
+Канон маркерів: [configmap.yaml.contains.yml](./template/configmap.yaml.contains.yml)
+
+**✓ Правильно**
+
+```yaml
+data:
+  OTEL_RESOURCE_ATTRIBUTES: 'service.name=my-svc,service.namespace=prod'
+```
+
+**✗ Неправильно**
+
+```yaml
+data:
+  OTEL_RESOURCE_ATTRIBUTES: 'service.name=my-svc'
+# Відсутній service.namespace= → deny
+```
+
+Ресурси типу `kind: Deployment` та інші non-ConfigMap — ігноруються.

package/rules/js-run/configmap/configmap.rego

@@ -0,0 +1,21 @@
+# Перевірка ConfigMap (js-run.mdc).
+#
+# Канон надходить через --data: { "template": { "contains": ... } }
+# Структура --data сформована з template/configmap.yaml.contains.yml.
+# Контекст: kind=ConfigMap; OTEL_RESOURCE_ATTRIBUTES має містити кожен substring
+# зі snippet (`service.name=`, `service.namespace=`).
+package js_run.configmap
+
+import rego.v1
+
+deny contains msg if {
+	input.kind == "ConfigMap"
+	some field, needles in data.template.contains.data
+	actual := object.get(object.get(input, "data", {}), field, "")
+	actual != ""
+	some needle in needles
+	not contains(actual, needle)
+	msg := sprintf("ConfigMap %q: %s має містити %q (js-run.mdc)", [cm_name, field, needle])
+}
+
+cm_name := object.get(object.get(input, "metadata", {}), "name", "?")

package/rules/js-run/configmap/template/configmap.yaml.contains.yml

@@ -0,0 +1,4 @@
+data:
+  OTEL_RESOURCE_ATTRIBUTES:
+    - 'service.name='
+    - 'service.namespace='

package/rules/js-run/docs/index.md

@@ -0,0 +1,11 @@
+---
+type: Directory Index
+title: npm/rules/js-run
+resource: npm/rules/js-run/
+---
+
+# npm/rules/js-run
+
+| Файл                | Тип       |
+| ------------------- | --------- |
+| [main.mjs](main.md) | JS Module |

package/rules/js-run/jsconfig/concern.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json",
+  "fixability": "config",
+  "policy": {
+    "files": {
+      "walkGlob": "**/jsconfig.json"
+    }
+  }
+}

package/rules/js-run/jsconfig/docs/fix-jsconfig.md

@@ -0,0 +1,29 @@
+---
+type: JS Module
+title: fix-jsconfig.mjs
+resource: npm/rules/js-run/jsconfig/fix-jsconfig.mjs
+docgen:
+  crc: 741b8fdc
+  model: openai-codex/gpt-5.4-mini
+  tier: cloud-min
+  score: 100
+  issues: judge:inaccurate:0.97
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Цей файл виконує merge-запис `jsconfig.json` з канонічними значеннями з `template/jsconfig.json.snippet.json` (`data.template.snippet`), щоб політика `js-run/jsconfig` залишалася однаковою всюди, де вона застосовується. Leaf-рівень `compilerOptions` перезаписується точними канонічними значеннями, бо rego очікує exact match, а top-level масиви на кшталт `include` теж звіряються як exact set. Поза каноном зберігаються локальні поля, інші секції `compilerOptions` і супровідні коментарі. Обробка fail-safe: помилки перехоплюються, назовні не кидаються, а за окремих помилок повертається порожнє значення.
+
+## Поведінка
+
+1. Знаходить випадки, де `jsconfig.json` порушує політику узгодження з канонічним `jsconfig.json.snippet.json`.
+2. Для кожного такого файлу звіряє значення з каноном і приводить до точного збігу ті поля, які визначені у сніпеті: `compilerOptions` оновлює на рівні окремих вкладених значень, а top-level масиви — як цілісні набори.
+3. Зберігає локальні нестандартні дані файлу поза канонічними полями, щоб не втратити супровідні секції чи коментарі-джерела.
+4. Якщо канонічний сніпет недоступний або файл не читається як JSON, не падає і просто нічого не змінює.
+5. Після успішного виправлення записує оновлений `jsconfig.json` і повертає перелік змінених файлів та короткий опис змін.
+
+## Гарантії поведінки
+
+- Перехоплює помилки і не пропускає винятків назовні (fail-safe).
+- За певних помилок повертає порожнє значення (напр. `null`) замість винятку.

package/rules/js-run/jsconfig/docs/index.md

@@ -0,0 +1,9 @@
+---
+type: Directory Index
+title: npm/rules/js-run/jsconfig
+resource: npm/rules/js-run/jsconfig/
+---
+
+| Файл                                | Тип       |
+| ----------------------------------- | --------- |
+| [fix-jsconfig.mjs](fix-jsconfig.md) | JS Module |

package/rules/js-run/jsconfig/fix-jsconfig.mjs

@@ -0,0 +1,119 @@
+/**
+ * T0-autofix для policy-concern-а `js-run/jsconfig`: merge-запис `jsconfig.json` з
+ * канонічними значеннями (`template/jsconfig.json.snippet.json`, той самий `data.template.snippet`,
+ * що бачить rego). Leaf-рівень `compilerOptions` перезаписується точним канонічним значенням
+ * (rego вимагає exact match, не subset), top-level масиви (`include`) — теж exact set.
+ * Локальні поля поза каноном (інші секції compilerOptions, коментарі-джерела) — зберігаються.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+/**
+ * Читає JSON-файл template-сніпета концерну; відсутній/невалідний → null.
+ * @param {string} path абсолютний шлях
+ * @returns {object|null} розпарсений об'єкт або null
+ */
+function readSnippet(path) {
+  if (!existsSync(path)) return null
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+/**
+ * @param {unknown} a значення
+ * @param {unknown} b значення
+ * @returns {boolean} чи однакові як множини (масиви) або строго (інше)
+ */
+function valuesMatch(a, b) {
+  if (Array.isArray(b)) {
+    return Array.isArray(a) && new Set(a).size === new Set(b).size && b.every(x => a.includes(x))
+  }
+  return a === b
+}
+
+/**
+ * Мерджить канонічну секцію (`compilerOptions`) у `cfg[field]`: кожен leaf перезаписується
+ * канонічним значенням, якщо відрізняється.
+ * @param {object} cfg поточний jsconfig
+ * @param {string} field назва секції
+ * @param {object} expectedSection канонічні leaf-значення секції
+ * @returns {string[]} список змінених шляхів (`field.leaf`)
+ */
+function mergeSection(cfg, field, expectedSection) {
+  const changes = []
+  const inner = typeof cfg[field] === 'object' && cfg[field] !== null ? cfg[field] : {}
+  cfg[field] = inner
+  for (const [leaf, leafExpected] of Object.entries(expectedSection)) {
+    if (valuesMatch(inner[leaf], leafExpected)) continue
+    inner[leaf] = leafExpected
+    changes.push(`${field}.${leaf}`)
+  }
+  return changes
+}
+
+/**
+ * Мерджить канонічний snippet у `jsconfig.json`: leaf-рівень (`compilerOptions.*`) і
+ * top-level масиви перезаписуються канонічним значенням, якщо відрізняються.
+ * @param {object} cfg поточний jsconfig
+ * @param {object} snippet канонічний snippet
+ * @returns {string[]} список змінених шляхів (для message)
+ */
+function mergeSnippet(cfg, snippet) {
+  const changes = []
+  for (const [field, expected] of Object.entries(snippet)) {
+    if (Array.isArray(expected)) {
+      if (!valuesMatch(cfg[field], expected)) {
+        cfg[field] = expected
+        changes.push(field)
+      }
+      continue
+    }
+    if (typeof expected === 'object' && expected !== null) {
+      changes.push(...mergeSection(cfg, field, expected))
+      continue
+    }
+    if (cfg[field] !== expected) {
+      cfg[field] = expected
+      changes.push(field)
+    }
+  }
+  return changes
+}
+
+/** @type {import('../../../scripts/lib/lint-surface/types.mjs').T0Pattern[]} */
+export const patterns = [
+  {
+    id: 'jsconfig-merge-canon',
+    test: violations => violations.some(v => v.reason === 'policy-deny' && v.file),
+    apply: (violations, ctx) => {
+      const snippet = readSnippet(join(ctx.concernDir ?? '', 'template', 'jsconfig.json.snippet.json'))
+      if (!snippet) return { touchedFiles: [] }
+
+      const files = [...new Set(violations.filter(v => v.file).map(v => v.file))]
+      const touchedFiles = []
+      const messages = []
+
+      for (const rel of files) {
+        const abs = join(ctx.cwd, rel)
+        let cfg
+        try {
+          cfg = JSON.parse(readFileSync(abs, 'utf8'))
+        } catch {
+          continue
+        }
+        const changes = mergeSnippet(cfg, snippet)
+        if (changes.length === 0) continue
+
+        ctx.recordWrite?.(abs)
+        writeFileSync(abs, `${JSON.stringify(cfg, null, 2)}\n`)
+        touchedFiles.push(abs)
+        messages.push(`${rel}: ${changes.join(', ')}`)
+      }
+
+      return touchedFiles.length > 0 ? { touchedFiles, message: messages.join('; ') } : { touchedFiles: [] }
+    }
+  }
+]

package/rules/js-run/jsconfig/jsconfig.mdc

@@ -0,0 +1,25 @@
+## Rego-gate: jsconfig.json
+
+Rego-пакет: `js-run.jsconfig`
+
+**Цільові файли:** `jsconfig.json` у корені backend workspace-пакету
+
+Порівнює `jsconfig.json` з каноном через walker по всіх листах template:
+
+- `compilerOptions.*` — значення мають збігатись точно
+- `include` — масив порівнюється як множина (точний склад)
+
+Канон: [jsconfig.json.snippet.json](./template/jsconfig.json.snippet.json)
+
+Перевірені поля:
+
+| Поле | Очікуване значення |
+|------|--------------------|
+| `compilerOptions.module` | `"NodeNext"` |
+| `compilerOptions.moduleResolution` | `"NodeNext"` |
+| `compilerOptions.target` | `"esnext"` |
+| `compilerOptions.lib` | `["esnext"]` |
+| `compilerOptions.checkJs` | `false` |
+| `include` | `["src/**/*"]` |
+
+Якщо розділ `compilerOptions` відсутній або не є обʼєктом — deny.

package/rules/js-run/jsconfig/jsconfig.rego

@@ -0,0 +1,59 @@
+# Перевірка `jsconfig.json` (js-run.mdc).
+#
+# Канон надходить через --data: { "template": { "snippet": ... } }
+# Структура --data сформована з template/jsconfig.json.snippet.yml.
+# Walker: для кожного leaf у template's snippet порівнюємо input[path].
+# Для масивів — equality (не subset-of, бо в jsconfig потрібен точний набір).
+package js_run.jsconfig
+
+import rego.v1
+
+# Generic 2-level walker: section → key → expected (для compilerOptions).
+deny contains msg if {
+	some section, expected_inner in data.template.snippet
+	is_object(expected_inner)
+	inner := object.get(input, section, {})
+	is_object(inner)
+	some leaf_key, expected_value in expected_inner
+	actual := object.get(inner, leaf_key, null)
+	not values_match(actual, expected_value)
+	msg := sprintf("jsconfig.json: %s.%s має бути %v (js-run.mdc)", [section, leaf_key, expected_value])
+}
+
+# Section відсутня або не обʼєкт.
+deny contains msg if {
+	some section, expected_inner in data.template.snippet
+	is_object(expected_inner)
+	raw := object.get(input, section, null)
+	not is_object(raw)
+	msg := sprintf("jsconfig.json: відсутній обʼєкт %s (js-run.mdc)", [section])
+}
+
+# Top-level масив (наприклад include) — порівнюємо як множину.
+deny contains msg if {
+	some field, expected_array in data.template.snippet
+	is_array(expected_array)
+	actual := object.get(input, field, null)
+	not is_array(actual)
+	msg := sprintf("jsconfig.json: %s має бути масив %v (js-run.mdc)", [field, expected_array])
+}
+
+deny contains msg if {
+	some field, expected_array in data.template.snippet
+	is_array(expected_array)
+	is_array(object.get(input, field, null))
+	{x | some x in input[field]} != {x | some x in expected_array}
+	msg := sprintf("jsconfig.json: %s має бути %v (js-run.mdc)", [field, expected_array])
+}
+
+# Helper: leaf-level value match, з підтримкою масивів як множин.
+values_match(actual, expected) if {
+	not is_array(expected)
+	actual == expected
+}
+
+values_match(actual, expected) if {
+	is_array(expected)
+	is_array(actual)
+	{x | some x in actual} == {x | some x in expected}
+}

package/rules/js-run/jsconfig/template/jsconfig.json.snippet.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "lib": ["esnext"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "target": "esnext",
+    "checkJs": false
+  },
+  "include": ["src/**/*"]
+}

package/rules/js-run/lib/bunyan-imports.mjs

@@ -0,0 +1,98 @@
+/**
+ * Знаходить імпорти з `@nitra/bunyan` (і застарілого `bunyan`) у джерелах — їх треба замінити
+ * на `@nitra/pino` згідно з js-run.mdc.
+ *
+ * Семантика береться з **oxc-parser** (`module.staticImports`) — без regex по тілу файлу.
+ * Додатково по AST програми ловимо `require('@nitra/bunyan')` і динамічний `import('@nitra/bunyan')`,
+ * щоб правило працювало й у CommonJS і при динамічному import у межах одного файлу.
+ *
+ * Сканер не вимагає, щоб файл компілювався: при синтаксичних помилках повертається порожній
+ * результат — спочатку треба полагодити синтаксис, потім перезапустити перевірку.
+ */
+import { parseSync } from 'oxc-parser'
+
+import {
+  dynamicImportModule,
+  langFromPath,
+  normalizeSnippet,
+  offsetToLine,
+  requireCallModule,
+  walkAstWithAncestors
+} from '../../../scripts/utils/ast-scan-utils.mjs'
+
+const SOURCE_FILE_RE = /\.([cm]?[jt]sx?)$/u
+const FORBIDDEN_MODULES = new Set(['@nitra/bunyan', 'bunyan'])
+
+/**
+ * Знаходить заборонені імпорти/require з `@nitra/bunyan` у тексті.
+ * @param {string} content вихідний код
+ * @param {string} [virtualPath] шлях для вибору `lang` (наприклад `pkg/src/foo.ts`)
+ * @returns {{ line: number, snippet: string, module: string }[]} список порушень
+ */
+export function findBunyanImportsInText(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, module: string }[]} */
+  const out = []
+
+  for (const imp of result.module?.staticImports ?? []) {
+    const mod = imp.moduleRequest?.value
+    if (mod && FORBIDDEN_MODULES.has(mod)) {
+      out.push({
+        line: offsetToLine(content, imp.start),
+        snippet: normalizeSnippet(content.slice(imp.start, imp.end)),
+        module: mod
+      })
+    }
+  }
+
+  walkAstWithAncestors(result.program, [], node => {
+    const reqMod = requireCallModule(node)
+    if (reqMod && FORBIDDEN_MODULES.has(reqMod)) {
+      out.push({
+        line: offsetToLine(content, node.start),
+        snippet: normalizeSnippet(content.slice(node.start, node.end)),
+        module: reqMod
+      })
+      return
+    }
+    const dynMod = dynamicImportModule(node)
+    if (dynMod && FORBIDDEN_MODULES.has(dynMod)) {
+      out.push({
+        line: offsetToLine(content, node.start),
+        snippet: normalizeSnippet(content.slice(node.start, node.end)),
+        module: dynMod
+      })
+    }
+  })
+
+  return out
+}
+
+/**
+ * Чи сканувати цей файл за розширенням (JS/TS-сім'я).
+ * @param {string} relativePath відносний шлях до файлу
+ * @returns {boolean} `true`, якщо розширення підходить для пошуку імпорту
+ */
+export function isBunyanScanSourceFile(relativePath) {
+  return SOURCE_FILE_RE.test(relativePath)
+}
+
+/**
+ * Чи слід пропустити файл під час обходу пакета (декларації типів).
+ * @param {string} relativePosix шлях з posix-слешами
+ * @returns {boolean} `true`, якщо файл не сканувати
+ */
+export function shouldSkipFileForBunyanScan(relativePosix) {
+  return relativePosix.endsWith('.d.ts')
+}