monomind 2.7.3 → 2.7.5

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/detector/shared/color.mjs

@@ -1,124 +0,0 @@
-// ─── Section 2: Color Utilities ─────────────────────────────────────────────
-
-function isNeutralColor(color) {
-  if (!color || color === 'transparent') return true;
-
-  // rgb/rgba — use channel spread. Threshold 30 ≈ 11.7% of the 0–255 range.
-  const rgb = color.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
-  if (rgb) {
-    return (Math.max(+rgb[1], +rgb[2], +rgb[3]) - Math.min(+rgb[1], +rgb[2], +rgb[3])) < 30;
-  }
-
-  // oklch()/lch() — chroma is the second numeric component.
-  // oklch chroma is ~0–0.4 in sRGB gamut; >= 0.02 reads as tinted, not gray.
-  // lch chroma is ~0–150; >= 3 reads as tinted. jsdom emits both formats
-  // literally (it does NOT convert them to rgb).
-  const oklch = color.match(/oklch\(\s*[\d.]+%?\s*([\d.-]+)/i);
-  if (oklch) return parseFloat(oklch[1]) < 0.02;
-  const lch = color.match(/lch\(\s*[\d.]+%?\s*([\d.-]+)/i);
-  if (lch) return parseFloat(lch[1]) < 3;
-
-  // oklab()/lab() — a and b are signed axes; chroma = sqrt(a² + b²).
-  // oklab a/b are ~-0.4..0.4, threshold 0.02. lab a/b are ~-128..127, threshold 3.
-  const oklab = color.match(/oklab\(\s*[\d.]+%?\s*([\d.-]+)\s+([\d.-]+)/i);
-  if (oklab) {
-    const a = parseFloat(oklab[1]), b = parseFloat(oklab[2]);
-    return Math.hypot(a, b) < 0.02;
-  }
-  const lab = color.match(/lab\(\s*[\d.]+%?\s*([\d.-]+)\s+([\d.-]+)/i);
-  if (lab) {
-    const a = parseFloat(lab[1]), b = parseFloat(lab[2]);
-    return Math.hypot(a, b) < 3;
-  }
-
-  // hsl/hsla — saturation is the second numeric component (percent).
-  // Modern jsdom usually converts hsl() to rgb, but handle it directly for
-  // safety across versions and for any engine that preserves the format.
-  const hsl = color.match(/hsla?\(\s*[\d.-]+\s*,?\s*([\d.]+)%/i);
-  if (hsl) return parseFloat(hsl[1]) < 10;
-
-  // hwb(hue whiteness% blackness%) — a pixel is fully gray when
-  // whiteness + blackness >= 100; chroma-like saturation = 1 - (w+b)/100.
-  const hwb = color.match(/hwb\(\s*[\d.-]+\s+([\d.]+)%\s+([\d.]+)%/i);
-  if (hwb) {
-    const w = parseFloat(hwb[1]), b = parseFloat(hwb[2]);
-    return (1 - Math.min(100, w + b) / 100) < 0.1;
-  }
-
-  // Unknown / unrecognized format — err on the side of DETECTING rather
-  // than silently skipping. This is the opposite of the previous default,
-  // which was the root cause of the oklch bug.
-  return false;
-}
-
-function parseRgb(color) {
-  if (!color || color === 'transparent') return null;
-  const m = color.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)/);
-  if (!m) return null;
-  return { r: +m[1], g: +m[2], b: +m[3], a: m[4] !== undefined ? +m[4] : 1 };
-}
-
-function relativeLuminance({ r, g, b }) {
-  const [rs, gs, bs] = [r / 255, g / 255, b / 255].map(c =>
-    c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4
-  );
-  return 0.2126 * rs + 0.7152 * gs + 0.0722 * bs;
-}
-
-function contrastRatio(c1, c2) {
-  const l1 = relativeLuminance(c1);
-  const l2 = relativeLuminance(c2);
-  return (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05);
-}
-
-function parseGradientColors(bgImage) {
-  if (!bgImage || !bgImage.includes('gradient')) return [];
-  const colors = [];
-  for (const m of bgImage.matchAll(/rgba?\([^)]+\)/g)) {
-    const c = parseRgb(m[0]);
-    if (c) colors.push(c);
-  }
-  for (const m of bgImage.matchAll(/#([0-9a-f]{6}|[0-9a-f]{3})\b/gi)) {
-    const h = m[1];
-    if (h.length === 6) {
-      colors.push({ r: parseInt(h.slice(0,2),16), g: parseInt(h.slice(2,4),16), b: parseInt(h.slice(4,6),16), a: 1 });
-    } else {
-      colors.push({ r: parseInt(h[0]+h[0],16), g: parseInt(h[1]+h[1],16), b: parseInt(h[2]+h[2],16), a: 1 });
-    }
-  }
-  return colors;
-}
-
-function hasChroma(c, threshold = 30) {
-  if (!c) return false;
-  return (Math.max(c.r, c.g, c.b) - Math.min(c.r, c.g, c.b)) >= threshold;
-}
-
-function getHue(c) {
-  if (!c) return 0;
-  const r = c.r / 255, g = c.g / 255, b = c.b / 255;
-  const max = Math.max(r, g, b), min = Math.min(r, g, b);
-  if (max === min) return 0;
-  const d = max - min;
-  let h;
-  if (max === r) h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
-  else if (max === g) h = ((b - r) / d + 2) / 6;
-  else h = ((r - g) / d + 4) / 6;
-  return Math.round(h * 360);
-}
-
-function colorToHex(c) {
-  if (!c) return '?';
-  return '#' + [c.r, c.g, c.b].map(v => v.toString(16).padStart(2, '0')).join('');
-}
-
-export {
-  isNeutralColor,
-  parseRgb,
-  relativeLuminance,
-  contrastRatio,
-  parseGradientColors,
-  hasChroma,
-  getHue,
-  colorToHex,
-};

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/detector/shared/constants.mjs

@@ -1,101 +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));
-}
-
-const GENERIC_FONTS = new Set([
-  'serif', 'sans-serif', 'monospace', 'cursive', 'fantasy',
-  'system-ui', 'ui-serif', 'ui-sans-serif', 'ui-monospace', 'ui-rounded',
-  '-apple-system', 'blinkmacsystemfont', 'segoe ui',
-  'inherit', 'initial', 'unset', 'revert',
-]);
-
-// 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);
-
-// 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,
-  WCAG_LARGE_TEXT_PX,
-  WCAG_LARGE_BOLD_TEXT_PX,
-  KNOWN_SERIF_FONTS,
-};

package/packages/@monomind/cli/.claude/skills/monodesign/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/packages/@monomind/cli/.claude/skills/monodesign/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 `.monodesign/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 monodesign scans —
- * `//`, `/* *\/`, `<!-- -->`, `#`, `{/* *\/}`, `{# #}`. Trailing comment closers
- * are stripped before the rule list is parsed.
- *
- * Syntax (reason optional; eslint `--` or biome `:` separator):
- *
- *   monodesign-disable <rule>[, <rule>...] [-- reason]   whole file
- *   monodesign-disable-line <rule>...      [-- reason]   the same line
- *   monodesign-disable-next-line <rule>... [-- reason]   the following line
- *   monodesign-disable                                   bare / `*` = every rule
- *
- * Examples:
- *
- *   <!-- monodesign-disable overused-font -- exported brand doc, font is first-party -->
- *   .brand { font-family: Inter; } /* monodesign-disable-line overused-font *\/
- *   // monodesign-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 = /monodesign-(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. `Monodesign-Disable`).
-  if (!/monodesign-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/packages/@monomind/cli/.claude/skills/monodesign/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 };