css-slop-detector 0.2.0__py3-none-any.whl

css_slop.py

@@ -0,0 +1,633 @@
+#!/usr/bin/env python3
+"""css-slop-detector: score CSS/HTML for AI-generated design cliches.
+
+Detects the visual fingerprints of AI-generated web design: oversized
+border radii, glassmorphism-everywhere, purple gradients, neon glows,
+pure-black dark mode with no light toggle, and giant centered hero titles.
+
+v2 adds --fix: an automatic rewrite loop that de-slops the flagged
+patterns (with backups and dry-run diff previews).
+
+Standard library only. No dependencies.
+"""
+
+from __future__ import annotations
+
+import argparse
+import difflib
+import json
+import re
+import shutil
+import sys
+from collections import Counter
+from dataclasses import dataclass, field
+
+
+VERSION = "0.2.0"
+
+# ---------------------------------------------------------------- checks
+
+@dataclass
+class Finding:
+    rule: str
+    line: int
+    message: str
+    weight: int
+    snippet: str = ""
+
+
+@dataclass
+class FileReport:
+    path: str
+    findings: list = field(default_factory=list)
+
+    @property
+    def score(self) -> int:
+        # weights are severity points; scale to a 0-100 slop score
+        return min(100, sum(f.weight for f in self.findings) * 4)
+
+    @property
+    def label(self) -> str:
+        s = self.score
+        if s <= 20:
+            return "clean"
+        if s <= 50:
+            return "mild slop"
+        if s <= 80:
+            return "slop"
+        return "peak slop"
+
+
+_PURPLE_RE = re.compile(
+    r"purple|violet|indigo|fuchsia|magenta|rebeccapurple"
+    r"|#8b5cf6|#a855f7|#7c3aed|#6d28d9|#d946ef|#c026d3",
+    re.IGNORECASE,
+)
+_RADIUS_RE = re.compile(r"border-radius\s*:\s*(\d+(?:\.\d+)?)\s*(px|rem|em)?", re.IGNORECASE)
+_GLASS_RE = re.compile(r"backdrop-filter\s*:[^;]*blur", re.IGNORECASE)
+_GRADIENT_RE = re.compile(r"(linear|radial|conic)-gradient\s*\(([^;{}]*)\)", re.IGNORECASE)
+_GLOW_RE = re.compile(
+    r"box-shadow\s*:[^;]*?(\d+(?:\.\d+)?)\s*(?:px)?\s+"
+    r"(\d+(?:\.\d+)?)\s*(?:px)?\s+(\d+(?:\.\d+)?)\s*px", re.IGNORECASE
+)
+_GLOW_COLOR_RE = re.compile(
+    r"box-shadow\s*:[^;]*(rgba?\s*\([^)]*\)|#[0-9a-f]{3,8})", re.IGNORECASE
+)
+_NEON_NAMED_COLORS = {
+    "red", "cyan", "magenta", "fuchsia", "lime", "yellow", "orange",
+    "purple", "violet", "indigo", "blue", "green", "pink", "hotpink",
+    "deeppink", "teal", "aqua", "chartreuse",
+}
+
+
+def _parse_shadow_rgb(color: str):
+    """Return (r, g, b) floats for hex / rgb() / rgba() colors, else None."""
+    color = color.strip()
+    hm = re.fullmatch(r"#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})",
+                      color, re.IGNORECASE)
+    if hm:
+        h = hm.group(1)
+        if len(h) in (3, 4):
+            h = "".join(c * 2 for c in h)
+        return (float(int(h[0:2], 16)), float(int(h[2:4], 16)),
+                float(int(h[4:6], 16)))
+    mm = re.fullmatch(r"rgba?\(\s*([^)]*)\)", color, re.IGNORECASE)
+    if mm:
+        vals = []
+        for part in mm.group(1).split(",")[:3]:
+            part = part.strip()
+            try:
+                vals.append(float(part[:-1]) * 255.0 / 100.0
+                            if part.endswith("%") else float(part))
+            except ValueError:
+                return None
+        if len(vals) == 3:
+            return tuple(vals)
+    return None
+
+
+def _is_neon_color(color: str) -> bool:
+    """A glow only counts as 'neon' if its color is vivid (saturated).
+
+    Plain black/gray/white shadows (e.g. Tailwind's large soft shadow
+    `rgba(0,0,0,.25)`) are normal depth cues, not neon glows.
+    """
+    rgb = _parse_shadow_rgb(color)
+    if rgb is None:
+        return color.strip().lower() in _NEON_NAMED_COLORS
+    r, g, b = rgb
+    return (max(r, g, b) - min(r, g, b)) >= 80 and max(r, g, b) >= 100
+_BG_DECL_RE = re.compile(r"background(?:-color)?\s*:\s*([^;{}]+)", re.IGNORECASE)
+_HEX_COLOR_RE = re.compile(r"#([0-9a-f]{3}|[0-9a-f]{6})\b", re.IGNORECASE)
+
+
+def _is_near_black_hex(hexcode: str) -> bool:
+    """True only if every channel is very dark (rules out #0066cc blue etc)."""
+    h = hexcode.lstrip("#")
+    if len(h) == 3:
+        h = "".join(c * 2 for c in h)
+    if len(h) != 6:
+        return False
+    r, g, b = int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)
+    return max(r, g, b) <= 0x1A
+
+
+def _black_bg_value(block: str) -> str | None:
+    """Return the near-black background value in a declaration block, if any."""
+    for m in _BG_DECL_RE.finditer(block):
+        val = m.group(1)
+        if re.search(r"\bblack\b", val, re.IGNORECASE):
+            return "black"
+        for hm in _HEX_COLOR_RE.finditer(val):
+            if _is_near_black_hex(hm.group(0)):
+                return hm.group(0)
+    return None
+_CENTER_RE = re.compile(r"text-align\s*:\s*center", re.IGNORECASE)
+_BIG_TEXT_RE = re.compile(r"font-size\s*:\s*(\d+(?:\.\d+)?)\s*(px|rem|em)?", re.IGNORECASE)
+_LIGHT_MODE_RE = re.compile(
+    r"prefers-color-scheme\s*:\s*light|data-theme\s*=\s*[\"']light[\"']"
+    r"|\.light-theme|theme-toggle|color-scheme\s*:\s*light",
+    re.IGNORECASE,
+)
+_RULE_RE = re.compile(r"([^{}]+)\{([^{}]*)\}")
+
+
+def _px(value: float, unit: str | None) -> float:
+    if (unit or "px").lower() == "px":
+        return value
+    return value * 16  # rem/em -> px approximation
+
+
+def check_rule_block(selector: str, block: str, line: int) -> list[Finding]:
+    out: list[Finding] = []
+
+    for m in _RADIUS_RE.finditer(block):
+        if _px(float(m.group(1)), m.group(2)) >= 20:
+            out.append(Finding(
+                "big-radius", line,
+                f"oversized border-radius ({m.group(1)}{m.group(2) or 'px'}) "
+                f"on '{selector.strip()}'",
+                2, m.group(0)))
+
+    if _GLASS_RE.search(block):
+        out.append(Finding(
+            "glass", line,
+            f"backdrop-filter blur on '{selector.strip()}' (glassmorphism)",
+            2, "backdrop-filter: blur(...)"))
+
+    for m in _GRADIENT_RE.finditer(block):
+        if _PURPLE_RE.search(m.group(2)):
+            out.append(Finding(
+                "purple-gradient", line,
+                f"purple/violet gradient on '{selector.strip()}'",
+                3, m.group(0)[:80]))
+
+    for m in _GLOW_RE.finditer(block):
+        if float(m.group(3)) < 24:
+            continue
+        cm = _GLOW_COLOR_RE.search(block)
+        if cm and _is_neon_color(cm.group(1)):
+            out.append(Finding(
+                "glow-shadow", line,
+                f"neon glow box-shadow (blur {m.group(3)}px) "
+                f"on '{selector.strip()}'",
+                2, m.group(0)[:80]))
+
+    black_bg = _black_bg_value(block)
+    if black_bg:
+        out.append(Finding(
+            "pure-black", line,
+            f"pure/near-black background ({black_bg}) on '{selector.strip()}'",
+            2, f"background: {black_bg}"))
+
+    big_text = None
+    for m in _BIG_TEXT_RE.finditer(block):
+        if _px(float(m.group(1)), m.group(2)) >= 40:
+            big_text = m.group(0)
+    if big_text and _CENTER_RE.search(block):
+        out.append(Finding(
+            "hero-center", line,
+            f"giant centered title ({big_text}) on '{selector.strip()}'",
+            3, big_text))
+
+    return out
+
+
+def scan_css_text(css: str, path: str, base_line: int = 0) -> FileReport:
+    report = FileReport(path)
+    for m in _RULE_RE.finditer(css):
+        selector, block = m.group(1), m.group(2)
+        # m.start() includes the selector's leading whitespace/newlines, so
+        # measure from the opening brace for an accurate line number.
+        brace_pos = m.start() + len(m.group(1))
+        line = base_line + css.count("\n", 0, brace_pos) + 1
+        report.findings.extend(check_rule_block(selector, block, line))
+    if not _LIGHT_MODE_RE.search(css) and _black_bg_value(css):
+        report.findings.append(Finding(
+            "no-light-mode", 1,
+            "dark-only design: near-black backgrounds with no light-mode "
+            "toggle or prefers-color-scheme: light found",
+            5, ""))
+    return report
+
+
+_STYLE_TAG_RE = re.compile(r"<style[^>]*>(.*?)</style>", re.IGNORECASE | re.DOTALL)
+_INLINE_STYLE_RE = re.compile(r'style\s*=\s*"([^"]*)"', re.IGNORECASE)
+
+
+def scan_html_text(html: str, path: str) -> FileReport:
+    report = FileReport(path)
+    for m in _STYLE_TAG_RE.finditer(html):
+        base_line = html.count("\n", 0, m.start(1))
+        sub = scan_css_text(m.group(1), path, base_line)
+        report.findings.extend(sub.findings)
+    # inline styles: wrap as a synthetic rule so block checks apply
+    for m in _INLINE_STYLE_RE.finditer(html):
+        line = html.count("\n", 0, m.start()) + 1
+        fake = f".inline{{{m.group(1)}}}"
+        sub = scan_css_text(fake, path, line - 1)
+        for f in sub.findings:
+            f.snippet = (f.snippet or "")[:60]
+        report.findings.extend(sub.findings)
+    if not _LIGHT_MODE_RE.search(html) and _black_bg_value(html):
+        report.findings.append(Finding(
+            "no-light-mode", 1,
+            "dark-only design: near-black backgrounds with no light-mode "
+            "toggle found",
+            5, ""))
+    return report
+
+
+def scan_path(path: str) -> FileReport:
+    with open(path, encoding="utf-8", errors="replace") as fh:
+        text = fh.read()
+    if path.lower().endswith((".html", ".htm")):
+        return scan_html_text(text, path)
+    return scan_css_text(text, path)
+
+
+def scan_text(text: str, path: str):
+    if path.lower().endswith((".html", ".htm")):
+        return scan_html_text(text, path)
+    return scan_css_text(text, path)
+
+
+# ---------------------------------------------------------------- fixes (v2)
+
+# The fixer mirrors the detectors: every automatic rewrite only touches a
+# pattern that the corresponding check would flag. Fixes are deterministic
+# and conservative — they de-slop, they don't redesign.
+
+_PURPLE_HEX_FIX = {
+    "#8b5cf6": "#64748b", "#a855f7": "#94a3b8", "#7c3aed": "#64748b",
+    "#6d28d9": "#475569", "#d946ef": "#94a3b8", "#c026d3": "#64748b",
+}
+_PURPLE_NAME_FIX = {
+    "purple": "#64748b", "violet": "#94a3b8", "indigo": "#64748b",
+    "fuchsia": "#94a3b8", "magenta": "#94a3b8", "rebeccapurple": "#64748b",
+}
+_PURPLE_NAME_FIX_RE = re.compile(
+    r"\b(" + "|".join(sorted(_PURPLE_NAME_FIX, key=len, reverse=True)) + r")\b",
+    re.IGNORECASE,
+)
+_PURPLE_HEX_FIX_RE = re.compile(
+    r"(" + "|".join(re.escape(h) for h in _PURPLE_HEX_FIX) + r")\b",
+    re.IGNORECASE,
+)
+
+_GLASS_DECL_RE = re.compile(r"backdrop-filter\s*:[^;{}]*blur[^;{}]*;?",
+                            re.IGNORECASE)
+_GLOW_DECL_RE = re.compile(r"box-shadow\s*:[^;{}]+;?", re.IGNORECASE)
+_BG_FIX_RE = re.compile(r"(background(?:-color)?\s*:\s*)([^;{}]+)",
+                        re.IGNORECASE)
+_BLACK_WORD_RE = re.compile(r"\bblack\b", re.IGNORECASE)
+
+# De-slop rewrite targets. The point is not a redesign — just kill the
+# tell-tale AI fingerprints: clamp the giant radius, drop the glass blur,
+# neutralize the purple gradient and neon glow, lift pure-black surfaces,
+# tame the giant centered hero title, and add a light-mode hook.
+FIX_RADIUS_PX = 12
+FIX_HERO_FONT_PX = 32
+FIX_BLACK_HEX = "#1e1e1e"          # lifted soft black, no longer "pure"
+FIX_SOFT_SHADOW = "box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1)"
+LIGHT_MODE_STUB = (
+    "@media (prefers-color-scheme: light) {\n"
+    "  /* added by css-slop-detector --fix: light-mode hook */\n"
+    "  :root { color-scheme: light; }\n"
+    "}"
+)
+
+
+def _fix_purple_colors(body: str) -> tuple[str, int]:
+    """Swap purple/violet gradient stops for neutral slate. Returns (new, n)."""
+    n = [0]
+
+    def hex_repl(m):
+        n[0] += 1
+        return _PURPLE_HEX_FIX[m.group(0).lower()]
+
+    def name_repl(m):
+        n[0] += 1
+        return _PURPLE_NAME_FIX[m.group(0).lower()]
+
+    body = _PURPLE_HEX_FIX_RE.sub(hex_repl, body)
+    body = _PURPLE_NAME_FIX_RE.sub(name_repl, body)
+    return body, n[0]
+
+
+def _fix_black_value(val: str) -> tuple[str, int]:
+    """Lift pure/near-black background values to a softer black."""
+    n = [0]
+
+    def hex_repl(m):
+        if _is_near_black_hex(m.group(0)):
+            n[0] += 1
+            return FIX_BLACK_HEX
+        return m.group(0)
+
+    val = _HEX_COLOR_RE.sub(hex_repl, val)
+
+    def word_repl(m):
+        n[0] += 1
+        return FIX_BLACK_HEX
+
+    val = _BLACK_WORD_RE.sub(word_repl, val)
+    return val, n[0]
+
+
+def _fix_block(block: str, fixes: Counter) -> str:
+    """Apply block-level rewrites to one declaration block. Returns new block."""
+
+    # big-radius -> clamp to FIX_RADIUS_PX
+    def radius_repl(m):
+        if _px(float(m.group(1)), m.group(2)) >= 20:
+            fixes["big-radius"] += 1
+            return f"border-radius: {FIX_RADIUS_PX}px"
+        return m.group(0)
+
+    block = _RADIUS_RE.sub(radius_repl, block)
+
+    # glass -> remove the backdrop-filter blur declaration
+    def glass_repl(m):
+        fixes["glass"] += 1
+        return ""
+
+    block = _GLASS_DECL_RE.sub(glass_repl, block)
+    block = re.sub(r";\s*;", ";", block)
+
+    # purple-gradient -> neutral slate gradient stops
+    def grad_repl(m):
+        new_body, count = _fix_purple_colors(m.group(2))
+        if count:
+            fixes["purple-gradient"] += count
+            return f"{m.group(1)}-gradient({new_body})"
+        return m.group(0)
+
+    block = _GRADIENT_RE.sub(grad_repl, block)
+
+    # glow-shadow -> soft neutral shadow (only neon glows, like the detector)
+    def glow_repl(m):
+        decl = m.group(0)
+        gm = _GLOW_RE.search(decl)
+        if not gm or float(gm.group(3)) < 24:
+            return decl
+        cm = _GLOW_COLOR_RE.search(decl)
+        if cm and _is_neon_color(cm.group(1)):
+            fixes["glow-shadow"] += 1
+            return FIX_SOFT_SHADOW
+        return decl
+
+    block = _GLOW_DECL_RE.sub(glow_repl, block)
+
+    # pure-black -> lift to a softer black
+    def bg_repl(m):
+        new_val, count = _fix_black_value(m.group(2))
+        if count:
+            fixes["pure-black"] += count
+            return m.group(1) + new_val
+        return m.group(0)
+
+    block = _BG_FIX_RE.sub(bg_repl, block)
+
+    # hero-center -> tame the giant centered title
+    big_font = any(
+        _px(float(m.group(1)), m.group(2)) >= 40
+        for m in _BIG_TEXT_RE.finditer(block)
+    )
+    if big_font and _CENTER_RE.search(block):
+        def size_repl(m):
+            if _px(float(m.group(1)), m.group(2)) >= 40:
+                return f"font-size: {FIX_HERO_FONT_PX}px"
+            return m.group(0)
+
+        block = _BIG_TEXT_RE.sub(size_repl, block)
+        block = _CENTER_RE.sub("text-align: left", block)
+        fixes["hero-center"] += 1
+
+    return block
+
+
+def fix_css_text(css: str, fixes: Counter) -> str:
+    """Apply block-level fixes to raw CSS text, recording counts in fixes."""
+
+    def rule_repl(m):
+        return m.group(1) + "{" + _fix_block(m.group(2), fixes) + "}"
+
+    return _RULE_RE.sub(rule_repl, css)
+
+
+def _append_light_stub(text: str, fixes: Counter, wrap_html: bool) -> str:
+    stub = LIGHT_MODE_STUB
+    if wrap_html:
+        stub = "<style>\n" + stub + "\n</style>"
+    text = text.rstrip("\n") + "\n\n" + stub + "\n"
+    fixes["no-light-mode"] += 1
+    return text
+
+
+def apply_fixes(text: str, path: str) -> tuple[str, Counter]:
+    """Rewrite slop patterns in text. Returns (new_text, fix_counts).
+
+    Only rewrites patterns the detectors would flag. Safe to run on
+    already-clean files (returns the text unchanged).
+    """
+    html = path.lower().endswith((".html", ".htm"))
+    fixes: Counter = Counter()
+    # The no-light-mode finding is computed on the original text, before
+    # pure-black lifting (lifting the blacks would hide it).
+    needs_light = _black_bg_value(text) is not None and not _LIGHT_MODE_RE.search(text)
+
+    if html:
+        def style_repl(m):
+            inner = fix_css_text(m.group(1), fixes)
+            return m.group(0)[: m.start(1) - m.start()] + inner \
+                + m.group(0)[m.end(1) - m.start():]
+
+        text = _STYLE_TAG_RE.sub(style_repl, text)
+
+        def inline_repl(m):
+            return 'style="' + _fix_block(m.group(1), fixes) + '"'
+
+        text = _INLINE_STYLE_RE.sub(inline_repl, text)
+    else:
+        text = fix_css_text(text, fixes)
+
+    if needs_light and not _LIGHT_MODE_RE.search(text):
+        text = _append_light_stub(text, fixes, wrap_html=html)
+
+    return text, fixes
+
+
+def unified_diff(path: str, old: str, new: str) -> str:
+    return "".join(difflib.unified_diff(
+        old.splitlines(keepends=True), new.splitlines(keepends=True),
+        fromfile=f"a/{path}", tofile=f"b/{path}"))
+
+
+def fix_file(path: str, *, dry_run: bool, backup_suffix: str) -> dict:
+    """Preview or apply fixes for one file. Returns a result dict."""
+    with open(path, encoding="utf-8", errors="replace") as fh:
+        original = fh.read()
+    before = scan_text(original, path)
+    new_text, fixes = apply_fixes(original, path)
+    after = scan_text(new_text, path) if new_text != original else before
+
+    result = {
+        "path": path,
+        "fixes": dict(fixes),
+        "fix_count": sum(fixes.values()),
+        "score_before": before.score,
+        "score_after": after.score,
+        "diff": unified_diff(path, original, new_text),
+        "wrote": False,
+        "backup": None,
+    }
+
+    if dry_run or new_text == original:
+        return result
+
+    backup = path + backup_suffix
+    shutil.copy2(path, backup)
+    with open(path, "w", encoding="utf-8") as fh:
+        fh.write(new_text)
+    result["wrote"] = True
+    result["backup"] = backup
+    return result
+
+
+def restore_file(path: str, backup_suffix: str) -> dict:
+    backup = path + backup_suffix
+    try:
+        shutil.copy2(backup, path)
+    except OSError as e:
+        return {"path": path, "restored": False, "error": str(e)}
+    return {"path": path, "restored": True, "backup": backup}
+
+
+# ---------------------------------------------------------------- cli
+
+def fmt_human(report: FileReport) -> str:
+    lines = [f"{report.path}: score {report.score}/100 ({report.label})"]
+    for f in report.findings:
+        lines.append(f"  L{f.line} [{f.rule}] {f.message}")
+    if not report.findings:
+        lines.append("  no slop detected")
+    return "\n".join(lines)
+
+
+def fmt_fix_human(res: dict, dry_run: bool) -> str:
+    if not res["fix_count"]:
+        return f"{res['path']}: no fixes needed (score {res['score_before']}/100)"
+    bits = ", ".join(f"{rule} x{n}" for rule, n in sorted(res["fixes"].items()))
+    head = (f"{res['path']}: {res['fix_count']} fixes "
+            f"({bits}) — score {res['score_before']} -> {res['score_after']}")
+    if dry_run:
+        head += " [dry-run, nothing written]"
+    elif res["wrote"]:
+        head += f" [applied, backup: {res['backup']}]"
+    return head + "\n" + res["diff"]
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(
+        prog="css-slop",
+        description="Score CSS/HTML for AI-generated design cliches "
+                    "(v2: --fix rewrites the slop automatically).")
+    ap.add_argument("paths", nargs="+", help="CSS or HTML files to scan")
+    ap.add_argument("--json", action="store_true", help="emit JSON report")
+    ap.add_argument("--fail-over", type=int, default=None, metavar="N",
+                    help="exit 1 if any file scores N or higher")
+    ap.add_argument("--fix", action="store_true",
+                    help="apply automatic de-slop rewrites (backs up originals)")
+    ap.add_argument("--dry-run", action="store_true",
+                    help="preview fixes as a diff without writing anything")
+    ap.add_argument("--restore", action="store_true",
+                    help="restore files from their --fix backups")
+    ap.add_argument("--backup-suffix", default=".bak", metavar="SUFFIX",
+                    help="backup file suffix for --fix (default: .bak)")
+    ap.add_argument("--version", action="store_true",
+                    help="print version and exit")
+    args = ap.parse_args(argv)
+
+    if args.version:
+        print(f"css-slop-detector {VERSION}")
+        return 0
+
+    if args.restore:
+        results = [restore_file(p, args.backup_suffix) for p in args.paths]
+        if args.json:
+            print(json.dumps(results, indent=2))
+        else:
+            for r in results:
+                if r["restored"]:
+                    print(f"{r['path']}: restored from {r['backup']}")
+                else:
+                    print(f"{r['path']}: restore failed: {r.get('error')}",
+                          file=sys.stderr)
+        return 0 if all(r["restored"] for r in results) else 2
+
+    if args.fix or args.dry_run:
+        results = []
+        for p in args.paths:
+            try:
+                results.append(fix_file(p, dry_run=args.dry_run,
+                                        backup_suffix=args.backup_suffix))
+            except OSError as e:
+                print(f"error: {p}: {e}", file=sys.stderr)
+                return 2
+        if args.json:
+            print(json.dumps([{k: v for k, v in r.items() if k != "diff"}
+                              for r in results], indent=2))
+        else:
+            print("\n\n".join(fmt_fix_human(r, args.dry_run)
+                              for r in results))
+        if args.fail_over is not None and any(
+                r["score_after"] >= args.fail_over for r in results):
+            return 1
+        return 0
+
+    reports = []
+    for p in args.paths:
+        try:
+            reports.append(scan_path(p))
+        except OSError as e:
+            print(f"error: {p}: {e}", file=sys.stderr)
+            return 2
+
+    if args.json:
+        print(json.dumps([
+            {"path": r.path, "score": r.score, "label": r.label,
+             "findings": [{"rule": f.rule, "line": f.line,
+                           "message": f.message, "weight": f.weight}
+                          for f in r.findings]}
+            for r in reports], indent=2))
+    else:
+        print("\n\n".join(fmt_human(r) for r in reports))
+
+    if args.fail_over is not None and any(r.score >= args.fail_over for r in reports):
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

css_slop_detector-0.2.0.dist-info/METADATA

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: css-slop-detector
+Version: 0.2.0
+Summary: Score CSS/HTML for AI-generated design cliches — and auto-fix them with --fix
+Author-email: hao li <haoli5933@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/hahahahahahahahah6/css-slop-detector
+Project-URL: Repository, https://github.com/hahahahahahahahah6/css-slop-detector
+Keywords: css,ai-slop,design,linter,html
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# css-slop-detector
+
+Score your CSS/HTML for **AI-generated design cliches** — the "AI slop" look:
+oversized border radii, glassmorphism on everything, purple gradients, neon
+glows, pure-black dark mode with no light toggle, and giant centered hero
+titles.
+
+If AI built your site, this tells you in one number how obvious it is.
+**v2 adds `--fix`: a one-click detect-and-fix loop that rewrites the slop
+for you** (with backups and dry-run diff previews).
+
+Zero dependencies. Python standard library only.
+
+## Install
+
+```bash
+pip install css-slop-detector
+```
+
+Or run the single file straight from the repo:
+
+```bash
+git clone https://github.com/hahahahahahahahah6/css-slop-detector
+cd css-slop-detector
+python3 css_slop.py scan style.css
+```
+
+Requires Python 3.9+.
+
+## Usage
+
+### Scan
+
+```bash
+$ css-slop styles.css
+styles.css: score 68/100 (slop)
+  L12 [big-radius] oversized border-radius (32px) on '.card'
+  L12 [glass] backdrop-filter blur on '.card' (glassmorphism)
+  L15 [purple-gradient] purple/violet gradient on '.hero'
+  L22 [hero-center] giant centered title (font-size: 72px) on '.hero h1'
+  L1 [no-light-mode] dark-only design: near-black backgrounds with no
+     light-mode toggle or prefers-color-scheme: light found
+```
+
+Works on `.css` files and `.html` files (scans `<style>` blocks and inline
+`style="..."` attributes). Machine-readable output with `--json`; fail CI
+with `--fail-over 50` (exit 1 when any file scores 50 or higher).
+
+### Fix (v2)
+
+Preview what the fixer would change — writes nothing:
+
+```bash
+$ css-slop --dry-run styles.css
+styles.css: 7 fixes (big-radius x1, glass x1, glow-shadow x1, hero-center x1,
+  no-light-mode x1, pure-black x1, purple-gradient x2) — score 100 -> 0 [dry-run, nothing written]
+--- a/styles.css
++++ b/styles.css
+...
+```
+
+Apply the fixes. The original is backed up to `styles.css.bak` first:
+
+```bash
+$ css-slop --fix styles.css
+styles.css: 7 fixes (...) — score 100 -> 0 [applied, backup: styles.css.bak]
+
+$ css-slop --restore styles.css   # undo: restore the backup
+```
+
+What `--fix` rewrites (only patterns the scanner flags — it de-slops, it
+doesn't redesign):
+
+| rule | automatic rewrite |
+|---|---|
+| `big-radius` | clamp `border-radius` ≥ 20px to `12px` |
+| `glass` | remove `backdrop-filter: blur(...)` |
+| `purple-gradient` | swap purple/violet stops for neutral slate |
+| `glow-shadow` | replace neon glow with a soft `0 4px 6px rgba(0,0,0,0.1)` shadow |
+| `pure-black` | lift `#000` surfaces to soft `#1e1e1e` |
+| `hero-center` | shrink giant centered titles to `32px`, left-align |
+| `no-light-mode` | append a `prefers-color-scheme: light` hook block |
+
+## Rules
+
+| rule | what it flags |
+|---|---|
+| `big-radius` | `border-radius` ≥ 20px |
+| `glass` | `backdrop-filter: blur` |
+| `purple-gradient` | purple/violet/indigo/fuchsia gradients |
+| `glow-shadow` | colored `box-shadow` with blur ≥ 24px |
+| `pure-black` | `#000`-style backgrounds |
+| `hero-center` | `text-align: center` + `font-size` ≥ 40px in one rule |
+| `no-light-mode` | dark-only design, no light-mode toggle found |
+
+Scores: 0–20 clean, 21–50 mild slop, 51–80 slop, 81–100 peak slop.
+
+## Differentiation
+
+**Generation side vs. detection+fix side.** Tools like
+[pbakaus/impeccable](https://github.com/pbakaus/impeccable) (and design-skill
+collections like ui-skills or hallmark) teach AI to *generate* better design —
+they improve the prompt. This does the opposite: it scores the *finished
+product's* AI fingerprints, then **closes the loop with one command** —
+`--fix` rewrites the flagged patterns for you, with a diff preview, automatic
+backups, and `--restore` to undo. Detect + fix, not just detect.
+
+One file, no dependencies, runs in CI.
+
+## License
+
+MIT

css_slop_detector-0.2.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+css_slop.py,sha256=6BRXJyif0SVi-cnKtwpX7qfH4Xohzfb6zvrfIPccUz8,21964
+css_slop_detector-0.2.0.dist-info/licenses/LICENSE,sha256=OYhQDg7nxWoFtnF6J8NkFUA8NMw5TKv9a1WTXHY-fu4,1063
+css_slop_detector-0.2.0.dist-info/METADATA,sha256=Kml_mzU9neU19mn05aDAofYd7sIk2DX2EftO5rfxZTA,4541
+css_slop_detector-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+css_slop_detector-0.2.0.dist-info/entry_points.txt,sha256=Wv_HTOP1dPIeJNfArMZbpFM4rMypnDsAtcx3T3y6xX4,43
+css_slop_detector-0.2.0.dist-info/top_level.txt,sha256=K30ntcnqzEHsYnxdw6fI7Q88onJFX_gX6zkrtxel_ak,9
+css_slop_detector-0.2.0.dist-info/RECORD,,

css_slop_detector-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

css_slop_detector-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+css-slop = css_slop:main

css_slop_detector-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hao li
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

css_slop_detector-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+css_slop