unslop-ui 0.1.0

package/dist/chunk-34KLV5KL.js

@@ -0,0 +1,1051 @@
+// src/config/load-config.ts
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import { createJiti } from "jiti";
+
+// src/config/default-config.ts
+var defaultConfig = {
+  include: [
+    "app/**/*.{ts,tsx,js,jsx}",
+    "pages/**/*.{ts,tsx,js,jsx}",
+    "components/**/*.{ts,tsx,js,jsx}",
+    "src/**/*.{ts,tsx,js,jsx}"
+  ],
+  ignore: [
+    "node_modules/**",
+    ".next/**",
+    "dist/**",
+    "build/**",
+    "coverage/**",
+    "*.test.*",
+    "*.spec.*"
+  ],
+  stack: {
+    react: true,
+    tailwind: true,
+    shadcn: true
+  },
+  rules: {
+    "ui-slop/token-bypass": "warn",
+    "ui-slop/arbitrary-tailwind-values": "warn",
+    "ui-slop/raw-hex-colors": "error",
+    "ui-slop/gradient-soup": "warn",
+    "ui-slop/card-lasagna": "warn",
+    "ui-slop/muted-everything": "warn",
+    "ui-slop/random-radius": "warn",
+    "ui-slop/random-shadow": "warn",
+    "ui-slop/shadcn-default-look": "warn",
+    "ui-slop/generic-ai-hero": "warn",
+    "ui-slop/inconsistent-icon-size": "warn"
+  }
+};
+
+// src/config/schema.ts
+import { z } from "zod";
+var severitySchema = z.enum(["off", "warn", "error"]);
+var configSchema = z.object({
+  include: z.array(z.string()).optional(),
+  ignore: z.array(z.string()).optional(),
+  stack: z.object({
+    react: z.boolean().optional(),
+    tailwind: z.boolean().optional(),
+    shadcn: z.boolean().optional()
+  }).optional(),
+  rules: z.record(z.string(), severitySchema).optional()
+}).strict();
+
+// src/config/load-config.ts
+var CONFIG_FILES = [
+  "unslop.config.ts",
+  "unslop.config.mts",
+  "unslop.config.js",
+  "unslop.config.mjs",
+  "unslop.config.cjs",
+  "unslop.config.json"
+];
+async function loadConfig(options) {
+  const configPath = options.configPath ? path.resolve(options.cwd, options.configPath) : findConfigFile(options.cwd);
+  if (!configPath) {
+    return { config: defaultConfig };
+  }
+  if (!existsSync(configPath)) {
+    throw new Error(`Config file not found: ${configPath}`);
+  }
+  const rawConfig = await importConfig(configPath);
+  const parsed = configSchema.parse(rawConfig ?? {});
+  return {
+    config: mergeConfig(parsed),
+    configPath
+  };
+}
+function findConfigFile(cwd) {
+  for (const fileName of CONFIG_FILES) {
+    const candidate = path.join(cwd, fileName);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+async function importConfig(configPath) {
+  if (configPath.endsWith(".json")) {
+    return JSON.parse(readFileSync(configPath, "utf8"));
+  }
+  const jiti = createJiti(import.meta.url);
+  const loaded = await jiti.import(configPath, { default: true });
+  return loaded ?? {};
+}
+function mergeConfig(config) {
+  return {
+    include: config.include ?? defaultConfig.include,
+    ignore: config.ignore ?? defaultConfig.ignore,
+    stack: {
+      ...defaultConfig.stack,
+      ...config.stack
+    },
+    rules: {
+      ...defaultConfig.rules,
+      ...config.rules
+    }
+  };
+}
+
+// src/utils/tailwind.ts
+var PALETTE_COLORS = [
+  "slate",
+  "gray",
+  "zinc",
+  "neutral",
+  "stone",
+  "red",
+  "orange",
+  "amber",
+  "yellow",
+  "lime",
+  "green",
+  "emerald",
+  "teal",
+  "cyan",
+  "sky",
+  "blue",
+  "indigo",
+  "violet",
+  "purple",
+  "fuchsia",
+  "pink",
+  "rose"
+];
+var COLOR_SCALE = "(?:50|100|200|300|400|500|600|700|800|900|950)";
+var PALETTE_PATTERN = new RegExp(
+  `^(?:bg|text|border|from|via|to|ring|fill|stroke)-(?:${PALETTE_COLORS.join("|")})-${COLOR_SCALE}$`
+);
+var MUTED_TEXT_PATTERN = /^(?:text-muted-foreground|text-(?:gray|slate|zinc|neutral)-[45]00)$/;
+function splitClasses(value) {
+  return value.split(/\s+/).map((part) => part.trim()).filter(Boolean);
+}
+function isPaletteColorClass(className) {
+  return PALETTE_PATTERN.test(stripVariantPrefixes(className));
+}
+function isMutedTextClass(className) {
+  return MUTED_TEXT_PATTERN.test(stripVariantPrefixes(className));
+}
+function stripVariantPrefixes(className) {
+  const arbitraryVariantIndex = className.lastIndexOf("]:");
+  if (arbitraryVariantIndex >= 0) {
+    return className.slice(arbitraryVariantIndex + 2);
+  }
+  const parts = className.split(":");
+  return parts[parts.length - 1] ?? className;
+}
+
+// src/rules/helpers.ts
+function createFinding(rule, context, options) {
+  return {
+    ruleId: rule.id,
+    severity: rule.defaultSeverity === "error" ? "error" : "warn",
+    filePath: context.filePath,
+    category: rule.category,
+    ...options
+  };
+}
+function allClasses(context) {
+  return context.classNames.flatMap((usage) => usage.classes);
+}
+function firstUsageLine(context, predicate) {
+  const usage = context.classNames.find((item) => item.classes.some(predicate));
+  return { line: usage?.line, column: usage?.column };
+}
+
+// src/rules/arbitrary-tailwind-values.ts
+var arbitraryTailwindValuesRule = {
+  id: "ui-slop/arbitrary-tailwind-values",
+  name: "Arbitrary Tailwind values",
+  category: "design-system",
+  defaultSeverity: "warn",
+  run(context) {
+    const arbitraryClasses = allClasses(context).filter(
+      (className) => /\[[^\]]+\]/.test(stripVariantPrefixes(className))
+    );
+    if (arbitraryClasses.length < 3) return [];
+    const location = firstUsageLine(context, (className) => /\[[^\]]+\]/.test(className));
+    const stronger = arbitraryClasses.length >= 8;
+    return [
+      createFinding(this, context, {
+        ...location,
+        message: stronger ? `Found ${arbitraryClasses.length} arbitrary Tailwind values. This strongly suggests non-systematic spacing, sizing, or color choices.` : `Found ${arbitraryClasses.length} arbitrary Tailwind values. This often indicates generated or non-systematic UI.`,
+        confidence: stronger ? "high" : "medium",
+        suggestion: "Prefer design tokens, Tailwind theme values, or a small documented exception."
+      })
+    ];
+  }
+};
+
+// src/rules/card-lasagna.ts
+var cardLasagnaRule = {
+  id: "ui-slop/card-lasagna",
+  name: "Card lasagna",
+  category: "layout",
+  defaultSeverity: "warn",
+  run(context) {
+    const cardLike = context.jsx.filter((element) => getCardSignals(element.classes).size >= 2);
+    const deepCardLike = cardLike.filter((element) => element.depth >= 4);
+    if (cardLike.length < 6 && deepCardLike.length < 3) return [];
+    const first = cardLike[0];
+    return [
+      createFinding(this, context, {
+        line: first?.line,
+        column: first?.column,
+        message: `Nested card-heavy layout detected: ${cardLike.length} card-like wrappers use stacked border, radius, shadow, background, or padding treatments.`,
+        confidence: cardLike.length >= 9 || deepCardLike.length >= 3 ? "high" : "medium",
+        suggestion: "Flatten the hierarchy or reduce repeated borders, shadows, and rounded containers."
+      })
+    ];
+  }
+};
+function getCardSignals(classes) {
+  const signals = /* @__PURE__ */ new Set();
+  for (const rawClass of classes) {
+    const className = stripVariantPrefixes(rawClass);
+    if (className === "card" || className === "bg-card" || className === "bg-white") {
+      signals.add("background");
+    }
+    if (className === "border" || className.startsWith("border-")) {
+      signals.add("border");
+    }
+    if (className === "rounded" || className.startsWith("rounded-")) {
+      signals.add("radius");
+    }
+    if (className === "shadow" || className.startsWith("shadow-")) {
+      signals.add("shadow");
+    }
+    if (/^p[trblxy]?-(?:\d+|\[[^\]]+\])$/.test(className)) {
+      signals.add("padding");
+    }
+  }
+  return signals;
+}
+
+// src/rules/generic-ai-hero.ts
+var GENERIC_WORDS = [
+  "ai-powered",
+  "supercharge",
+  "transform",
+  "beautiful",
+  "modern",
+  "seamless",
+  "workflow",
+  "ship faster"
+];
+var genericAiHeroRule = {
+  id: "ui-slop/generic-ai-hero",
+  name: "Generic AI hero",
+  category: "ai-slop",
+  defaultSeverity: "warn",
+  run(context) {
+    const classes = allClasses(context).map(stripVariantPrefixes);
+    const sourceText = context.jsx.map((element) => element.text).join(" ").toLowerCase();
+    const sourceLower = context.source.toLowerCase();
+    let score = 0;
+    if (classes.includes("text-center") && classes.some((className) => /^max-w-[34]xl$/.test(className))) {
+      score += 2;
+    }
+    if (classes.some((className) => /^text-(?:5xl|6xl|7xl)$/.test(className)) || classes.includes("tracking-tight")) {
+      score += 1;
+    }
+    if (classes.includes("bg-clip-text") && classes.includes("text-transparent")) {
+      score += 2;
+    }
+    if (classes.some((className) => /^(?:rounded-full|border|px-[23]|py-1)$/.test(className)) && /badge|pill/i.test(context.source)) {
+      score += 1;
+    }
+    if ((sourceLower.match(/<button|<Button|role=["']button|href=/g) ?? []).length >= 2) {
+      score += 1;
+    }
+    if (GENERIC_WORDS.some((word) => sourceText.includes(word))) {
+      score += 2;
+    }
+    if (score < 5) return [];
+    const firstHero = context.jsx.find((element) => ["section", "main", "header"].includes(element.elementName));
+    return [
+      createFinding(this, context, {
+        line: firstHero?.line,
+        column: firstHero?.column,
+        message: "Hero matches a common AI-generated SaaS pattern. Make the layout and copy more specific to the product.",
+        confidence: score >= 7 ? "high" : "medium",
+        suggestion: "Replace generic badge/headline/gradient/dual-CTA structure with product-specific proof and layout."
+      })
+    ];
+  }
+};
+
+// src/rules/gradient-soup.ts
+var AI_GRADIENT_COLORS = /^(?:from|via|to)-(?:purple|pink|blue|indigo|violet|fuchsia|cyan)-/;
+var gradientSoupRule = {
+  id: "ui-slop/gradient-soup",
+  name: "Gradient soup",
+  category: "ai-slop",
+  defaultSeverity: "warn",
+  run(context) {
+    const classes = allClasses(context).map(stripVariantPrefixes);
+    const gradientUtilities = classes.filter(
+      (className) => className.startsWith("bg-gradient-to-") || /^(?:from|via|to)-/.test(className)
+    );
+    const glowUtilities = classes.filter(
+      (className) => /^(?:blur-[23]xl|blur-\[[^\]]+\]|opacity-[3-9]0)$/.test(className)
+    );
+    const hasAiGradientColors = classes.some((className) => AI_GRADIENT_COLORS.test(className));
+    if (gradientUtilities.length < 3 && !(gradientUtilities.length >= 2 && glowUtilities.length > 0)) {
+      return [];
+    }
+    return [
+      createFinding(this, context, {
+        ...firstUsageLine(
+          context,
+          (className) => stripVariantPrefixes(className).startsWith("bg-gradient-to-")
+        ),
+        message: hasAiGradientColors && glowUtilities.length > 0 ? "Gradient-heavy styling with glow utilities detected. This is a common AI-generated SaaS UI pattern." : "Gradient-heavy styling detected. This is a common AI-generated SaaS UI pattern.",
+        confidence: hasAiGradientColors ? "high" : "medium",
+        suggestion: "Use gradients sparingly and tie color choices back to the product visual system."
+      })
+    ];
+  }
+};
+
+// src/rules/inconsistent-icon-size.ts
+var inconsistentIconSizeRule = {
+  id: "ui-slop/inconsistent-icon-size",
+  name: "Inconsistent icon size",
+  category: "components",
+  defaultSeverity: "warn",
+  run(context) {
+    const classes = allClasses(context).map(stripVariantPrefixes);
+    const directSizes = classes.map((className) => /^size-(\d+)$/.exec(className)?.[1]).filter((value) => Boolean(value));
+    const heightSizes = classes.map((className) => /^h-(\d+)$/.exec(className)?.[1]).filter((value) => Boolean(value));
+    const widthSizes = classes.map((className) => /^w-(\d+)$/.exec(className)?.[1]).filter((value) => Boolean(value));
+    const pairedSizes = heightSizes.filter((size) => widthSizes.includes(size));
+    const uniqueSizes = [.../* @__PURE__ */ new Set([...directSizes, ...pairedSizes])];
+    if (uniqueSizes.length < 3) return [];
+    return [
+      createFinding(this, context, {
+        ...firstUsageLine(context, (className) => /^(?:size|h|w)-\d+$/.test(stripVariantPrefixes(className))),
+        message: `Inconsistent icon sizing detected (${uniqueSizes.map((size) => `${size}`).join(", ")}). Use a smaller set of icon sizes for better rhythm.`,
+        confidence: uniqueSizes.length >= 4 ? "high" : "medium",
+        suggestion: "Standardize icon sizes by role, such as 16px for dense controls and 20px for primary actions."
+      })
+    ];
+  }
+};
+
+// src/rules/muted-everything.ts
+var mutedEverythingRule = {
+  id: "ui-slop/muted-everything",
+  name: "Muted everything",
+  category: "typography",
+  defaultSeverity: "warn",
+  run(context) {
+    const mutedTextClasses = allClasses(context).filter(isMutedTextClass);
+    const textBearingElements = context.jsx.filter((element) => element.text.length > 0);
+    const mutedRatio = textBearingElements.length > 0 ? mutedTextClasses.length / textBearingElements.length : 0;
+    if (mutedTextClasses.length < 4 && !(mutedTextClasses.length >= 3 && mutedRatio >= 0.5)) {
+      return [];
+    }
+    return [
+      createFinding(this, context, {
+        ...firstUsageLine(context, isMutedTextClass),
+        message: `Muted text is overused (${mutedTextClasses.length} muted text utilities). Primary explanatory copy usually needs stronger contrast.`,
+        confidence: mutedRatio >= 0.5 ? "high" : "medium",
+        suggestion: "Reserve muted text for secondary metadata, helper copy, and de-emphasized labels."
+      })
+    ];
+  }
+};
+
+// src/rules/random-radius.ts
+var randomRadiusRule = {
+  id: "ui-slop/random-radius",
+  name: "Random radius",
+  category: "design-system",
+  defaultSeverity: "warn",
+  run(context) {
+    const radiusClasses = [
+      ...new Set(
+        allClasses(context).map(stripVariantPrefixes).filter(
+          (className) => /^rounded(?:$|-(?:none|sm|md|lg|xl|2xl|3xl|full|\[[^\]]+\]|[trbl][trbl]?-.+))/.test(
+            className
+          )
+        )
+      )
+    ];
+    if (radiusClasses.length <= 4) return [];
+    return [
+      createFinding(this, context, {
+        ...firstUsageLine(context, (className) => stripVariantPrefixes(className).startsWith("rounded")),
+        message: `Too many border-radius variants found (${radiusClasses.length}). This creates inconsistent UI rhythm.`,
+        confidence: radiusClasses.length >= 7 ? "high" : "medium",
+        suggestion: "Standardize around a small radius scale for repeated surfaces and controls."
+      })
+    ];
+  }
+};
+
+// src/rules/random-shadow.ts
+var randomShadowRule = {
+  id: "ui-slop/random-shadow",
+  name: "Random shadow",
+  category: "design-system",
+  defaultSeverity: "warn",
+  run(context) {
+    const shadowClasses = allClasses(context).map(stripVariantPrefixes).filter((className) => /^shadow(?:$|-(?:sm|md|lg|xl|2xl|inner|none|\[[^\]]+\]))$/.test(className));
+    const uniqueShadowClasses = [...new Set(shadowClasses)];
+    const heavyShadowCount = shadowClasses.filter((className) => ["shadow-xl", "shadow-2xl"].includes(className)).length;
+    if (uniqueShadowClasses.length <= 3 && heavyShadowCount < 2) return [];
+    return [
+      createFinding(this, context, {
+        ...firstUsageLine(context, (className) => stripVariantPrefixes(className).startsWith("shadow")),
+        message: "Inconsistent or heavy shadow usage detected.",
+        confidence: uniqueShadowClasses.length >= 5 || heavyShadowCount >= 3 ? "high" : "medium",
+        suggestion: "Use a smaller shadow scale and avoid heavy shadows on repeated surfaces."
+      })
+    ];
+  }
+};
+
+// src/utils/source-location.ts
+function getLineAndColumn(source, index) {
+  let line = 1;
+  let column = 1;
+  for (let i = 0; i < index; i += 1) {
+    if (source.charCodeAt(i) === 10) {
+      line += 1;
+      column = 1;
+    } else {
+      column += 1;
+    }
+  }
+  return { line, column };
+}
+function firstRegexLocation(source, pattern) {
+  const flags = pattern.flags.replaceAll("g", "").replaceAll("y", "");
+  const regex = new RegExp(pattern.source, flags);
+  const match = regex.exec(source);
+  if (!match || match.index === void 0) return void 0;
+  return getLineAndColumn(source, match.index);
+}
+
+// src/rules/raw-hex-colors.ts
+var HEX_COLOR_PATTERN = /#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})\b/g;
+var rawHexColorsRule = {
+  id: "ui-slop/raw-hex-colors",
+  name: "Raw hex colors",
+  category: "design-system",
+  defaultSeverity: "error",
+  run(context) {
+    HEX_COLOR_PATTERN.lastIndex = 0;
+    const matches = [...context.source.matchAll(HEX_COLOR_PATTERN)];
+    if (matches.length === 0) return [];
+    return [
+      createFinding(this, context, {
+        ...firstRegexLocation(context.source, HEX_COLOR_PATTERN),
+        message: matches.length === 1 ? "Raw hex color found. Prefer semantic tokens or Tailwind theme colors." : `Found ${matches.length} raw hex colors. Prefer semantic tokens or Tailwind theme colors.`,
+        confidence: "high",
+        suggestion: "Move color choices into semantic tokens such as bg-card, text-foreground, or primary."
+      })
+    ];
+  }
+};
+
+// src/rules/shadcn-default-look.ts
+var shadcnDefaultLookRule = {
+  id: "ui-slop/shadcn-default-look",
+  name: "shadcn default look",
+  category: "components",
+  defaultSeverity: "warn",
+  run(context) {
+    const defaultishElements = context.jsx.filter((element) => {
+      const classes = new Set(element.classes.map(stripVariantPrefixes));
+      let score = 0;
+      if (classes.has("rounded-lg")) score += 1;
+      if (classes.has("border")) score += 1;
+      if (classes.has("bg-card")) score += 1;
+      if (classes.has("text-card-foreground")) score += 1;
+      if (classes.has("shadow-sm")) score += 1;
+      if (classes.has("text-muted-foreground")) score += 1;
+      if (classes.has("space-y-1.5")) score += 1;
+      return score >= 3;
+    });
+    const mutedDefaults = context.classNames.filter(
+      (usage) => usage.classes.map(stripVariantPrefixes).includes("text-muted-foreground")
+    );
+    if (defaultishElements.length < 2 || mutedDefaults.length < 2) return [];
+    const first = defaultishElements[0];
+    return [
+      createFinding(this, context, {
+        line: first?.line,
+        column: first?.column,
+        message: "UI appears close to default shadcn styling. Consider applying product-specific visual language.",
+        confidence: defaultishElements.length >= 4 ? "high" : "medium",
+        suggestion: "Keep the component behavior, but tune spacing, type, density, and surface treatments."
+      })
+    ];
+  }
+};
+
+// src/rules/token-bypass.ts
+var tokenBypassRule = {
+  id: "ui-slop/token-bypass",
+  name: "Token bypass",
+  category: "design-system",
+  defaultSeverity: "warn",
+  run(context) {
+    const directPaletteColors = allClasses(context).filter(isPaletteColorClass);
+    const uniquePaletteColors = [...new Set(directPaletteColors)];
+    if (uniquePaletteColors.length < 5) return [];
+    return [
+      createFinding(this, context, {
+        ...firstUsageLine(context, isPaletteColorClass),
+        message: `Tailwind palette colors are used directly ${uniquePaletteColors.length} times. Prefer semantic design tokens like bg-card, text-muted-foreground, border-border, primary, or secondary.`,
+        confidence: uniquePaletteColors.length >= 9 ? "high" : "medium",
+        suggestion: "Map repeated palette choices to semantic tokens in your theme."
+      })
+    ];
+  }
+};
+
+// src/rules/index.ts
+var allRules = [
+  rawHexColorsRule,
+  arbitraryTailwindValuesRule,
+  tokenBypassRule,
+  gradientSoupRule,
+  cardLasagnaRule,
+  mutedEverythingRule,
+  randomRadiusRule,
+  randomShadowRule,
+  shadcnDefaultLookRule,
+  genericAiHeroRule,
+  inconsistentIconSizeRule
+];
+
+// src/scanner/scan-project.ts
+import { readFile } from "fs/promises";
+import path3 from "path";
+
+// src/core/score.ts
+function calculateScore(findings) {
+  const errorCount = findings.filter((finding) => finding.severity === "error").length;
+  const warnCount = findings.filter((finding) => finding.severity === "warn").length;
+  const lowConfidenceCount = findings.filter((finding) => finding.confidence === "low").length;
+  return Math.max(0, 100 - errorCount * 8 - warnCount * 3 - lowConfidenceCount);
+}
+function getScoreLabel(score) {
+  if (score >= 90) return "Clean";
+  if (score >= 75) return "Minor slop";
+  if (score >= 60) return "Noticeable slop";
+  if (score >= 40) return "Heavy slop";
+  return "Slop emergency";
+}
+
+// src/core/rule-engine.ts
+function runRules(context, rules) {
+  const findings = [];
+  for (const rule of rules) {
+    const configuredSeverity = context.project.config.rules[rule.id] ?? rule.defaultSeverity;
+    if (configuredSeverity === "off") {
+      continue;
+    }
+    for (const finding of rule.run(context)) {
+      findings.push({
+        ...finding,
+        severity: configuredSeverity
+      });
+    }
+  }
+  return findings.sort((a, b) => {
+    const severityDelta = severityRank(b.severity) - severityRank(a.severity);
+    if (severityDelta !== 0) return severityDelta;
+    return `${a.filePath}:${a.line ?? 0}:${a.ruleId}`.localeCompare(
+      `${b.filePath}:${b.line ?? 0}:${b.ruleId}`
+    );
+  });
+}
+function severityRank(severity) {
+  return severity === "error" ? 2 : 1;
+}
+
+// src/core/types.ts
+var TOOL_NAME = "unslop-ui";
+var TOOL_VERSION = "0.1.0";
+
+// src/utils/paths.ts
+import path2 from "path";
+function toPosixPath(filePath) {
+  return filePath.split(path2.sep).join("/");
+}
+function relativePosixPath(root, filePath) {
+  return toPosixPath(path2.relative(root, filePath));
+}
+
+// src/scanner/extract-classnames.ts
+var CLASS_HELPERS = /* @__PURE__ */ new Set(["cn", "clsx", "classnames", "cva"]);
+function extractClassNameUsages(ast, filePath) {
+  const usages = [];
+  walk(ast, (node) => {
+    if (!isRecord(node) || node.type !== "JSXOpeningElement") return;
+    const elementName = getJsxName(node.name);
+    const attributes = Array.isArray(node.attributes) ? node.attributes : [];
+    for (const attribute of attributes) {
+      if (!isRecord(attribute) || attribute.type !== "JSXAttribute") continue;
+      if (!isRecord(attribute.name) || attribute.name.name !== "className") continue;
+      const values = extractClassNameValues(attribute.value);
+      for (const value of values) {
+        const classes = splitClasses(value);
+        if (classes.length === 0) continue;
+        usages.push({
+          value,
+          classes,
+          filePath,
+          line: getLine(attribute),
+          column: getColumn(attribute),
+          elementName
+        });
+      }
+    }
+  });
+  return usages;
+}
+function extractClassNameValues(node) {
+  if (!isRecord(node)) return [];
+  switch (node.type) {
+    case "StringLiteral":
+      return typeof node.value === "string" ? [node.value] : [];
+    case "JSXExpressionContainer":
+      return extractClassNameValues(node.expression);
+    case "TemplateLiteral":
+      return [
+        ...getTemplateQuasis(node),
+        ...getArray(node.expressions).flatMap((expression) => extractClassNameValues(expression))
+      ];
+    case "CallExpression": {
+      const calleeName = getCalleeName(node.callee);
+      if (!calleeName || !CLASS_HELPERS.has(calleeName)) return [];
+      return getArray(node.arguments).flatMap((argument) => extractClassNameValues(argument));
+    }
+    case "ConditionalExpression":
+      return [
+        ...extractClassNameValues(node.consequent),
+        ...extractClassNameValues(node.alternate)
+      ];
+    case "LogicalExpression":
+      return extractClassNameValues(node.left).concat(extractClassNameValues(node.right));
+    case "ArrayExpression":
+      return getArray(node.elements).flatMap((element) => extractClassNameValues(element));
+    case "ObjectExpression":
+      return getArray(node.properties).flatMap((property) => {
+        if (!isRecord(property) || property.type !== "ObjectProperty") return [];
+        return extractObjectKey(property.key);
+      });
+    case "BinaryExpression":
+      if (node.operator !== "+") return [];
+      return extractClassNameValues(node.left).concat(extractClassNameValues(node.right));
+    default:
+      return [];
+  }
+}
+function walk(node, visitor) {
+  if (!isRecord(node)) return;
+  visitor(node);
+  for (const [key, value] of Object.entries(node)) {
+    if (shouldSkipKey(key)) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (isAstNode(item)) walk(item, visitor);
+      }
+    } else if (isAstNode(value)) {
+      walk(value, visitor);
+    }
+  }
+}
+function extractObjectKey(node) {
+  if (!isRecord(node)) return [];
+  if (node.type === "StringLiteral" && typeof node.value === "string") return [node.value];
+  if (node.type === "Identifier" && typeof node.name === "string") return [node.name];
+  return [];
+}
+function getTemplateQuasis(node) {
+  return getArray(node.quasis).map((quasi) => {
+    if (!isRecord(quasi) || !isRecord(quasi.value)) return "";
+    return typeof quasi.value.cooked === "string" ? quasi.value.cooked : "";
+  }).filter(Boolean);
+}
+function getCalleeName(node) {
+  if (!isRecord(node)) return void 0;
+  if (node.type === "Identifier" && typeof node.name === "string") return node.name;
+  if (node.type === "MemberExpression" && isRecord(node.property)) {
+    return typeof node.property.name === "string" ? node.property.name : void 0;
+  }
+  return void 0;
+}
+function getJsxName(node) {
+  if (!isRecord(node)) return void 0;
+  if (node.type === "JSXIdentifier" && typeof node.name === "string") return node.name;
+  if (node.type === "JSXMemberExpression") {
+    const objectName = getJsxName(node.object);
+    const propertyName = getJsxName(node.property);
+    return [objectName, propertyName].filter(Boolean).join(".");
+  }
+  return void 0;
+}
+function getLine(node) {
+  return isRecord(node.loc) && isRecord(node.loc.start) && typeof node.loc.start.line === "number" ? node.loc.start.line : void 0;
+}
+function getColumn(node) {
+  return isRecord(node.loc) && isRecord(node.loc.start) && typeof node.loc.start.column === "number" ? node.loc.start.column + 1 : void 0;
+}
+function shouldSkipKey(key) {
+  return [
+    "loc",
+    "start",
+    "end",
+    "extra",
+    "leadingComments",
+    "trailingComments",
+    "innerComments"
+  ].includes(key);
+}
+function isAstNode(value) {
+  return isRecord(value) && typeof value.type === "string";
+}
+function getArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/scanner/extract-jsx.ts
+function extractJsxUsages(ast, filePath) {
+  const usages = [];
+  walkJsx(ast, filePath, usages, 0);
+  return usages;
+}
+function walkJsx(node, filePath, usages, depth) {
+  if (!isRecord2(node)) return;
+  if (node.type === "JSXElement") {
+    const opening = isRecord2(node.openingElement) ? node.openingElement : void 0;
+    const className = opening ? getClassName(opening) : void 0;
+    const classes = className ? splitClasses(className) : [];
+    usages.push({
+      elementName: opening ? getJsxName2(opening.name) ?? "unknown" : "unknown",
+      classes,
+      className,
+      filePath,
+      line: opening ? getLine2(opening) : void 0,
+      column: opening ? getColumn2(opening) : void 0,
+      depth,
+      text: collectText(node)
+    });
+    for (const child of getArray2(node.children)) {
+      walkJsx(child, filePath, usages, depth + 1);
+    }
+    return;
+  }
+  for (const [key, value] of Object.entries(node)) {
+    if (shouldSkipKey2(key)) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (isAstNode2(item)) walkJsx(item, filePath, usages, depth);
+      }
+    } else if (isAstNode2(value)) {
+      walkJsx(value, filePath, usages, depth);
+    }
+  }
+}
+function getClassName(openingElement) {
+  const attributes = getArray2(openingElement.attributes);
+  for (const attribute of attributes) {
+    if (!isRecord2(attribute) || attribute.type !== "JSXAttribute") continue;
+    if (!isRecord2(attribute.name) || attribute.name.name !== "className") continue;
+    return extractClassNameValues(attribute.value).join(" ").trim() || void 0;
+  }
+  return void 0;
+}
+function collectText(node) {
+  if (!isRecord2(node)) return "";
+  if (node.type === "JSXElement") {
+    return getArray2(node.children).map((child) => collectText(child)).join(" ").replace(/\s+/g, " ").trim();
+  }
+  if (node.type === "JSXExpressionContainer") {
+    return collectText(node.expression);
+  }
+  if (node.type === "JSXText" && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node.type === "StringLiteral" && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node.type === "TemplateLiteral") {
+    return getArray2(node.quasis).map((quasi) => {
+      if (!isRecord2(quasi) || !isRecord2(quasi.value)) return "";
+      return typeof quasi.value.cooked === "string" ? quasi.value.cooked : "";
+    }).join(" ");
+  }
+  let text = "";
+  for (const [key, value] of Object.entries(node)) {
+    if (shouldSkipKey2(key)) continue;
+    if (Array.isArray(value)) {
+      text += ` ${value.map((item) => collectText(item)).join(" ")}`;
+    } else if (isAstNode2(value)) {
+      text += ` ${collectText(value)}`;
+    }
+  }
+  return text.replace(/\s+/g, " ").trim();
+}
+function getJsxName2(node) {
+  if (!isRecord2(node)) return void 0;
+  if (node.type === "JSXIdentifier" && typeof node.name === "string") return node.name;
+  if (node.type === "JSXMemberExpression") {
+    const objectName = getJsxName2(node.object);
+    const propertyName = getJsxName2(node.property);
+    return [objectName, propertyName].filter(Boolean).join(".");
+  }
+  return void 0;
+}
+function getLine2(node) {
+  return isRecord2(node.loc) && isRecord2(node.loc.start) && typeof node.loc.start.line === "number" ? node.loc.start.line : void 0;
+}
+function getColumn2(node) {
+  return isRecord2(node.loc) && isRecord2(node.loc.start) && typeof node.loc.start.column === "number" ? node.loc.start.column + 1 : void 0;
+}
+function shouldSkipKey2(key) {
+  return [
+    "loc",
+    "start",
+    "end",
+    "extra",
+    "leadingComments",
+    "trailingComments",
+    "innerComments"
+  ].includes(key);
+}
+function isAstNode2(value) {
+  return isRecord2(value) && typeof value.type === "string";
+}
+function getArray2(value) {
+  return Array.isArray(value) ? value : [];
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/scanner/file-discovery.ts
+import fg from "fast-glob";
+async function discoverFiles(root, config) {
+  const files = await fg(config.include, {
+    cwd: root,
+    absolute: true,
+    onlyFiles: true,
+    ignore: config.ignore,
+    dot: false
+  });
+  return files.sort((a, b) => toPosixPath(a).localeCompare(toPosixPath(b)));
+}
+
+// src/scanner/parse-file.ts
+import { parse } from "@babel/parser";
+function parseFile(source, filePath) {
+  try {
+    return {
+      ast: parse(source, {
+        sourceFilename: filePath,
+        sourceType: "unambiguous",
+        errorRecovery: true,
+        plugins: ["jsx", "typescript", "decorators-legacy"]
+      })
+    };
+  } catch (error) {
+    return {
+      ast: null,
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+
+// src/scanner/scan-project.ts
+async function scanProject(targetPath = ".", options = {}) {
+  const cwd = options.cwd ? path3.resolve(options.cwd) : process.cwd();
+  const root = path3.resolve(cwd, targetPath);
+  const loaded = await loadConfig({
+    cwd: root,
+    configPath: options.configPath ? path3.isAbsolute(options.configPath) ? options.configPath : path3.resolve(cwd, options.configPath) : void 0
+  });
+  const files = await discoverFiles(root, loaded.config);
+  const project = {
+    root,
+    config: loaded.config,
+    files: files.map((file) => relativePosixPath(root, file))
+  };
+  const findings = [];
+  for (const absolutePath of files) {
+    const source = await readFile(absolutePath, "utf8");
+    const filePath = relativePosixPath(root, absolutePath);
+    const parsed = parseFile(source, filePath);
+    const classNames = parsed.ast ? extractClassNameUsages(parsed.ast, filePath) : [];
+    const jsx = parsed.ast ? extractJsxUsages(parsed.ast, filePath) : [];
+    findings.push(
+      ...runRules(
+        {
+          filePath,
+          absolutePath,
+          source,
+          classNames,
+          jsx,
+          project
+        },
+        allRules
+      )
+    );
+  }
+  const score = calculateScore(findings);
+  return {
+    tool: TOOL_NAME,
+    version: TOOL_VERSION,
+    root,
+    score,
+    label: getScoreLabel(score),
+    filesScanned: files.length,
+    findingCount: findings.length,
+    findings
+  };
+}
+
+// src/reporters/json.ts
+function formatJsonReport(result) {
+  return `${JSON.stringify(
+    {
+      tool: result.tool,
+      version: result.version,
+      score: result.score,
+      label: result.label,
+      filesScanned: result.filesScanned,
+      findingCount: result.findingCount,
+      findings: result.findings.map((finding) => ({
+        ruleId: finding.ruleId,
+        severity: finding.severity,
+        category: finding.category,
+        confidence: finding.confidence,
+        filePath: finding.filePath,
+        line: finding.line,
+        column: finding.column,
+        message: finding.message,
+        suggestion: finding.suggestion
+      }))
+    },
+    null,
+    2
+  )}
+`;
+}
+
+// src/reporters/terminal.ts
+import pc from "picocolors";
+var CATEGORY_LABELS = {
+  "design-system": "Design system",
+  "ai-slop": "AI slop",
+  layout: "Layout",
+  typography: "Typography",
+  components: "Components"
+};
+function formatTerminalReport(result, options = {}) {
+  if (options.quiet) {
+    return `Unslop UI: ${result.score}/100 - ${result.label}; ${result.findingCount} findings in ${result.filesScanned} files
+`;
+  }
+  const maxFindings = options.maxFindings ?? 20;
+  const lines = [
+    pc.bold("Unslop UI"),
+    "",
+    `Score: ${colorScore(result.score, `${result.score}/100`)} - ${result.label}`,
+    `Files scanned: ${result.filesScanned}`,
+    `Findings: ${result.findingCount}`
+  ];
+  if (result.findings.length === 0) {
+    lines.push("", pc.green("No findings. The UI surface looks controlled."));
+    return `${lines.join("\n")}
+`;
+  }
+  const errors = result.findings.filter((finding) => finding.severity === "error");
+  const warnings = result.findings.filter((finding) => finding.severity === "warn");
+  appendFindingGroup(lines, "High impact", errors, maxFindings);
+  appendFindingGroup(lines, "Warnings", warnings, Math.max(0, maxFindings - errors.length));
+  const hiddenCount = Math.max(0, result.findings.length - maxFindings);
+  if (hiddenCount > 0) {
+    lines.push("", pc.dim(`Showing ${maxFindings} of ${result.findings.length} findings. Re-run with --verbose to show all.`));
+  }
+  lines.push("", pc.bold("Summary by category"));
+  for (const [category, count] of getCategoryCounts(result.findings)) {
+    lines.push(`  ${CATEGORY_LABELS[category]}: ${count}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function appendFindingGroup(lines, title, findings, maxCount) {
+  if (findings.length === 0 || maxCount <= 0) return;
+  lines.push("", pc.bold(title));
+  for (const finding of findings.slice(0, maxCount)) {
+    lines.push(`  ${formatSeverity(finding.severity)} ${finding.ruleId}`);
+    lines.push(`  ${finding.filePath}${finding.line ? `:${finding.line}` : ""}`);
+    lines.push(`  ${finding.message}`);
+    if (finding.suggestion) {
+      lines.push(`  ${pc.dim(finding.suggestion)}`);
+    }
+    lines.push("");
+  }
+  if (lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+}
+function formatSeverity(severity) {
+  return severity === "error" ? pc.red("error") : pc.yellow("warn");
+}
+function colorScore(score, value) {
+  if (score >= 90) return pc.green(value);
+  if (score >= 75) return pc.cyan(value);
+  if (score >= 60) return pc.yellow(value);
+  return pc.red(value);
+}
+function getCategoryCounts(findings) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const finding of findings) {
+    counts.set(finding.category, (counts.get(finding.category) ?? 0) + 1);
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1]);
+}
+
+export {
+  loadConfig,
+  allRules,
+  scanProject,
+  formatJsonReport,
+  formatTerminalReport
+};
+//# sourceMappingURL=chunk-34KLV5KL.js.map