1#!/usr/bin/env node
2/**
3 * `/impeccable hooks <on|off|status|reset>` — manage the design hook runtime
4 * via the `hook` key and shared detector ignores via the `detector` key in
5 * .impeccable/config.json / .impeccable/config.local.json.
6 *
7 * Usage:
8 *   node hook-admin.mjs status                         # print current state
9 *   node hook-admin.mjs on                             # set enabled: true
10 *   node hook-admin.mjs off                            # set enabled: false
11 *   node hook-admin.mjs ignore-rule <rule-id>          # append to ignoreRules
12 *   node hook-admin.mjs ignore-rule overused-font --all-values
13 *   node hook-admin.mjs ignore-file <glob>             # append to ignoreFiles
14 *   node hook-admin.mjs ignore-value <rule> <value>    # append to shared ignoreValues
15 *   node hook-admin.mjs ignore-value <rule> <value> --local
16 *   node hook-admin.mjs reset                          # remove all config + cache
17 *
18 * Designed to be invoked by the LLM from the reference/hooks.md flow.
19 * Output is human-readable; the harness will pass it back to the user.
20 */
21 
22import fs from 'node:fs';
23import path from 'node:path';
24 
25import {
26  getConfigPath,
27  getLocalConfigPath,
28  getCachePath,
29  getPendingPath,
30  readConfig,
31  DEFAULT_CONFIG,
32  ensureHookGitExcludes,
33  normalizeIgnoreValue,
34  normalizeIgnoreValueEntries,
35} from './hook-lib.mjs';
36 
37const ACTIONS = new Set(['status', 'on', 'off', 'ignore-rule', 'ignore-file', 'ignore-value', 'reset']);
38const IMPECCABLE_HOOK_COMMAND_MARKERS = [
39  'skills/impeccable/scripts/hook-probe.mjs',
40  'skills/impeccable/scripts/hook.mjs',
41  'skills/impeccable/scripts/hook-before-edit.mjs',
42  'skills/impeccable/scripts/hook-after-edit.mjs',
43  'skills/impeccable/scripts/hook-stop.mjs',
44];
45const TIMEOUT_SECONDS = 5;
46const STATUS_MESSAGE = 'Checking UI changes';
47 
48const HOOK_MANIFEST_TARGETS = [
49  {
50    provider: '.claude',
51    skillRel: '.claude/skills/impeccable',
52    destRel: '.claude/settings.local.json',
53    sharedDestRel: '.claude/settings.json',
54    manifest: () => ({
55      description: 'Impeccable design detector: runs after Edit/Write/MultiEdit on UI files and surfaces findings as system reminders.',
56      hooks: {
57        PostToolUse: [
58          {
59            matcher: 'Edit|Write|MultiEdit',
60            hooks: [
61              {
62                type: 'command',
63                command: 'node "${CLAUDE_PROJECT_DIR}/.claude/skills/impeccable/scripts/hook.mjs"',
64                timeout: TIMEOUT_SECONDS,
65                statusMessage: STATUS_MESSAGE,
66              },
67            ],
68          },
69        ],
70      },
71    }),
72  },
73  {
74    provider: '.agents',
75    skillRel: '.agents/skills/impeccable',
76    destRel: '.codex/hooks.json',
77    manifest: () => ({
78      description: 'Impeccable design detector: runs after Edit/Write/apply_patch on UI files and surfaces findings as system reminders.',
79      hooks: {
80        PostToolUse: [
81          {
82            matcher: 'Edit|Write|apply_patch',
83            hooks: [
84              {
85                type: 'command',
86                command: 'node "$(git rev-parse --show-toplevel)/.agents/skills/impeccable/scripts/hook.mjs"',
87                timeout: TIMEOUT_SECONDS,
88                statusMessage: STATUS_MESSAGE,
89              },
90            ],
91          },
92        ],
93      },
94    }),
95  },
96  {
97    provider: '.cursor',
98    skillRel: '.cursor/skills/impeccable',
99    destRel: '.cursor/hooks.json',
100    manifest: () => ({
101      version: 1,
102      hooks: {
103        preToolUse: [
104          {
105            command: 'node ".cursor/skills/impeccable/scripts/hook-before-edit.mjs"',
106            timeout: TIMEOUT_SECONDS,
107          },
108        ],
109      },
110    }),
111  },
112  {
113    // GitHub Copilot reads repo-level hooks from `.github/hooks/*.json`. The same
114    // manifest is honored by the CLI (once committed to the default branch) and
115    // the cloud/app agent. Schema differs: lowercase `postToolUse`, flat entries,
116    // `bash`/`timeoutSec`, and a `matcher` regex against the `edit`/`create` tools.
117    provider: '.github',
118    skillRel: '.github/skills/impeccable',
119    destRel: '.github/hooks/impeccable.json',
120    manifest: () => ({
121      version: 1,
122      hooks: {
123        postToolUse: [
124          {
125            type: 'command',
126            matcher: 'edit|create|apply_patch',
127            bash: 'node "$(git rev-parse --show-toplevel)/.github/skills/impeccable/scripts/hook.mjs"',
128            timeoutSec: TIMEOUT_SECONDS,
129          },
130        ],
131      },
132    }),
133  },
134];
135 
136function readRawConfigFile(filePath) {
137  if (!fs.existsSync(filePath)) return { exists: false, malformed: false, raw: null };
138  try {
139    return { exists: true, malformed: false, raw: JSON.parse(fs.readFileSync(filePath, 'utf-8')) };
140  } catch {
141    return { exists: true, malformed: true, raw: null };
142  }
143}
144 
145const DETECTOR_CONFIG_KEYS = new Set(['ignoreRules', 'ignoreFiles', 'ignoreValues', 'designSystem']);
146 
147function hookSection(unified) {
148  return unified && typeof unified === 'object' && !Array.isArray(unified) && unified.hook && typeof unified.hook === 'object' && !Array.isArray(unified.hook)
149    ? unified.hook
150    : null;
151}
152 
153function detectorSection(unified) {
154  return unified && typeof unified === 'object' && !Array.isArray(unified) && unified.detector && typeof unified.detector === 'object' && !Array.isArray(unified.detector)
155    ? unified.detector
156    : null;
157}
158 
159function readRawHookConfig(cwd, opts = {}) {
160  const unified = readRawConfigFile(opts.local ? getLocalConfigPath(cwd) : getConfigPath(cwd)).raw;
161  return hookSection(unified);
162}
163 
164function readRawDetectorConfig(cwd, opts = {}) {
165  const unified = readRawConfigFile(opts.local ? getLocalConfigPath(cwd) : getConfigPath(cwd)).raw;
166  const merged = mergeDetectorConfig(hookSection(unified));
167  return mergeDetectorConfig(detectorSection(unified), merged);
168}
169 
170function stripDetectorKeys(raw) {
171  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {};
172  const out = {};
173  for (const [key, value] of Object.entries(raw)) {
174    if (!DETECTOR_CONFIG_KEYS.has(key)) out[key] = value;
175  }
176  return out;
177}
178 
179// Write hook runtime config under `hook`, leaving detector filters in
180// `detector` and preserving sibling keys such as updateCheck.
181function writeHookConfig(cwd, hookConfig, opts = {}) {
182  const filePath = opts.local ? getLocalConfigPath(cwd) : getConfigPath(cwd);
183  if (opts.local) ensureHookGitExcludes(cwd);
184  const existingRaw = readRawConfigFile(filePath).raw;
185  const existing = existingRaw && typeof existingRaw === 'object' && !Array.isArray(existingRaw) ? existingRaw : {};
186  const existingHook = stripDetectorKeys(hookSection(existing));
187  // Merge over the existing hook object so fields the merge helpers don't manage
188  // (consent, quiet, auditLog) survive a `/impeccable hooks` edit.
189  const next = { ...existing, hook: { ...existingHook, ...hookConfig } };
190  fs.mkdirSync(path.dirname(filePath), { recursive: true });
191  fs.writeFileSync(filePath, JSON.stringify(next, null, 2) + '\n');
192  return filePath;
193}
194 
195function writeDetectorConfig(cwd, detectorConfig, opts = {}) {
196  const filePath = opts.local ? getLocalConfigPath(cwd) : getConfigPath(cwd);
197  if (opts.local) ensureHookGitExcludes(cwd);
198  const existingRaw = readRawConfigFile(filePath).raw;
199  const existing = existingRaw && typeof existingRaw === 'object' && !Array.isArray(existingRaw) ? existingRaw : {};
200  const nextHook = stripDetectorKeys(hookSection(existing));
201  const existingDetector = mergeDetectorConfig(detectorSection(existing));
202  const next = {
203    ...existing,
204    detector: mergeDetectorConfig(detectorConfig, existingDetector),
205  };
206  if (Object.keys(nextHook).length > 0) next.hook = nextHook;
207  else delete next.hook;
208  fs.mkdirSync(path.dirname(filePath), { recursive: true });
209  fs.writeFileSync(filePath, JSON.stringify(next, null, 2) + '\n');
210  return filePath;
211}
212 
213function mergeHookConfig(existing) {
214  const base = existing && typeof existing === 'object' ? existing : {};
215  return {
216    enabled: base.enabled === false ? false : true,
217    limits: {
218      maxFindings: Number.isFinite(base?.limits?.maxFindings) ? base.limits.maxFindings : DEFAULT_CONFIG.limits.maxFindings,
219      maxChars: Number.isFinite(base?.limits?.maxChars) ? base.limits.maxChars : DEFAULT_CONFIG.limits.maxChars,
220    },
221  };
222}
223 
224function mergeDetectorConfig(existing, seed = null) {
225  const base = existing && typeof existing === 'object' ? existing : {};
226  const out = seed ? {
227    ignoreRules: [...seed.ignoreRules],
228    ignoreFiles: [...seed.ignoreFiles],
229    ignoreValues: normalizeIgnoreValueEntries(seed.ignoreValues),
230  } : {
231    ignoreRules: [],
232    ignoreFiles: [],
233    ignoreValues: [],
234  };
235  if (seed?.designSystem && typeof seed.designSystem === 'object' && !Array.isArray(seed.designSystem)) {
236    out.designSystem = { ...seed.designSystem };
237  }
238  if (base.designSystem && typeof base.designSystem === 'object' && !Array.isArray(base.designSystem)) {
239    out.designSystem = {
240      ...(out.designSystem || {}),
241      enabled: base.designSystem.enabled === false ? false : true,
242    };
243  }
244  if (Array.isArray(base.ignoreRules)) {
245    out.ignoreRules = Array.from(new Set([...out.ignoreRules, ...base.ignoreRules.map(String)]));
246  }
247  if (Array.isArray(base.ignoreFiles)) {
248    out.ignoreFiles = Array.from(new Set([...out.ignoreFiles, ...base.ignoreFiles.map(String)]));
249  }
250  if (Array.isArray(base.ignoreValues)) {
251    out.ignoreValues = mergeIgnoreValueEntries(out.ignoreValues, base.ignoreValues);
252  }
253  return out;
254}
255 
256function mergeIgnoreValueEntries(existing, incoming) {
257  const map = new Map();
258  for (const entry of normalizeIgnoreValueEntries(existing)) {
259    map.set(ignoreValueEntryKey(entry), entry);
260  }
261  for (const entry of normalizeIgnoreValueEntries(incoming)) {
262    map.set(ignoreValueEntryKey(entry), entry);
263  }
264  return Array.from(map.values());
265}
266 
267function ignoreValueEntryKey(entry) {
268  const files = Array.isArray(entry.files) && entry.files.length > 0 ? entry.files.join('\x1f') : '';
269  return `${entry.rule}\0${entry.value}\0${files}`;
270}
271 
272function statusReport(cwd) {
273  const shared = readRawConfigFile(getConfigPath(cwd));
274  const local = readRawConfigFile(getLocalConfigPath(cwd));
275  const cfg = readConfig(cwd);
276  const envKill = process.env.IMPECCABLE_HOOK_DISABLED;
277  const envState = envKill ? `IMPECCABLE_HOOK_DISABLED=${envKill}` : 'unset';
278  const cfgPath = path.relative(cwd, getConfigPath(cwd)) || '.impeccable/config.json';
279  const localPath = path.relative(cwd, getLocalConfigPath(cwd)) || '.impeccable/config.local.json';
280  const cachePath = path.relative(cwd, getCachePath(cwd)) || '.impeccable/hook.cache.json';
281  const fileState = (info, relPath, absent) => {
282    if (info.malformed) return `${relPath} (malformed; ignored)`;
283    if (info.exists) return relPath;
284    return `${relPath} (${absent})`;
285  };
286  const ignoreValues = cfg.ignoreValues.map((entry) => `${entry.rule}=${entry.value}`);
287 
288  const lines = [
289    `Impeccable design hook`,
290    `  state:        ${cfg.enabled ? 'enabled' : 'disabled'}`,
291    `  shared file:  ${fileState(shared, cfgPath, 'using defaults; file not present')}`,
292    `  local file:   ${fileState(local, localPath, 'not present')}`,
293    `  ignoreRules:  ${cfg.ignoreRules.length ? cfg.ignoreRules.join(', ') : '(none)'}`,
294    `  ignoreFiles:  ${cfg.ignoreFiles.length ? cfg.ignoreFiles.join(', ') : '(none)'}`,
295    `  ignoreValues: ${ignoreValues.length ? ignoreValues.join(', ') : '(none)'}`,
296    `  maxFindings:  ${cfg.limits.maxFindings}`,
297    `  maxChars:     ${cfg.limits.maxChars}`,
298    `  env override: ${envState}`,
299    `  cache file:   ${fs.existsSync(getCachePath(cwd)) ? cachePath : `${cachePath} (not present)`}`,
300  ];
301  return lines.join('\n');
302}
303 
304function setEnabled(cwd, value) {
305  const config = mergeHookConfig(readRawHookConfig(cwd));
306  config.enabled = value;
307  const target = writeHookConfig(cwd, config);
308  if (!value) {
309    return `Design hook disabled for this project (wrote ${path.relative(cwd, target) || target}).`;
310  }
311 
312  const localTarget = writeHookConfig(cwd, { consent: 'accepted' }, { local: true });
313  const repaired = repairHookManifests(cwd);
314  const parts = [
315    `Design hook enabled for this project (wrote ${path.relative(cwd, target) || target}).`,
316    `Recorded local hook consent in ${path.relative(cwd, localTarget) || localTarget}.`,
317  ];
318  if (repaired.written.length > 0) {
319    parts.push(`Installed or repaired hook manifests for: ${repaired.written.join(', ')}.`);
320  } else if (repaired.already.length > 0) {
321    parts.push(`Hook manifests already installed for: ${repaired.already.join(', ')}.`);
322  } else {
323    parts.push('No installed provider skill folders found to repair.');
324  }
325  if (repaired.backups.length > 0) {
326    parts.push(`Backed up malformed manifest(s): ${repaired.backups.map((filePath) => path.relative(cwd, filePath) || filePath).join(', ')}.`);
327  }
328  return parts.join(' ');
329}
330 
331function repairHookManifests(cwd) {
332  const result = { written: [], already: [], backups: [] };
333  for (const target of HOOK_MANIFEST_TARGETS) {
334    if (!fs.existsSync(path.join(cwd, target.skillRel))) continue;
335    const dest = path.join(cwd, target.destRel);
336    const sharedDest = target.sharedDestRel ? path.join(cwd, target.sharedDestRel) : null;
337 
338    if (sharedDest && fileHasImpeccableHookMarker(sharedDest)) {
339      pruneImpeccableHookFromManifest(dest);
340      result.already.push(target.provider);
341      continue;
342    }
343 
344    const fresh = target.manifest();
345    let next = fresh;
346    if (fs.existsSync(dest)) {
347      try {
348        next = mergeHookManifests(JSON.parse(fs.readFileSync(dest, 'utf-8')), fresh);
349      } catch {
350        const backup = `${dest}.bak`;
351        fs.copyFileSync(dest, backup);
352        result.backups.push(backup);
353      }
354    }
355 
356    const serialized = `${JSON.stringify(next, null, 2)}\n`;
357    const current = fs.existsSync(dest) ? safeReadText(dest) : null;
358    if (current === serialized) {
359      result.already.push(target.provider);
360      continue;
361    }
362    fs.mkdirSync(path.dirname(dest), { recursive: true });
363    fs.writeFileSync(dest, serialized);
364    result.written.push(target.provider);
365  }
366  return result;
367}
368 
369function safeReadText(filePath) {
370  try {
371    return fs.readFileSync(filePath, 'utf-8');
372  } catch {
373    return null;
374  }
375}
376 
377function mergeHookManifests(existing, fresh) {
378  const existingObject = existing && typeof existing === 'object' && !Array.isArray(existing) ? existing : {};
379  const freshObject = fresh && typeof fresh === 'object' && !Array.isArray(fresh) ? fresh : {};
380  const existingHooks = existingObject.hooks && typeof existingObject.hooks === 'object' && !Array.isArray(existingObject.hooks)
381    ? existingObject.hooks
382    : {};
383  const freshHooks = freshObject.hooks && typeof freshObject.hooks === 'object' && !Array.isArray(freshObject.hooks)
384    ? freshObject.hooks
385    : {};
386 
387  const merged = { ...existingObject, hooks: {} };
388  if (freshObject.version !== undefined) merged.version = freshObject.version;
389  if (freshObject.description !== undefined) merged.description = freshObject.description;
390 
391  const hookEvents = new Set([...Object.keys(existingHooks), ...Object.keys(freshHooks)]);
392  for (const event of hookEvents) {
393    const preserved = stripImpeccableHookEntries(existingHooks[event]);
394    const added = Array.isArray(freshHooks[event]) ? freshHooks[event] : [];
395    const mergedEntries = [...preserved, ...added];
396    if (mergedEntries.length > 0) merged.hooks[event] = mergedEntries;
397  }
398  return merged;
399}
400 
401function fileHasImpeccableHookMarker(filePath) {
402  if (!fs.existsSync(filePath)) return false;
403  let parsed;
404  try {
405    parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
406  } catch {
407    return false;
408  }
409  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return false;
410  if (!parsed.hooks || typeof parsed.hooks !== 'object') return false;
411  return valueHasImpeccableHookMarker(parsed.hooks);
412}
413 
414function valueHasImpeccableHookMarker(value) {
415  if (typeof value === 'string') {
416    return IMPECCABLE_HOOK_COMMAND_MARKERS.some((marker) => value.includes(marker));
417  }
418  if (Array.isArray(value)) return value.some(valueHasImpeccableHookMarker);
419  if (value && typeof value === 'object') return Object.values(value).some(valueHasImpeccableHookMarker);
420  return false;
421}
422 
423function stripImpeccableHookEntry(entry) {
424  if (!entry || typeof entry !== 'object') return entry;
425  // `command`/`args`: Claude/Codex/Cursor. `bash`/`powershell`: GitHub Copilot's
426  // flat entry shape, where the marker lives under the shell-command keys.
427  if (valueHasImpeccableHookMarker(entry.command) || valueHasImpeccableHookMarker(entry.args)
428    || valueHasImpeccableHookMarker(entry.bash) || valueHasImpeccableHookMarker(entry.powershell)) {
429    return null;
430  }
431  if (!Array.isArray(entry.hooks)) return entry;
432 
433  const strippedHooks = entry.hooks
434    .map(stripImpeccableHookEntry)
435    .filter(Boolean);
436 
437  if (strippedHooks.length === 0 && entry.hooks.some(valueHasImpeccableHookMarker)) {
438    return null;
439  }
440  return { ...entry, hooks: strippedHooks };
441}
442 
443function stripImpeccableHookEntries(entries) {
444  if (!Array.isArray(entries)) return [];
445  return entries
446    .map(stripImpeccableHookEntry)
447    .filter(Boolean);
448}
449 
450function pruneImpeccableHookFromManifest(manifestPath) {
451  if (!fileHasImpeccableHookMarker(manifestPath)) return false;
452  let parsed;
453  try {
454    parsed = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
455  } catch {
456    return false;
457  }
458 
459  const existingHooks = parsed.hooks && typeof parsed.hooks === 'object' && !Array.isArray(parsed.hooks)
460    ? parsed.hooks
461    : {};
462  const cleanedHooks = {};
463  for (const [event, entries] of Object.entries(existingHooks)) {
464    const kept = stripImpeccableHookEntries(entries);
465    if (kept.length > 0) cleanedHooks[event] = kept;
466  }
467 
468  const next = { ...parsed };
469  if (Object.keys(cleanedHooks).length > 0) {
470    next.hooks = cleanedHooks;
471  } else {
472    delete next.hooks;
473    delete next.description;
474    delete next.version;
475  }
476 
477  if (Object.keys(next).length === 0) {
478    fs.rmSync(manifestPath, { force: true });
479  } else {
480    fs.writeFileSync(manifestPath, `${JSON.stringify(next, null, 2)}\n`);
481  }
482  return true;
483}
484 
485function normalizeRuleId(rule) {
486  return String(rule || '').trim().toLowerCase();
487}
488 
489function parseIgnoreRuleArgs(args) {
490  const positionals = [];
491  let allValues = false;
492 
493  for (let i = 0; i < args.length; i++) {
494    const arg = String(args[i] || '');
495    if (arg === '--all-values') {
496      allValues = true;
497    } else if (arg === '--reason') {
498      while (i + 1 < args.length && !String(args[i + 1]).startsWith('--')) i++;
499    } else if (arg.startsWith('--reason=')) {
500      // Accepted for command symmetry; ignoreRules stores rule ids only.
501    } else if (arg.startsWith('--')) {
502      throw new Error(`Unknown ignore-rule flag: ${arg}`);
503    } else {
504      positionals.push(arg);
505    }
506  }
507 
508  return {
509    rule: normalizeRuleId(positionals[0]),
510    allValues,
511  };
512}
513 
514function addIgnoreRule(cwd, args) {
515  const parsed = parseIgnoreRuleArgs(args);
516  const rule = parsed.rule;
517  if (!rule) throw new Error('Pass a rule id, e.g. /impeccable hooks ignore-rule side-tab');
518  if (rule === 'overused-font' && !parsed.allValues) {
519    throw new Error('overused-font is value-specific by default. Use /impeccable hooks ignore-value overused-font <font> for a confirmed font, or /impeccable hooks ignore-rule overused-font --all-values only when the user asked to ignore overused fonts generally.');
520  }
521  const config = mergeDetectorConfig(readRawDetectorConfig(cwd));
522  if (!config.ignoreRules.includes(rule)) config.ignoreRules.push(rule);
523  writeDetectorConfig(cwd, config);
524  return `Added "${rule}" to detector.ignoreRules. Current: ${config.ignoreRules.join(', ')}`;
525}
526 
527function addIgnoreFile(cwd, glob) {
528  if (!glob) throw new Error('Pass a glob, e.g. /impeccable hooks ignore-file "src/legacy/**"');
529  const config = mergeDetectorConfig(readRawDetectorConfig(cwd));
530  if (!config.ignoreFiles.includes(glob)) config.ignoreFiles.push(glob);
531  writeDetectorConfig(cwd, config);
532  return `Added "${glob}" to detector.ignoreFiles. Current: ${config.ignoreFiles.join(', ')}`;
533}
534 
535function parseIgnoreValueArgs(args) {
536  const positionals = [];
537  let shared = false;
538  let local = false;
539  let reason = '';
540 
541  for (let i = 0; i < args.length; i++) {
542    const arg = args[i];
543    if (arg === '--shared') {
544      shared = true;
545    } else if (arg === '--local') {
546      local = true;
547    } else if (arg === '--reason') {
548      const chunks = [];
549      while (i + 1 < args.length && !String(args[i + 1]).startsWith('--')) {
550        chunks.push(args[++i]);
551      }
552      reason = chunks.join(' ').trim();
553    } else if (String(arg).startsWith('--reason=')) {
554      reason = String(arg).slice('--reason='.length).trim();
555    } else {
556      positionals.push(arg);
557    }
558  }
559 
560  const [rule, ...valueParts] = positionals;
561  return {
562    rule: String(rule || '').trim().toLowerCase(),
563    value: normalizeIgnoreValue(valueParts.join(' ')),
564    shared,
565    local,
566    reason,
567  };
568}
569 
570function addIgnoreValue(cwd, args) {
571  const parsed = parseIgnoreValueArgs(args);
572  if (!parsed.rule || !parsed.value) {
573    throw new Error('Pass a rule id and value, e.g. /impeccable hooks ignore-value overused-font Inter');
574  }
575 
576  if (parsed.shared && parsed.local) {
577    throw new Error('Pass only one scope flag: --shared or --local');
578  }
579 
580  const local = parsed.local;
581  const config = mergeDetectorConfig(readRawDetectorConfig(cwd, { local }));
582  const key = `${parsed.rule}\0${parsed.value}`;
583  const existing = config.ignoreValues.find((entry) => `${entry.rule}\0${entry.value}` === key);
584 
585  if (existing) {
586    if (parsed.reason) existing.reason = parsed.reason;
587  } else {
588    const entry = {
589      rule: parsed.rule,
590      value: parsed.value,
591      createdAt: new Date().toISOString(),
592    };
593    if (parsed.reason) entry.reason = parsed.reason;
594    config.ignoreValues.push(entry);
595  }
596 
597  const target = writeDetectorConfig(cwd, config, { local });
598  const scope = local ? 'local detector.ignoreValues' : 'shared detector.ignoreValues';
599  return `Added ${parsed.rule}=${parsed.value} to ${scope} (${path.relative(cwd, target) || target}).`;
600}
601 
602function reset(cwd) {
603  const removed = [];
604  // Unified files may hold non-hook keys (e.g. updateCheck); strip only the
605  // hook/detector subtrees and keep the rest, deleting the file only if nothing remains.
606  for (const filePath of [getConfigPath(cwd), getLocalConfigPath(cwd)]) {
607    try {
608      const raw = readRawConfigFile(filePath).raw;
609      if (!raw || typeof raw !== 'object' || Array.isArray(raw) || (!('hook' in raw) && !('detector' in raw))) continue;
610      const { hook, detector, ...rest } = raw;
611      if (Object.keys(rest).length === 0) {
612        fs.unlinkSync(filePath);
613      } else {
614        fs.writeFileSync(filePath, JSON.stringify(rest, null, 2) + '\n');
615      }
616      removed.push(path.relative(cwd, filePath) || filePath);
617    } catch { /* ignore */ }
618  }
619  // State files are wholly ours; delete outright.
620  for (const filePath of [getCachePath(cwd), getPendingPath(cwd)]) {
621    try {
622      if (fs.existsSync(filePath)) {
623        fs.unlinkSync(filePath);
624        removed.push(path.relative(cwd, filePath) || filePath);
625      }
626    } catch { /* ignore */ }
627  }
628  return removed.length
629    ? `Reset design hook config and cache (removed: ${removed.join(', ')}).`
630    : 'No hook config or cache to remove. Already at defaults.';
631}
632 
633function main() {
634  const [, , actionArg, ...rest] = process.argv;
635  const action = (actionArg || 'status').toLowerCase();
636  const cwd = process.cwd();
637 
638  if (!ACTIONS.has(action)) {
639    process.stderr.write(`Unknown action: ${action}\nValid: ${Array.from(ACTIONS).join(', ')}\n`);
640    process.exit(1);
641  }
642 
643  try {
644    let out = '';
645    switch (action) {
646      case 'status': out = statusReport(cwd); break;
647      case 'on':     out = setEnabled(cwd, true); break;
648      case 'off':    out = setEnabled(cwd, false); break;
649      case 'ignore-rule': out = addIgnoreRule(cwd, rest); break;
650      case 'ignore-file': out = addIgnoreFile(cwd, rest[0]); break;
651      case 'ignore-value': out = addIgnoreValue(cwd, rest); break;
652      case 'reset':  out = reset(cwd); break;
653    }
654    process.stdout.write(out + '\n');
655  } catch (err) {
656    process.stderr.write(`Error: ${err.message || err}\n`);
657    process.exit(1);
658  }
659}
660 
661main();
662