1/**
2 * CLI-side reader/writer for the unified `.impeccable` config.
3 *
4 * The CLI (published to npm) and the skill scripts (bundled into the install)
5 * live in separate trees and cannot share runtime code, so this duplicates a
6 * small slice of skill/scripts/hook-lib.mjs — the config-path layout, detector
7 * ignore semantics, and the `.git/info/exclude` handling. Keep the schema,
8 * ignore filtering, and exclude marker in sync if either side changes.
9 *
10 * Schema (config.json shared / config.local.json gitignored, per-developer):
11 *   {
12 *     "detector": { "ignoreRules": [], "ignoreFiles": [], "ignoreValues": [], "designSystem": { "enabled": true } },
13 *     "hook": { "consent": "accepted" | "declined", ... },
14 *     "updateCheck": bool
15 *   }
16 */
17 
18import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync } from 'node:fs';
19import { join, dirname, isAbsolute, relative, resolve, sep } from 'node:path';
20 
21export function getConfigPath(root) {
22  return join(root, '.impeccable', 'config.json');
23}
24 
25export function getLocalConfigPath(root) {
26  return join(root, '.impeccable', 'config.local.json');
27}
28 
29function safeReadJson(filePath) {
30  try {
31    const raw = JSON.parse(readFileSync(filePath, 'utf-8'));
32    return raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : null;
33  } catch {
34    return null;
35  }
36}
37 
38function hookSection(raw) {
39  return raw && raw.hook && typeof raw.hook === 'object' && !Array.isArray(raw.hook) ? raw.hook : null;
40}
41 
42function detectorSection(raw) {
43  return raw && raw.detector && typeof raw.detector === 'object' && !Array.isArray(raw.detector) ? raw.detector : null;
44}
45 
46const DETECTOR_CONFIG_KEYS = new Set(['ignoreRules', 'ignoreFiles', 'ignoreValues', 'designSystem']);
47 
48const DEFAULT_DETECTION_CONFIG = Object.freeze({
49  ignoreRules: [],
50  ignoreFiles: [],
51  ignoreValues: [],
52  designSystem: { enabled: true },
53});
54 
55function cloneDetectionConfig() {
56  return {
57    ignoreRules: [],
58    ignoreFiles: [],
59    ignoreValues: [],
60    designSystem: { ...DEFAULT_DETECTION_CONFIG.designSystem },
61  };
62}
63 
64function cloneRawDetectionConfig() {
65  return {
66    ignoreRules: [],
67    ignoreFiles: [],
68    ignoreValues: [],
69  };
70}
71 
72function applyDetectionConfigSource(config, raw) {
73  if (!raw || typeof raw !== 'object') return config;
74  if (raw.designSystem && typeof raw.designSystem === 'object' && !Array.isArray(raw.designSystem)) {
75    config.designSystem = {
76      ...config.designSystem,
77      enabled: raw.designSystem.enabled === false ? false : true,
78    };
79  }
80  if (Array.isArray(raw.ignoreRules)) {
81    config.ignoreRules = uniqueStrings([...config.ignoreRules, ...raw.ignoreRules]);
82  }
83  if (Array.isArray(raw.ignoreFiles)) {
84    config.ignoreFiles = uniqueStrings([...config.ignoreFiles, ...raw.ignoreFiles]);
85  }
86  if (Array.isArray(raw.ignoreValues)) {
87    config.ignoreValues = mergeIgnoreValues(config.ignoreValues, raw.ignoreValues);
88  }
89  return config;
90}
91 
92function uniqueStrings(values) {
93  return Array.from(new Set(values.map(String)));
94}
95 
96/**
97 * Detector filters shared by `npx impeccable detect` and the design hook.
98 * `hook.enabled` remains hook lifecycle state; manual CLI scans still run when
99 * the hook is disabled, but they honor the same ignore rules and design-system
100 * toggle.
101 */
102export function readDetectionConfig(root) {
103  const config = cloneDetectionConfig();
104  for (const filePath of [getConfigPath(root), getLocalConfigPath(root)]) {
105    const raw = safeReadJson(filePath);
106    // Back-compat: old builds stored detector filters under hook.*.
107    applyDetectionConfigSource(config, hookSection(raw));
108    applyDetectionConfigSource(config, detectorSection(raw));
109  }
110  return config;
111}
112 
113export function readRawDetectionConfig(root, opts = {}) {
114  const raw = safeReadJson(opts.local ? getLocalConfigPath(root) : getConfigPath(root));
115  const config = cloneRawDetectionConfig();
116  applyDetectionConfigSource(config, hookSection(raw));
117  applyDetectionConfigSource(config, detectorSection(raw));
118  return config;
119}
120 
121export function writeDetectionConfig(root, detectorConfig, opts = {}) {
122  const filePath = opts.local ? getLocalConfigPath(root) : getConfigPath(root);
123  if (opts.local) ensureConfigGitExclude(root);
124  const existing = safeReadJson(filePath) || {};
125  const existingHook = hookSection(existing);
126  const nextHook = stripDetectorKeys(existingHook);
127  const nextDetector = {
128    ...(detectorSection(existing) || {}),
129    ...normalizeDetectionConfigForWrite(detectorConfig),
130  };
131  const next = {
132    ...existing,
133    detector: nextDetector,
134  };
135  if (nextHook && Object.keys(nextHook).length > 0) {
136    next.hook = nextHook;
137  } else {
138    delete next.hook;
139  }
140  mkdirSync(dirname(filePath), { recursive: true });
141  writeFileSync(filePath, `${JSON.stringify(next, null, 2)}\n`);
142  return filePath;
143}
144 
145function normalizeDetectionConfigForWrite(config) {
146  const out = {};
147  if (Array.isArray(config?.ignoreRules)) {
148    out.ignoreRules = uniqueStrings(config.ignoreRules.map((rule) => normalizeIgnoreRule(rule)).filter(Boolean));
149  }
150  if (Array.isArray(config?.ignoreFiles)) {
151    out.ignoreFiles = uniqueStrings(config.ignoreFiles.filter(v => typeof v === 'string' && v.trim()).map(v => v.trim()));
152  }
153  out.ignoreValues = normalizeIgnoreValueEntries(config?.ignoreValues || []);
154  if (config?.designSystem && typeof config.designSystem === 'object' && !Array.isArray(config.designSystem)) {
155    out.designSystem = {
156      enabled: config.designSystem.enabled === false ? false : true,
157    };
158  }
159  return out;
160}
161 
162function stripDetectorKeys(raw) {
163  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
164  const out = {};
165  for (const [key, value] of Object.entries(raw)) {
166    if (!DETECTOR_CONFIG_KEYS.has(key)) out[key] = value;
167  }
168  return out;
169}
170 
171export function normalizeIgnoreValue(value) {
172  return String(value || '')
173    .trim()
174    .replace(/^["']|["']$/g, '')
175    .replace(/\+/g, ' ')
176    .replace(/\s+/g, ' ')
177    .toLowerCase();
178}
179 
180function normalizeIgnoreRule(rule) {
181  return String(rule || '').trim().toLowerCase();
182}
183 
184function colorIgnoreKey(value) {
185  const color = parseIgnoreColor(value);
186  if (!color) return '';
187  return `${color.r},${color.g},${color.b},${Math.round(color.a * 255)}`;
188}
189 
190function parseIgnoreColor(value) {
191  const text = String(value || '').trim().toLowerCase();
192  if (!text) return null;
193 
194  const hex = text.match(/^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i);
195  if (hex) return parseHexIgnoreColor(hex[1]);
196 
197  const rgb = text.match(/^rgba?\((.*)\)$/i);
198  if (rgb) {
199    const parts = splitColorArgs(rgb[1]);
200    if (parts.length < 3 || parts.length > 4) return null;
201    const r = parseRgbChannel(parts[0]);
202    const g = parseRgbChannel(parts[1]);
203    const b = parseRgbChannel(parts[2]);
204    const a = parts[3] === undefined ? 1 : parseAlphaChannel(parts[3]);
205    if ([r, g, b, a].some((v) => v === null)) return null;
206    return { r, g, b, a };
207  }
208 
209  const hsl = text.match(/^hsla?\((.*)\)$/i);
210  if (hsl) {
211    const parts = splitColorArgs(hsl[1]);
212    if (parts.length < 3 || parts.length > 4) return null;
213    const h = parseHueChannel(parts[0]);
214    const s = parsePercentChannel(parts[1]);
215    const l = parsePercentChannel(parts[2]);
216    const a = parts[3] === undefined ? 1 : parseAlphaChannel(parts[3]);
217    if ([h, s, l, a].some((v) => v === null)) return null;
218    return hslToRgb(h, s, l, a);
219  }
220 
221  return null;
222}
223 
224function parseHexIgnoreColor(hex) {
225  if (hex.length === 3 || hex.length === 4) {
226    const r = parseInt(hex[0] + hex[0], 16);
227    const g = parseInt(hex[1] + hex[1], 16);
228    const b = parseInt(hex[2] + hex[2], 16);
229    const a = hex.length === 4 ? parseInt(hex[3] + hex[3], 16) / 255 : 1;
230    return { r, g, b, a };
231  }
232  const r = parseInt(hex.slice(0, 2), 16);
233  const g = parseInt(hex.slice(2, 4), 16);
234  const b = parseInt(hex.slice(4, 6), 16);
235  const a = hex.length === 8 ? parseInt(hex.slice(6, 8), 16) / 255 : 1;
236  return { r, g, b, a };
237}
238 
239function splitColorArgs(body) {
240  const text = String(body || '').trim();
241  if (!text) return [];
242  if (text.includes(',')) {
243    const parts = text.split(',').map((part) => part.trim()).filter(Boolean);
244    const last = parts[parts.length - 1];
245    if (last && last.includes('/')) {
246      const split = last.split('/').map((part) => part.trim()).filter(Boolean);
247      return [...parts.slice(0, -1), ...split];
248    }
249    return parts;
250  }
251  return text.replace(/\s*\/\s*/g, ' / ').split(/\s+/).filter((part) => part && part !== '/');
252}
253 
254function parseRgbChannel(raw) {
255  const text = String(raw || '').trim();
256  const match = text.match(/^(-?\d*\.?\d+)(%)?$/);
257  if (!match) return null;
258  const value = Number.parseFloat(match[1]);
259  if (!Number.isFinite(value)) return null;
260  const scaled = match[2] ? value * 2.55 : value;
261  if (scaled < 0 || scaled > 255) return null;
262  return Math.round(scaled);
263}
264 
265function parseAlphaChannel(raw) {
266  const text = String(raw || '').trim();
267  const match = text.match(/^(-?\d*\.?\d+)(%)?$/);
268  if (!match) return null;
269  const value = Number.parseFloat(match[1]);
270  if (!Number.isFinite(value)) return null;
271  const alpha = match[2] ? value / 100 : value;
272  return alpha >= 0 && alpha <= 1 ? alpha : null;
273}
274 
275function parseHueChannel(raw) {
276  const text = String(raw || '').trim();
277  const match = text.match(/^(-?\d*\.?\d+)(deg|rad|turn|grad)?$/);
278  if (!match) return null;
279  const value = Number.parseFloat(match[1]);
280  if (!Number.isFinite(value)) return null;
281  const unit = match[2] || 'deg';
282  if (unit === 'turn') return value * 360;
283  if (unit === 'rad') return value * (180 / Math.PI);
284  if (unit === 'grad') return value * 0.9;
285  return value;
286}
287 
288function parsePercentChannel(raw) {
289  const text = String(raw || '').trim();
290  const match = text.match(/^(-?\d*\.?\d+)%$/);
291  if (!match) return null;
292  const value = Number.parseFloat(match[1]);
293  if (!Number.isFinite(value)) return null;
294  return value >= 0 && value <= 100 ? value / 100 : null;
295}
296 
297function hslToRgb(hue, saturation, lightness, alpha) {
298  const h = (((hue % 360) + 360) % 360) / 360;
299  if (saturation === 0) {
300    const gray = clampByte(Math.round(lightness * 255));
301    return { r: gray, g: gray, b: gray, a: alpha };
302  }
303  const q = lightness < 0.5
304    ? lightness * (1 + saturation)
305    : lightness + saturation - lightness * saturation;
306  const p = 2 * lightness - q;
307  const toRgb = (t) => {
308    let channel = t;
309    if (channel < 0) channel += 1;
310    if (channel > 1) channel -= 1;
311    if (channel < 1 / 6) return p + (q - p) * 6 * channel;
312    if (channel < 1 / 2) return q;
313    if (channel < 2 / 3) return p + (q - p) * (2 / 3 - channel) * 6;
314    return p;
315  };
316  return {
317    r: clampByte(Math.round(toRgb(h + 1 / 3) * 255)),
318    g: clampByte(Math.round(toRgb(h) * 255)),
319    b: clampByte(Math.round(toRgb(h - 1 / 3) * 255)),
320    a: alpha,
321  };
322}
323 
324function clampByte(value) {
325  return Math.min(255, Math.max(0, value));
326}
327 
328function ignoreValueMatches(rule, entryValue, findingValue) {
329  if (entryValue === findingValue) return true;
330  if (rule !== 'design-system-color') return false;
331  const entryColor = colorIgnoreKey(entryValue);
332  return Boolean(entryColor && entryColor === colorIgnoreKey(findingValue));
333}
334 
335export function normalizeIgnoreValueEntries(entries) {
336  if (!Array.isArray(entries)) return [];
337  const out = [];
338  for (const entry of entries) {
339    if (!entry || typeof entry !== 'object') continue;
340    const rule = normalizeIgnoreRule(entry.rule);
341    const value = normalizeIgnoreValue(entry.value);
342    if (!rule || !value) continue;
343    const normalized = { rule, value };
344    const files = uniqueStrings([
345      ...(typeof entry.file === 'string' && entry.file.trim() ? [entry.file.trim()] : []),
346      ...(Array.isArray(entry.files) ? entry.files.filter(v => typeof v === 'string' && v.trim()).map(v => v.trim()) : []),
347    ]);
348    if (files.length > 0) normalized.files = files;
349    if (typeof entry.reason === 'string' && entry.reason.trim()) {
350      normalized.reason = entry.reason.trim();
351    }
352    if (typeof entry.createdAt === 'string' && entry.createdAt.trim()) {
353      normalized.createdAt = entry.createdAt.trim();
354    }
355    out.push(normalized);
356  }
357  return out;
358}
359 
360function mergeIgnoreValues(existing, incoming) {
361  const map = new Map();
362  for (const entry of normalizeIgnoreValueEntries(existing)) {
363    map.set(`${entry.rule}\0${entry.value}\0${ignoreValueFilesKey(entry.files)}`, entry);
364  }
365  for (const entry of normalizeIgnoreValueEntries(incoming)) {
366    map.set(`${entry.rule}\0${entry.value}\0${ignoreValueFilesKey(entry.files)}`, entry);
367  }
368  return Array.from(map.values());
369}
370 
371function ignoreValueFilesKey(files) {
372  return Array.isArray(files) && files.length > 0 ? files.join('\x1f') : '';
373}
374 
375// Glob -> RegExp. Supports `**`, `*`, `?`, and `{a,b}` alternation.
376function globToRegex(glob) {
377  let re = '^';
378  let i = 0;
379  while (i < glob.length) {
380    const c = glob[i];
381    if (c === '*') {
382      if (glob[i + 1] === '*') {
383        re += '.*';
384        i += 2;
385        if (glob[i] === '/') i += 1;
386      } else {
387        re += '[^/]*';
388        i += 1;
389      }
390    } else if (c === '?') {
391      re += '[^/]';
392      i += 1;
393    } else if (c === '{') {
394      const end = glob.indexOf('}', i);
395      if (end === -1) { re += '\\{'; i += 1; continue; }
396      const parts = glob.slice(i + 1, end).split(',').map((p) => p.replace(/[.+^$()|[\]\\]/g, '\\$&'));
397      re += `(?:${parts.join('|')})`;
398      i = end + 1;
399    } else if (/[.+^$()|[\]\\]/.test(c)) {
400      re += `\\${c}`;
401      i += 1;
402    } else {
403      re += c;
404      i += 1;
405    }
406  }
407  re += '$';
408  return new RegExp(re);
409}
410 
411export function matchesAnyGlob(filePath, globs) {
412  if (!Array.isArray(globs) || globs.length === 0) return false;
413  const normalized = String(filePath || '').split(sep).join('/');
414  for (const glob of globs) {
415    try {
416      const re = globToRegex(String(glob));
417      if (re.test(normalized)) return true;
418      const base = normalized.split('/').pop();
419      if (re.test(base)) return true;
420    } catch {
421      /* malformed glob, skip */
422    }
423  }
424  return false;
425}
426 
427export function shouldIgnoreDetectionFile(filePath, root, config) {
428  const globs = config?.ignoreFiles || [];
429  if (!Array.isArray(globs) || globs.length === 0) return false;
430  const raw = String(filePath || '').trim();
431  if (!raw) return false;
432  if (matchesAnyGlob(raw, globs)) return true;
433 
434  try {
435    const abs = isAbsolute(raw) ? raw : resolve(root, raw);
436    if (matchesAnyGlob(abs, globs)) return true;
437    const rel = relative(root, abs);
438    if (rel && !rel.startsWith('..') && !isAbsolute(rel)) {
439      return matchesAnyGlob(rel, globs);
440    }
441  } catch {
442    /* ignore */
443  }
444  return false;
445}
446 
447export function filterDetectionFindings(findings, config) {
448  if (!Array.isArray(findings) || findings.length === 0) return [];
449  const ignoreRules = new Set((config?.ignoreRules || []).map((rule) => normalizeIgnoreRule(rule)));
450  const ignoreValues = normalizeIgnoreValueEntries(config?.ignoreValues || []);
451  return findings.filter((finding) => {
452    if (!finding || typeof finding !== 'object') return false;
453    if (ignoreRules.has(normalizeIgnoreRule(finding.antipattern))) return false;
454    if (isIgnoredFindingValue(finding, ignoreValues)) return false;
455    return true;
456  });
457}
458 
459function isIgnoredFindingValue(finding, ignoreValues) {
460  if (!Array.isArray(ignoreValues) || ignoreValues.length === 0) return false;
461  const rule = normalizeIgnoreRule(finding.antipattern);
462  const value = extractFindingIgnoreValue(finding);
463  if (!rule || !value) return false;
464  return ignoreValues.some((entry) => {
465    const wildcardValue = entry.value === '*';
466    if (entry.rule !== rule || (!wildcardValue && !ignoreValueMatches(rule, entry.value, value))) return false;
467    if (!Array.isArray(entry.files) || entry.files.length === 0) return !wildcardValue;
468    return findingMatchesScopedIgnoreFile(finding, entry.files);
469  });
470}
471 
472function findingMatchesScopedIgnoreFile(finding, globs) {
473  const filePath = String(finding?.file || '').trim();
474  if (!filePath) return false;
475  if (matchesAnyGlob(filePath, globs)) return true;
476 
477  const normalized = filePath.split(sep).join('/');
478  const parts = normalized.split('/').filter(Boolean);
479  for (let i = 0; i < parts.length; i++) {
480    const suffix = parts.slice(i).join('/');
481    if (matchesAnyGlob(suffix, globs)) return true;
482  }
483  return false;
484}
485 
486export function extractFindingIgnoreValue(finding) {
487  if (!finding || typeof finding !== 'object') return '';
488  const rule = normalizeIgnoreRule(finding.antipattern);
489  const directValueRules = new Set([
490    'overused-font',
491    'bounce-easing',
492    'design-system-font',
493    'design-system-color',
494    'design-system-radius',
495  ]);
496  if (!directValueRules.has(rule)) return '';
497  return normalizeIgnoreValue(extractFindingIgnoreValueRaw(finding, rule));
498}
499 
500function extractFindingIgnoreValueRaw(finding, rule = normalizeIgnoreRule(finding?.antipattern)) {
501  const direct = cleanIgnoreValueDisplay(finding.ignoreValue || finding.value || '');
502  if (direct) return direct;
503 
504  const candidates = [finding.detail, finding.snippet].filter((v) => typeof v === 'string' && v);
505  for (const text of candidates) {
506    if (rule === 'bounce-easing') {
507      const motion = extractMotionIgnoreValue(text);
508      if (motion) return motion;
509      continue;
510    }
511 
512    const primary = text.match(/Primary font:\s*([^()\n;]+)/i);
513    if (primary) return cleanIgnoreValueDisplay(primary[1]);
514 
515    const family = text.match(/font-family\s*:\s*["']?([^'",;\n]+)/i);
516    if (family) return cleanIgnoreValueDisplay(family[1]);
517 
518    const google = text.match(/[?&]family=([^&:;\n]+)/i);
519    if (google) {
520      try {
521        return cleanIgnoreValueDisplay(decodeURIComponent(google[1]));
522      } catch {
523        return cleanIgnoreValueDisplay(google[1]);
524      }
525    }
526  }
527 
528  return '';
529}
530 
531function extractMotionIgnoreValue(text) {
532  const tailwind = text.match(/\banimate-bounce\b/i);
533  if (tailwind) return cleanIgnoreValueDisplay(tailwind[0]);
534 
535  const bezier = text.match(/cubic-bezier\([^)]+\)/i);
536  if (bezier) return cleanIgnoreValueDisplay(bezier[0]);
537 
538  const animation = text.match(/animation(?:-name)?\s*:\s*([^;\n]+)/i);
539  if (animation) {
540    const token = animation[1]
541      .split(/[,\s]+/)
542      .find((part) => /bounce|elastic|wobble|jiggle|spring/i.test(part));
543    if (token) return cleanIgnoreValueDisplay(token);
544  }
545 
546  return '';
547}
548 
549function cleanIgnoreValueDisplay(value) {
550  return String(value || '')
551    .trim()
552    .replace(/^["']|["']$/g, '')
553    .replace(/\+/g, ' ')
554    .replace(/\s+/g, ' ');
555}
556 
557/**
558 * The recorded design-hook decision: 'accepted' | 'declined' | undefined.
559 * config.local.json (per-developer) overrides config.json.
560 */
561export function getHookConsent(root) {
562  let consent;
563  for (const filePath of [getConfigPath(root), getLocalConfigPath(root)]) {
564    const hook = hookSection(safeReadJson(filePath));
565    if (hook && (hook.consent === 'accepted' || hook.consent === 'declined')) consent = hook.consent;
566  }
567  return consent;
568}
569 
570/**
571 * Persist the per-developer decision to config.local.json, preserving any
572 * sibling keys, and ensure the file is gitignored.
573 */
574export function setHookConsent(root, value) {
575  const filePath = getLocalConfigPath(root);
576  const existing = safeReadJson(filePath) || {};
577  const hook = hookSection(existing) || {};
578  const next = { ...existing, hook: { ...hook, consent: value } };
579  mkdirSync(dirname(filePath), { recursive: true });
580  writeFileSync(filePath, `${JSON.stringify(next, null, 2)}\n`);
581  ensureConfigGitExclude(root);
582  return filePath;
583}
584 
585const EXCLUDE_OPEN = '# impeccable-config-ignore-start';
586const EXCLUDE_CLOSE = '# impeccable-config-ignore-end';
587const EXCLUDE_PATTERNS = ['.impeccable/config.local.json'];
588 
589/**
590 * Add config.local.json to `.git/info/exclude` so a developer's decision is
591 * never committed. Idempotent via marker comments. Best-effort; returns false
592 * when there is no resolvable git dir.
593 */
594export function ensureConfigGitExclude(root) {
595  try {
596    const gitDir = resolveGitDir(root);
597    if (!gitDir) return false;
598    const target = join(gitDir, 'info', 'exclude');
599    const existing = existsSync(target) ? readFileSync(target, 'utf-8') : '';
600    const block = [EXCLUDE_OPEN, ...EXCLUDE_PATTERNS, EXCLUDE_CLOSE].join('\n');
601    const markerRe = new RegExp(`${escapeRegExp(EXCLUDE_OPEN)}[\\s\\S]*?${escapeRegExp(EXCLUDE_CLOSE)}`);
602    let updated;
603    if (markerRe.test(existing)) {
604      updated = existing.replace(markerRe, block);
605    } else {
606      const prefix = existing.length === 0 ? '' : existing.endsWith('\n') ? existing : `${existing}\n`;
607      updated = `${prefix}${block}\n`;
608    }
609    if (updated !== existing) {
610      mkdirSync(dirname(target), { recursive: true });
611      writeFileSync(target, updated);
612    }
613    return true;
614  } catch {
615    return false;
616  }
617}
618 
619function resolveGitDir(root) {
620  const dotGit = join(root, '.git');
621  if (!existsSync(dotGit)) return null;
622  try {
623    if (statSync(dotGit).isDirectory()) return dotGit;
624    // A `.git` file (worktree/submodule) points elsewhere: "gitdir: <path>".
625    const match = readFileSync(dotGit, 'utf-8').match(/gitdir:\s*(.+)/);
626    if (match) {
627      const resolved = match[1].trim();
628      return isAbsolute(resolved) ? resolved : join(root, resolved);
629    }
630  } catch {
631    /* fall through */
632  }
633  return null;
634}
635 
636function escapeRegExp(value) {
637  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
638}
639