uilint-core 0.1.1 → 0.1.4

package/dist/{chunk-P5RPW6PI.js → chunk-P2QQGDQS.js}

@@ -23,6 +23,7 @@ Focus on:
 2. Inconsistent font sizes or weights
 3. Spacing values that don't follow a consistent scale (e.g., 4px base unit)
 4. Mixed border-radius values
+5. If utility/Tailwind classes are present in the summary, treat them as the styling surface area and flag inconsistent utility usage (e.g., mixing px-4 and px-5 for the same component type)
 
 Be concise and actionable. Only report significant inconsistencies.
 
@@ -50,6 +51,7 @@ Generate a style guide with these sections:
 2. Typography - Font families, sizes, and weights
 3. Spacing - Base unit and common spacing values
 4. Components - Common component patterns
+5. Tailwind (if utility classes are present) - list commonly used utilities and any relevant theme tokens
 
 Use this format:
 # UI Style Guide
@@ -91,45 +93,6 @@ ${query}
 
 Provide a clear, concise answer based on the style guide above. If the style guide doesn't contain the information needed, say so and suggest what might be missing.`;
 }
-function buildValidationPrompt(code, styleGuide) {
-  const guideSection = styleGuide ? `## Style Guide
-${styleGuide}
-
-` : "## No Style Guide\nValidate for general best practices.\n\n";
-  return `You are a UI code validator. Check the following code against the style guide and best practices.
-
-${guideSection}
-
-## Code to Validate
-\`\`\`tsx
-${code}
-\`\`\`
-
-Respond with a JSON object containing:
-- valid: boolean (true if no errors found)
-- issues: array of issues, each with:
-  - type: "error" or "warning"
-  - message: description of the issue
-  - suggestion: how to fix it
-
-Focus on:
-1. Colors not in the style guide
-2. Spacing values not following the design system
-3. Typography inconsistencies
-4. Accessibility issues (missing alt text, etc.)
-
-Example response:
-{
-  "valid": false,
-  "issues": [
-    {
-      "type": "warning",
-      "message": "Color #FF0000 is not in the style guide",
-      "suggestion": "Use the error color #EF4444 instead"
-    }
-  ]
-}`;
-}
 
 // src/ollama/client.ts
 var DEFAULT_BASE_URL = "http://localhost:11434";
@@ -191,19 +154,6 @@ var OllamaClient = class {
       return "Failed to query style guide. Please try again.";
     }
   }
-  /**
-   * Validates code against the style guide
-   */
-  async validateCode(code, styleGuide) {
-    const prompt = buildValidationPrompt(code, styleGuide);
-    try {
-      const response = await this.generate(prompt);
-      return this.parseValidationResponse(response);
-    } catch (error) {
-      console.error("[UILint] Validation failed:", error);
-      return { valid: true, issues: [] };
-    }
-  }
   /**
    * Core generate method that calls Ollama API
    */
@@ -243,21 +193,6 @@ var OllamaClient = class {
       return [];
     }
   }
-  /**
-   * Parses validation result from LLM response
-   */
-  parseValidationResponse(response) {
-    try {
-      const parsed = JSON.parse(response);
-      return {
-        valid: parsed.valid ?? true,
-        issues: parsed.issues || []
-      };
-    } catch {
-      console.warn("[UILint] Failed to parse validation response");
-      return { valid: true, issues: [] };
-    }
-  }
   /**
    * Checks if Ollama is available
    */
@@ -293,6 +228,65 @@ function getOllamaClient(options) {
   return defaultClient;
 }
 
+// src/tailwind/class-tokens.ts
+function extractClassTokensFromHtml(html, options = {}) {
+  const { maxTokens = 2e4 } = options;
+  const utilities = /* @__PURE__ */ new Map();
+  const variants = /* @__PURE__ */ new Map();
+  if (!html) return { utilities, variants };
+  const attrPattern = /\b(?:class|className)\s*=\s*["']([^"']+)["']/g;
+  let tokenBudget = maxTokens;
+  let match;
+  while ((match = attrPattern.exec(html)) && tokenBudget > 0) {
+    const raw = match[1];
+    if (!raw) continue;
+    const tokens = raw.split(/\s+/g).filter(Boolean);
+    for (const token of tokens) {
+      if (tokenBudget-- <= 0) break;
+      const { base, variantList } = splitVariants(token);
+      const normalizedBase = normalizeUtility(base);
+      if (!normalizedBase) continue;
+      increment(utilities, normalizedBase);
+      for (const v of variantList) increment(variants, v);
+    }
+  }
+  return { utilities, variants };
+}
+function topEntries(map, limit) {
+  return [...map.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit).map(([token, count]) => ({ token, count }));
+}
+function increment(map, key) {
+  map.set(key, (map.get(key) || 0) + 1);
+}
+function normalizeUtility(token) {
+  const t = token.trim();
+  if (!t) return null;
+  const noImportant = t.startsWith("!") ? t.slice(1) : t;
+  if (!noImportant || noImportant === "{" || noImportant === "}") return null;
+  return noImportant;
+}
+function splitVariants(token) {
+  const parts = [];
+  let buf = "";
+  let bracketDepth = 0;
+  for (let i = 0; i < token.length; i++) {
+    const ch = token[i];
+    if (ch === "[") bracketDepth++;
+    if (ch === "]" && bracketDepth > 0) bracketDepth--;
+    if (ch === ":" && bracketDepth === 0) {
+      parts.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  parts.push(buf);
+  if (parts.length <= 1) return { base: token, variantList: [] };
+  const base = parts[parts.length - 1] || "";
+  const variantList = parts.slice(0, -1).map((v) => v.trim()).filter(Boolean);
+  return { base, variantList };
+}
+
 // src/scanner/style-extractor.ts
 function extractStyles(root, getComputedStyle) {
   const styles = {
@@ -372,7 +366,10 @@ function deserializeStyles(serialized) {
     borderRadius: new Map(Object.entries(serialized.borderRadius))
   };
 }
-function createStyleSummary(styles) {
+function createStyleSummary(styles, options = {}) {
+  return createStyleSummaryWithOptions(styles, options);
+}
+function createStyleSummaryWithOptions(styles, options = {}) {
   const lines = [];
   lines.push("## Detected Styles Summary\n");
   lines.push("### Colors");
@@ -406,7 +403,9 @@ function createStyleSummary(styles) {
   });
   lines.push("");
   lines.push("### Spacing Values");
-  const sortedSpacing = [...styles.spacing.entries()].sort((a, b) => b[1] - a[1]);
+  const sortedSpacing = [...styles.spacing.entries()].sort(
+    (a, b) => b[1] - a[1]
+  );
   sortedSpacing.slice(0, 15).forEach(([value, count]) => {
     lines.push(`- ${value}: ${count} occurrences`);
   });
@@ -418,6 +417,38 @@ function createStyleSummary(styles) {
   sortedBorderRadius.forEach(([value, count]) => {
     lines.push(`- ${value}: ${count} occurrences`);
   });
+  if (options.html) {
+    const tokens = extractClassTokensFromHtml(options.html);
+    const topUtilities = topEntries(tokens.utilities, 40);
+    const topVariants = topEntries(tokens.variants, 15);
+    lines.push("");
+    lines.push("### Utility Classes (from markup)");
+    if (topUtilities.length === 0) {
+      lines.push("- (none detected)");
+    } else {
+      topUtilities.forEach(({ token, count }) => {
+        lines.push(`- ${token}: ${count} occurrences`);
+      });
+    }
+    if (topVariants.length > 0) {
+      lines.push("");
+      lines.push("### Common Variants");
+      topVariants.forEach(({ token, count }) => {
+        lines.push(`- ${token}: ${count} occurrences`);
+      });
+    }
+  }
+  if (options.tailwindTheme) {
+    const tt = options.tailwindTheme;
+    lines.push("");
+    lines.push("### Tailwind Theme Tokens (from config)");
+    lines.push(`- configPath: ${tt.configPath}`);
+    lines.push(`- colors: ${tt.colors.length}`);
+    lines.push(`- spacingKeys: ${tt.spacingKeys.length}`);
+    lines.push(`- borderRadiusKeys: ${tt.borderRadiusKeys.length}`);
+    lines.push(`- fontFamilyKeys: ${tt.fontFamilyKeys.length}`);
+    lines.push(`- fontSizeKeys: ${tt.fontSizeKeys.length}`);
+  }
   return lines.join("\n");
 }
 function truncateHTML(html, maxLength = 5e4) {
@@ -671,9 +702,87 @@ function extractStyleValues(content) {
   }
   return result;
 }
+function extractTailwindAllowlist(content) {
+  const empty = {
+    allowAnyColor: false,
+    allowStandardSpacing: false,
+    allowedTailwindColors: /* @__PURE__ */ new Set(),
+    allowedUtilities: /* @__PURE__ */ new Set(),
+    allowedSpacingKeys: /* @__PURE__ */ new Set(),
+    allowedBorderRadiusKeys: /* @__PURE__ */ new Set(),
+    allowedFontSizeKeys: /* @__PURE__ */ new Set(),
+    allowedFontFamilyKeys: /* @__PURE__ */ new Set()
+  };
+  const sections = parseStyleGuideSections(content);
+  const tailwindSection = sections["tailwind"] ?? // defensive: some styleguides use different casing/spacing
+  sections["tailwind utilities"] ?? "";
+  if (!tailwindSection) return empty;
+  const parsed = tryParseFirstJsonCodeBlock(tailwindSection);
+  if (parsed && typeof parsed === "object") {
+    const allowAnyColor = Boolean(parsed.allowAnyColor);
+    const allowStandardSpacing = Boolean(parsed.allowStandardSpacing);
+    const allowedUtilitiesArr = Array.isArray(parsed.allowedUtilities) ? parsed.allowedUtilities.filter(
+      (u) => typeof u === "string"
+    ) : [];
+    const themeTokens = parsed.themeTokens ?? {};
+    const themeColors = Array.isArray(themeTokens.colors) ? themeTokens.colors.filter((c) => typeof c === "string") : [];
+    const spacingKeys = Array.isArray(themeTokens.spacingKeys) ? themeTokens.spacingKeys.filter((k) => typeof k === "string") : [];
+    const borderRadiusKeys = Array.isArray(themeTokens.borderRadiusKeys) ? themeTokens.borderRadiusKeys.filter((k) => typeof k === "string") : [];
+    const fontFamilyKeys = Array.isArray(themeTokens.fontFamilyKeys) ? themeTokens.fontFamilyKeys.filter((k) => typeof k === "string") : [];
+    const fontSizeKeys = Array.isArray(themeTokens.fontSizeKeys) ? themeTokens.fontSizeKeys.filter((k) => typeof k === "string") : [];
+    const allowedTailwindColors = /* @__PURE__ */ new Set();
+    for (const c of themeColors) {
+      const raw = c.trim();
+      if (!raw) continue;
+      if (raw.toLowerCase().startsWith("tailwind:")) {
+        allowedTailwindColors.add(raw.toLowerCase());
+        continue;
+      }
+      const m = raw.match(/^([a-zA-Z]+)-(\d{2,3})$/);
+      if (m) {
+        allowedTailwindColors.add(`tailwind:${m[1].toLowerCase()}-${m[2]}`);
+      }
+    }
+    return {
+      allowAnyColor,
+      allowStandardSpacing,
+      allowedTailwindColors,
+      allowedUtilities: new Set(allowedUtilitiesArr.map((s) => s.trim()).filter(Boolean)),
+      allowedSpacingKeys: new Set(spacingKeys.map((s) => s.trim()).filter(Boolean)),
+      allowedBorderRadiusKeys: new Set(borderRadiusKeys.map((s) => s.trim()).filter(Boolean)),
+      allowedFontSizeKeys: new Set(fontSizeKeys.map((s) => s.trim()).filter(Boolean)),
+      allowedFontFamilyKeys: new Set(fontFamilyKeys.map((s) => s.trim()).filter(Boolean))
+    };
+  }
+  const backticked = [];
+  for (const m of tailwindSection.matchAll(/`([^`]+)`/g)) {
+    backticked.push(m[1]);
+  }
+  return {
+    ...empty,
+    allowedUtilities: new Set(
+      backticked.flatMap((s) => s.split(/[,\s]+/g)).map((s) => s.trim()).filter(Boolean)
+    )
+  };
+}
+function tryParseFirstJsonCodeBlock(section) {
+  const jsonBlocks = [...section.matchAll(/```json\s*([\s\S]*?)```/gi)];
+  const anyBlocks = [...section.matchAll(/```\s*([\s\S]*?)```/g)];
+  const candidates = (jsonBlocks.length ? jsonBlocks : anyBlocks).map((m) => m[1]);
+  for (const raw of candidates) {
+    const trimmed = raw.trim();
+    if (!trimmed) continue;
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
 
 // src/styleguide/generator.ts
-function generateStyleGuideFromStyles(styles) {
+function generateStyleGuideFromStyles(styles, options = {}) {
   const lines = [];
   lines.push("# UI Style Guide");
   lines.push("");
@@ -681,9 +790,18 @@ function generateStyleGuideFromStyles(styles) {
     "> Auto-generated by UILint. Edit this file to define your design system."
   );
   lines.push("");
+  const html = options.html || "";
+  const mergedColors = new Map(styles.colors);
+  if (html) {
+    for (const m of html.matchAll(/#[A-Fa-f0-9]{6}\b/g)) {
+      const hex = (m[0] || "").toUpperCase();
+      if (!hex) continue;
+      mergedColors.set(hex, (mergedColors.get(hex) || 0) + 1);
+    }
+  }
   lines.push("## Colors");
   lines.push("");
-  const sortedColors = [...styles.colors.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
+  const sortedColors = [...mergedColors.entries()].sort((a, b) => b[1] - a[1]);
   if (sortedColors.length > 0) {
     const colorNames = [
       "Primary",
@@ -763,6 +881,71 @@ function generateStyleGuideFromStyles(styles) {
   lines.push("- **Cards**: Define card styles here");
   lines.push("- **Inputs**: Define input styles here");
   lines.push("");
+  const classTokens = html ? extractClassTokensFromHtml(html) : null;
+  const topUtilities = classTokens ? topEntries(classTokens.utilities, 50) : [];
+  const topVariants = classTokens ? topEntries(classTokens.variants, 20) : [];
+  const allUtilities = classTokens ? [...classTokens.utilities.entries()].sort((a, b) => b[1] - a[1] ? b[1] - a[1] : a[0].localeCompare(b[0])).map(([token]) => token) : [];
+  const theme = options.tailwindTheme;
+  const themeColors = theme?.colors || [];
+  const themeSpacingKeys = theme?.spacingKeys || [];
+  const themeBorderRadiusKeys = theme?.borderRadiusKeys || [];
+  const themeFontFamilyKeys = theme?.fontFamilyKeys || [];
+  const themeFontSizeKeys = theme?.fontSizeKeys || [];
+  const hasTailwindSection = topUtilities.length > 0 || themeColors.length > 0 || themeSpacingKeys.length > 0 || themeBorderRadiusKeys.length > 0 || themeFontFamilyKeys.length > 0 || themeFontSizeKeys.length > 0;
+  if (hasTailwindSection) {
+    lines.push("## Tailwind");
+    lines.push("");
+    lines.push(
+      "> Optional. Captures Tailwind/utility class conventions for validation and consistency."
+    );
+    lines.push("");
+    if (topUtilities.length > 0) {
+      const utilityList = topUtilities.slice(0, 25).map((u) => `\`${u.token}\``).join(", ");
+      lines.push(`- **Observed utilities (top)**: ${utilityList}`);
+    } else {
+      lines.push("- **Observed utilities (top)**: (none detected)");
+    }
+    if (topVariants.length > 0) {
+      const variantList = topVariants.slice(0, 12).map((v) => `\`${v.token}\``).join(", ");
+      lines.push(`- **Common variants**: ${variantList}`);
+    }
+    if (theme) {
+      lines.push(`- **Config path**: \`${theme.configPath}\``);
+      if (themeColors.length > 0) {
+        lines.push(
+          `- **Theme colors (tokens)**: ${themeColors.slice(0, 25).map((t) => `\`${t}\``).join(", ")}${themeColors.length > 25 ? ", ..." : ""}`
+        );
+      } else {
+        lines.push("- **Theme colors (tokens)**: (none specified in config)");
+      }
+      if (themeSpacingKeys.length > 0) {
+        lines.push(
+          `- **Theme spacing keys**: ${themeSpacingKeys.slice(0, 25).map((k) => `\`${k}\``).join(", ")}${themeSpacingKeys.length > 25 ? ", ..." : ""}`
+        );
+      }
+    }
+    const payload = {
+      // IMPORTANT: include all observed utilities (not just "top N"), otherwise
+      // init+validate on the same file can be inconsistent.
+      allowedUtilities: allUtilities,
+      allowAnyColor: !!theme && themeColors.length === 0,
+      // avoid noisy warnings when config doesn't define colors
+      allowStandardSpacing: !!theme && themeSpacingKeys.length === 0,
+      themeTokens: theme ? {
+        configPath: theme.configPath,
+        colors: themeColors,
+        spacingKeys: themeSpacingKeys,
+        borderRadiusKeys: themeBorderRadiusKeys,
+        fontFamilyKeys: themeFontFamilyKeys,
+        fontSizeKeys: themeFontSizeKeys
+      } : null
+    };
+    lines.push("");
+    lines.push("```json");
+    lines.push(JSON.stringify(payload, null, 2));
+    lines.push("```");
+    lines.push("");
+  }
   return lines.join("\n");
 }
 function findGCD(numbers) {
@@ -812,201 +995,10 @@ function styleGuideToMarkdown(guide) {
   return lines.join("\n");
 }
 
-// src/validation/validate.ts
-function validateCode(code, styleGuide) {
-  const issues = [];
-  if (!styleGuide) {
-    return {
-      valid: true,
-      issues: [
-        {
-          type: "warning",
-          message: "No style guide found. Create .uilint/styleguide.md to enable validation."
-        }
-      ]
-    };
-  }
-  const styleValues = extractStyleValues(styleGuide);
-  const codeColors = extractColorsFromCode(code);
-  for (const color of codeColors) {
-    if (!styleValues.colors.includes(color.toUpperCase())) {
-      const similar = findSimilarColor(color, styleValues.colors);
-      issues.push({
-        type: "warning",
-        message: `Color ${color} is not in the style guide`,
-        suggestion: similar ? `Consider using ${similar} instead` : `Add ${color} to the style guide if intentional`
-      });
-    }
-  }
-  const hardcodedPixels = code.matchAll(
-    /(?:margin|padding|gap)[-:].*?(\d+)px/gi
-  );
-  for (const match of hardcodedPixels) {
-    const value = parseInt(match[1]);
-    if (value % 4 !== 0) {
-      issues.push({
-        type: "warning",
-        message: `Spacing value ${value}px doesn't follow the 4px grid`,
-        suggestion: `Use ${Math.round(value / 4) * 4}px instead`
-      });
-    }
-  }
-  if (code.includes("style={{") || code.includes("style={")) {
-    const inlineStyleCount = (code.match(/style=\{/g) || []).length;
-    if (inlineStyleCount > 2) {
-      issues.push({
-        type: "warning",
-        message: `Found ${inlineStyleCount} inline styles. Consider using CSS classes for consistency.`
-      });
-    }
-  }
-  return {
-    valid: issues.filter((i) => i.type === "error").length === 0,
-    issues
-  };
-}
-function lintSnippet(code, styleGuide) {
-  const issues = [];
-  issues.push(...lintBasicPatterns(code));
-  if (styleGuide) {
-    issues.push(...lintAgainstStyleGuide(code, styleGuide));
-  }
-  const errorCount = issues.filter((i) => i.severity === "error").length;
-  const warningCount = issues.filter((i) => i.severity === "warning").length;
-  return {
-    issues,
-    summary: issues.length === 0 ? "No issues found" : `Found ${errorCount} errors and ${warningCount} warnings`
-  };
-}
-function lintBasicPatterns(code) {
-  const issues = [];
-  const magicNumbers = code.matchAll(
-    /(?:width|height|size):\s*(\d+)(?!px|rem|em|%)/g
-  );
-  for (const match of magicNumbers) {
-    issues.push({
-      severity: "warning",
-      type: "spacing",
-      message: `Magic number ${match[1]} found without unit`,
-      code: match[0],
-      suggestion: `Add a unit like ${match[1]}px or use a design token`
-    });
-  }
-  const hardcodedTailwindColors = code.matchAll(
-    /className=["'][^"']*(?:bg|text|border)-\[#[A-Fa-f0-9]+\][^"']*/g
-  );
-  for (const match of hardcodedTailwindColors) {
-    issues.push({
-      severity: "warning",
-      type: "color",
-      message: "Hardcoded color in Tailwind arbitrary value",
-      code: match[0],
-      suggestion: "Use a color from your Tailwind config or style guide"
-    });
-  }
-  if (code.includes("<img") && !code.includes("alt=")) {
-    issues.push({
-      severity: "error",
-      type: "accessibility",
-      message: "Image without alt attribute",
-      suggestion: 'Add alt="" for decorative images or descriptive alt text'
-    });
-  }
-  if (code.includes("<button") && !code.match(/<button[^>]*>.*\S.*<\/button>/s)) {
-    issues.push({
-      severity: "warning",
-      type: "accessibility",
-      message: "Button may be missing accessible text",
-      suggestion: "Ensure button has visible text or aria-label"
-    });
-  }
-  const singleQuotes = (code.match(/className='/g) || []).length;
-  const doubleQuotes = (code.match(/className="/g) || []).length;
-  if (singleQuotes > 0 && doubleQuotes > 0) {
-    issues.push({
-      severity: "info",
-      type: "component",
-      message: "Mixed quote styles in className attributes",
-      suggestion: "Use consistent quote style throughout"
-    });
-  }
-  return issues;
-}
-function lintAgainstStyleGuide(code, styleGuide) {
-  const issues = [];
-  const values = extractStyleValues(styleGuide);
-  const codeColors = code.matchAll(/#[A-Fa-f0-9]{6}\b/g);
-  for (const match of codeColors) {
-    const color = match[0].toUpperCase();
-    if (!values.colors.includes(color)) {
-      issues.push({
-        severity: "warning",
-        type: "color",
-        message: `Color ${color} not in style guide`,
-        code: match[0],
-        suggestion: `Allowed colors: ${values.colors.slice(0, 5).join(", ")}${values.colors.length > 5 ? "..." : ""}`
-      });
-    }
-  }
-  const spacingValues = code.matchAll(/(?:p|m|gap)-(\d+)/g);
-  for (const match of spacingValues) {
-    const value = parseInt(match[1]);
-    if (value > 12 && value % 4 !== 0) {
-      issues.push({
-        severity: "info",
-        type: "spacing",
-        message: `Spacing value ${match[0]} might not align with design system`,
-        suggestion: "Consider using standard Tailwind spacing values (1-12, 16, 20, 24...)"
-      });
-    }
-  }
-  return issues;
-}
-function extractColorsFromCode(code) {
-  const colors = [];
-  const hexMatches = code.matchAll(/#[A-Fa-f0-9]{6}\b/g);
-  for (const match of hexMatches) {
-    colors.push(match[0].toUpperCase());
-  }
-  const tailwindMatches = code.matchAll(/(?:bg|text|border)-(\w+)-(\d+)/g);
-  for (const match of tailwindMatches) {
-    colors.push(`tailwind:${match[1]}-${match[2]}`);
-  }
-  return [...new Set(colors)];
-}
-function findSimilarColor(color, allowedColors) {
-  const colorRgb = hexToRgb(color);
-  if (!colorRgb) return null;
-  let closest = null;
-  let closestDistance = Infinity;
-  for (const allowed of allowedColors) {
-    const allowedRgb = hexToRgb(allowed);
-    if (!allowedRgb) continue;
-    const distance = Math.sqrt(
-      Math.pow(colorRgb.r - allowedRgb.r, 2) + Math.pow(colorRgb.g - allowedRgb.g, 2) + Math.pow(colorRgb.b - allowedRgb.b, 2)
-    );
-    if (distance < closestDistance && distance < 50) {
-      closestDistance = distance;
-      closest = allowed;
-    }
-  }
-  return closest;
-}
-function hexToRgb(hex) {
-  const match = hex.match(/^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i);
-  if (!match) return null;
-  return {
-    r: parseInt(match[1], 16),
-    g: parseInt(match[2], 16),
-    b: parseInt(match[3], 16)
-  };
-}
-
 export {
   buildAnalysisPrompt,
   buildStyleGuidePrompt,
   buildQueryPrompt,
-  buildValidationPrompt,
   OllamaClient,
   getOllamaClient,
   extractStyles,
@@ -1025,9 +1017,8 @@ export {
   parseStyleGuide,
   parseStyleGuideSections,
   extractStyleValues,
+  extractTailwindAllowlist,
   generateStyleGuideFromStyles,
-  styleGuideToMarkdown,
-  validateCode,
-  lintSnippet
+  styleGuideToMarkdown
 };
-//# sourceMappingURL=chunk-P5RPW6PI.js.map
+//# sourceMappingURL=chunk-P2QQGDQS.js.map