quiver-cli 1.3.1 → 2.0.0

package/template/.agents/skills/design/impeccable/scripts/detector/shared/constants.mjs

@@ -1,127 +0,0 @@
-// ─── Section 1: Constants ───────────────────────────────────────────────────
-
-const SAFE_TAGS = new Set([
-  'blockquote', 'nav', 'a', 'input', 'textarea', 'select',
-  'pre', 'code', 'span', 'th', 'td', 'tr', 'li', 'label',
-  'button', 'hr', 'html', 'head', 'body', 'script', 'style',
-  'link', 'meta', 'title', 'br', 'img', 'svg', 'path', 'circle',
-  'rect', 'line', 'polyline', 'polygon', 'g', 'defs', 'use',
-]);
-
-// Per-check safe-tags override for the border (side-tab / border-accent)
-// rule. We intentionally re-allow <label> here because card-shaped clickable
-// labels (e.g. .checklist-item wrapping a checkbox + content) are one of the
-// canonical side-tab anti-pattern shapes and must be detected. The rule's
-// other preconditions (non-neutral color, width >= 2px on a single side,
-// radius > 0 or width >= 3, element size >= 20x20 in the browser path)
-// already filter out plain inline form labels so this does not introduce
-// false positives. See modern-color-borders.html for the test matrix.
-const BORDER_SAFE_TAGS = new Set(
-  [...SAFE_TAGS].filter(t => t !== 'label')
-);
-
-const OVERUSED_FONTS = new Set([
-  // Older monoculture (still ubiquitous):
-  'inter', 'roboto', 'open sans', 'lato', 'montserrat', 'arial', 'helvetica',
-  // Newer monoculture (the Anthropic-skill / Vercel / GitHub default wave):
-  'fraunces', 'instrument sans', 'instrument serif',
-  'geist', 'geist sans', 'geist mono',
-  'mona sans',
-  'plus jakarta sans', 'space grotesk', 'recoleta',
-]);
-
-// Brand-associated fonts: don't flag these as "overused" on the brand's own domains.
-// Keys are font names, values are arrays of hostname suffixes where the font is allowed.
-const GOOGLE_DOMAINS = [
-  'google.com', 'youtube.com', 'android.com', 'chromium.org',
-  'chrome.com', 'web.dev', 'gstatic.com', 'firebase.google.com',
-];
-const VERCEL_DOMAINS = ['vercel.com', 'nextjs.org', 'v0.app'];
-const GITHUB_DOMAINS = ['github.com', 'githubnext.com'];
-const BRAND_FONT_DOMAINS = {
-  'roboto': GOOGLE_DOMAINS,
-  'google sans': GOOGLE_DOMAINS,
-  'product sans': GOOGLE_DOMAINS,
-  'geist': VERCEL_DOMAINS,
-  'geist sans': VERCEL_DOMAINS,
-  'geist mono': VERCEL_DOMAINS,
-  'mona sans': GITHUB_DOMAINS,
-};
-
-function isBrandFontOnOwnDomain(font) {
-  if (typeof location === 'undefined') return false;
-  const allowed = BRAND_FONT_DOMAINS[font];
-  if (!allowed) return false;
-  const host = location.hostname.toLowerCase();
-  return allowed.some(suffix => host === suffix || host.endsWith('.' + suffix));
-}
-
-// Overused-font primary selection skips only CSS generics so a system stack
-// keeps the system face as primary; GENERIC_FONTS still includes platform
-// faces for design-system/serif resolution.
-const CSS_GENERIC_FONTS = new Set([
-  'serif', 'sans-serif', 'monospace', 'cursive', 'fantasy',
-  'inherit', 'initial', 'unset', 'revert',
-]);
-
-const GENERIC_FONTS = new Set([
-  ...CSS_GENERIC_FONTS,
-  'system-ui', 'ui-serif', 'ui-sans-serif', 'ui-monospace', 'ui-rounded',
-  '-apple-system', 'blinkmacsystemfont', 'segoe ui',
-]);
-
-function primaryFontFace(fontFamily, skip = CSS_GENERIC_FONTS) {
-  return String(fontFamily || '')
-    .split(',')
-    .map(f => f.trim().replace(/^['"]|['"]$/g, '').toLowerCase())
-    .find(f => f && !skip.has(f)) || null;
-}
-
-// WCAG large text thresholds are defined in points: 18pt normal text and
-// 14pt bold text. Browsers expose font-size in CSS pixels at 96px per inch.
-const WCAG_LARGE_TEXT_PX = 18 * (96 / 72);
-const WCAG_LARGE_BOLD_TEXT_PX = 14 * (96 / 72);
-
-// Em-dash overuse (advisory) thresholds, shared by the regex/static-HTML
-// analyzer and the browser DOM check so both fire on the same saturation
-// pattern. Two gates must hold: an absolute floor of EM_DASH_FLOOR dashes, and
-// a density of at least one dash per EM_DASH_CHARS_PER_DASH characters of body
-// text. A long article that uses a few em-dashes is left alone; a short,
-// dash-per-clause page is not.
-const EM_DASH_FLOOR = 8;
-const EM_DASH_CHARS_PER_DASH = 500;
-
-// Serif faces that show up in italic-display heroes. The rule also fires when
-// the primary face is unknown but the stack ends in the generic `serif` token,
-// which catches custom/private faces with a serif fallback.
-const KNOWN_SERIF_FONTS = new Set([
-  'fraunces', 'recoleta', 'newsreader', 'playfair display', 'playfair',
-  'cormorant', 'cormorant garamond', 'garamond', 'eb garamond',
-  'tiempos', 'tiempos headline', 'tiempos text',
-  'lora', 'vollkorn', 'spectral',
-  'source serif pro', 'source serif 4', 'source serif',
-  'ibm plex serif', 'merriweather',
-  'libre caslon', 'libre baskerville', 'baskerville',
-  'georgia', 'times new roman', 'times',
-  'dm serif display', 'dm serif text',
-  'instrument serif', 'gt sectra', 'ogg', 'canela',
-  'freight display', 'freight text',
-]);
-
-export {
-  SAFE_TAGS,
-  BORDER_SAFE_TAGS,
-  OVERUSED_FONTS,
-  GOOGLE_DOMAINS,
-  VERCEL_DOMAINS,
-  GITHUB_DOMAINS,
-  BRAND_FONT_DOMAINS,
-  isBrandFontOnOwnDomain,
-  GENERIC_FONTS,
-  primaryFontFace,
-  WCAG_LARGE_TEXT_PX,
-  WCAG_LARGE_BOLD_TEXT_PX,
-  EM_DASH_FLOOR,
-  EM_DASH_CHARS_PER_DASH,
-  KNOWN_SERIF_FONTS,
-};

package/template/.agents/skills/design/impeccable/scripts/detector/shared/fonts.mjs

@@ -1,30 +0,0 @@
-const GOOGLE_FONTS_URL_RE = /fonts\.googleapis\.com\/css2?\?[^"'\s)<>]*/gi;
-
-function normalizeGoogleFontFamilyParam(value) {
-  return String(value || '')
-    .split('|')
-    .map(part => part.split(':')[0].trim().toLowerCase())
-    .filter(Boolean);
-}
-
-function extractGoogleFontFamilies(text) {
-  const families = [];
-  if (!text) return families;
-
-  GOOGLE_FONTS_URL_RE.lastIndex = 0;
-  let urlMatch;
-  while ((urlMatch = GOOGLE_FONTS_URL_RE.exec(text)) !== null) {
-    const url = urlMatch[0];
-    const queryStart = url.indexOf('?');
-    if (queryStart === -1) continue;
-
-    const params = new URLSearchParams(url.slice(queryStart + 1).replace(/&amp;/g, '&'));
-    for (const value of params.getAll('family')) {
-      families.push(...normalizeGoogleFontFamilyParam(value));
-    }
-  }
-
-  return families;
-}
-
-export { extractGoogleFontFamilies };

package/template/.agents/skills/design/impeccable/scripts/detector/shared/inline-ignores.mjs

@@ -1,148 +0,0 @@
-/**
- * Inline, in-file ignore directives — eslint-disable-style waivers that live at
- * the point they apply and travel with the artifact instead of (or alongside)
- * an ignore in `.impeccable/config.json`.
- *
- * A config ignore is the right default for repo-wide policy. This complements it
- * for the one case config can't cover: a waiver that belongs to a single file and
- * needs to follow that file when it leaves the repo — a generated/exported
- * standalone document, an emailed HTML file, a snippet scanned out of context.
- *
- * Comment-syntax-agnostic: the directive is a raw token matched anywhere on a
- * line, so the same marker works across every comment style impeccable scans —
- * `//`, `/* *\/`, `<!-- -->`, `#`, `{/* *\/}`, `{# #}`. Trailing comment closers
- * are stripped before the rule list is parsed.
- *
- * Syntax (reason optional; eslint `--` or biome `:` separator):
- *
- *   impeccable-disable <rule>[, <rule>...] [-- reason]   whole file
- *   impeccable-disable-line <rule>...      [-- reason]   the same line
- *   impeccable-disable-next-line <rule>... [-- reason]   the following line
- *   impeccable-disable                                   bare / `*` = every rule
- *
- * Examples:
- *
- *   <!-- impeccable-disable overused-font -- exported brand doc, font is first-party -->
- *   .brand { font-family: Inter; } /* impeccable-disable-line overused-font *\/
- *   // impeccable-disable-next-line bounce-easing: intentional playful affordance
- *
- * Behavior is suppression, for parity with config ignores: a matched directive
- * drops the finding. The inline reason is self-documenting in the diff; it is not
- * required and is discarded at scan time (only used here to keep reason words out
- * of the parsed rule list).
- */
-
-const DIRECTIVE_RE = /impeccable-(disable-next-line|disable-line|disable)\b[ \t]*([^\n\r]*)/gi;
-
-// Trailing comment closers, so `*/`, `*/}`, `-->`, `*}`, `#}`, `%>`, `}}` don't
-// leak into the rule list. Anchored to end-of-line; the leading `\s*` mops up the
-// space before the closer. `--+>` covers `-->` and any longer dash run.
-const TRAILING_CLOSER_RE = /\s*(?:\*\/\}?|--+>|\*\}|#\}|%>|\}\})\s*$/;
-
-function normalizeRule(token) {
-  return String(token || '').trim().toLowerCase();
-}
-
-// Split the directive remainder into rule tokens, dropping any human reason that
-// follows an eslint-style `--` or biome-style `:` separator. Rule ids only ever
-// contain single hyphens (`overused-font`, `bounce-easing`), so `--` and `:`
-// are unambiguous separators.
-function parseRuleList(remainder) {
-  let text = String(remainder || '').replace(TRAILING_CLOSER_RE, '').trim();
-  // Cut off a human reason at the first `--` (eslint) or `:` (biome) separator.
-  const reasonSep = text.match(/\s*(?:--+|:)\s*/);
-  if (reasonSep) text = text.slice(0, reasonSep.index);
-  const tokens = text.split(/[\s,]+/).map(normalizeRule).filter(Boolean);
-  if (tokens.length === 0 || tokens.includes('*')) return ['*'];
-  return tokens;
-}
-
-function addRules(set, rules) {
-  for (const rule of rules) set.add(rule);
-}
-
-function getSet(map, key) {
-  let set = map.get(key);
-  if (!set) {
-    set = new Set();
-    map.set(key, set);
-  }
-  return set;
-}
-
-/**
- * Parse every inline ignore directive in a file's raw text.
- *
- * Returns sets keyed by the 1-based line the directive *targets* so matching is a
- * direct lookup:
- *   - file:     rules disabled for the whole file
- *   - line:     line -> rules disabled on that exact line (disable-line)
- *   - nextLine: line -> rules disabled on that line (disable-next-line on line-1)
- *
- * `*` in any set means "every rule".
- */
-function parseInlineIgnores(content) {
-  const result = { file: new Set(), line: new Map(), nextLine: new Map() };
-  const text = typeof content === 'string' ? content : '';
-  // Cheap bail-out: the substring must be present for any directive to exist.
-  // Case-insensitive to match DIRECTIVE_RE's `i` flag (e.g. `Impeccable-Disable`).
-  if (!/impeccable-disable/i.test(text)) return result;
-
-  // Split on `\n` only, exactly as detectText numbers lines, so directive line
-  // keys line up with finding `line` values (incl. on `\r`-only line endings).
-  // The directive regex excludes `\r`, so a trailing `\r` on `\r\n` files is
-  // never captured into the rule list.
-  const lines = text.split('\n');
-  for (let i = 0; i < lines.length; i++) {
-    DIRECTIVE_RE.lastIndex = 0;
-    let m;
-    while ((m = DIRECTIVE_RE.exec(lines[i])) !== null) {
-      const variant = m[1].toLowerCase();
-      const rules = parseRuleList(m[2]);
-      if (variant === 'disable') {
-        addRules(result.file, rules);
-      } else if (variant === 'disable-line') {
-        addRules(getSet(result.line, i + 1), rules);
-      } else {
-        // disable-next-line on line i+1 targets line i+2.
-        addRules(getSet(result.nextLine, i + 2), rules);
-      }
-    }
-  }
-  return result;
-}
-
-function setMatches(set, rule) {
-  return Boolean(set) && (set.has('*') || set.has(rule));
-}
-
-function isInlineIgnored(finding, directives) {
-  const rule = normalizeRule(finding && finding.antipattern);
-  if (!rule) return false;
-  if (setMatches(directives.file, rule)) return true;
-  const line = Number(finding && finding.line) || 0;
-  if (line > 0) {
-    if (setMatches(directives.line.get(line), rule)) return true;
-    if (setMatches(directives.nextLine.get(line), rule)) return true;
-  }
-  return false;
-}
-
-function hasDirectives(directives) {
-  return directives.file.size > 0 || directives.line.size > 0 || directives.nextLine.size > 0;
-}
-
-/**
- * Drop findings waived by an inline directive in the same file's source text.
- * Findings without a usable line number (e.g. static-HTML page-level findings)
- * are only matched by whole-file directives — which is the standalone-document
- * case this primitive exists for.
- */
-function applyInlineIgnores(findings, content) {
-  if (!Array.isArray(findings) || findings.length === 0) return findings;
-  const directives = parseInlineIgnores(content);
-  if (!hasDirectives(directives)) return findings;
-  return findings.filter((finding) => !isInlineIgnored(finding, directives));
-}
-
-export { parseInlineIgnores, applyInlineIgnores, isInlineIgnored };

package/template/.agents/skills/design/impeccable/scripts/detector/shared/page.mjs

@@ -1,7 +0,0 @@
-/** Check if content looks like a full page (not a component/partial) */
-function isFullPage(content) {
-  const stripped = content.replace(/<!--[\s\S]*?-->/g, '');
-  return /<!doctype\s|<html[\s>]|<head[\s>]/i.test(stripped);
-}
-
-export { isFullPage };

package/template/.agents/skills/design/impeccable/scripts/doctor.mjs

@@ -1,329 +0,0 @@
-#!/usr/bin/env node
-/**
- * Deep staleness pass over Impeccable's own project artifacts.
- *
- *   node doctor.mjs                 # human-readable report
- *   node doctor.mjs --json          # machine-readable, for the skill command
- *   node doctor.mjs --fix           # apply the mechanical migrations only
- *   node doctor.mjs --target <path> # pick a monorepo workspace
- *
- * The boot check in context.mjs reports what a session can afford to measure.
- * This runs everything: git drift, per-workspace sweep, ignore-list validation
- * against the live rule registry, hook script resolution.
- *
- * `--fix` is deliberately narrow. It performs only the migrations marked
- * severity 'auto', the ones with no judgment in them: stamp the product record,
- * move a sidecar out of a retired location. Anything that needs an answer from
- * the user (a platform value, whether an inherited record still describes an
- * app, whether a document has drifted from the code) is reported and left
- * alone. Exit code is 0 unless the run itself failed; findings are not errors.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { loadContext, extractPlatform, resolveTargetSelection } from './context.mjs';
-import { parseTargetOptions } from './lib/target-args.mjs';
-import { IMPECCABLE_COMMAND, IMPECCABLE_PROVIDER_ID } from './lib/provider.mjs';
-import { parseDesignMd } from './lib/design-parser.mjs';
-import {
-  PRODUCT_SCHEMA_VERSION,
-  readProductSchemaVersion,
-  stampProductSchema,
-} from './lib/artifact-schema.mjs';
-import {
-  collectBootFindingGroups,
-  checkNativePlatformEvidence,
-  designSidecarCandidatesFor,
-} from './lib/staleness.mjs';
-import {
-  checkDesignCoverage,
-  checkDesignDrift,
-  checkDetectorIgnores,
-  checkHookInstallation,
-  checkLegacyLiveState,
-  checkWorkspaces,
-  loadKnownRuleIds,
-} from './lib/staleness-deep.mjs';
-
-const SCRIPTS_DIR = path.dirname(fileURLToPath(import.meta.url));
-
-function safeRead(filePath) {
-  try {
-    return fs.readFileSync(filePath, 'utf-8');
-  } catch {
-    return null;
-  }
-}
-
-function parseArgs(argv) {
-  const passthrough = [];
-  const flags = { json: false, fix: false, help: false };
-  for (const arg of argv) {
-    if (arg === '--json') flags.json = true;
-    else if (arg === '--fix') flags.fix = true;
-    else if (arg === '--help' || arg === '-h') flags.help = true;
-    else passthrough.push(arg);
-  }
-  return { flags, targetOptions: parseTargetOptions(passthrough, { strict: true }) };
-}
-
-function usage() {
-  return [
-    `Usage: node doctor.mjs [--json] [--fix] [--target <path>]`,
-    '',
-    "Report drift between this project's Impeccable artifacts and what the",
-    'installed version reads: PRODUCT.md, DESIGN.md and its sidecar,',
-    '.impeccable/config.json, surface briefs, and the design hook.',
-    '',
-    '  --json           Emit findings as JSON.',
-    '  --fix            Apply the mechanical migrations (severity "auto") only.',
-    '  --target <path>  Select a workspace in a monorepo.',
-  ].join('\n');
-}
-
-async function collect(cwd, targetOptions) {
-  const ctx = loadContext(cwd, targetOptions);
-  const projectRoot = ctx.projectRoot || cwd;
-  const absProductPath = ctx.productPath ? path.resolve(cwd, ctx.productPath) : null;
-  const absDesignPath = ctx.designPath ? path.resolve(cwd, ctx.designPath) : null;
-  const sidecarCandidates = designSidecarCandidatesFor(projectRoot, ctx.contextDir);
-  const knownRuleIds = await loadKnownRuleIds(SCRIPTS_DIR);
-
-  const selection = resolveTargetSelection(cwd, targetOptions);
-  const workspaceCandidates = selection?.targetCandidates || [];
-
-  const workspaceResult = checkWorkspaces({
-    repoRoot: ctx.repoRoot,
-    candidates: workspaceCandidates,
-    checkNativePlatformEvidence,
-    extractPlatform,
-    readFile: safeRead,
-  });
-  const bootFindings = collectBootFindingGroups(ctx, {
-    absDesignPath,
-    sidecarCandidates,
-    projectRootPatterns: readProjectRootPatterns(ctx.repoRoot),
-    targetCandidates: workspaceCandidates,
-  });
-
-  const findings = [
-    ...bootFindings.product,
-    ...bootFindings.nativePlatform,
-    ...bootFindings.designSidecar,
-    ...checkDesignDrift({ designPath: absDesignPath, projectRoot }),
-    ...checkDesignCoverage({ design: ctx.design, designPath: ctx.designPath, parseDesignMd }),
-    ...bootFindings.config,
-    ...bootFindings.buildPath,
-    ...checkDetectorIgnores({ projectRoot, knownRuleIds }),
-    ...bootFindings.surfaceBriefs,
-    ...checkHookInstallation({
-      projectRoot,
-      repoRoot: ctx.repoRoot,
-      providerId: IMPECCABLE_PROVIDER_ID,
-    }),
-    ...checkLegacyLiveState({ projectRoot }),
-    ...bootFindings.projectRoots,
-    ...workspaceResult.findings,
-  ];
-
-  return {
-    ctx,
-    projectRoot,
-    absProductPath,
-    sidecarCandidates,
-    findings,
-    workspaces: workspaceResult.workspaces,
-    ruleRegistryAvailable: knownRuleIds !== null,
-  };
-}
-
-// Read straight from disk rather than importing context.mjs's private reader.
-// Only the positive/negative pattern strings matter here.
-function readProjectRootPatterns(repoRoot) {
-  if (!repoRoot) return [];
-  const patterns = [];
-  for (const name of ['config.json', 'config.local.json']) {
-    try {
-      const raw = JSON.parse(fs.readFileSync(path.join(repoRoot, '.impeccable', name), 'utf-8'));
-      if (Array.isArray(raw?.projectRoots)) {
-        for (const entry of raw.projectRoots) {
-          if (typeof entry === 'string' && entry.trim()) patterns.push(entry.trim());
-        }
-      }
-    } catch { /* missing or malformed: nothing to check */ }
-  }
-  return patterns;
-}
-
-/**
- * Apply the migrations that carry no decision. Returns what was done and what
- * was deliberately left for the user.
- */
-function applyFixes(report) {
-  const applied = [];
-  const skipped = [];
-
-  for (const entry of report.findings) {
-    if (entry.severity !== 'auto') {
-      skipped.push({ id: entry.id, reason: 'needs a decision from the user' });
-      continue;
-    }
-    if (entry.id === 'design-sidecar-legacy-path') {
-      const canonical = report.sidecarCandidates[0];
-      const present = report.sidecarCandidates.find((candidate) => fs.existsSync(candidate));
-      if (!canonical || !present || path.resolve(canonical) === path.resolve(present)) continue;
-      if (fs.existsSync(canonical)) {
-        skipped.push({ id: entry.id, reason: `${rel(canonical, report.projectRoot)} already exists; not overwriting` });
-        continue;
-      }
-      fs.mkdirSync(path.dirname(canonical), { recursive: true });
-      fs.renameSync(present, canonical);
-      applied.push(`Moved ${rel(present, report.projectRoot)} to ${rel(canonical, report.projectRoot)}.`);
-      continue;
-    }
-    if (entry.id === 'legacy-live-state') {
-      // Reported, never deleted here: a running live session still reads these,
-      // and losing session state to a doctor run is a worse outcome than a
-      // stale file. The report says what to remove and when.
-      skipped.push({ id: entry.id, reason: 'delete by hand once no live session is running' });
-      continue;
-    }
-    skipped.push({ id: entry.id, reason: 'no automatic migration implemented' });
-  }
-
-  // Stamping the product record is additive and safe, and it is what stops a
-  // later version proposing an interview the user has already sat through.
-  const productPath = report.absProductPath;
-  if (productPath && report.ctx.product && readProductSchemaVersion(report.ctx.product) === null
-    && !report.findings.some((entry) => entry.id === 'product-schema-legacy')) {
-    fs.writeFileSync(productPath, stampProductSchema(report.ctx.product), 'utf-8');
-    applied.push(`Stamped ${rel(productPath, report.projectRoot)} as product-schema ${PRODUCT_SCHEMA_VERSION}.`);
-  }
-
-  return { applied, skipped };
-}
-
-function rel(filePath, root) {
-  const value = path.relative(root, filePath);
-  return value && !value.startsWith('..') ? value.split(path.sep).join('/') : filePath;
-}
-
-const SEVERITY_LABEL = {
-  auto: 'automatic',
-  mention: 'worth saying',
-  route: 'needs a command',
-};
-
-function renderText(report, fixes) {
-  const lines = [];
-  const { findings } = report;
-
-  lines.push(`Impeccable doctor: ${rel(report.projectRoot, process.cwd()) || '.'}`);
-  if (report.ctx.isMonorepo) {
-    lines.push(`Monorepo, repo root ${rel(report.ctx.repoRoot, process.cwd()) || '.'}.`);
-  }
-  lines.push('');
-
-  if (!findings.length) {
-    lines.push('No drift found. Every artifact matches what this version reads.');
-  } else {
-    const order = ['route', 'mention', 'auto'];
-    for (const severity of order) {
-      const group = findings.filter((entry) => entry.severity === severity);
-      if (!group.length) continue;
-      lines.push(`${SEVERITY_LABEL[severity]} (${group.length}):`);
-      for (const entry of group) {
-        lines.push(`  ${entry.id}${entry.path ? `  [${entry.path}]` : ''}`);
-        lines.push(`    ${entry.summary}`);
-        lines.push(`    → ${entry.fix}`);
-      }
-      lines.push('');
-    }
-  }
-
-  if (report.workspaces.length) {
-    lines.push('Workspaces:');
-    for (const workspace of report.workspaces) {
-      lines.push(`  ${workspace.path}  product: ${workspace.productStatus}`
-        + `  design: ${workspace.designStatus}`
-        + `${workspace.platform ? `  platform: ${workspace.platform}` : ''}`);
-    }
-    lines.push('');
-  }
-
-  if (!report.ruleRegistryAvailable) {
-    lines.push('Note: the bundled detector could not be resolved, so ignored rule ids were not validated.');
-    lines.push('');
-  }
-
-  if (fixes) {
-    lines.push(fixes.applied.length ? 'Applied:' : 'Applied nothing.');
-    for (const entry of fixes.applied) lines.push(`  ${entry}`);
-    const held = fixes.skipped.filter((entry) => entry.reason !== 'needs a decision from the user');
-    if (held.length) {
-      lines.push('Left alone:');
-      for (const entry of held) lines.push(`  ${entry.id}: ${entry.reason}`);
-    }
-  } else if (findings.some((entry) => entry.severity === 'auto')) {
-    lines.push(`Run \`node doctor.mjs --fix\` to apply the automatic migrations, `
-      + `or \`${IMPECCABLE_COMMAND} doctor\` to work through all of them.`);
-  }
-
-  return lines.join('\n');
-}
-
-async function cli() {
-  let parsed;
-  try {
-    parsed = parseArgs(process.argv.slice(2));
-  } catch (err) {
-    process.stderr.write(`${err.message}\n`);
-    process.exit(1);
-  }
-  if (parsed.flags.help) {
-    process.stdout.write(`${usage()}\n`);
-    return;
-  }
-
-  const report = await collect(process.cwd(), parsed.targetOptions);
-  const fixes = parsed.flags.fix ? applyFixes(report) : null;
-
-  if (parsed.flags.json) {
-    process.stdout.write(`${JSON.stringify({
-      projectRoot: report.projectRoot,
-      repoRoot: report.ctx.repoRoot,
-      isMonorepo: report.ctx.isMonorepo,
-      productPath: report.ctx.productPath,
-      designPath: report.ctx.designPath,
-      platform: report.ctx.platform,
-      ruleRegistryAvailable: report.ruleRegistryAvailable,
-      findings: report.findings,
-      workspaces: report.workspaces,
-      ...(fixes ? { fixes } : {}),
-    }, null, 2)}\n`);
-    return;
-  }
-
-  process.stdout.write(`${renderText(report, fixes)}\n`);
-}
-
-function invokedAsScript() {
-  const arg = process.argv[1];
-  if (!arg) return false;
-  try {
-    return fs.realpathSync(arg) === fs.realpathSync(fileURLToPath(import.meta.url));
-  } catch {
-    return false;
-  }
-}
-
-if (invokedAsScript()) {
-  cli().catch((err) => {
-    process.stderr.write(`impeccable doctor failed: ${err?.message || err}\n`);
-    process.exit(1);
-  });
-}
-
-export { collect, applyFixes, renderText };