@nitra/cursor 1.37.0 → 1.39.0

package/scripts/lib/rule-meta-helpers.mjs

@@ -0,0 +1,103 @@
+/**
+ * Чисті хелпери конфігу/репо для автодетекту правил: id-міграції, нормалізація
+ * списків, repository URL, monorepo-детект.
+ *
+ * Винесені з `auto-rules.mjs`, щоб `rule-predicates.mjs` міг використати
+ * `getRepositoryUrl` без циклу імпортів. `auto-rules.mjs` пізніше ре-експортує їх звідси.
+ */
+
+/**
+ * Карта міграції застарілих rule-id у `.n-cursor.json` на актуальні.
+ * Застосовується автоматично при читанні конфігу (як для `rules`, так і для `disable-rules`).
+ * Приклад: `image` → `image-compress` + `image-avif` (правило розщеплене у 1.8.197).
+ */
+export const RULE_MIGRATIONS = Object.freeze(
+  /** @type {Record<string, readonly string[]>} */ ({
+    image: Object.freeze(['image-compress', 'image-avif'])
+  })
+)
+
+/**
+ * Розгортає застарілі rule-id у списку згідно з `RULE_MIGRATIONS`. Зберігає порядок,
+ * дедуплікує. Чистий хелпер: не мутує вхід, не логує.
+ * @param {string[]} ids нормалізований список id (як з `normalizeIdList`)
+ * @returns {string[]} список з legacy-id, заміненими на нові; решта без змін
+ */
+export function migrateRuleIds(ids) {
+  /** @type {string[]} */
+  const out = []
+  for (const id of ids) {
+    const replacement = Object.hasOwn(RULE_MIGRATIONS, id) ? RULE_MIGRATIONS[id] : [id]
+    for (const newId of replacement) {
+      if (!out.includes(newId)) out.push(newId)
+    }
+  }
+  return out
+}
+
+/**
+ * Повертає лише ті legacy rule-id зі списку, для яких є запис у `RULE_MIGRATIONS`.
+ * Використовується для людинозрозумілого логування міграції при синхронізації CLI.
+ * @param {string[]} ids нормалізований список id
+ * @returns {string[]} legacy id, які потребуватимуть заміни у `migrateRuleIds`
+ */
+export function detectLegacyRuleIds(ids) {
+  return ids.filter(id => Object.hasOwn(RULE_MIGRATIONS, id))
+}
+
+/**
+ * Нормалізує список ідентифікаторів (trim + lowercase + унікальність збереженням порядку).
+ * @param {unknown} value вихідне значення з `.n-cursor.json`
+ * @returns {string[]} масив id у нормалізованому вигляді
+ */
+export function normalizeIdList(value) {
+  if (!Array.isArray(value)) {
+    return []
+  }
+  const out = []
+  for (const item of value) {
+    const normalized = String(item).trim().toLowerCase()
+    if (normalized && !out.includes(normalized)) {
+      out.push(normalized)
+    }
+  }
+  return out
+}
+
+/**
+ * Повертає URL репозиторію з package.json (`repository` може бути рядком або обʼєктом).
+ * @param {unknown} repository значення `packageJson.repository`
+ * @returns {string | null} URL або null
+ */
+export function getRepositoryUrl(repository) {
+  if (typeof repository === 'string') {
+    return repository
+  }
+  if (repository && typeof repository === 'object' && !Array.isArray(repository)) {
+    const url = /** @type {Record<string, unknown>} */ (repository).url
+    if (typeof url === 'string') {
+      return url
+    }
+  }
+  return null
+}
+
+/**
+ * Чи package.json виглядає як монорепо (поле `workspaces`).
+ * @param {unknown} packageJson кореневий package.json як JS-обʼєкт
+ * @returns {boolean} true, якщо оголошено workspaces
+ */
+export function isMonorepoPackage(packageJson) {
+  if (packageJson === null || typeof packageJson !== 'object' || Array.isArray(packageJson)) {
+    return false
+  }
+  const workspaces = /** @type {Record<string, unknown>} */ (packageJson).workspaces
+  if (Array.isArray(workspaces)) {
+    return workspaces.length > 0
+  }
+  if (workspaces && typeof workspaces === 'object' && !Array.isArray(workspaces)) {
+    const packages = /** @type {Record<string, unknown>} */ (workspaces).packages
+    return Array.isArray(packages) && packages.length > 0
+  }
+  return false
+}

package/scripts/lib/rule-meta.mjs

@@ -0,0 +1,66 @@
+/**
+ * Парсер метаданих правила з `npm/rules/<id>/meta.json` (data-driven автодетект).
+ *
+ * `meta.json.auto` має один із чотирьох видів:
+ *  - `"завжди"`                       → always-on;
+ *  - `["rule", …]`                    → активується, коли всі правила-залежності виявлені;
+ *  - `{ "glob": "<pat>" | [<pat>] }`  → наявність файлів/каталогів за glob (OR);
+ *  - `{ "predicate": "<name>", "arg"? }` → незводимий предикат із реєстру `rule-predicates.mjs`.
+ *
+ * Поля `worktree` правило НЕ має (це скілова вісь). Дзеркало `skill-meta.mjs`.
+ */
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+/** Літерал безумовної активації (українською, як у скілах). */
+export const RULE_ALWAYS = 'завжди'
+
+/**
+ * @typedef {{ always: true } | { rules: string[] } | { glob: string[] } | { predicate: string, arg: unknown }} RuleAutoSpec
+ */
+
+/**
+ * Нормалізує значення `meta.json.auto` у дискриміновану форму.
+ * @param {unknown} value значення поля `auto`
+ * @returns {RuleAutoSpec | null} `null` — формат не розпізнано (= opt-in)
+ */
+export function parseRuleAutoSpec(value) {
+  if (value === RULE_ALWAYS) return { always: true }
+
+  if (Array.isArray(value)) {
+    const rules = value.map(s => String(s).trim()).filter(s => s.length > 0)
+    return rules.length > 0 ? { rules } : null
+  }
+
+  if (value !== null && typeof value === 'object') {
+    const obj = /** @type {Record<string, unknown>} */ (value)
+    if ('glob' in obj) {
+      const raw = obj.glob
+      const globs = (Array.isArray(raw) ? raw : [raw]).filter(g => typeof g === 'string' && g.length > 0)
+      return globs.length > 0 ? { glob: /** @type {string[]} */ (globs) } : null
+    }
+    if ('predicate' in obj) {
+      return typeof obj.predicate === 'string' && obj.predicate.length > 0
+        ? { predicate: obj.predicate, arg: obj.arg }
+        : null
+    }
+  }
+  return null
+}
+
+/**
+ * Читає й парсить `meta.json` одного правила.
+ * @param {string} ruleDir абсолютний шлях до каталогу правила
+ * @returns {Record<string, unknown> | null} обʼєкт або `null` (немає файлу / невалідний JSON / не-обʼєкт)
+ */
+export function readRuleMetaRaw(ruleDir) {
+  const metaPath = join(ruleDir, 'meta.json')
+  if (!existsSync(metaPath)) return null
+  try {
+    const parsed = JSON.parse(readFileSync(metaPath, 'utf8'))
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) return null
+    return /** @type {Record<string, unknown>} */ (parsed)
+  } catch {
+    return null
+  }
+}

package/scripts/lib/rule-predicates.mjs

@@ -0,0 +1,147 @@
+/**
+ * Реєстр незводимих до даних предикатів автодетекту правил.
+ *
+ * Прості умови (наявність файлів) живуть як `glob` у `meta.json`; ці предикати —
+ * для умов, що вимагають парсингу залежностей, сканування вмісту source чи URL repo.
+ * Декларація «який предикат + аргумент» — у `meta.json.auto.predicate`; тут — реалізація.
+ *
+ * Сигнатури неоднорідні (одні беруть `facts`, інші — `cwd`/`packageJson`), бо предикати
+ * читають різні джерела; виклик диспетчиться в `auto-rules.mjs` за іменем предиката.
+ */
+import { readdir, readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+import { getRepositoryUrl } from './rule-meta-helpers.mjs'
+
+const IGNORED_DIR_NAMES = new Set(['node_modules', '.git', '.next', '.turbo'])
+
+/**
+ * Чи package.json дерева містить будь-який із зазначених пакетів у dependencies.
+ * @param {string} root корінь репо
+ * @param {string[]} keys імена пакетів
+ * @returns {Promise<boolean>} true, якщо знайдено хоч один
+ */
+async function anyDepInTree(root, keys) {
+  const wanted = new Set(keys)
+  let found = false
+  /** @param {string} dir каталог обходу @returns {Promise<void>} */
+  async function walk(dir) {
+    if (found) return
+    let entries
+    try {
+      entries = await readdir(dir, { withFileTypes: true })
+    } catch {
+      return
+    }
+    for (const entry of entries) {
+      if (found) return
+      const abs = join(dir, entry.name)
+      if (entry.isDirectory()) {
+        if (!IGNORED_DIR_NAMES.has(entry.name)) await walk(abs)
+      } else if (entry.isFile() && entry.name === 'package.json') {
+        try {
+          const deps = JSON.parse(await readFile(abs, 'utf8'))?.dependencies
+          if (deps && typeof deps === 'object' && !Array.isArray(deps)) {
+            for (const k of wanted) if (Object.hasOwn(deps, k)) found = true
+          }
+        } catch {
+          /* ігноруємо пошкоджені package.json */
+        }
+      }
+    }
+  }
+  await walk(root)
+  return found
+}
+
+/**
+ * Чи існує вкладений (не кореневий) package.json без `vite` у devDependencies.
+ * @param {string} root корінь репо
+ * @returns {Promise<boolean>} true, якщо знайдено
+ */
+async function nestedWithoutVite(root) {
+  const rootPkg = join(root, 'package.json')
+  let result = false
+  /** @param {string} dir каталог @returns {Promise<void>} */
+  async function walk(dir) {
+    if (result) return
+    let entries
+    try {
+      entries = await readdir(dir, { withFileTypes: true })
+    } catch {
+      return
+    }
+    for (const entry of entries) {
+      if (result) return
+      const abs = join(dir, entry.name)
+      if (entry.isDirectory()) {
+        if (!IGNORED_DIR_NAMES.has(entry.name)) await walk(abs)
+      } else if (entry.isFile() && entry.name === 'package.json' && abs !== rootPkg) {
+        try {
+          const dev = JSON.parse(await readFile(abs, 'utf8'))?.devDependencies
+          const hasVite = dev && typeof dev === 'object' && !Array.isArray(dev) && Object.hasOwn(dev, 'vite')
+          if (!hasVite) result = true
+        } catch {
+          /* пошкоджений package.json не вважаємо vite-проєктом */
+        }
+      }
+    }
+  }
+  await walk(root)
+  return result
+}
+
+/** Реєстр предикатів: імʼя → реалізація. Виклик за `meta.json.auto.predicate`. */
+export const RULE_PREDICATES = {
+  /**
+   * @param {unknown} packageJson кореневий package.json
+   * @param {string} arg підрядок-маркер URL
+   * @returns {boolean} true, якщо repository.url містить маркер
+   */
+  repoUrlMarker(packageJson, arg) {
+    const url = getRepositoryUrl(
+      packageJson && typeof packageJson === 'object' && !Array.isArray(packageJson)
+        ? /** @type {Record<string, unknown>} */ (packageJson).repository
+        : null
+    )
+    return typeof url === 'string' && url.toLowerCase().includes(String(arg).toLowerCase())
+  },
+  /**
+   * @param {string} cwd корінь репо
+   * @param {string[]} arg імена пакетів
+   * @returns {Promise<boolean>} true, якщо будь-який пакет у dependencies дерева
+   */
+  depInAnyPackageJson(cwd, arg) {
+    return anyDepInTree(cwd, Array.isArray(arg) ? arg : [])
+  },
+  /**
+   * @param {{ hasGqlTaggedTemplates: boolean }} facts факти
+   * @returns {boolean} true, якщо є gql-літерал
+   */
+  gqlTaggedTemplate(facts) {
+    return facts.hasGqlTaggedTemplates === true
+  },
+  /**
+   * @param {{ hasHasuraConfig: boolean }} facts факти
+   * @returns {boolean} true, якщо config.yaml із маркером
+   */
+  hasuraConfigMarker(facts) {
+    return facts.hasHasuraConfig === true
+  },
+  /**
+   * @param {string} cwd корінь репо
+   * @param {{ hasBunSqlImport: boolean }} facts факти
+   * @returns {Promise<boolean>} true, якщо deps pg/pg-format/mysql2 або import sql з bun
+   */
+  async jsBunDbSignal(cwd, facts) {
+    if (facts.hasBunSqlImport === true) return true
+    return anyDepInTree(cwd, ['pg', 'pg-format', 'mysql2'])
+  },
+  /**
+   * @param {string} cwd корінь репо
+   * @returns {Promise<boolean>} true, якщо вкладений package.json без vite
+   */
+  nestedPackageWithoutVite(cwd) {
+    return nestedWithoutVite(cwd)
+  }
+}

package/scripts/lib/worktree.mjs

@@ -0,0 +1,73 @@
+/**
+ * Чиста логіка worktree-tool `n-cursor worktree` (без git/fs side-effects).
+ *
+ * Тут — детерміновані, тестовані без git функції:
+ *  - `sanitizeBranch` — імʼя гілки → безпечне імʼя каталогу/файла (слеш та інші
+ *    небезпечні для шляху символи → дефіс), щоб структура `.worktrees/` лишалась пласкою;
+ *  - `worktreePaths` — шляхи checkout і файла-опису поруч;
+ *  - `buildDescription` — текст інвентарного `.worktrees/<name>.md` за конвенцією worktree.mdc;
+ *  - `findOrphanDescFiles` — `.md`-описи без зареєстрованого worktree (для `prune`).
+ *
+ * Оркестрація (виклики git, запис файлів, argv) — у `npm/scripts/worktree-cli.mjs`.
+ */
+import { basename, join } from 'node:path'
+
+/** Символи, безпечні для імені каталогу/файла; решта → дефіс. */
+const UNSAFE_PATH_CHARS_RE = /[^a-zA-Z0-9._-]+/gu
+
+/**
+ * Перетворює імʼя git-гілки на безпечне імʼя каталогу/файла для `.worktrees/`.
+ * @param {string} branch імʼя git-гілки (наприклад `feat/skill-meta`)
+ * @returns {string} пласке імʼя (наприклад `feat-skill-meta`)
+ */
+export function sanitizeBranch(branch) {
+  if (typeof branch !== 'string' || branch.trim() === '') {
+    throw new Error('worktree: імʼя гілки обовʼязкове')
+  }
+  const sanitized = branch.trim().replace(UNSAFE_PATH_CHARS_RE, '-').replace(/^-+|-+$/gu, '')
+  if (sanitized === '') {
+    throw new Error(`worktree: імʼя гілки "${branch}" не містить допустимих символів`)
+  }
+  return sanitized
+}
+
+/**
+ * Детерміновані шляхи checkout і файла-опису для гілки.
+ * @param {string} repoRoot абсолютний корінь репозиторію
+ * @param {string} branch імʼя git-гілки
+ * @returns {{ checkout: string, descFile: string }} абсолютні шляхи
+ */
+export function worktreePaths(repoRoot, branch) {
+  const name = sanitizeBranch(branch)
+  const dir = join(repoRoot, '.worktrees')
+  return { checkout: join(dir, name), descFile: join(dir, `${name}.md`) }
+}
+
+/**
+ * Текст інвентарного файла-опису worktree.
+ * @param {{ branch: string, task: string, baseCommit: string, date: string }} params поля опису
+ * @returns {string} markdown-вміст `.worktrees/<name>.md`
+ */
+export function buildDescription({ branch, task, baseCommit, date }) {
+  return [
+    `# ${branch}`,
+    '',
+    `**Задача:** ${task}`,
+    `**Дата:** ${date}`,
+    `**База (коміт):** ${baseCommit}`,
+    '',
+    'Прибрати: ' + '`' + `npx @nitra/cursor worktree remove ${branch}` + '`',
+    ''
+  ].join('\n')
+}
+
+/**
+ * `.md`-описи без відповідного зареєстрованого worktree-checkout.
+ * @param {string[]} descFiles абсолютні шляхи `.worktrees/*.md`
+ * @param {string[]} registeredCheckouts абсолютні шляхи зареєстрованих worktree-checkout
+ * @returns {string[]} осиротілі `.md` (підмножина `descFiles`)
+ */
+export function findOrphanDescFiles(descFiles, registeredCheckouts) {
+  const checkoutBasenames = new Set(registeredCheckouts.map(c => basename(c)))
+  return descFiles.filter(md => !checkoutBasenames.has(basename(md).replace(/\.md$/u, '')))
+}

package/scripts/worktree-cli.mjs

@@ -0,0 +1,200 @@
+/**
+ * CLI-оркестратор worktree-tool `n-cursor worktree` (виконавець конвенції `.worktrees/`).
+ *
+ * Підкоманди:
+ *   add <branch> "<опис>"     — git worktree add .worktrees/<sanit> -b <branch> (від HEAD) + .md-опис
+ *   remove <branch> [--force] — прибрати checkout + .md (гілку лишає)
+ *   list                      — git worktree list + вміст .md-описів
+ *   prune                     — git worktree prune + видалити осиротілі .md
+ *
+ * Чисті функції (санітизація, шляхи, текст опису, осиротілі) — у `lib/worktree.mjs`.
+ * Тут лише git-виклики, запис файлів, парсинг argv і звіт.
+ */
+import { spawnSync } from 'node:child_process'
+import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { cwd as processCwd } from 'node:process'
+
+import { buildDescription, findOrphanDescFiles, worktreePaths } from './lib/worktree.mjs'
+
+const USAGE = [
+  'Usage:',
+  '  npx @nitra/cursor worktree add <branch> "<опис>"',
+  '  npx @nitra/cursor worktree remove <branch> [--force]',
+  '  npx @nitra/cursor worktree list',
+  '  npx @nitra/cursor worktree prune'
+].join('\n')
+
+/**
+ * Запускає git, повертає { status, stdout, stderr }.
+ * @param {string[]} args аргументи git
+ * @param {string} cwd робочий каталог
+ * @returns {{ status: number, stdout: string, stderr: string }} результат
+ */
+function git(args, cwd) {
+  const r = spawnSync('git', args, { cwd, encoding: 'utf8' })
+  return { status: r.status ?? 1, stdout: r.stdout ?? '', stderr: r.stderr ?? '' }
+}
+
+/**
+ * Поточна дата YYYY-MM-DD (ін'єкція через ctx.now для тестів).
+ * @param {() => Date} now фабрика дати
+ * @returns {string} дата у форматі YYYY-MM-DD
+ */
+function today(now) {
+  return now().toISOString().slice(0, 10)
+}
+
+/**
+ * Реєстровані worktree-checkout (абсолютні шляхи) з `git worktree list --porcelain`.
+ * @param {string} cwd корінь репо
+ * @returns {string[]} абсолютні шляхи checkout
+ */
+function listRegisteredCheckouts(cwd) {
+  return git(['worktree', 'list', '--porcelain'], cwd)
+    .stdout.split('\n')
+    .filter(line => line.startsWith('worktree '))
+    .map(line => line.slice('worktree '.length).trim())
+}
+
+/**
+ * Абсолютні шляхи `.worktrees/*.md`.
+ * @param {string} cwd корінь репо
+ * @returns {string[]} шляхи файлів-описів
+ */
+function listDescFiles(cwd) {
+  const dir = join(cwd, '.worktrees')
+  if (!existsSync(dir)) return []
+  return readdirSync(dir)
+    .filter(n => n.endsWith('.md'))
+    .map(n => join(dir, n))
+}
+
+/**
+ * add: створити worktree від HEAD + .md-опис.
+ * @param {string[]} rest [branch, ...descParts]
+ * @param {{ cwd: string, log: Function, logError: Function, now: () => Date }} ctx контекст
+ * @returns {number} exit code
+ */
+function cmdAdd(rest, ctx) {
+  const [branch, ...descParts] = rest
+  const task = descParts.join(' ').trim()
+  if (!branch) {
+    ctx.logError('worktree add: потрібне імʼя гілки')
+    ctx.logError(USAGE)
+    return 1
+  }
+  if (!task) {
+    ctx.logError('worktree add: опис обовʼязковий — `worktree add <branch> "<опис>"`')
+    return 1
+  }
+  let paths
+  try {
+    paths = worktreePaths(ctx.cwd, branch)
+  } catch (error) {
+    ctx.logError(error.message)
+    return 1
+  }
+  const added = git(['worktree', 'add', paths.checkout, '-b', branch], ctx.cwd)
+  if (added.status !== 0) {
+    ctx.logError(`worktree add не вдався: ${added.stderr.trim()}`)
+    return 1
+  }
+  const baseCommit = git(['rev-parse', '--short', 'HEAD'], ctx.cwd).stdout.trim()
+  const md = buildDescription({ branch, task, baseCommit, date: today(ctx.now) })
+  writeFileSync(paths.descFile, md, 'utf8')
+  ctx.log(`✅ worktree: ${paths.checkout}`)
+  ctx.log(`   опис:    ${paths.descFile}`)
+  return 0
+}
+
+/**
+ * remove: прибрати checkout + .md (гілку лишає).
+ * @param {string[]} rest [branch, ...flags]
+ * @param {{ cwd: string, log: Function, logError: Function }} ctx контекст
+ * @returns {number} exit code
+ */
+function cmdRemove(rest, ctx) {
+  const branch = rest.find(a => !a.startsWith('--'))
+  const force = rest.includes('--force')
+  if (!branch) {
+    ctx.logError('worktree remove: потрібне імʼя гілки')
+    return 1
+  }
+  let paths
+  try {
+    paths = worktreePaths(ctx.cwd, branch)
+  } catch (error) {
+    ctx.logError(error.message)
+    return 1
+  }
+  const args = ['worktree', 'remove', paths.checkout]
+  if (force) args.push('--force')
+  const removed = git(args, ctx.cwd)
+  if (removed.status !== 0) {
+    ctx.logError(`worktree remove не вдався: ${removed.stderr.trim()} (спробуй --force, якщо дерево брудне)`)
+    return 1
+  }
+  if (existsSync(paths.descFile)) rmSync(paths.descFile, { force: true })
+  ctx.log(`✅ прибрано: ${paths.checkout} (гілку ${branch} лишено)`)
+  return 0
+}
+
+/**
+ * list: git worktree list + вміст .md-описів.
+ * @param {{ cwd: string, log: Function }} ctx контекст
+ * @returns {number} exit code
+ */
+function cmdList(ctx) {
+  ctx.log(git(['worktree', 'list'], ctx.cwd).stdout.trimEnd())
+  for (const md of listDescFiles(ctx.cwd)) {
+    ctx.log(`\n--- ${md} ---`)
+    ctx.log(readFileSync(md, 'utf8').trimEnd())
+  }
+  return 0
+}
+
+/**
+ * prune: git worktree prune + видалити осиротілі .md.
+ * @param {{ cwd: string, log: Function }} ctx контекст
+ * @returns {number} exit code
+ */
+function cmdPrune(ctx) {
+  git(['worktree', 'prune'], ctx.cwd)
+  const orphans = findOrphanDescFiles(listDescFiles(ctx.cwd), listRegisteredCheckouts(ctx.cwd))
+  for (const md of orphans) {
+    rmSync(md, { force: true })
+    ctx.log(`🧹 видалено осиротілий опис: ${md}`)
+  }
+  ctx.log(`prune завершено (осиротілих описів: ${orphans.length})`)
+  return 0
+}
+
+/**
+ * Точка входу підкоманди worktree.
+ * @param {string[]} argv аргументи після `worktree`
+ * @param {{ cwd?: string, log?: Function, logError?: Function, now?: () => Date }} [options] ін'єкція для тестів
+ * @returns {Promise<number>} exit code
+ */
+export function runWorktreeCli(argv, options = {}) {
+  const ctx = {
+    cwd: options.cwd ?? processCwd(),
+    log: options.log ?? (line => console.log(line)),
+    logError: options.logError ?? (line => console.error(line)),
+    now: options.now ?? (() => new Date())
+  }
+  const [sub, ...rest] = argv
+  switch (sub) {
+    case 'add':
+      return Promise.resolve(cmdAdd(rest, ctx))
+    case 'remove':
+      return Promise.resolve(cmdRemove(rest, ctx))
+    case 'list':
+      return Promise.resolve(cmdList(ctx))
+    case 'prune':
+      return Promise.resolve(cmdPrune(ctx))
+    default:
+      ctx.logError(USAGE)
+      return Promise.resolve(1)
+  }
+}

package/skills/worktree/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: worktree
+description: >-
+  Створення та керування git-worktree через n-cursor worktree CLI: ізольований
+  workspace у .worktrees/<branch>/ з інвентарним файлом-описом
+---
+
+# worktree — ізольований workspace через CLI
+
+Для роботи в окремому git-worktree використовуй CLI `n-cursor worktree` — він
+однаковий у Claude і Cursor, кладе worktree у `.worktrees/` (gitignored) і сам
+створює інвентарний файл-опис поруч.
+
+## Команди
+
+- Створити (опис **обовʼязковий**):
+  `npx @nitra/cursor worktree add <branch> "<навіщо цей worktree>"`
+- Список активних з описами:
+  `npx @nitra/cursor worktree list`
+- Прибрати (гілку лишає; `--force` для брудного дерева):
+  `npx @nitra/cursor worktree remove <branch> [--force]`
+- Прибрати осиротілі описи / метадані:
+  `npx @nitra/cursor worktree prune`
+
+## Приклад
+
+```bash
+npx @nitra/cursor worktree add feat/skill-meta "реалізація Spec A: meta.json"
+cd .worktrees/feat-skill-meta
+# … робота в ізоляції …
+cd -
+npx @nitra/cursor worktree remove feat/skill-meta
+```
+
+Слеш у гілці перетворюється на дефіс для пласкої структури: `feat/skill-meta`
+→ `.worktrees/feat-skill-meta/`. Git-гілка лишається `feat/skill-meta`.
+
+Конвенція й заборони (де НЕ створювати worktree) — `.cursor/rules/n-worktree.mdc`.

package/skills/worktree/meta.json

@@ -0,0 +1 @@
+{ "auto": "завжди", "worktree": false }

package/rules/abie/auto.md

@@ -1 +0,0 @@
-якщо в кореневому package.json в секції "repository" присутній текст "<https://github.com/abinbevefes/**/>"

package/rules/adr/auto.md

@@ -1 +0,0 @@
-завжди

package/rules/bun/auto.md

@@ -1 +0,0 @@
-якщо в корені проекту є package.json

package/rules/capacitor/auto.md

@@ -1 +0,0 @@
-якщо в проекті є хоч один файл capacitor.config.json

package/rules/changelog/auto.md

@@ -1 +0,0 @@
-[bun]

package/rules/docker/auto.md

@@ -1 +0,0 @@
-якщо в проекті є хоч один Dockerfile

package/rules/efes/auto.md

@@ -1 +0,0 @@
-якщо в кореневому package.json в секції "repository" присутній текст "<https://github.com/efes-cloud/**/>"

package/rules/ga/auto.md

@@ -1 +0,0 @@
-якщо присутня директорія .github/workflows

package/rules/graphql/auto.md

@@ -1 +0,0 @@
-якщо хоч в одному js або vue файлі присутній gql` темплейт літерал

package/rules/hasura/auto.md

@@ -1 +0,0 @@
-якщо в директорії присутній config.yaml, який містить рядок `metadata_directory: metadata`

package/rules/image-avif/auto.md

@@ -1 +0,0 @@
-[vue, image-compress]

package/rules/image-compress/auto.md

@@ -1 +0,0 @@
-[bun]

package/rules/js-bun-db/auto.md

@@ -1 +0,0 @@
-якщо в хоч одному package.json в секції dependencies присутній пакет pg, pg-format або mysql2 або є імпорт sql/SQL з Bun (приклад: import { sql } from "bun")