@gessobuild/anti-slop 0.4.2

package/dist/engine.js

@@ -0,0 +1,138 @@
+// Anti-slop: engine.
+//
+// Three generic operations over a rule registry:
+//   - runSlopGuard:              detect -> { pass, issues, severity, counts }
+//   - applySlopFixes:            run every FIX/BASE rule's deterministic rewrite
+//   - buildSlopConstraintsBlock: render the prevention text for a prompt
+//
+// Every rule call is wrapped in try/catch: a buggy regex must never break a
+// live generation; it degrades to "no hits" / "no fix".
+/** Per-rule severity is capped so one runaway pattern can't dwarf the others. */
+export const PER_RULE_SEVERITY_CAP = 4;
+// Hit details quote evidence from the scanned document, which is untrusted
+// input that ends up embedded in reports, agent context, and retry prompts.
+// Bound what an author of a hostile document can smuggle through: collapse
+// control characters and newlines, and cap the excerpt length.
+const DETAIL_MAX_LENGTH = 80;
+function sanitizeDetail(detail) {
+    const flat = detail
+        .replace(/[\u0000-\u001f\u007f\u2028\u2029]+/g, " ")
+        .replace(/\s{2,}/g, " ")
+        .trim();
+    return flat.length > DETAIL_MAX_LENGTH
+        ? `${flat.slice(0, DETAIL_MAX_LENGTH)}...`
+        : flat;
+}
+function isSanctioned(rule, ctx) {
+    try {
+        return rule.sanctionedBy?.(ctx.styleRef, ctx) ?? false;
+    }
+    catch {
+        return false;
+    }
+}
+function activeRules(ctx, rules) {
+    return rules.filter((r) => !isSanctioned(r, ctx));
+}
+/**
+ * Detect slop in generated HTML. Severity-scored for a retry comparator;
+ * style-aware via each rule's sanctionedBy().
+ */
+export function runSlopGuard(html, ctx, rules) {
+    const issues = [];
+    const byRule = {};
+    let severity = 0;
+    let gatingTotal = 0;
+    for (const rule of activeRules(ctx, rules)) {
+        // "base" rules inject a base-style default; their absence is not a defect,
+        // so they never count toward pass/severity/issues (only applySlopFixes
+        // consumes their detect()).
+        if (rule.tier === "base")
+            continue;
+        let hits;
+        try {
+            hits = rule.detect(html, ctx);
+        }
+        catch {
+            hits = [];
+        }
+        if (hits.length === 0)
+            continue;
+        byRule[rule.id] = hits.length;
+        // "flag" rules are advisory by contract (see SlopTier): they are reported
+        // in issues and counted in byRule for telemetry, but they never gate the
+        // verdict or feed the retry comparator's severity.
+        const advisory = rule.tier === "flag";
+        if (!advisory) {
+            gatingTotal += hits.length;
+            severity += Math.min(PER_RULE_SEVERITY_CAP, hits.length * rule.severity);
+        }
+        const examples = hits.slice(0, 3).map((h) => sanitizeDetail(h.detail));
+        issues.push(`[${rule.category}/${rule.id}]${advisory ? " [advisory]" : ""} ${hits.length}x: ${rule.tell}` +
+            (examples.length > 0 ? ` (e.g. ${examples.join("; ")})` : ""));
+    }
+    const total = Object.values(byRule).reduce((a, b) => a + b, 0);
+    return { pass: gatingTotal === 0, issues, severity, counts: { byRule, total } };
+}
+/**
+ * Apply every FIX/BASE-tier rule's deterministic rewrite. Idempotent:
+ * re-running on already-clean HTML is a no-op. A fixer that throws leaves
+ * the HTML untouched (a guard must never break generation).
+ */
+export function applySlopFixes(html, ctx, rules) {
+    let working = html;
+    const fixes = {};
+    for (const rule of activeRules(ctx, rules)) {
+        if ((rule.tier !== "fix" && rule.tier !== "base") || !rule.fix)
+            continue;
+        let before = 0;
+        try {
+            before = rule.detect(working, ctx).length;
+        }
+        catch {
+            before = 0;
+        }
+        if (before === 0)
+            continue;
+        try {
+            const next = rule.fix(working, ctx);
+            if (next !== working) {
+                working = next;
+                fixes[rule.id] = before;
+            }
+        }
+        catch {
+            // Leave the HTML as-is on any fixer error.
+        }
+    }
+    const total = Object.values(fixes).reduce((a, b) => a + b, 0);
+    return { html: working, fixes, total };
+}
+/**
+ * Render the prevention block for a system prompt. Drops rules the active
+ * style legitimately sanctions, so the prompt never contradicts the style
+ * reference.
+ */
+export function buildSlopConstraintsBlock(styleRef, rules) {
+    const active = rules.filter((r) => !isSanctioned(r, { styleRef }));
+    const byCat = new Map();
+    for (const r of active) {
+        const arr = byCat.get(r.category) ?? [];
+        arr.push(`- ${r.prevention}`);
+        byCat.set(r.category, arr);
+    }
+    const sections = [...byCat.entries()].map(([cat, lines]) => `${cat.toUpperCase()}:\n${lines.join("\n")}`);
+    return [
+        "AI-SLOP GUARD (these patterns are auto-detected/auto-fixed after generation, avoid them up front):",
+        ...sections,
+    ].join("\n\n");
+}
+/** Corrective message for a retry path. */
+export function buildSlopCorrectionPrompt(check) {
+    return [
+        "Your previous output tripped the AI-slop guard:",
+        ...check.issues.map((i) => `- ${i}`),
+        "",
+        "Re-emit the screen with these patterns removed. Keep every other design decision intact.",
+    ].join("\n");
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { applySlopFixes, buildSlopConstraintsBlock, buildSlopCorrectionPrompt, PER_RULE_SEVERITY_CAP, runSlopGuard, } from "./engine.js";
+export { FLAGSHIP_RULES } from "./rules.js";
+export type { SlopCategory, SlopCheck, SlopCtx, SlopCtxLike, SlopFixResult, SlopHit, SlopRule, SlopStyleHints, SlopTier, } from "./types.js";

package/dist/index.js

@@ -0,0 +1,13 @@
+// @gessobuild/anti-slop: deterministic AI-slop detection and fixing for
+// generated HTML/CSS.
+//
+//   import { runSlopGuard, applySlopFixes, FLAGSHIP_RULES } from "@gessobuild/anti-slop"
+//
+//   const check = runSlopGuard(html, {}, FLAGSHIP_RULES)   // detect
+//   const fixed = applySlopFixes(html, {}, FLAGSHIP_RULES) // rewrite
+//
+// The engine is generic over the rule context, so hosts can register their
+// own rules with richer style/token types alongside (or instead of) the
+// flagship registry.
+export { applySlopFixes, buildSlopConstraintsBlock, buildSlopCorrectionPrompt, PER_RULE_SEVERITY_CAP, runSlopGuard, } from "./engine.js";
+export { FLAGSHIP_RULES } from "./rules.js";

package/dist/rules.d.ts

@@ -0,0 +1,2 @@
+import type { SlopCtx, SlopRule } from "./types.js";
+export declare const FLAGSHIP_RULES: SlopRule<SlopCtx>[];