@empline/preflight 1.0.20

package/dist/checks/organization/steering-bloat-prevention.js

@@ -0,0 +1,1197 @@
+"use strict";
+/**
+ * Steering Quality & Bloat Prevention Preflight
+ *
+ * Ensures optimal agent steering quality and prevents token bloat:
+ *
+ * QUALITY CHECKS:
+ * - Front matter validation (inclusion, loadWith, lastUpdated)
+ * - Cross-reference integrity (no broken #references)
+ * - README index completeness (all files listed)
+ * - Best practices compliance
+ * - Date validation (future dates, invalid formats)
+ *
+ * BLOAT PREVENTION:
+ * - ASCII art diagrams (decorative boxes)
+ * - Verbose code examples (>25 lines)
+ * - Duplicate information across files
+ * - Always-loaded files that should be manual
+ * - Content redundancy between files
+ * - Redundant preflight commands
+ *
+ * DRIFT PREVENTION:
+ * - Orphaned files (not in README index)
+ * - Stale lastUpdated dates (>90 days)
+ * - Missing cross-references
+ * - Token budget trend tracking
+ * - Cross-reference dependency graph
+ *
+ * COST OPTIMIZATION:
+ * - Token budget tracking with historical trends
+ * - Always-loaded content minimization
+ * - Redundancy elimination suggestions
+ * - Whitelisted large files (comprehensive references)
+ *
+ * Run: pnpm preflight:steering-quality
+ *      pnpm preflight:steering-quality --fix (auto-fix suggestions)
+ *      pnpm preflight:steering-quality --graph (show dependency graph)
+ * Created: 2025-12-26
+ * Enhanced: 2026-01-04
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tags = exports.description = exports.blocking = exports.category = exports.name = exports.id = void 0;
+exports.validateSteeringQuality = validateSteeringQuality;
+exports.validateSteeringBloat = validateSteeringQuality;
+const fs_1 = __importDefault(require("fs"));
+const glob_1 = require("glob");
+const path_1 = __importDefault(require("path"));
+const console_chars_1 = require("../../utils/console-chars");
+// Check metadata
+exports.id = "organization/steering-bloat-prevention";
+exports.name = "Steering Bloat Prevention";
+exports.category = "organization";
+exports.blocking = false;
+exports.description = "Steering Quality & Bloat Prevention Preflight";
+exports.tags = ["organization"];
+// CONFIGURATION
+const CONFIG = {
+    // Token limits (approximate - 1 token ≈ 4 chars)
+    MAX_ALWAYS_LOADED_TOKENS: 2000,
+    MAX_SINGLE_FILE_TOKENS: 8000,
+    WARN_FILE_TOKENS: 5000,
+    // Line limits
+    MAX_ALWAYS_LOADED_LINES: 150,
+    MAX_MANUAL_FILE_LINES: 500,
+    WARN_FILE_LINES: 400,
+    // Code block limits
+    MAX_CODE_BLOCK_LINES: 25,
+    WARN_CODE_BLOCK_LINES: 22,
+    // Staleness (days)
+    STALE_THRESHOLD_DAYS: 90,
+    // Similarity threshold for redundancy
+    SIMILARITY_THRESHOLD: 0.7,
+    // Token trend threshold (percentage)
+    TOKEN_TREND_WARN_THRESHOLD: 5,
+    // Files that should always be in README index
+    REQUIRED_INDEX_ENTRIES: ["core-rules.md", "quick-decisions.md", "preflight-reference.md"],
+    // Whitelisted large files (intentionally comprehensive)
+    WHITELISTED_LARGE_FILES: [
+        "all-rules.md", // Comprehensive 75-rule reference
+        "database-guide.md", // Comprehensive Prisma guide
+        "CHANGELOG.md", // Historical record
+    ],
+    // Canonical files for specific content
+    CANONICAL_CONTENT: {
+        "order-status": "business-operations.md",
+        "payment-flow": "business-operations.md",
+        "seller-setup": "business-operations.md",
+        "preflight-commands": "preflight-reference.md",
+        "component-patterns": "components-guide.md",
+        "ui-styling": "ui-guide.md",
+        "database-patterns": "database-guide.md",
+        "schema-updates": "database-guide.md",
+        "regression-tests": "e2e-testing.md",
+        "e2e-tests": "e2e-testing.md",
+        "design-system": "components-guide.md",
+        "listing-workflow": "business-workflows.md",
+    },
+    // Workflow files should only be index/reference (not duplicates)
+    WORKFLOW_MAX_LINES: 150,
+    WORKFLOW_DIR: ".kiro/steering/workflows/",
+    // Token history file
+    TOKEN_HISTORY_FILE: ".kiro/steering/.token-history.json",
+};
+// MAIN VALIDATION FUNCTION
+async function validateSteeringQuality(options = {}) {
+    const issues = [];
+    const contentBlocks = [];
+    // Load all steering files
+    const steeringFiles = await loadSteeringFiles();
+    // Load README for index validation
+    const readmeContent = fs_1.default.existsSync(".kiro/steering/README.md")
+        ? fs_1.default.readFileSync(".kiro/steering/README.md", "utf-8")
+        : "";
+    // Calculate token budget
+    const tokenBudget = calculateTokenBudget(steeringFiles);
+    // Build cross-reference graph
+    const graph = buildCrossRefGraph(steeringFiles);
+    // Run all validation checks
+    for (const file of steeringFiles) {
+        // Quality checks
+        validateFrontMatter(file, issues);
+        validateFrontMatterDate(file, issues);
+        validateCrossReferences(file, steeringFiles, issues);
+        checkBestPractices(file, issues);
+        // Bloat prevention
+        checkAsciiArt(file, issues);
+        checkVerboseCode(file, issues);
+        checkFileLength(file, issues);
+        checkDuplicateContent(file, issues);
+        // Workflow redundancy check
+        checkWorkflowRedundancy(file, steeringFiles, issues);
+        // Drift prevention
+        checkStaleness(file, issues);
+        checkIndexPresence(file, readmeContent, issues);
+        // Extract content blocks for cross-file analysis
+        extractContentBlocks(file, contentBlocks);
+    }
+    // Cross-file analysis
+    analyzeContentRedundancy(contentBlocks, issues);
+    analyzePreflightRedundancy(contentBlocks, issues);
+    // Token budget validation (with whitelist)
+    validateTokenBudget(tokenBudget, issues);
+    // Check README completeness
+    validateReadmeIndex(steeringFiles, readmeContent, issues);
+    // Analyze cross-reference graph for orphans
+    analyzeGraphForOrphans(graph, steeringFiles, issues);
+    // Check token trends
+    const tokenTrend = await checkTokenTrend(tokenBudget, steeringFiles, issues);
+    // Save current token history
+    await saveTokenHistory(tokenBudget, steeringFiles);
+    // Calculate stats
+    const alwaysLoadedFiles = steeringFiles.filter((f) => f.frontMatter?.inclusion === "always");
+    return {
+        errors: issues.filter((i) => i.severity === "error"),
+        warnings: issues.filter((i) => i.severity === "warning"),
+        info: issues.filter((i) => i.severity === "info"),
+        stats: {
+            totalFiles: steeringFiles.length,
+            alwaysLoadedFiles: alwaysLoadedFiles.length,
+            totalTokens: tokenBudget.total,
+            alwaysLoadedTokens: tokenBudget.alwaysLoaded,
+            tokenTrend,
+        },
+        graph: options.showGraph ? graph : undefined,
+    };
+}
+// FILE LOADING
+async function loadSteeringFiles() {
+    const filePaths = await (0, glob_1.glob)(".kiro/steering/*.md");
+    // Also load workflow files for redundancy checking
+    const workflowPaths = await (0, glob_1.glob)(".kiro/steering/workflows/*.md");
+    const allPaths = [...filePaths, ...workflowPaths];
+    return allPaths.map((filePath) => {
+        const content = fs_1.default.readFileSync(filePath, "utf-8");
+        const lines = content.split("\n");
+        const frontMatter = parseFrontMatter(content);
+        const tokenEstimate = Math.ceil(content.length / 4);
+        return {
+            path: filePath,
+            name: path_1.default.basename(filePath),
+            content,
+            lines,
+            frontMatter,
+            lineCount: lines.length,
+            tokenEstimate,
+        };
+    });
+}
+function parseFrontMatter(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return null;
+    const yaml = match[1];
+    const inclusion = yaml.match(/inclusion:\s*(always|manual|fileMatch)/)?.[1];
+    const loadWith = yaml.match(/loadWith:\s*["']?([^"'\n]+)["']?/)?.[1];
+    const lastUpdated = yaml.match(/lastUpdated:\s*(\d{4}-\d{2}-\d{2})/)?.[1];
+    const fileMatchPattern = yaml.match(/fileMatchPattern:\s*["']?([^"'\n]+)["']?/)?.[1];
+    if (!inclusion)
+        return null;
+    return { inclusion, loadWith, lastUpdated, fileMatchPattern };
+}
+function calculateTokenBudget(files) {
+    const budget = {
+        alwaysLoaded: 0,
+        manualFiles: new Map(),
+        total: 0,
+    };
+    for (const file of files) {
+        budget.total += file.tokenEstimate;
+        if (file.frontMatter?.inclusion === "always") {
+            budget.alwaysLoaded += file.tokenEstimate;
+        }
+        else {
+            budget.manualFiles.set(file.name, file.tokenEstimate);
+        }
+    }
+    return budget;
+}
+// CROSS-REFERENCE GRAPH
+function buildCrossRefGraph(files) {
+    const nodes = files.map((f) => f.name);
+    const edges = [];
+    const incomingCount = new Map();
+    const outgoingCount = new Map();
+    // Initialize counts
+    for (const node of nodes) {
+        incomingCount.set(node, 0);
+        outgoingCount.set(node, 0);
+    }
+    for (const file of files) {
+        // Create new regex for each file to reset lastIndex
+        // Match #reference followed by whitespace, backtick, end, paren, pipe, or bracket
+        // Note: hyphen must be at end of character class or escaped
+        const refPattern = /#([a-z][a-z0-9-]*)(?=[\s`|)\]]|$)/g;
+        let match;
+        const seenRefs = new Set();
+        while ((match = refPattern.exec(file.content)) !== null) {
+            const ref = match[1];
+            if (seenRefs.has(ref))
+                continue;
+            seenRefs.add(ref);
+            // Find target file
+            const targetFile = files.find((f) => f.name === `${ref}.md` || f.frontMatter?.loadWith === `#${ref}`);
+            if (targetFile && targetFile.name !== file.name) {
+                edges.push({ from: file.name, to: targetFile.name });
+                outgoingCount.set(file.name, (outgoingCount.get(file.name) || 0) + 1);
+                incomingCount.set(targetFile.name, (incomingCount.get(targetFile.name) || 0) + 1);
+            }
+        }
+    }
+    return { nodes, edges, incomingCount, outgoingCount };
+}
+function analyzeGraphForOrphans(graph, files, issues) {
+    // Find files with no incoming references (except README and core-rules)
+    const exemptFiles = ["README.md", "core-rules.md", "CHANGELOG.md"];
+    for (const [fileName, count] of graph.incomingCount) {
+        if (count === 0 && !exemptFiles.includes(fileName)) {
+            const file = files.find((f) => f.name === fileName);
+            if (file && file.frontMatter?.inclusion !== "always") {
+                issues.push({
+                    file: `.kiro/steering/${fileName}`,
+                    line: 1,
+                    type: "orphaned-file",
+                    message: `No incoming cross-references. Consider adding references from related guides.`,
+                    severity: "info",
+                    suggestion: `Add #${fileName.replace(".md", "")} reference in related steering files.`,
+                });
+            }
+        }
+    }
+}
+// TOKEN TREND TRACKING
+async function loadTokenHistory() {
+    try {
+        if (fs_1.default.existsSync(CONFIG.TOKEN_HISTORY_FILE)) {
+            const content = fs_1.default.readFileSync(CONFIG.TOKEN_HISTORY_FILE, "utf-8");
+            return JSON.parse(content);
+        }
+    }
+    catch {
+        // Ignore errors, return empty history
+    }
+    return [];
+}
+async function saveTokenHistory(budget, files) {
+    const history = await loadTokenHistory();
+    const entry = {
+        timestamp: new Date().toISOString(),
+        totalTokens: budget.total,
+        alwaysLoadedTokens: budget.alwaysLoaded,
+        fileCount: files.length,
+        files: Object.fromEntries(files.map((f) => [f.name, f.tokenEstimate])),
+    };
+    // Keep last 30 entries
+    history.push(entry);
+    if (history.length > 30) {
+        history.splice(0, history.length - 30);
+    }
+    // Ensure directory exists
+    const dir = path_1.default.dirname(CONFIG.TOKEN_HISTORY_FILE);
+    if (!fs_1.default.existsSync(dir)) {
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+    fs_1.default.writeFileSync(CONFIG.TOKEN_HISTORY_FILE, JSON.stringify(history, null, 2));
+}
+async function checkTokenTrend(budget, files, issues) {
+    const history = await loadTokenHistory();
+    if (history.length === 0) {
+        return undefined;
+    }
+    const lastEntry = history[history.length - 1];
+    const change = ((budget.total - lastEntry.totalTokens) / lastEntry.totalTokens) * 100;
+    let direction = "stable";
+    if (change > CONFIG.TOKEN_TREND_WARN_THRESHOLD) {
+        direction = "up";
+        issues.push({
+            file: ".kiro/steering/",
+            line: 1,
+            type: "token-trend",
+            message: `Token count increased by ${change.toFixed(1)}% since last check (${lastEntry.totalTokens} → ${budget.total}).`,
+            severity: "warning",
+            suggestion: "Review recent changes for unnecessary content growth.",
+        });
+    }
+    else if (change < -CONFIG.TOKEN_TREND_WARN_THRESHOLD) {
+        direction = "down";
+    }
+    // Check individual file growth
+    for (const file of files) {
+        const previousTokens = lastEntry.files[file.name];
+        if (previousTokens) {
+            const fileChange = ((file.tokenEstimate - previousTokens) / previousTokens) * 100;
+            if (fileChange > 20) {
+                issues.push({
+                    file: file.path,
+                    line: 1,
+                    type: "token-trend",
+                    message: `File grew by ${fileChange.toFixed(1)}% (${previousTokens} → ${file.tokenEstimate} tokens).`,
+                    severity: "info",
+                    suggestion: "Review recent additions for consolidation opportunities.",
+                });
+            }
+        }
+    }
+    return { change: Math.round(change * 10) / 10, direction };
+}
+// FRONT MATTER VALIDATION
+function validateFrontMatter(file, issues) {
+    if (!file.frontMatter) {
+        issues.push({
+            file: file.path,
+            line: 1,
+            type: "missing-frontmatter",
+            message: "Missing front matter. Add inclusion, loadWith, and lastUpdated fields.",
+            severity: "error",
+            suggestion: `---\ninclusion: manual\nloadWith: "#${file.name.replace(".md", "")}"\nlastUpdated: ${new Date().toISOString().split("T")[0]}\n---`,
+            autoFixable: true,
+        });
+        return;
+    }
+    if (file.frontMatter.inclusion === "manual" && !file.frontMatter.loadWith) {
+        issues.push({
+            file: file.path,
+            line: 1,
+            type: "missing-frontmatter",
+            message: 'Manual inclusion file missing "loadWith" field.',
+            severity: "warning",
+            suggestion: `loadWith: "#${file.name.replace(".md", "")}"`,
+            autoFixable: true,
+        });
+    }
+    if (!file.frontMatter.lastUpdated) {
+        issues.push({
+            file: file.path,
+            line: 1,
+            type: "missing-frontmatter",
+            message: 'Missing "lastUpdated" field for tracking staleness.',
+            severity: "warning",
+            suggestion: `lastUpdated: ${new Date().toISOString().split("T")[0]}`,
+            autoFixable: true,
+        });
+    }
+    if (file.frontMatter.inclusion === "fileMatch" && !file.frontMatter.fileMatchPattern) {
+        issues.push({
+            file: file.path,
+            line: 1,
+            type: "missing-frontmatter",
+            message: 'fileMatch inclusion requires "fileMatchPattern" field.',
+            severity: "error",
+        });
+    }
+}
+function validateFrontMatterDate(file, issues) {
+    if (!file.frontMatter?.lastUpdated)
+        return;
+    const dateStr = file.frontMatter.lastUpdated;
+    // Validate date format (YYYY-MM-DD)
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) {
+        issues.push({
+            file: file.path,
+            line: 1,
+            type: "invalid-date",
+            message: `Invalid date format "${dateStr}". Use YYYY-MM-DD format.`,
+            severity: "error",
+            suggestion: `lastUpdated: ${new Date().toISOString().split("T")[0]}`,
+            autoFixable: true,
+        });
+        return;
+    }
+    // Parse and validate date
+    const date = new Date(dateStr);
+    if (isNaN(date.getTime())) {
+        issues.push({
+            file: file.path,
+            line: 1,
+            type: "invalid-date",
+            message: `Invalid date "${dateStr}". Check month/day values.`,
+            severity: "error",
+            suggestion: `lastUpdated: ${new Date().toISOString().split("T")[0]}`,
+            autoFixable: true,
+        });
+        return;
+    }
+    // Check for future dates
+    const now = new Date();
+    now.setHours(23, 59, 59, 999); // End of today
+    if (date > now) {
+        issues.push({
+            file: file.path,
+            line: 1,
+            type: "invalid-date",
+            message: `Future date "${dateStr}" detected. lastUpdated should be today or earlier.`,
+            severity: "warning",
+            suggestion: `lastUpdated: ${new Date().toISOString().split("T")[0]}`,
+            autoFixable: true,
+        });
+    }
+}
+// CROSS-REFERENCE VALIDATION
+function validateCrossReferences(file, allFiles, issues) {
+    // Skip references inside code blocks
+    const codeBlockRanges = [];
+    const codeBlockPattern = /```[\s\S]*?```/g;
+    let codeMatch;
+    while ((codeMatch = codeBlockPattern.exec(file.content)) !== null) {
+        codeBlockRanges.push({
+            start: codeMatch.index,
+            end: codeMatch.index + codeMatch[0].length,
+        });
+    }
+    const isInCodeBlock = (index) => {
+        return codeBlockRanges.some((range) => index >= range.start && index < range.end);
+    };
+    // Example patterns that should be skipped
+    const examplePatterns = ["filename", "cross-reference", "category"];
+    // Historical references (consolidated files)
+    const historicalRefs = [
+        "payment-workflows",
+        "order-lifecycle",
+        "seller-onboarding",
+        "changelog-historical",
+        "ui-styling",
+        "ui-quality-checks",
+        "ui-spacing-standards",
+    ];
+    const refPattern = /#([a-z-]+)(?:\s|`|$|\))/g;
+    let match;
+    while ((match = refPattern.exec(file.content)) !== null) {
+        const ref = match[1];
+        if (isInCodeBlock(match.index))
+            continue;
+        if (["if", "else", "endif", "define", "include", "pragma"].includes(ref))
+            continue;
+        if (examplePatterns.includes(ref))
+            continue;
+        const targetFile = allFiles.find((f) => f.name === `${ref}.md` || f.frontMatter?.loadWith === `#${ref}`);
+        if (!targetFile) {
+            const lineNum = file.content.substring(0, match.index).split("\n").length;
+            const isHistorical = historicalRefs.includes(ref);
+            const isInChangelog = file.name === "CHANGELOG.md";
+            if (isHistorical && isInChangelog) {
+                // Historical references in CHANGELOG are intentional - don't report
+                continue;
+            }
+            else if (isHistorical) {
+                issues.push({
+                    file: file.path,
+                    line: lineNum,
+                    type: "broken-reference",
+                    message: `Outdated reference "#${ref}" - file was consolidated.`,
+                    severity: "warning",
+                    suggestion: `Update to #business-operations or #ui-guide.`,
+                    autoFixable: true,
+                });
+            }
+            else {
+                issues.push({
+                    file: file.path,
+                    line: lineNum,
+                    type: "broken-reference",
+                    message: `Broken cross-reference "#${ref}" - no matching file found.`,
+                    severity: "error",
+                    suggestion: `Check if ${ref}.md exists or update the reference.`,
+                });
+            }
+        }
+    }
+}
+// BEST PRACTICES
+function checkBestPractices(file, issues) {
+    const fileName = file.name;
+    // Skip whitelisted files for best practice suggestions
+    if (CONFIG.WHITELISTED_LARGE_FILES.includes(fileName))
+        return;
+    // Tables vs lists
+    const listItemCount = (file.content.match(/^- /gm) || []).length;
+    const tableCount = (file.content.match(/^\|/gm) || []).length;
+    if (listItemCount > 20 && tableCount < 5 && !fileName.includes("CHANGELOG")) {
+        issues.push({
+            file: file.path,
+            line: 1,
+            type: "best-practice",
+            message: `${listItemCount} list items but only ${tableCount} table rows. Consider tables.`,
+            severity: "info",
+            suggestion: "Tables are more token-efficient and scannable.",
+        });
+    }
+    // Duplicate patterns - only flag if file doesn't already cross-reference the canonical source
+    const duplicatePatterns = [
+        {
+            pattern: /pnpm preflight:[a-z:-]+/g,
+            canonical: "preflight-reference.md",
+            topic: "preflight commands",
+            minMatches: 5,
+        },
+        {
+            pattern: /PENDING.*PAID.*SHIPPED/s,
+            canonical: "business-operations.md",
+            topic: "order status",
+            minMatches: 1,
+        },
+        {
+            pattern: /PayPal.*webhook.*capture/s,
+            canonical: "business-operations.md",
+            topic: "payment flow",
+            minMatches: 1,
+        },
+    ];
+    for (const { pattern, canonical, topic, minMatches } of duplicatePatterns) {
+        if (pattern.test(file.content) && !file.name.includes(canonical.replace(".md", ""))) {
+            const matches = file.content.match(pattern);
+            if (matches && matches.length > minMatches) {
+                // Skip whitelisted files
+                if (CONFIG.WHITELISTED_LARGE_FILES.includes(file.name))
+                    continue;
+                // Skip if file already cross-references the canonical source
+                const canonicalRef = `#${canonical.replace(".md", "")}`;
+                if (file.content.includes(canonicalRef))
+                    continue;
+                // Skip README.md for preflight commands (it's an index)
+                if (file.name === "README.md" && topic === "preflight commands")
+                    continue;
+                issues.push({
+                    file: file.path,
+                    line: 1,
+                    type: "best-practice",
+                    message: `Multiple ${topic} references. Cross-reference #${canonical.replace(".md", "")} instead.`,
+                    severity: "info",
+                });
+            }
+        }
+    }
+    // Vague references - skip if in quotes (examples) or in code blocks
+    const vagueRefs = file.content.match(/[Ss]ee .+ for (more )?(details|information)/g) || [];
+    for (const ref of vagueRefs) {
+        if (!ref.includes("#") && !ref.includes(".md")) {
+            const lineNum = file.content.indexOf(ref);
+            const line = file.content.substring(0, lineNum).split("\n").length;
+            // Skip if this is in quotes (it's an example of what NOT to do)
+            const contextStart = Math.max(0, lineNum - 10);
+            const contextEnd = Math.min(file.content.length, lineNum + ref.length + 10);
+            const context = file.content.substring(contextStart, contextEnd);
+            if (context.includes(`"${ref}"`) ||
+                context.includes(`'${ref}'`) ||
+                context.includes(`\`${ref}\``)) {
+                continue;
+            }
+            issues.push({
+                file: file.path,
+                line,
+                type: "best-practice",
+                message: `Vague reference "${ref}". Use specific #cross-reference.`,
+                severity: "info",
+            });
+        }
+    }
+}
+// BLOAT DETECTION
+function checkAsciiArt(file, issues) {
+    for (let i = 0; i < file.lines.length; i++) {
+        const line = file.lines[i];
+        // Skip markdown table lines (start with | or contain | for cell separators)
+        // Tables use | which is valid markdown, not decorative ASCII art
+        if (/^\s*\|/.test(line) || /\|.*\|/.test(line)) {
+            continue;
+        }
+        // Detect Unicode box-drawing characters (single-line)
+        // ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ─ │
+        if (/[\u250c\u2510\u2514\u2518\u251c\u2524\u252c\u2534\u253c\u2500\u2502]{10,}/.test(line)) {
+            issues.push({
+                file: file.path,
+                line: i + 1,
+                type: "ascii-art",
+                message: "ASCII art diagram detected. Use simple text flow: A → B → C",
+                severity: "warning",
+                autoFixable: true,
+            });
+        }
+        // Detect Unicode box-drawing characters (double-line)
+        // ═ ║ ╔ ╗ ╚ ╝ ╠ ╣ ╦ ╩ ╬
+        if (/[\u2550\u2551\u2554\u2557\u255a\u255d\u2560\u2563\u2566\u2569\u256c]{5,}/.test(line)) {
+            issues.push({
+                file: file.path,
+                line: i + 1,
+                type: "ascii-art",
+                message: "Decorative double-line box characters detected. Simplify to plain text or table.",
+                severity: "warning",
+                autoFixable: true,
+            });
+        }
+        // Detect ASCII art using +, -, | patterns (but not markdown tables)
+        // Pattern: lines with multiple +---+ or |   | patterns that form boxes
+        if (/\+[-=]{3,}\+/.test(line) || /^\s*[-=]{10,}\s*$/.test(line)) {
+            issues.push({
+                file: file.path,
+                line: i + 1,
+                type: "ascii-art",
+                message: "ASCII box pattern detected. Use markdown tables or simple text.",
+                severity: "warning",
+                autoFixable: true,
+            });
+        }
+    }
+}
+function checkVerboseCode(file, issues) {
+    let inCodeBlock = false;
+    let codeBlockStart = 0;
+    let codeBlockLines = 0;
+    for (let i = 0; i < file.lines.length; i++) {
+        const line = file.lines[i];
+        if (line.startsWith("```")) {
+            if (inCodeBlock) {
+                if (codeBlockLines > CONFIG.MAX_CODE_BLOCK_LINES) {
+                    issues.push({
+                        file: file.path,
+                        line: codeBlockStart,
+                        type: "verbose-code",
+                        message: `Code block is ${codeBlockLines} lines (max ${CONFIG.MAX_CODE_BLOCK_LINES}). Condense to signature + comment.`,
+                        severity: "warning",
+                        autoFixable: true,
+                    });
+                }
+                else if (codeBlockLines > CONFIG.WARN_CODE_BLOCK_LINES) {
+                    issues.push({
+                        file: file.path,
+                        line: codeBlockStart,
+                        type: "verbose-code",
+                        message: `Code block is ${codeBlockLines} lines. Consider condensing.`,
+                        severity: "info",
+                    });
+                }
+                inCodeBlock = false;
+                codeBlockLines = 0;
+            }
+            else {
+                inCodeBlock = true;
+                codeBlockStart = i + 1;
+                codeBlockLines = 0;
+            }
+        }
+        else if (inCodeBlock) {
+            codeBlockLines++;
+        }
+    }
+}
+function checkFileLength(file, issues) {
+    const isAlwaysLoaded = file.frontMatter?.inclusion === "always";
+    const isWhitelisted = CONFIG.WHITELISTED_LARGE_FILES.includes(file.name);
+    // Always-loaded files have strict limits
+    if (isAlwaysLoaded && file.lineCount > CONFIG.MAX_ALWAYS_LOADED_LINES) {
+        issues.push({
+            file: file.path,
+            line: 1,
+            type: "wrong-inclusion",
+            message: `Always-loaded file has ${file.lineCount} lines (max ${CONFIG.MAX_ALWAYS_LOADED_LINES}). Change to manual or reduce.`,
+            severity: "error",
+        });
+    }
+    // Skip whitelisted files for length warnings
+    if (isWhitelisted)
+        return;
+    if (file.lineCount > CONFIG.MAX_MANUAL_FILE_LINES) {
+        issues.push({
+            file: file.path,
+            line: 1,
+            type: "verbose-code",
+            message: `File has ${file.lineCount} lines (max ${CONFIG.MAX_MANUAL_FILE_LINES}). Consider splitting.`,
+            severity: "warning",
+        });
+    }
+    else if (file.lineCount > CONFIG.WARN_FILE_LINES) {
+        issues.push({
+            file: file.path,
+            line: 1,
+            type: "verbose-code",
+            message: `File has ${file.lineCount} lines. Monitor for growth.`,
+            severity: "info",
+        });
+    }
+}
+function checkDuplicateContent(file, issues) {
+    // Skip whitelisted files
+    if (CONFIG.WHITELISTED_LARGE_FILES.includes(file.name))
+        return;
+    if (file.name === "quick-decisions.md")
+        return;
+    const content = file.content.toLowerCase();
+    const contentChecks = [
+        {
+            patterns: ["pending", "paid", "shipped", "delivered", "cancelled"],
+            minMatches: 4,
+            canonical: "business-operations.md",
+            topic: "order status",
+        },
+        {
+            patterns: ["paypal", "webhook", "capture", "refund"],
+            minMatches: 3,
+            canonical: "business-operations.md",
+            topic: "payment flow",
+        },
+        {
+            patterns: ["store setup", "seller verification", "payout"],
+            minMatches: 2,
+            canonical: "business-operations.md",
+            topic: "seller onboarding",
+        },
+    ];
+    for (const check of contentChecks) {
+        const matchCount = check.patterns.filter((p) => content.includes(p)).length;
+        if (matchCount >= check.minMatches && !file.name.includes(check.canonical.replace(".md", ""))) {
+            issues.push({
+                file: file.path,
+                line: 1,
+                type: "duplicate-info",
+                message: `${check.topic} content detected. Reference #${check.canonical.replace(".md", "")} instead.`,
+                severity: "warning",
+            });
+        }
+    }
+}
+// WORKFLOW REDUNDANCY DETECTION
+function checkWorkflowRedundancy(file, allFiles, issues) {
+    // Only check workflow files
+    if (!file.path.includes("/workflows/"))
+        return;
+    // README.md in workflows is the index - skip it
+    if (file.name === "README.md")
+        return;
+    // Check if workflow file is too large (should be cross-references, not duplicates)
+    if (file.lineCount > CONFIG.WORKFLOW_MAX_LINES) {
+        issues.push({
+            file: file.path,
+            line: 1,
+            type: "content-redundancy",
+            message: `Workflow file has ${file.lineCount} lines (max ${CONFIG.WORKFLOW_MAX_LINES}). Should be cross-references to canonical guides.`,
+            severity: "error",
+            suggestion: "Move detailed content to canonical steering file and use cross-references.",
+        });
+    }
+    // Check for content that should be in canonical files
+    const canonicalChecks = [
+        {
+            patterns: ["pnpm db:generate", "prisma format", "migration"],
+            canonical: "database-guide.md",
+            topic: "schema updates",
+        },
+        {
+            patterns: ["pnpm test:e2e", "playwright", "regression"],
+            canonical: "e2e-testing.md",
+            topic: "E2E testing",
+        },
+        {
+            patterns: ["pnpm preflight:", "preflight:all", "preflight:commit"],
+            canonical: "preflight-reference.md",
+            topic: "preflight commands",
+        },
+        {
+            patterns: ["UnifiedSkeleton", "UnifiedStatus", "design system"],
+            canonical: "components-guide.md",
+            topic: "design system",
+        },
+        {
+            patterns: ["listingStatus", "DRAFT", "admin approval"],
+            canonical: "business-workflows.md",
+            topic: "listing workflow",
+        },
+    ];
+    const content = file.content.toLowerCase();
+    for (const check of canonicalChecks) {
+        const matchCount = check.patterns.filter((p) => content.includes(p.toLowerCase())).length;
+        if (matchCount >= 2) {
+            // Check if this workflow has significant content (not just references)
+            const codeBlockCount = (file.content.match(/```/g) || []).length / 2;
+            if (codeBlockCount >= 3) {
+                issues.push({
+                    file: file.path,
+                    line: 1,
+                    type: "content-redundancy",
+                    message: `Workflow duplicates ${check.topic} content. Use cross-reference to #${check.canonical.replace(".md", "")} instead.`,
+                    severity: "warning",
+                    suggestion: `Replace detailed content with: See \`#${check.canonical.replace(".md", "")}\` for ${check.topic}.`,
+                });
+            }
+        }
+    }
+    // Check similarity with canonical files
+    const mainFiles = allFiles.filter((f) => !f.path.includes("/workflows/"));
+    for (const mainFile of mainFiles) {
+        const similarity = calculateSimilarity(file.content, mainFile.content);
+        if (similarity > 0.4) {
+            // 40% similarity threshold for workflows
+            issues.push({
+                file: file.path,
+                line: 1,
+                type: "content-redundancy",
+                message: `${Math.round(similarity * 100)}% similar to ${mainFile.name}. Workflow should cross-reference, not duplicate.`,
+                severity: similarity > 0.6 ? "error" : "warning",
+                relatedFile: mainFile.path,
+                similarity,
+                suggestion: `Replace with cross-reference: See \`#${mainFile.name.replace(".md", "")}\``,
+            });
+            break; // Only report highest similarity
+        }
+    }
+}
+// DRIFT DETECTION
+function checkStaleness(file, issues) {
+    if (!file.frontMatter?.lastUpdated)
+        return;
+    const lastUpdated = new Date(file.frontMatter.lastUpdated);
+    const now = new Date();
+    const daysSinceUpdate = Math.floor((now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24));
+    if (daysSinceUpdate > CONFIG.STALE_THRESHOLD_DAYS) {
+        issues.push({
+            file: file.path,
+            line: 1,
+            type: "stale-content",
+            message: `Last updated ${daysSinceUpdate} days ago (${file.frontMatter.lastUpdated}). Review for accuracy.`,
+            severity: "info",
+            suggestion: `Update lastUpdated to ${new Date().toISOString().split("T")[0]} after review.`,
+            autoFixable: true,
+        });
+    }
+}
+function checkIndexPresence(file, readmeContent, issues) {
+    if (file.name === "README.md" || file.name === "CHANGELOG.md")
+        return;
+    const fileRef = file.name.replace(".md", "");
+    const isInIndex = readmeContent.includes(file.name) ||
+        readmeContent.includes(`#${fileRef}`) ||
+        readmeContent.includes(`\`${fileRef}\``);
+    if (!isInIndex) {
+        issues.push({
+            file: file.path,
+            line: 1,
+            type: "orphaned-file",
+            message: "File not listed in README.md index. Add to Conditional Loading table or delete.",
+            severity: "warning",
+        });
+    }
+}
+function validateReadmeIndex(files, readmeContent, issues) {
+    for (const required of CONFIG.REQUIRED_INDEX_ENTRIES) {
+        if (!readmeContent.includes(required)) {
+            issues.push({
+                file: ".kiro/steering/README.md",
+                line: 1,
+                type: "missing-from-index",
+                message: `Required file "${required}" not found in README index.`,
+                severity: "error",
+            });
+        }
+    }
+    const fileRefs = readmeContent.match(/`([a-z-]+\.md)`/g) || [];
+    for (const ref of fileRefs) {
+        const fileName = ref.replace(/`/g, "");
+        const exists = files.some((f) => f.name === fileName);
+        if (!exists) {
+            issues.push({
+                file: ".kiro/steering/README.md",
+                line: 1,
+                type: "broken-reference",
+                message: `README references "${fileName}" but file doesn't exist.`,
+                severity: "error",
+            });
+        }
+    }
+}
+function validateTokenBudget(budget, issues) {
+    if (budget.alwaysLoaded > CONFIG.MAX_ALWAYS_LOADED_TOKENS) {
+        issues.push({
+            file: ".kiro/steering/",
+            line: 1,
+            type: "token-budget",
+            message: `Always-loaded uses ~${budget.alwaysLoaded} tokens (max ${CONFIG.MAX_ALWAYS_LOADED_TOKENS}). Reduce.`,
+            severity: "error",
+        });
+    }
+    for (const [fileName, tokens] of budget.manualFiles) {
+        // Skip whitelisted files
+        if (CONFIG.WHITELISTED_LARGE_FILES.includes(fileName))
+            continue;
+        if (tokens > CONFIG.MAX_SINGLE_FILE_TOKENS) {
+            issues.push({
+                file: `.kiro/steering/${fileName}`,
+                line: 1,
+                type: "token-budget",
+                message: `File uses ~${tokens} tokens (max ${CONFIG.MAX_SINGLE_FILE_TOKENS}). Consider splitting.`,
+                severity: "warning",
+            });
+        }
+        else if (tokens > CONFIG.WARN_FILE_TOKENS) {
+            issues.push({
+                file: `.kiro/steering/${fileName}`,
+                line: 1,
+                type: "token-budget",
+                message: `File uses ~${tokens} tokens. Monitor for growth.`,
+                severity: "info",
+            });
+        }
+    }
+}
+// CONTENT ANALYSIS
+function extractContentBlocks(file, contentBlocks) {
+    let inCodeBlock = false;
+    let codeBlockStart = 0;
+    let codeBlockContent = [];
+    for (let i = 0; i < file.lines.length; i++) {
+        const line = file.lines[i];
+        if (line.startsWith("```")) {
+            if (inCodeBlock) {
+                if (codeBlockContent.length > 5) {
+                    contentBlocks.push({
+                        file: file.path,
+                        content: codeBlockContent.join("\n"),
+                        startLine: codeBlockStart,
+                        endLine: i,
+                        type: "code",
+                    });
+                }
+                inCodeBlock = false;
+                codeBlockContent = [];
+            }
+            else {
+                inCodeBlock = true;
+                codeBlockStart = i + 1;
+                codeBlockContent = [];
+            }
+        }
+        else if (inCodeBlock) {
+            codeBlockContent.push(line);
+        }
+        if (line.includes("pnpm preflight:")) {
+            const matches = line.match(/pnpm preflight:[a-z:-]+/g);
+            if (matches) {
+                matches.forEach((command) => {
+                    contentBlocks.push({
+                        file: file.path,
+                        content: command,
+                        startLine: i + 1,
+                        endLine: i + 1,
+                        type: "preflight-command",
+                    });
+                });
+            }
+        }
+    }
+}
+function analyzeContentRedundancy(contentBlocks, issues) {
+    const analyzed = new Set();
+    for (let i = 0; i < contentBlocks.length; i++) {
+        const block1 = contentBlocks[i];
+        if (block1.type !== "code")
+            continue;
+        // Skip whitelisted files
+        const fileName1 = path_1.default.basename(block1.file);
+        if (CONFIG.WHITELISTED_LARGE_FILES.includes(fileName1))
+            continue;
+        const key1 = `${block1.file}:${block1.startLine}`;
+        if (analyzed.has(key1))
+            continue;
+        for (let j = i + 1; j < contentBlocks.length; j++) {
+            const block2 = contentBlocks[j];
+            if (block2.type !== "code" || block1.file === block2.file)
+                continue;
+            // Skip if either file is whitelisted
+            const fileName2 = path_1.default.basename(block2.file);
+            if (CONFIG.WHITELISTED_LARGE_FILES.includes(fileName2))
+                continue;
+            const key2 = `${block2.file}:${block2.startLine}`;
+            if (analyzed.has(key2))
+                continue;
+            const similarity = calculateSimilarity(block1.content, block2.content);
+            if (similarity > CONFIG.SIMILARITY_THRESHOLD) {
+                issues.push({
+                    file: block1.file,
+                    line: block1.startLine,
+                    type: "content-redundancy",
+                    message: `${Math.round(similarity * 100)}% similar code in ${fileName2}:${block2.startLine}. Consolidate.`,
+                    severity: similarity > 0.9 ? "warning" : "info",
+                    relatedFile: block2.file,
+                    similarity,
+                });
+                analyzed.add(key1);
+                analyzed.add(key2);
+                break;
+            }
+        }
+    }
+}
+function analyzePreflightRedundancy(contentBlocks, issues) {
+    const preflightCommands = contentBlocks.filter((b) => b.type === "preflight-command");
+    const commandCounts = new Map();
+    for (const block of preflightCommands) {
+        if (!commandCounts.has(block.content)) {
+            commandCounts.set(block.content, new Set());
+        }
+        commandCounts.get(block.content).add(block.file);
+    }
+    for (const [command, files] of commandCounts) {
+        if (files.size >= 3) {
+            const fileNames = Array.from(files).map((f) => path_1.default.basename(f));
+            const firstFile = Array.from(files)[0];
+            // Skip if preflight-reference.md is one of the files (it's the canonical source)
+            if (fileNames.includes("preflight-reference.md"))
+                continue;
+            // Skip if all files are whitelisted
+            const nonWhitelisted = fileNames.filter((f) => !CONFIG.WHITELISTED_LARGE_FILES.includes(f));
+            if (nonWhitelisted.length < 3)
+                continue;
+            issues.push({
+                file: firstFile,
+                line: 1,
+                type: "preflight-redundancy",
+                message: `"${command}" in ${files.size} files. Consolidate in preflight-reference.md.`,
+                severity: files.size >= 5 ? "warning" : "info",
+            });
+        }
+    }
+}
+function calculateSimilarity(text1, text2) {
+    const normalize = (text) => text
+        .toLowerCase()
+        .replace(/[^\w\s]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    const norm1 = normalize(text1);
+    const norm2 = normalize(text2);
+    if (norm1.length === 0 || norm2.length === 0)
+        return 0;
+    const words1 = new Set(norm1.split(" "));
+    const words2 = new Set(norm2.split(" "));
+    const intersection = new Set([...words1].filter((w) => words2.has(w)));
+    const union = new Set([...words1, ...words2]);
+    return intersection.size / union.size;
+}
+// CLI RUNNER
+function printGraph(graph) {
+    console.log(`\n${console_chars_1.emoji.chart} Cross-Reference Graph:\n`);
+    // Sort by incoming references (most referenced first)
+    const sortedNodes = [...graph.nodes].sort((a, b) => (graph.incomingCount.get(b) || 0) - (graph.incomingCount.get(a) || 0));
+    console.log("  Most Referenced Files:");
+    for (const node of sortedNodes.slice(0, 5)) {
+        const incoming = graph.incomingCount.get(node) || 0;
+        const outgoing = graph.outgoingCount.get(node) || 0;
+        if (incoming > 0) {
+            console.log(`    ${node}: ${incoming} incoming, ${outgoing} outgoing`);
+        }
+    }
+    // Find files with no incoming references
+    const orphans = sortedNodes.filter((n) => (graph.incomingCount.get(n) || 0) === 0 &&
+        !["README.md", "core-rules.md", "CHANGELOG.md"].includes(n));
+    if (orphans.length > 0) {
+        console.log("\n  Files with No Incoming References:");
+        for (const orphan of orphans) {
+            console.log(`    ${orphan}`);
+        }
+    }
+    console.log("");
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const verbose = args.includes("--verbose");
+    const warnOnly = args.includes("--warn");
+    const showGraph = args.includes("--graph");
+    const fix = args.includes("--fix");
+    console.log(`\n${console_chars_1.emoji.search} Steering Quality & Bloat Prevention Check\n`);
+    const result = await validateSteeringQuality({ showGraph, fix });
+    const { errors, warnings, info, stats, graph } = result;
+    // Print stats
+    console.log(`${console_chars_1.emoji.chart} Stats:`);
+    console.log(`  Files: ${stats.totalFiles} (${stats.alwaysLoadedFiles} always-loaded)`);
+    console.log(`  Tokens: ~${stats.totalTokens} total (~${stats.alwaysLoadedTokens} always-loaded)`);
+    // Print token trend
+    if (stats.tokenTrend) {
+        const arrow = stats.tokenTrend.direction === "up" ? "↑" : stats.tokenTrend.direction === "down" ? "↓" : "→";
+        const color = stats.tokenTrend.direction === "up"
+            ? console_chars_1.emoji.warning
+            : stats.tokenTrend.direction === "down"
+                ? console_chars_1.emoji.success
+                : console_chars_1.emoji.info;
+        console.log(`  Trend: ${color} ${arrow} ${Math.abs(stats.tokenTrend.change)}% since last check`);
+    }
+    console.log("");
+    // Print whitelisted files info
+    if (verbose) {
+        console.log(`${console_chars_1.emoji.info} Whitelisted Large Files (no warnings):`);
+        for (const file of CONFIG.WHITELISTED_LARGE_FILES) {
+            console.log(`  - ${file}`);
+        }
+        console.log("");
+    }
+    // Print errors
+    if (errors.length > 0) {
+        console.log(`${console_chars_1.emoji.error} ERRORS (${errors.length}):`);
+        for (const issue of errors) {
+            console.log(`  ${path_1.default.basename(issue.file)}:${issue.line} - ${issue.message}`);
+            if (verbose && issue.suggestion) {
+                console.log(`    ${console_chars_1.emoji.info} Suggestion: ${issue.suggestion}`);
+            }
+            if (fix && issue.autoFixable) {
+                console.log(`    ${console_chars_1.emoji.warning} Auto-fixable with --fix`);
+            }
+        }
+        console.log("");
+    }
+    // Print warnings
+    if (warnings.length > 0) {
+        console.log(`${console_chars_1.emoji.warning} WARNINGS (${warnings.length}):`);
+        for (const issue of warnings) {
+            console.log(`  ${path_1.default.basename(issue.file)}:${issue.line} - ${issue.message}`);
+            if (verbose && issue.suggestion) {
+                console.log(`    ${console_chars_1.emoji.info} Suggestion: ${issue.suggestion}`);
+            }
+        }
+        console.log("");
+    }
+    // Print info (only in verbose mode)
+    if (verbose && info.length > 0) {
+        console.log(`${console_chars_1.emoji.info} INFO (${info.length}):`);
+        for (const issue of info) {
+            console.log(`  ${path_1.default.basename(issue.file)}:${issue.line} - ${issue.message}`);
+        }
+        console.log("");
+    }
+    // Print graph
+    if (showGraph && graph) {
+        printGraph(graph);
+    }
+    // Summary
+    if (errors.length === 0 && warnings.length === 0) {
+        console.log(`${console_chars_1.emoji.success} All steering files pass quality checks!`);
+    }
+    else {
+        console.log(`${console_chars_1.emoji.chart} Summary: ${errors.length} errors, ${warnings.length} warnings` +
+            (verbose ? `, ${info.length} info` : ""));
+    }
+    // Auto-fix count
+    const autoFixable = [...errors, ...warnings, ...info].filter((i) => i.autoFixable);
+    if (autoFixable.length > 0 && !fix) {
+        console.log(`\n${console_chars_1.emoji.info} ${autoFixable.length} issues are auto-fixable. Run with --fix to see suggestions.`);
+    }
+    // Exit code
+    if (errors.length > 0 && !warnOnly) {
+        process.exit(1);
+    }
+}
+if (require.main === module) {
+    main().catch((error) => {
+        console.error("Error running steering quality check:", error);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=steering-bloat-prevention.js.map