@7n/rules 1.0.0

package/scripts/lib/workspaces.mjs

@@ -0,0 +1,109 @@
+/**
+ * Допоміжний модуль для скриптів перевірки монорепо.
+ *
+ * Зчитує кореневий `package.json` і повертає список каталогів-пакетів (корінь `.` плюс шляхи
+ * з `workspaces`, з урахуванням glob).
+ */
+import { existsSync } from 'node:fs'
+import { glob, readFile } from 'node:fs/promises'
+import { dirname, join, relative } from 'node:path'
+
+const TRAILING_SLASH_RE = /\/$/
+const LEADING_DOTSLASH_RE = /^\.\//
+
+/** Glob-ігнор для workspace-патернів із `*` (узгоджено з `rules/changelog/js/consistency/package-manifest.mjs`). */
+export const WORKSPACE_GLOB_IGNORE = Object.freeze(['**/node_modules/**', '**/.git/**', '**/.venv/**', '**/venv/**'])
+
+/**
+ * Чи слід виключити каталог зі списку workspace-коренів (не стосується `.`).
+ * @param {string} ws відносний шлях воркспейсу
+ * @returns {boolean} true — пропустити
+ */
+export function isIgnoredWorkspaceRoot(ws) {
+  if (ws === '.') return false
+  const p = ws.replaceAll('\\', '/').replace(LEADING_DOTSLASH_RE, '')
+  const segments = new Set(p.split('/'))
+  return segments.has('node_modules') || segments.has('.git') || segments.has('.venv') || segments.has('venv')
+}
+
+/**
+ * Нормалізує workspace-патерн до POSIX-формату і прибирає хвостові `/`.
+ * @param {string} pattern сирий workspace-патерн
+ * @returns {string} нормалізований патерн або `.`
+ */
+function normalizeWorkspacePattern(pattern) {
+  let normalized = pattern.replaceAll('\\', '/')
+  while (TRAILING_SLASH_RE.test(normalized)) {
+    normalized = normalized.slice(0, -1)
+  }
+  return normalized || '.'
+}
+
+/**
+ * Додає каталоги пакетів до set за workspace-патерном.
+ * @param {Set<string>} roots set коренів пакетів
+ * @param {string} repoRoot корінь репозиторію
+ * @param {string} workspacePattern нормалізований workspace-патерн
+ * @returns {Promise<void>}
+ */
+async function addWorkspaceRootsByPattern(roots, repoRoot, workspacePattern) {
+  if (workspacePattern.includes('*')) {
+    const globPat = `${workspacePattern}/package.json`
+    for await (const relPkgJsonPath of glob(globPat, {
+      cwd: repoRoot,
+      ignore: [...WORKSPACE_GLOB_IGNORE]
+    })) {
+      const absPkgJsonPath = join(repoRoot, relPkgJsonPath)
+      const relRoot = relative(repoRoot, dirname(absPkgJsonPath))
+      const ws = relRoot === '' ? '.' : relRoot
+      if (!isIgnoredWorkspaceRoot(ws)) {
+        roots.add(ws)
+      }
+    }
+    return
+  }
+
+  const pkgJsonPath = join(repoRoot, workspacePattern, 'package.json')
+  if (existsSync(pkgJsonPath) && !isIgnoredWorkspaceRoot(workspacePattern)) {
+    roots.add(workspacePattern)
+  }
+}
+
+/**
+ * Нормалізує поле `workspaces` з package.json до масиву шляхів / glob-патернів.
+ * @param {unknown} workspaces значення `workspaces` з кореневого package.json
+ * @returns {string[]} масив патернів workspaces
+ */
+export function normalizeWorkspacePatterns(workspaces) {
+  if (!workspaces) return []
+  if (Array.isArray(workspaces)) return workspaces
+  if (typeof workspaces === 'object' && workspaces !== null && Array.isArray(workspaces.packages)) {
+    return workspaces.packages
+  }
+  return []
+}
+
+/**
+ * Повертає каталоги з `package.json`: корінь репозиторію та всі пакети з `workspaces`.
+ * @param {string} repoRoot зазвичай `process.cwd()`
+ * @returns {Promise<string[]>} відносні шляхи до коренів пакетів; `'.'` першим, без дублікатів
+ */
+export async function getMonorepoPackageRootDirs(repoRoot = '.') {
+  const roots = new Set(['.'])
+  const rootPkgPath = join(repoRoot, 'package.json')
+  if (!existsSync(rootPkgPath)) {
+    return ['.']
+  }
+  const pkg = JSON.parse(await readFile(rootPkgPath, 'utf8'))
+  for (const raw of normalizeWorkspacePatterns(pkg.workspaces)) {
+    const workspacePattern = normalizeWorkspacePattern(raw)
+    await addWorkspaceRootsByPattern(roots, repoRoot, workspacePattern)
+  }
+  const list = [...roots].filter(ws => !isIgnoredWorkspaceRoot(ws))
+  list.sort((a, b) => {
+    if (a === '.') return -1
+    if (b === '.') return 1
+    return a.localeCompare(b)
+  })
+  return list
+}

package/scripts/lib/worktree-notice.mjs

@@ -0,0 +1,183 @@
+/**
+ * Вшивання worktree-інструкції у синкнутий `SKILL.md` (рішення D2 зі spec).
+ *
+ * Коли `main.json.worktree === true`, скіл має виконуватись в окремому git-worktree
+ * і не паралелитись. Підказка адресована агенту, який читає `SKILL.md`, тож
+ * вставляється в текст між стабільними маркерами — ре-синк ідемпотентний:
+ * наявний блок замінюється, при `worktree:false` — видаляється.
+ *
+ * Крок 0.1 блоку додає `bun install` у щойно створеному дереві (локальна копія
+ * CLI усуває гонку з CDN) і shell-обгортку `n_rules_npx` навколо bootstrap-виклику
+ * `npx`: на ETARGET/notarget та мережевих помилках npm падає ДО запуску бінарника,
+ * тож retry мусить жити на рівні shell-інструкції, а не в JS-хендлерах CLI.
+ * Обгортка ретраїть лише транзитні помилки реєстру/мережі (30с інтервал, дефолт
+ * 5 хв, env `N_RULES_NPX_RETRY_MAX_MIN`, ceiling 10 хв) і віддає реальний nonzero
+ * CLI одразу. Команди винесені окремим кроком ПІСЛЯ worktree-створення, бо
+ * вимагають command substitution, заборонену у «без-expansion» preflight-снипеті
+ * (узгоджено з worktree.mdc).
+ */
+
+/** Маркер початку worktree-блоку (стабільний, не залежить від тексту всередині). */
+export const WORKTREE_START = '<!-- n-rules:worktree:start -->'
+/** Маркер кінця worktree-блоку. */
+export const WORKTREE_END = '<!-- n-rules:worktree:end -->'
+
+const FALLBACK_SUFFIX = 'task'
+
+/** Наявний блок разом із сусідніми порожніми рядками (для чистого видалення). */
+// Матчить і legacy `n-rules:`-маркери, щоб ре-синк замінював блоки, згенеровані до перейменування пакету
+const BLOCK_RE =
+  /\n{0,8}<!-- n-(?:cursor|rules):worktree:start -->[\s\S]*?<!-- n-(?:cursor|rules):worktree:end -->\n{0,8}/u
+
+/** Закриття YAML-frontmatter на початку файла. */
+const FRONTMATTER_RE = /^(---\n[\s\S]*?\n---\n)/u
+
+/** Значення `name` з YAML-frontmatter. */
+const NAME_RE = /^name:[ \t]{0,8}["']?([^"'\n]+?)["']?[ \t]{0,8}$/mu
+
+/** Перший H1 як fallback, якщо frontmatter не містить `name`. */
+const H1_RE = /^#[ \t]{1,8}(.+)$/mu
+
+const N_PREFIX_RE = /^n-/u
+const COMBINING_DIACRITICS_RE = /[̀-ͯ]/gu
+const NON_ALPHANUM_RE = /[^a-z0-9]+/gu
+const TRAILING_DASHES_RE = /^-{1,80}|-{1,80}$/gu
+const TRAILING_DASH_RE = /-{1,80}$/u
+const LEADING_NEWLINES_RE = /^\n+/u
+
+const CYRILLIC_TRANSLIT = new Map(
+  Object.entries({
+    а: 'a',
+    б: 'b',
+    в: 'v',
+    г: 'h',
+    ґ: 'g',
+    д: 'd',
+    е: 'e',
+    є: 'ye',
+    ж: 'zh',
+    з: 'z',
+    и: 'y',
+    і: 'i',
+    ї: 'yi',
+    й: 'y',
+    к: 'k',
+    л: 'l',
+    м: 'm',
+    н: 'n',
+    о: 'o',
+    п: 'p',
+    р: 'r',
+    с: 's',
+    т: 't',
+    у: 'u',
+    ф: 'f',
+    х: 'kh',
+    ц: 'ts',
+    ч: 'ch',
+    ш: 'sh',
+    щ: 'shch',
+    ь: '',
+    ю: 'yu',
+    я: 'ya',
+    ы: 'y',
+    э: 'e',
+    ё: 'yo',
+    ъ: ''
+  })
+)
+
+/**
+ * Транслітерує кирилицю в ASCII для короткого suffix.
+ * @param {string} value вхідний текст
+ * @returns {string} транслітерований текст
+ */
+function transliterate(value) {
+  return Array.from(value.toLowerCase(), char => CYRILLIC_TRANSLIT.get(char) ?? char).join('')
+}
+
+/**
+ * Робить короткий безпечний suffix для worktree-гілки з назви скіла.
+ * @param {string} content вміст `SKILL.md`
+ * @returns {string} suffix до 10 символів
+ */
+function deriveSuffix(content) {
+  const raw = content.match(NAME_RE)?.[1] ?? content.match(H1_RE)?.[1] ?? FALLBACK_SUFFIX
+  const slug = transliterate(raw)
+    .trim()
+    .replace(N_PREFIX_RE, '')
+    .normalize('NFKD')
+    .replaceAll(COMBINING_DIACRITICS_RE, '')
+    .replaceAll(NON_ALPHANUM_RE, '-')
+    .replaceAll(TRAILING_DASHES_RE, '')
+
+  return (slug || FALLBACK_SUFFIX).slice(0, 10).replace(TRAILING_DASH_RE, '') || FALLBACK_SUFFIX
+}
+
+/**
+ * Тіло worktree-інструкції з конкретним суфіксом, щоб агент не питав назву гілки.
+ * @param {string} suffix короткий suffix задачі
+ * @returns {string} markdown-блок без маркерів
+ */
+function buildNoticeBody(suffix) {
+  return `> [!IMPORTANT]
+> **Worktree-only skill.** Виконується **виключно** в окремому git-worktree (\`.worktrees/<current-branch>-${suffix}/\`) і **не** паралелиться — один інстанс за раз.
+
+**Крок 0 — preflight (обовʼязковий, перед будь-якими іншими діями).** Якщо перевірка падає — **STOP**: не питай користувача про назву гілки, а сам створи worktree від поточної гілки за конвенцією \`<current-branch>-${suffix}\`. Суфікс \`${suffix}\` — коротка (до 10 символів) транслітерація задачі. Не виконуй **жоден** наступний крок скіла, поки preflight не завершився успіхом.
+
+\`\`\`bash
+pwd
+git rev-parse --show-toplevel
+git branch --show-current
+\`\`\`
+
+**Root-assert.** Якщо \`pwd\` **не** збігається з виводом \`git rev-parse --show-toplevel\` — ти в **піддиректорії** робочого дерева (worktree-шляхи нижче відносні до кореня репо). Спершу перейди в корінь: \`cd <toplevel>\` (literal-шлях із виводу), і лише тоді продовжуй preflight. Не створюй worktree з піддиректорії — \`cd .worktrees/<…>\` звідти впаде.
+
+Якщо \`git rev-parse --show-toplevel\` показав, що ти **не** в \`.worktrees/\`, візьми вивід \`git branch --show-current\` як \`<current-branch>\` і виконай **literal-команди без shell expansion** (без command substitution, variable expansion чи backticks). Наприклад, якщо поточна гілка \`feature/x\`:
+
+\`\`\`bash
+npx @7n/mt worktree create "feature/x-${suffix}" "n-${suffix}: worktree-only skill"
+cd ".worktrees/feature-x-${suffix}"
+\`\`\`
+
+Тобто branch-argument лишає slash як у git-гілці, а шлях для \`cd\` бере sanitized форму: slash → \`-\`.
+
+**Крок 0.1 — bootstrap у новому дереві (після \`cd\`).** Дерево щойно створене й **без** \`node_modules\`. Постав залежності локально — тоді \`npx @7n/rules <cmd>\` бере локальну копію без походу в реєстр:
+
+\`\`\`bash
+bun install
+\`\`\``
+}
+
+/**
+ * Канонічний блок worktree-інструкції.
+ * @param {string} content вміст `SKILL.md`
+ * @returns {string} текст блоку від START до END
+ */
+function buildBlock(content) {
+  return `${WORKTREE_START}\n${buildNoticeBody(deriveSuffix(content))}\n${WORKTREE_END}`
+}
+
+/**
+ * Вставляє / оновлює / видаляє worktree-блок у вмісті `SKILL.md`.
+ * @param {string} content вміст `SKILL.md`
+ * @param {boolean} enabled чи має бути блок (значення `main.json.worktree`)
+ * @returns {string} оновлений вміст (ідемпотентно)
+ */
+export function injectWorktreeNotice(content, enabled) {
+  const hadBlock = content.includes(WORKTREE_START)
+  const withoutBlock = content.replace(BLOCK_RE, '\n\n')
+
+  if (!enabled) {
+    return hadBlock ? withoutBlock : content
+  }
+
+  const block = buildBlock(withoutBlock)
+  const fm = withoutBlock.match(FRONTMATTER_RE)
+  if (fm) {
+    const head = fm[1]
+    const rest = withoutBlock.slice(head.length).replace(LEADING_NEWLINES_RE, '')
+    return `${head}\n${block}\n\n${rest}`
+  }
+  return `${block}\n\n${withoutBlock.replace(LEADING_NEWLINES_RE, '')}`
+}

package/scripts/post-tool-use-check.mjs

@@ -0,0 +1,82 @@
+/**
+ * PostToolUse hook для Claude Code: read-only детект конформності **всіх** активованих правил
+ * після редагування файлу. Запускається після кожного `Edit` / `Write` / `MultiEdit`.
+ *
+ * Раніше хук маршрутизував змінений файл у релевантні правила й ганяв повний `fix` (автофікс
+ * + LLM) — дорого, тож звужували. Тепер хук — **детект** (нуль мутацій, нуль LLM), тож роутинг
+ * зайвий: один виклик `_fix-check` (per-rule `check.mjs run()` = перевірка) по всіх правилах.
+ *
+ * Контракт:
+ * - stdin Claude Code: JSON із `tool_input.file_path`; якщо файлу немає (напр. Bash) — exit 0 (skip);
+ * - інакше пряма `runConformanceCheck` (детект усіх правил, без subprocess-обгортки), exit-код прозоро:
+ *   1 — є порушення конформності (PostToolUse не блокує turn, але код лишаємо інформативним).
+ */
+import { once } from 'node:events'
+import { cwd as processCwd } from 'node:process'
+
+import { detectAll } from './lib/lint-surface/run-detectors.mjs'
+
+/**
+ * Зчитує stdin до EOF як utf8 рядок. На TTY — повертає `''` одразу.
+ * @returns {Promise<string>} вміст stdin
+ */
+async function readStdin() {
+  if (process.stdin.isTTY) {
+    return ''
+  }
+  process.stdin.setEncoding('utf8')
+  const chunks = []
+  process.stdin.on('data', chunk => {
+    chunks.push(chunk)
+  })
+  try {
+    await once(process.stdin, 'end')
+  } catch {
+    // 'error' на stdin — повертаємо те, що встигли зібрати
+  }
+  return chunks.join('')
+}
+
+/**
+ * Дістає `tool_input.file_path` зі stdin JSON Claude Code. Невалідний JSON
+ * або відсутнє поле → `null` (не помилка: дехто з інструментів — напр. Bash — не пише `file_path`).
+ * @param {string} stdinJson сирий вміст stdin
+ * @returns {string | null} відносний шлях або `null`
+ */
+export function extractFilePath(stdinJson) {
+  if (!stdinJson) {
+    return null
+  }
+  try {
+    const obj = JSON.parse(stdinJson)
+    const fp = obj?.tool_input?.file_path
+    return typeof fp === 'string' && fp !== '' ? fp : null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Точка входу. Викликається з `bin/n-rules.js` коли argv[0] === `post-tool-use-check`.
+ * Параметри доступні для інʼєкції для тестів: `stdinJson` обходить read від `process.stdin`,
+ * `runConformanceCheckFn` — заміна `runConformanceCheck`.
+ * @param {{ stdinJson?: string, detectFn?: typeof detectAll }} [options] параметри для тестів
+ * @returns {Promise<number>} exit code (0 — пропущено / OK; 1 — є порушення)
+ */
+export async function runPostToolUseCheckCli(options = {}) {
+  const stdinJson = options.stdinJson ?? (await readStdin())
+  const filePath = extractFilePath(stdinJson)
+  // Тільки після редагування файлу (Edit/Write/MultiEdit мають file_path); Bash тощо — skip.
+  if (filePath === null) {
+    return 0
+  }
+  const detect = options.detectFn ?? detectAll
+  // Read-only per-file детект (unified lint surface) зміненого файлу; рендер — у runner-і.
+  try {
+    const { exitCode } = await detect({ files: [filePath], cwd: processCwd(), log: s => process.stderr.write(s) })
+    return exitCode === 0 ? 0 : 1
+  } catch (error) {
+    process.stderr.write(`post-tool-use-check: не вдалося запустити детект — ${error.message}\n`)
+    return 1
+  }
+}

package/scripts/rename-yaml-extensions.mjs

@@ -0,0 +1,170 @@
+/**
+ * Перейменовує розширення YAML за домовленістю репозиторію (k8s.mdc, ga.mdc). Лише логіка; **CLI** — **`bin/rename-yaml-extensions.mjs`**
+ * Підкоманда **`npx \@7n/rules rename-yaml-extensions`** у головному CLI (**`bin/n-rules.js`**).
+ *
+ * - Файли з сегментом шляху `k8s` та суфіксом `.yml` → `.yaml` (маніфести під k8s).
+ * - Файли з сегментом `.github` та суфіксом `.yaml` → `.yml` (workflows тощо; у workflows лише `.yml`).
+ *
+ * Обхід з пропуском `node_modules`, `.git`, `dist`, `coverage`, `.turbo`, `.next` — як у **`walkDir`**.
+ *
+ * Розбір аргументів для CLI: **`parseRenameYamlArgs`** (`--dry-run`, `--root=…`).
+ */
+import { existsSync } from 'node:fs'
+import { rename } from 'node:fs/promises'
+import { cwd } from 'node:process'
+import { relative, resolve } from 'node:path'
+
+import { loadCursorIgnorePaths } from './lib/load-cursor-config.mjs'
+import { walkDir } from './utils/walkDir.mjs'
+
+const K8S_YML_RE = /\.yml$/iu
+const GITHUB_YAML_RE = /\.yaml$/iu
+const EXTENSION_RE = /^(.+)(\.[^./\\]+)$/u
+
+/**
+ * Відносний шлях від кореня з `/`; `null`, якщо поза root.
+ * @param {string} rootAbs абсолютний корінь
+ * @param {string} fileAbs абсолютний шлях до файлу
+ * @returns {string | null} відносний шлях з `/` або null, якщо fileAbs поза rootAbs
+ */
+export function posixRelFromRoot(rootAbs, fileAbs) {
+  const r = (relative(rootAbs, resolve(fileAbs)) || fileAbs).replaceAll('\\', '/')
+  if (r.startsWith('..')) return null
+  return r
+}
+
+/**
+ * Чи шлях підходить під k8s-маніфести: є сегмент `k8s`, суфікс `.yml` (регістр розширення ігнорується).
+ * @param {string} relPosix відносний шлях
+ * @returns {boolean} true, якщо є сегмент k8s і суфікс .yml
+ */
+export function pathMatchesK8sYml(relPosix) {
+  if (!K8S_YML_RE.test(relPosix)) return false
+  return relPosix.split('/').includes('k8s')
+}
+
+/**
+ * Чи шлях підходить під `.github`: є сегмент `.github`, суфікс `.yaml` (регістр розширення ігнорується).
+ * @param {string} relPosix відносний шлях
+ * @returns {boolean} true, якщо є сегмент .github і суфікс .yaml
+ */
+export function pathMatchesGithubYaml(relPosix) {
+  if (!GITHUB_YAML_RE.test(relPosix)) return false
+  return relPosix.split('/').includes('.github')
+}
+
+/**
+ * Замінює останнє розширення файлу на **newExt** (з крапкою, наприклад **`.yaml`**).
+ * @param {string} relPosix відносний шлях
+ * @param {string} newExt нове розширення
+ * @returns {string} шлях з останнім розширенням, заміненим на newExt
+ */
+export function replaceExtension(relPosix, newExt) {
+  const m = relPosix.match(EXTENSION_RE)
+  if (!m) return relPosix + newExt
+  return m[1] + newExt
+}
+
+/**
+ * Збирає операції перейменування (без виконання).
+ * @param {string} rootAbs абсолютний корінь репозиторію
+ * @param {string[]} ignorePaths абсолютні шляхи каталогів, повністю виключених з обходу
+ * @returns {Promise<Array<{ kind: 'k8s' | 'github', fromAbs: string, toAbs: string, relFrom: string, relTo: string }>>} відсортовані операції перейменування без запису на диск
+ */
+async function collectRenameOps(rootAbs, ignorePaths) {
+  /** @type {Array<{ kind: 'k8s' | 'github', fromAbs: string, toAbs: string, relFrom: string, relTo: string }>} */
+  const ops = []
+
+  await walkDir(
+    rootAbs,
+    fileAbs => {
+      const rel = posixRelFromRoot(rootAbs, fileAbs)
+      if (rel === null) return
+      if (pathMatchesK8sYml(rel)) {
+        const relTo = replaceExtension(rel, '.yaml')
+        if (relTo === rel) return
+        ops.push({
+          kind: 'k8s',
+          fromAbs: resolve(rootAbs, rel),
+          toAbs: resolve(rootAbs, relTo),
+          relFrom: rel,
+          relTo
+        })
+        return
+      }
+      if (pathMatchesGithubYaml(rel)) {
+        const relTo = replaceExtension(rel, '.yml')
+        if (relTo === rel) return
+        ops.push({
+          kind: 'github',
+          fromAbs: resolve(rootAbs, rel),
+          toAbs: resolve(rootAbs, relTo),
+          relFrom: rel,
+          relTo
+        })
+      }
+    },
+    ignorePaths
+  )
+
+  ops.sort((a, b) => {
+    const ko = (a.kind === 'k8s' ? 0 : 1) - (b.kind === 'k8s' ? 0 : 1)
+    if (ko !== 0) return ko
+    return a.relFrom.localeCompare(b.relFrom)
+  })
+
+  return ops
+}
+
+/**
+ * Виконує перейменування за правилами k8s / .github.
+ * @param {string} root корінь обходу (відносний або абсолютний)
+ * @param {{ dryRun?: boolean }} [options] опції: лише симуляція без `rename`, якщо dryRun true
+ * @returns {Promise<{ renamed: { relFrom: string, relTo: string }[], errors: string[] }>} списки успішних перейменувань і текстів помилок
+ */
+export async function renameYamlExtensions(root, options = {}) {
+  const dryRun = options.dryRun === true
+  const rootAbs = resolve(root)
+  const ignorePaths = await loadCursorIgnorePaths(rootAbs)
+  const ops = await collectRenameOps(rootAbs, ignorePaths)
+
+  /** @type { { relFrom: string, relTo: string }[]} */
+  const renamed = []
+  /** @type {string[]} */
+  const errors = []
+
+  for (const op of ops) {
+    if (!existsSync(op.fromAbs)) {
+      errors.push(`${op.relFrom}: файл зник перед перейменуванням`)
+    } else if (existsSync(op.toAbs)) {
+      errors.push(`${op.relFrom} → ${op.relTo}: цільовий файл уже існує, пропущено`)
+    } else if (dryRun) {
+      renamed.push({ relFrom: op.relFrom, relTo: op.relTo })
+    } else {
+      try {
+        await rename(op.fromAbs, op.toAbs)
+        renamed.push({ relFrom: op.relFrom, relTo: op.relTo })
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error)
+        errors.push(`${op.relFrom}: ${msg}`)
+      }
+    }
+  }
+
+  return { renamed, errors }
+}
+
+/**
+ * Розбір CLI: **`--dry-run`**, **`--root=...`**.
+ * @param {string[]} argv зазвичай **`process.argv.slice(2)`**
+ * @returns {{ dryRun: boolean, root: string }} прапор симуляції та абсолютний корінь обходу
+ */
+export function parseRenameYamlArgs(argv) {
+  let dryRun = false
+  let root = cwd()
+  for (const a of argv) {
+    if (a === '--dry-run') dryRun = true
+    else if (a.startsWith('--root=')) root = resolve(a.slice('--root='.length))
+  }
+  return { dryRun, root }
+}