@empline/preflight 1.0.20

package/dist/checks/system/preflight-redundancy-detection.js

@@ -0,0 +1,1168 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Preflight Redundancy Detection (BLOCKING)
+ *
+ * Detects redundant preflights by analyzing:
+ * 1. Regex patterns being checked (same pattern in multiple preflights)
+ * 2. File glob patterns being scanned (same files scanned multiple times)
+ * 3. Error codes emitted (duplicate error codes = duplicate checks)
+ * 4. Similar check names (semantic overlap)
+ * 5. Content hash duplicates (copy-pasted preflights)
+ * 6. Local exclude definitions (should use shared/glob-patterns.ts)
+ *
+ * This runs on every build to ensure efficiency - we don't want to waste
+ * CI time running the same checks multiple times.
+ *
+ * Usage:
+ *   pnpm preflight:redundancy
+ *   pnpm preflight:redundancy --verbose    # Show info-level issues
+ *   pnpm preflight:redundancy --json       # Output JSON for trend tracking
+ *   tsx scripts/active/preflights/system/preflight-redundancy-detection.ts
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tags = exports.description = exports.blocking = exports.category = exports.name = exports.id = void 0;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const console_chars_1 = require("../../utils/console-chars");
+// Check metadata
+exports.id = "system/preflight-redundancy-detection";
+exports.name = "Preflight Redundancy Detection";
+exports.category = "system";
+exports.blocking = true;
+exports.description = "Preflight Redundancy Detection (BLOCKING)";
+exports.tags = ["system"];
+// Import shared patterns to exclude from duplicate detection
+// These are expected to appear in many files since they're the shared source
+const file_cache_1 = require("../../shared/file-cache");
+const glob_patterns_1 = require("../../shared/glob-patterns");
+const issues = [];
+// Patterns to ignore (too generic to be meaningful for redundancy detection)
+const IGNORE_PATTERNS = new Set([
+    // Generic regex patterns
+    ".*",
+    ".+",
+    "\\s+",
+    "\\w+",
+    "\\d+",
+    '[^"]+',
+    "[^']+",
+    "\\n",
+    "\\r?\\n",
+    // Common words that appear in many preflights (not actual redundancy)
+    "system",
+    "shared",
+    "scripts",
+    "constants",
+    "components",
+    "utils",
+    "hooks",
+    "types",
+    "config",
+    "error",
+    "warning",
+    "success",
+    "failed",
+    "import",
+    "export",
+    "function",
+    "const",
+    "return",
+    "async",
+    "await",
+    "string",
+    "number",
+    "boolean",
+    "object",
+    "array",
+    "null",
+    "undefined",
+    "true",
+    "false",
+]);
+// File globs to ignore (too generic)
+const IGNORE_GLOBS = new Set(["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx", "*.ts", "*.tsx"]);
+// Shared pattern globs - these are expected to appear in many files
+// Don't flag them as duplicates since they come from glob-patterns.ts or are common patterns
+const SHARED_PATTERN_GLOBS = new Set([
+    // Exclusion patterns from glob-patterns.ts
+    ...glob_patterns_1.CORE_EXCLUDES,
+    ...glob_patterns_1.STANDARD_EXCLUDES,
+    ...glob_patterns_1.FULL_EXCLUDES,
+    // Common test/story exclusion patterns
+    "**/*.test.ts",
+    "**/*.test.tsx",
+    "**/*.spec.ts",
+    "**/*.spec.tsx",
+    "**/tests/**",
+    "**/__tests__/**",
+    "**/__mocks__/**",
+    "**/*.stories.ts",
+    "**/*.stories.tsx",
+    "**/stories/**",
+    "**/.storybook/**",
+    // Common INCLUDE patterns - these are expected to be used by many preflights
+    "**/*.{ts,tsx}",
+    "**/*.{tsx,jsx}",
+    "**/*.{ts,tsx,js,jsx}",
+    "**/*.{tsx,ts}",
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/*.test.{ts,tsx}",
+    "**/*.spec.{ts,tsx}",
+    "**/*.stories.*",
+    "**/*.stories.{ts,tsx}",
+    "**/scripts/**",
+    "**/scripts/active/preflights/**",
+    "**/packages/ui/**",
+    "tests/e2e/**/*.spec.ts",
+    "tests/e2e/**/*.ts",
+    "app/**/page.tsx",
+    "app/**/page.{ts,tsx,js,jsx}",
+    "app/**/layout.tsx",
+    "app/**/*.tsx",
+    "app/api/**/*.ts",
+    "lib/**/*.ts",
+    "{app,components,lib,hooks}/**/*.{ts,tsx}",
+    "{app,components}/**/*.{tsx,jsx}",
+    "app/api/**/route.{ts,js}",
+    "app/api/**/route.ts",
+    "components/**/*.tsx",
+    "components/**/*.ts",
+    "components/**/*.{tsx,jsx}",
+    "**/ui/**",
+    "**/docs/**",
+    "**/components/ui/**",
+    "app/**/*Client.tsx",
+    "{app,components}/**/*.tsx",
+    "scripts/active/preflights/**/*.ts",
+    "**/utils/**",
+    "app/**/*.ts",
+    "{app,lib,components}/**/*.{ts,tsx}",
+    "app/**/*.{tsx,jsx}",
+    "packages/ui/src/**/*.tsx",
+    "**/test/**",
+    "**/*.d.ts",
+]);
+function extractRegexPatterns(content) {
+    const patterns = [];
+    // Match regex literals: /pattern/flags
+    const regexLiteralMatches = content.matchAll(/\/([^\/\n]{5,})\/[gimsuvy]*/g);
+    for (const match of regexLiteralMatches) {
+        const pattern = match[1];
+        if (pattern && !IGNORE_PATTERNS.has(pattern) && pattern.length > 5) {
+            patterns.push(pattern);
+        }
+    }
+    // Match new RegExp('pattern')
+    const regexpConstructorMatches = content.matchAll(/new RegExp\s*\(\s*['"`]([^'"`]{5,})['"`]/g);
+    for (const match of regexpConstructorMatches) {
+        const pattern = match[1];
+        if (pattern && !IGNORE_PATTERNS.has(pattern)) {
+            patterns.push(pattern);
+        }
+    }
+    // Match .match(/pattern/) and .test(/pattern/)
+    const methodMatches = content.matchAll(/\.(match|test|replace|search)\s*\(\s*\/([^\/\n]{5,})\/[gimsuvy]*/g);
+    for (const match of methodMatches) {
+        const pattern = match[2];
+        if (pattern && !IGNORE_PATTERNS.has(pattern)) {
+            patterns.push(pattern);
+        }
+    }
+    return [...new Set(patterns)];
+}
+function extractFileGlobs(content) {
+    const globs = [];
+    // Match glob patterns in strings
+    const globMatches = content.matchAll(/['"`](\*\*\/[^'"`]+|[^'"`]*\*\.[a-z]+)['"`]/g);
+    for (const match of globMatches) {
+        const pattern = match[1];
+        if (pattern && !IGNORE_GLOBS.has(pattern)) {
+            globs.push(pattern);
+        }
+    }
+    // Match directory patterns
+    const dirMatches = content.matchAll(/glob\s*\(\s*['"`]([^'"`]+)['"`]/g);
+    for (const match of dirMatches) {
+        const pattern = match[1];
+        if (pattern && !IGNORE_GLOBS.has(pattern)) {
+            globs.push(pattern);
+        }
+    }
+    return [...new Set(globs)];
+}
+function extractErrorCodes(content) {
+    const codes = [];
+    // Match code: 'ERROR_CODE' patterns
+    const codeMatches = content.matchAll(/code:\s*['"]([A-Z][A-Z0-9_]+)['"]/g);
+    for (const match of codeMatches) {
+        if (match[1])
+            codes.push(match[1]);
+    }
+    // Match error code constants
+    const constMatches = content.matchAll(/const\s+([A-Z][A-Z0-9_]+)\s*=\s*['"]([A-Z][A-Z0-9_]+)['"]/g);
+    for (const match of constMatches) {
+        if (match[2])
+            codes.push(match[2]);
+    }
+    return [...new Set(codes)];
+}
+function extractCheckDescriptions(content) {
+    const descriptions = [];
+    // Match console.log with check descriptions
+    const logMatches = content.matchAll(/console\.log\s*\(\s*['"`]([^'"`]{20,})['"`]/g);
+    for (const match of logMatches) {
+        if (match[1] &&
+            !match[1].includes("${box.heavyHorizontal}") &&
+            !match[1].includes("${box.doubleHorizontal}")) {
+            descriptions.push(match[1]);
+        }
+    }
+    // Match description fields
+    const descMatches = content.matchAll(/description:\s*['"`]([^'"`]{20,})['"`]/g);
+    for (const match of descMatches) {
+        if (match[1])
+            descriptions.push(match[1]);
+    }
+    return descriptions;
+}
+function calculateContentHash(content) {
+    // Normalize content for comparison (remove comments, whitespace)
+    const normalized = content
+        .replace(/\/\/.*$/gm, "")
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    return crypto.createHash("md5").update(normalized).digest("hex").slice(0, 12);
+}
+function calculateSimilarity(str1, str2) {
+    const words1 = new Set(str1
+        .toLowerCase()
+        .split(/\W+/)
+        .filter((w) => w.length > 2));
+    const words2 = new Set(str2
+        .toLowerCase()
+        .split(/\W+/)
+        .filter((w) => w.length > 2));
+    if (words1.size === 0 || words2.size === 0)
+        return 0;
+    const intersection = new Set([...words1].filter((w) => words2.has(w)));
+    const union = new Set([...words1, ...words2]);
+    return intersection.size / union.size;
+}
+// CACHED FILE LISTS - Scan once, use everywhere
+let _cachedPreflightFiles = null;
+async function getPreflightFiles() {
+    if (!_cachedPreflightFiles) {
+        _cachedPreflightFiles = await file_cache_1.fileCache.getPreflightFiles();
+    }
+    return _cachedPreflightFiles;
+}
+async function analyzePreflightFile(filePath) {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const relativePath = path.relative(process.cwd(), filePath);
+    // Extract preflight name from file or content
+    const nameMatch = content.match(/name:\s*['"]([^'"]+)['"]/);
+    const name = nameMatch?.[1] || path.basename(filePath, path.extname(filePath));
+    // Check if file imports from shared glob-patterns
+    const usesSharedPatterns = content.includes("from '../shared/glob-patterns'") ||
+        content.includes('from "../../shared/glob-patterns"') ||
+        content.includes("...STANDARD_EXCLUDES") ||
+        content.includes("...CORE_EXCLUDES") ||
+        content.includes("...FULL_EXCLUDES") ||
+        content.includes("...PRODUCTION_CODE_EXCLUDES");
+    return {
+        file: relativePath,
+        name,
+        regexPatterns: extractRegexPatterns(content),
+        fileGlobs: extractFileGlobs(content),
+        errorCodes: extractErrorCodes(content),
+        checkDescriptions: extractCheckDescriptions(content),
+        contentHash: calculateContentHash(content),
+        lineCount: content.split("\n").length,
+        usesSharedPatterns,
+    };
+}
+function findDuplicatePatterns(analyses) {
+    // Re-enabled with smarter filtering - only flag truly identical complex patterns
+    const patternToFiles = new Map();
+    for (const analysis of analyses) {
+        for (const pattern of analysis.regexPatterns) {
+            // Skip short/generic patterns
+            if (pattern.length < 20)
+                continue;
+            // Skip common patterns that are legitimately reused
+            if (/flex|grid|gap|margin|padding|className/i.test(pattern))
+                continue;
+            if (!patternToFiles.has(pattern)) {
+                patternToFiles.set(pattern, []);
+            }
+            patternToFiles.get(pattern).push(analysis.file);
+        }
+    }
+    for (const [pattern, files] of patternToFiles) {
+        if (files.length >= 3) {
+            // Only flag if 3+ preflights use the exact same complex pattern
+            issues.push({
+                type: "duplicate-pattern",
+                severity: "info",
+                message: `Complex regex pattern used by ${files.length} preflights - consider extracting to shared module`,
+                files,
+                pattern: pattern.substring(0, 50) + (pattern.length > 50 ? "..." : ""),
+            });
+        }
+    }
+}
+function findDuplicateGlobs(analyses) {
+    const globToFiles = new Map();
+    for (const analysis of analyses) {
+        for (const glob of analysis.fileGlobs) {
+            // Skip shared patterns - they're expected to be in many files
+            if (SHARED_PATTERN_GLOBS.has(glob))
+                continue;
+            if (!globToFiles.has(glob)) {
+                globToFiles.set(glob, []);
+            }
+            globToFiles.get(glob).push(analysis.file);
+        }
+    }
+    for (const [globPattern, files] of globToFiles) {
+        if (files.length >= 6) {
+            // Only flag if 6+ preflights scan same glob (meaningful redundancy)
+            issues.push({
+                type: "duplicate-glob",
+                severity: files.length >= 10 ? "warning" : "info",
+                message: `File glob "${globPattern}" scanned by ${files.length} preflights - consider consolidating`,
+                files,
+                pattern: globPattern,
+            });
+        }
+    }
+}
+function findDuplicateErrorCodes(analyses) {
+    const codeToFiles = new Map();
+    for (const analysis of analyses) {
+        for (const code of analysis.errorCodes) {
+            if (!codeToFiles.has(code)) {
+                codeToFiles.set(code, []);
+            }
+            codeToFiles.get(code).push(analysis.file);
+        }
+    }
+    for (const [code, files] of codeToFiles) {
+        if (files.length > 1) {
+            issues.push({
+                type: "duplicate-error-code",
+                severity: "error", // Duplicate error codes are a real problem
+                message: `Error code "${code}" emitted by ${files.length} preflights - indicates duplicate checks`,
+                files,
+                pattern: code,
+            });
+        }
+    }
+}
+// Generic names that shouldn't trigger similar-name warnings
+const GENERIC_NAMES = new Set([
+    "delete",
+    "create",
+    "update",
+    "read",
+    "get",
+    "set",
+    "check",
+    "validate",
+    "test",
+    "run",
+    "execute",
+    "process",
+    "handle",
+    "main",
+    "init",
+    "setup",
+    "development",
+    "database",
+    "security",
+    "performance",
+    "quality",
+    // Workflow file names that call other preflights
+    "esm import extensions",
+    "image optimization",
+    "code quality",
+    "cost optimization",
+    "strict-lint",
+    "strict lint",
+]);
+function findSimilarNames(analyses) {
+    // Re-enabled with better heuristics - only flag very high similarity (>0.8)
+    const checked = new Set();
+    for (let i = 0; i < analyses.length; i++) {
+        for (let j = i + 1; j < analyses.length; j++) {
+            const a1 = analyses[i];
+            const a2 = analyses[j];
+            const key = `${a1.file}:${a2.file}`;
+            if (checked.has(key))
+                continue;
+            checked.add(key);
+            // Skip workflow files - they legitimately have similar names
+            if (a1.file.includes("/workflows/") || a2.file.includes("/workflows/"))
+                continue;
+            // Skip consolidated files - they're meant to replace others
+            if (a1.file.includes("/consolidated/") || a2.file.includes("/consolidated/"))
+                continue;
+            const similarity = calculateSimilarity(a1.name, a2.name);
+            // Only flag very high similarity (>0.8) and same directory
+            if (similarity > 0.8) {
+                const dir1 = path.dirname(a1.file);
+                const dir2 = path.dirname(a2.file);
+                if (dir1 === dir2) {
+                    issues.push({
+                        type: "similar-name",
+                        severity: "info",
+                        message: `Very similar names in same directory (${(similarity * 100).toFixed(0)}% match) - consider consolidating`,
+                        files: [a1.file, a2.file],
+                        similarity,
+                    });
+                }
+            }
+        }
+    }
+}
+function findHighOverlap(analyses) {
+    const checked = new Set();
+    for (let i = 0; i < analyses.length; i++) {
+        for (let j = i + 1; j < analyses.length; j++) {
+            const a1 = analyses[i];
+            const a2 = analyses[j];
+            const key = `${a1.file}:${a2.file}`;
+            if (checked.has(key))
+                continue;
+            checked.add(key);
+            // Calculate overlap in regex patterns
+            const patterns1 = new Set(a1.regexPatterns);
+            const patterns2 = new Set(a2.regexPatterns);
+            const patternOverlap = [...patterns1].filter((p) => patterns2.has(p));
+            // Calculate overlap in error codes
+            const codes1 = new Set(a1.errorCodes);
+            const codes2 = new Set(a2.errorCodes);
+            const codeOverlap = [...codes1].filter((c) => codes2.has(c));
+            // High overlap = many shared patterns AND shared error codes
+            if (patternOverlap.length >= 3 && codeOverlap.length >= 1) {
+                issues.push({
+                    type: "high-overlap",
+                    severity: "error",
+                    message: `High overlap between preflights: ${patternOverlap.length} shared patterns, ${codeOverlap.length} shared error codes. Consider merging.`,
+                    files: [a1.file, a2.file],
+                    similarity: patternOverlap.length / Math.max(patterns1.size, patterns2.size),
+                });
+            }
+        }
+    }
+}
+/**
+ * Find domain fragmentation - too many preflights in the same category
+ * that could be consolidated into fewer modules.
+ *
+ * Re-enabled with smarter thresholds - only flag categories with 10+ standalone files
+ * that are NOT already orchestrated by consolidated/*.ts files.
+ */
+function findDomainFragmentation(analyses) {
+    const categoryToFiles = new Map();
+    // Get list of already orchestrated preflights
+    const orchestratedPreflights = getOrchestratedPreflights();
+    for (const analysis of analyses) {
+        // Extract category from path (e.g., "ui" from "scripts/active/preflights/ui/button-consistency.ts")
+        // Normalize path separators for cross-platform compatibility
+        const normalizedPath = analysis.file.replace(/\\/g, "/");
+        const match = normalizedPath.match(/preflights\/([^\/]+)\//);
+        if (!match)
+            continue;
+        const category = match[1];
+        // Skip consolidated, workflows, system, shared, utils - these are organizational
+        if (["consolidated", "workflows", "system", "shared", "utils"].includes(category))
+            continue;
+        // Skip files that are orchestrators themselves
+        if (isOrchestratorFile(analysis.file))
+            continue;
+        // Skip files that are already orchestrated
+        const relativePath = normalizedPath.replace(/^scripts\/active\/preflights\//, "");
+        if (orchestratedPreflights.has(relativePath) || orchestratedPreflights.has(normalizedPath)) {
+            continue;
+        }
+        if (!categoryToFiles.has(category)) {
+            categoryToFiles.set(category, []);
+        }
+        categoryToFiles.get(category).push(analysis.file);
+    }
+    for (const [category, files] of categoryToFiles) {
+        // Only flag if 10+ NON-ORCHESTRATED files exist
+        if (files.length >= 10) {
+            // Check if this category already has a consolidated orchestrator
+            if (hasConsolidatedOrchestrator(category, analyses)) {
+                continue; // Already has orchestrator - not fragmentation
+            }
+            issues.push({
+                type: "similar-name", // Using existing type for domain fragmentation
+                severity: "info",
+                message: `Category "${category}" has ${files.length} non-orchestrated preflights - consider consolidating into fewer modules`,
+                files: files.slice(0, 5),
+            });
+        }
+    }
+}
+/**
+ * Find preflights scanning the same test files that could share a single scan
+ *
+ * DISABLED: This check is advisory only. Many preflights legitimately scan
+ * test files for different purposes (patterns, coverage, performance, etc.)
+ */
+function findTestFileScanOverlap(_analyses) {
+    // Disabled - produces advisory findings that don't indicate actual problems
+    return;
+}
+/**
+ * NEW: Find orphaned preflights - not referenced in package.json or workflows
+ * These may be dead code or forgotten preflights that should be removed or integrated.
+ *
+ * IMPORTANT: Files orchestrated by consolidated/*.ts are NOT orphaned - they're
+ * called via runCheck() which this function now recognizes.
+ */
+async function findOrphanedPreflights(analyses) {
+    try {
+        const packageJsonPath = path.join(process.cwd(), "package.json");
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+        const scripts = packageJson.scripts || {};
+        const scriptValues = Object.values(scripts).join(" ");
+        // Get list of orchestrated preflights (called by consolidated/*.ts)
+        const orchestratedPreflights = getOrchestratedPreflights();
+        // Also check workflow files
+        const workflowDir = path.join(process.cwd(), "scripts/active/preflights/workflows");
+        let workflowContent = "";
+        if (fs.existsSync(workflowDir)) {
+            const workflowFiles = fs.readdirSync(workflowDir).filter((f) => f.endsWith(".ts"));
+            for (const wf of workflowFiles) {
+                workflowContent += fs.readFileSync(path.join(workflowDir, wf), "utf-8");
+            }
+        }
+        // Also check consolidated files for references
+        const consolidatedDir = path.join(process.cwd(), "scripts/active/preflights/consolidated");
+        let consolidatedContent = "";
+        if (fs.existsSync(consolidatedDir)) {
+            const consolidatedFiles = fs.readdirSync(consolidatedDir).filter((f) => f.endsWith(".ts"));
+            for (const cf of consolidatedFiles) {
+                consolidatedContent += fs.readFileSync(path.join(consolidatedDir, cf), "utf-8");
+            }
+        }
+        const orphaned = [];
+        for (const analysis of analyses) {
+            // Skip workflow files, system files, shared utilities, consolidated files
+            if (analysis.file.includes("/workflows/"))
+                continue;
+            if (analysis.file.includes("/system/"))
+                continue;
+            if (analysis.file.includes("/shared/"))
+                continue;
+            if (analysis.file.includes("/utils/"))
+                continue;
+            if (analysis.file.includes("/consolidated/"))
+                continue;
+            const fileName = path.basename(analysis.file, path.extname(analysis.file));
+            const relativePath = analysis.file.replace(/^scripts\/active\/preflights\//, "");
+            // Check if orchestrated by consolidated/*.ts
+            if (orchestratedPreflights.has(relativePath) || orchestratedPreflights.has(analysis.file)) {
+                continue; // Not orphaned - called by orchestrator
+            }
+            // Check if referenced in package.json scripts
+            const inPackageJson = scriptValues.includes(fileName) || scriptValues.includes(analysis.file);
+            // Check if imported in workflow files
+            const inWorkflows = workflowContent.includes(fileName) ||
+                workflowContent.includes(`from './${fileName}'`) ||
+                workflowContent.includes(`from "../${path.basename(path.dirname(analysis.file))}/${fileName}"`);
+            // Check if referenced in consolidated files
+            const inConsolidated = consolidatedContent.includes(fileName) ||
+                consolidatedContent.includes(analysis.file) ||
+                consolidatedContent.includes(relativePath);
+            if (!inPackageJson && !inWorkflows && !inConsolidated) {
+                orphaned.push(analysis.file);
+            }
+        }
+        if (orphaned.length > 5) {
+            issues.push({
+                type: "local-excludes", // Reusing type for orphaned detection
+                severity: "info",
+                message: `${orphaned.length} preflights not referenced in package.json, workflows, or consolidated files - may be orphaned`,
+                files: orphaned.slice(0, 10),
+            });
+        }
+    }
+    catch {
+        // Skip if can't read package.json
+    }
+}
+/**
+ * NEW: Find build command redundancy - preflights called multiple times in build
+ */
+function findBuildCommandRedundancy() {
+    try {
+        const packageJsonPath = path.join(process.cwd(), "package.json");
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+        const scripts = packageJson.scripts || {};
+        const buildCommand = scripts.build || "";
+        // Check if preflight:all is called AND individual preflights are also called
+        if (buildCommand.includes("preflight:all")) {
+            const redundantCalls = [];
+            // These are likely already included in preflight:all
+            const likelyIncluded = [
+                "preflight:ui:consistency",
+                "preflight:mobile-responsive",
+                "preflight:product-image-animations",
+                "preflight:ux-consistency",
+            ];
+            for (const preflight of likelyIncluded) {
+                if (buildCommand.includes(preflight)) {
+                    redundantCalls.push(preflight);
+                }
+            }
+            if (redundantCalls.length > 0) {
+                issues.push({
+                    type: "duplicate-glob", // Reusing type for build redundancy
+                    severity: "warning",
+                    message: `Build command calls preflight:all AND ${redundantCalls.length} individual preflights that may already be included. Check if these are redundant: ${redundantCalls.join(", ")}`,
+                    files: ["package.json"],
+                });
+            }
+        }
+    }
+    catch {
+        // Skip if can't read package.json
+    }
+}
+/**
+ * Detect if a file is an orchestrator (calls other preflights)
+ * Orchestrators use patterns like:
+ * - runCheck('name', 'path/to/preflight.ts')
+ * - exec('pnpm preflight:xxx')
+ * - import from other preflight files
+ */
+function isOrchestratorFile(filePath) {
+    // Consolidated and workflow files are always orchestrators
+    if (filePath.includes("/consolidated/") || filePath.includes("/workflows/")) {
+        return true;
+    }
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        // Check for runCheck pattern (used in consolidated/*.ts)
+        if (/runCheck\s*\(\s*['"][^'"]+['"]\s*,\s*['"][^'"]+\.ts['"]/.test(content)) {
+            return true;
+        }
+        // Check for exec pattern calling other preflights
+        if (/exec\s*\(\s*['"`].*preflight.*\.ts/.test(content)) {
+            return true;
+        }
+        // Check for pnpm preflight commands
+        if (/pnpm\s+preflight:/.test(content)) {
+            return true;
+        }
+        // Check for importing and calling multiple preflight modules
+        const preflightImports = content.match(/from\s+['"][^'"]*preflights\/[^'"]+['"]/g);
+        if (preflightImports && preflightImports.length >= 3) {
+            return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get list of preflights that are already orchestrated by consolidated/*.ts files
+ */
+function getOrchestratedPreflights() {
+    const orchestrated = new Set();
+    const consolidatedDir = path.join(process.cwd(), "scripts/active/preflights/consolidated");
+    const workflowsDir = path.join(process.cwd(), "scripts/active/preflights/workflows");
+    const scanDir = (dir) => {
+        if (!fs.existsSync(dir))
+            return;
+        const files = fs.readdirSync(dir).filter((f) => f.endsWith(".ts"));
+        for (const file of files) {
+            try {
+                const content = fs.readFileSync(path.join(dir, file), "utf-8");
+                // Extract preflight paths from runCheck calls
+                // Pattern: runCheck("name", "scripts/active/preflights/path.ts")
+                const runCheckMatches = content.matchAll(/runCheck\s*\(\s*['"][^'"]+['"]\s*,\s*['"]([^'"]+\.(?:ts|js|mjs))['"]/g);
+                for (const match of runCheckMatches) {
+                    if (match[1]) {
+                        // Normalize path
+                        const preflightPath = match[1].replace(/^scripts\/active\/preflights\//, "");
+                        orchestrated.add(preflightPath);
+                    }
+                }
+                // Extract from exec calls
+                const execMatches = content.matchAll(/exec\s*\(\s*['"`][^'"`]*scripts\/active\/preflights\/([^'"`\s]+\.(?:ts|js|mjs))/g);
+                for (const match of execMatches) {
+                    if (match[1]) {
+                        orchestrated.add(match[1]);
+                    }
+                }
+                // Extract from script arrays (used in quality.ts pattern)
+                // Pattern: { name: "...", script: "scripts/active/preflights/path.ts" }
+                const scriptArrayMatches = content.matchAll(/script:\s*['"]scripts\/active\/preflights\/([^'"]+\.(?:ts|js|mjs))['"]/g);
+                for (const match of scriptArrayMatches) {
+                    if (match[1]) {
+                        orchestrated.add(match[1]);
+                    }
+                }
+                // Extract from string literals containing preflight paths
+                // Pattern: "scripts/active/preflights/specialized/file.ts"
+                const stringLiteralMatches = content.matchAll(/['"]scripts\/active\/preflights\/(specialized\/[^'"]+\.(?:ts|js|mjs))['"]/g);
+                for (const match of stringLiteralMatches) {
+                    if (match[1]) {
+                        orchestrated.add(match[1]);
+                    }
+                }
+            }
+            catch {
+                // Skip files that can't be read
+            }
+        }
+    };
+    scanDir(consolidatedDir);
+    scanDir(workflowsDir);
+    return orchestrated;
+}
+/**
+ * Check if a category already has a consolidated orchestrator
+ */
+function hasConsolidatedOrchestrator(category, analyses) {
+    const categoryLower = category.toLowerCase().replace(/-/g, "");
+    // Check consolidated directory for matching orchestrator
+    return analyses.some((a) => {
+        if (!a.file.includes("/consolidated/"))
+            return false;
+        const fileName = path.basename(a.file, path.extname(a.file)).toLowerCase().replace(/-/g, "");
+        // Match category name or related names
+        return (fileName.includes(categoryLower) ||
+            categoryLower.includes(fileName) ||
+            // Special mappings
+            (category === "prisma" && fileName.includes("database")) ||
+            (category === "forms" && fileName.includes("uiforms")) ||
+            (category === "buttons" && fileName.includes("uibuttons")) ||
+            (category === "cards" && fileName.includes("uicards")) ||
+            (category === "responsive" &&
+                (fileName.includes("uiresponsive") || fileName.includes("uigrid"))) ||
+            (category === "spacing" && fileName.includes("uispacing")) ||
+            (category === "typography" && fileName.includes("uitypography")) ||
+            (category === "accessibility" && fileName.includes("uiaccessibility")) ||
+            (category === "dark-mode" && fileName.includes("darkmode")));
+    });
+}
+function findConsolidationOpportunities(analyses) {
+    const opportunities = [];
+    // Get list of already orchestrated preflights
+    const orchestratedPreflights = getOrchestratedPreflights();
+    // Group files by prefix patterns (e.g., "button-", "card-", "form-", "grid-")
+    const prefixGroups = new Map();
+    const prefixPatterns = [
+        { prefix: "button-", category: "buttons", suggestedName: "ui-buttons" },
+        { prefix: "card-", category: "cards", suggestedName: "ui-cards" },
+        { prefix: "form-", category: "forms", suggestedName: "ui-forms" },
+        { prefix: "formfield-", category: "forms", suggestedName: "ui-forms" },
+        { prefix: "grid-", category: "grid", suggestedName: "ui-grid-responsive" },
+        { prefix: "spacing-", category: "spacing", suggestedName: "ui-spacing" },
+        { prefix: "deprecated-", category: "deprecated", suggestedName: "ui-deprecated" },
+        { prefix: "prisma-", category: "prisma", suggestedName: "database-prisma" },
+        { prefix: "select-", category: "forms", suggestedName: "ui-forms" },
+        { prefix: "textfield-", category: "forms", suggestedName: "ui-forms" },
+        { prefix: "mobile-", category: "responsive", suggestedName: "ui-grid-responsive" },
+        { prefix: "table-", category: "tables", suggestedName: "ui-tables" },
+        { prefix: "typography-", category: "typography", suggestedName: "ui-typography" },
+        { prefix: "dark-mode-", category: "dark-mode", suggestedName: "ui-dark-mode" },
+        { prefix: "accessibility-", category: "accessibility", suggestedName: "ui-accessibility" },
+        { prefix: "css-", category: "css", suggestedName: "css-validation" },
+    ];
+    for (const analysis of analyses) {
+        // Skip organizational directories
+        if (analysis.file.includes("/consolidated/"))
+            continue;
+        if (analysis.file.includes("/workflows/"))
+            continue;
+        if (analysis.file.includes("/system/"))
+            continue;
+        if (analysis.file.includes("/shared/"))
+            continue;
+        if (analysis.file.includes("/utils/"))
+            continue;
+        // Skip files that are orchestrators themselves
+        if (isOrchestratorFile(analysis.file))
+            continue;
+        // Skip files that are already orchestrated by consolidated/*.ts
+        // Normalize path separators for cross-platform compatibility
+        const relativePath = analysis.file
+            .replace(/\\/g, "/")
+            .replace(/^scripts\/active\/preflights\//, "");
+        if (orchestratedPreflights.has(relativePath) ||
+            orchestratedPreflights.has(analysis.file.replace(/\\/g, "/"))) {
+            continue;
+        }
+        const fileName = path.basename(analysis.file, path.extname(analysis.file));
+        for (const { prefix, category } of prefixPatterns) {
+            if (fileName.startsWith(prefix)) {
+                if (!prefixGroups.has(category)) {
+                    prefixGroups.set(category, []);
+                }
+                prefixGroups.get(category).push(analysis);
+                break;
+            }
+        }
+    }
+    // Check for groups with 3+ files that could be consolidated
+    for (const [category, files] of prefixGroups) {
+        if (files.length >= 3) {
+            // Check if a consolidated orchestrator already exists for this category
+            if (hasConsolidatedOrchestrator(category, analyses)) {
+                continue; // Already consolidated - not a real opportunity
+            }
+            const patternInfo = prefixPatterns.find((p) => p.category === category);
+            opportunities.push({
+                category,
+                files: files.map((f) => f.file),
+                reason: `${files.length} preflights with "${category}" prefix could be merged`,
+                suggestedName: patternInfo?.suggestedName || `consolidated-${category}`,
+                priority: files.length >= 5 ? "high" : files.length >= 3 ? "medium" : "low",
+            });
+        }
+    }
+    // Check for files in same directory with similar functionality
+    // BUT only if the directory doesn't already have a consolidated orchestrator
+    const dirGroups = new Map();
+    for (const analysis of analyses) {
+        // Skip organizational directories
+        if (analysis.file.includes("/consolidated/"))
+            continue;
+        if (analysis.file.includes("/workflows/"))
+            continue;
+        if (analysis.file.includes("/system/"))
+            continue;
+        if (analysis.file.includes("/shared/"))
+            continue;
+        if (analysis.file.includes("/utils/"))
+            continue;
+        // Skip orchestrators
+        if (isOrchestratorFile(analysis.file))
+            continue;
+        // Skip already orchestrated files
+        // Normalize path separators for cross-platform compatibility
+        const relativePath = analysis.file
+            .replace(/\\/g, "/")
+            .replace(/^scripts\/active\/preflights\//, "");
+        if (orchestratedPreflights.has(relativePath) ||
+            orchestratedPreflights.has(analysis.file.replace(/\\/g, "/"))) {
+            continue;
+        }
+        const dir = path.dirname(analysis.file);
+        if (!dirGroups.has(dir)) {
+            dirGroups.set(dir, []);
+        }
+        dirGroups.get(dir).push(analysis);
+    }
+    for (const [dir, files] of dirGroups) {
+        // Skip if directory has fewer than 8 NON-ORCHESTRATED standalone files
+        if (files.length < 8)
+            continue;
+        const dirName = path.basename(dir);
+        // Skip organizational directories that shouldn't be consolidated
+        if (["workflows", "utils", "system", "shared", "consolidated"].includes(dirName)) {
+            continue;
+        }
+        // Check if this directory already has a consolidated orchestrator
+        if (hasConsolidatedOrchestrator(dirName, analyses)) {
+            continue; // Already has orchestrator - not a real opportunity
+        }
+        opportunities.push({
+            category: dirName,
+            files: files.slice(0, 10).map((f) => f.file),
+            reason: `Directory "${dirName}" has ${files.length} non-orchestrated preflights - consider creating consolidated/${dirName}.ts`,
+            suggestedName: `${dirName}`,
+            priority: files.length >= 15 ? "high" : "medium",
+        });
+    }
+    return opportunities;
+}
+/**
+ * Find preflights with identical or near-identical content (copy-pasted).
+ * Uses content hash to detect duplicates.
+ */
+function findDuplicateContent(analyses) {
+    const hashToFiles = new Map();
+    for (const analysis of analyses) {
+        if (!hashToFiles.has(analysis.contentHash)) {
+            hashToFiles.set(analysis.contentHash, []);
+        }
+        hashToFiles.get(analysis.contentHash).push(analysis);
+    }
+    for (const [hash, duplicates] of hashToFiles) {
+        if (duplicates.length > 1) {
+            issues.push({
+                type: "duplicate-content",
+                severity: "error",
+                message: `${duplicates.length} preflights have identical content (hash: ${hash}). These are likely copy-pasted and should be consolidated.`,
+                files: duplicates.map((d) => d.file),
+                pattern: hash,
+            });
+        }
+    }
+}
+/**
+ * Find preflights not using shared patterns that should be migrated.
+ * Tracks adoption rate of shared glob-patterns.ts
+ */
+function findSharedPatternAdoption(analyses) {
+    const notUsingShared = analyses.filter((a) => !a.usesSharedPatterns);
+    const adoptionRate = (((analyses.length - notUsingShared.length) / analyses.length) *
+        100).toFixed(1);
+    // Only flag if adoption is below 20% (most preflights don't need shared patterns)
+    // This is just for tracking, not actionable
+    if (parseFloat(adoptionRate) < 20) {
+        issues.push({
+            type: "local-excludes",
+            severity: "info",
+            message: `Shared pattern adoption: ${adoptionRate}%. Consider migrating more preflights to use shared/glob-patterns.ts.`,
+            files: notUsingShared.slice(0, 5).map((a) => a.file),
+        });
+    }
+}
+/**
+ * Find preflights with local EXCLUDED definitions that should use shared glob-patterns.ts
+ * This prevents the pattern duplication problem from recurring.
+ *
+ * Only flags const definitions with hardcoded glob strings (not regex patterns or spread operators).
+ */
+function findLocalExcludeDefinitions(analyses) {
+    const filesWithLocalExcludes = [];
+    for (const analysis of analyses) {
+        // Skip the shared glob-patterns file itself
+        if (analysis.file.includes("shared/glob-patterns"))
+            continue;
+        try {
+            const content = fs.readFileSync(analysis.file, "utf-8");
+            // Check if file has local EXCLUDED/EXCLUDED_PATHS/SKIP_PATTERNS const definition
+            // with hardcoded glob strings (not using spread from shared patterns)
+            const localExcludedMatch = content.match(/const\s+(?:EXCLUDED|EXCLUDED_PATHS|SKIP_PATTERNS)\s*=\s*\[([^\]]*)\]/s);
+            if (localExcludedMatch) {
+                const arrayContent = localExcludedMatch[1] || "";
+                // Skip if it uses spread operator from shared patterns (already migrated)
+                if (arrayContent.includes("...STANDARD_EXCLUDES") ||
+                    arrayContent.includes("...CORE_EXCLUDES") ||
+                    arrayContent.includes("...PRODUCTION_CODE_EXCLUDES") ||
+                    arrayContent.includes("...FULL_EXCLUDES") ||
+                    arrayContent.includes("extendExcludes")) {
+                    continue;
+                }
+                // Skip if it's regex patterns (like /node_modules/) not glob strings
+                if (arrayContent.includes("/node_modules/") &&
+                    !arrayContent.includes("'**/node_modules/**'") &&
+                    !arrayContent.includes('"**/node_modules/**"')) {
+                    continue;
+                }
+                // Check if it has hardcoded glob strings like '**/node_modules/**'
+                const hasHardcodedGlobs = /['"](\*\*\/[^'"]+|[^'"]*\*\.[a-z]+)['"]/.test(arrayContent);
+                if (hasHardcodedGlobs) {
+                    filesWithLocalExcludes.push(analysis.file);
+                }
+            }
+        }
+        catch {
+            // Skip files that can't be read
+        }
+    }
+    if (filesWithLocalExcludes.length > 0) {
+        issues.push({
+            type: "duplicate-glob",
+            severity: "error",
+            message: `${filesWithLocalExcludes.length} preflight(s) define local EXCLUDED/SKIP_PATTERNS arrays with hardcoded globs instead of using shared/glob-patterns.ts. Run: pnpm tsx scripts/active/maintenance-tools/migrate-preflight-excludes.ts --apply`,
+            files: filesWithLocalExcludes,
+        });
+    }
+}
+async function main() {
+    const isVerbose = process.argv.includes("--verbose");
+    const isJson = process.argv.includes("--json");
+    if (!isJson) {
+        console.log(`\n${console_chars_1.emoji.search} Preflight Redundancy Detection (blocking)\n`);
+        console.log((0, console_chars_1.createDivider)(70, "heavy"));
+    }
+    // Find all preflight files
+    const preflightFiles = await getPreflightFiles();
+    if (!isJson) {
+        console.log(`${console_chars_1.emoji.chart} Analyzing ${preflightFiles.length} preflight files...\n`);
+    }
+    // Analyze each preflight
+    const analyses = [];
+    for (const file of preflightFiles) {
+        try {
+            const analysis = await analyzePreflightFile(file);
+            analyses.push(analysis);
+        }
+        catch (err) {
+            if (!isJson) {
+                console.warn(`${console_chars_1.emoji.warning}  Could not analyze ${file}: ${err}`);
+            }
+        }
+    }
+    // Find redundancies
+    findDuplicatePatterns(analyses);
+    findDuplicateGlobs(analyses);
+    findDuplicateErrorCodes(analyses);
+    findSimilarNames(analyses);
+    findHighOverlap(analyses);
+    findDomainFragmentation(analyses);
+    findTestFileScanOverlap(analyses);
+    findDuplicateContent(analyses);
+    findSharedPatternAdoption(analyses);
+    findLocalExcludeDefinitions(analyses);
+    await findOrphanedPreflights(analyses);
+    findBuildCommandRedundancy();
+    // Find consolidation opportunities
+    const consolidationOpportunities = findConsolidationOpportunities(analyses);
+    // Report results
+    const errors = issues.filter((i) => i.severity === "error");
+    const warnings = issues.filter((i) => i.severity === "warning");
+    const infos = issues.filter((i) => i.severity === "info");
+    // JSON output for trend tracking
+    if (isJson) {
+        const report = {
+            timestamp: new Date().toISOString(),
+            totalPreflights: analyses.length,
+            errors: errors.length,
+            warnings: warnings.length,
+            infos: infos.length,
+            totalRegexPatterns: analyses.reduce((sum, a) => sum + a.regexPatterns.length, 0),
+            totalErrorCodes: analyses.reduce((sum, a) => sum + a.errorCodes.length, 0),
+            issues: issues,
+        };
+        console.log(JSON.stringify(report, null, 2));
+        process.exit(errors.length > 0 ? 1 : 0);
+    }
+    if (errors.length > 0) {
+        console.log(`${console_chars_1.emoji.error} ERRORS (blocking - must fix):`);
+        for (const issue of errors) {
+            console.log(`\n  [${issue.type}] ${issue.message}`);
+            console.log(`    Files: ${issue.files.map((f) => path.basename(f)).join(", ")}`);
+        }
+        console.log("");
+    }
+    if (warnings.length > 0) {
+        console.log(`${console_chars_1.emoji.warning}  WARNINGS (should fix):`);
+        for (const issue of warnings.slice(0, 10)) {
+            console.log(`\n  [${issue.type}] ${issue.message}`);
+            console.log(`    Files: ${issue.files.map((f) => path.basename(f)).join(", ")}`);
+        }
+        if (warnings.length > 10) {
+            console.log(`\n  ... and ${warnings.length - 10} more warnings`);
+        }
+        console.log("");
+    }
+    if (infos.length > 0 && isVerbose) {
+        console.log(`${console_chars_1.emoji.info}  INFO (for awareness):`);
+        for (const issue of infos.slice(0, 5)) {
+            console.log(`  [${issue.type}] ${issue.message}`);
+        }
+        if (infos.length > 5) {
+            console.log(`  ... and ${infos.length - 5} more info items`);
+        }
+        console.log("");
+    }
+    // Show consolidation opportunities
+    if (consolidationOpportunities.length > 0) {
+        console.log(`\n${console_chars_1.emoji.hint} CONSOLIDATION OPPORTUNITIES:`);
+        console.log((0, console_chars_1.createDivider)(70, "light"));
+        const highPriority = consolidationOpportunities.filter((o) => o.priority === "high");
+        const mediumPriority = consolidationOpportunities.filter((o) => o.priority === "medium");
+        if (highPriority.length > 0) {
+            console.log(`\n  ${console_chars_1.emoji.error} HIGH PRIORITY (5+ files):`);
+            for (const opp of highPriority) {
+                console.log(`\n    Category: ${opp.category}`);
+                console.log(`    Reason: ${opp.reason}`);
+                console.log(`    Suggested: consolidated/${opp.suggestedName}.ts`);
+                console.log(`    Files: ${opp.files
+                    .slice(0, 5)
+                    .map((f) => path.basename(f))
+                    .join(", ")}${opp.files.length > 5 ? ` (+${opp.files.length - 5} more)` : ""}`);
+            }
+        }
+        if (mediumPriority.length > 0 && isVerbose) {
+            console.log(`\n  ${console_chars_1.emoji.warning}  MEDIUM PRIORITY (3-4 files):`);
+            for (const opp of mediumPriority.slice(0, 5)) {
+                console.log(`\n    Category: ${opp.category}`);
+                console.log(`    Reason: ${opp.reason}`);
+                console.log(`    Suggested: consolidated/${opp.suggestedName}.ts`);
+            }
+            if (mediumPriority.length > 5) {
+                console.log(`\n    ... and ${mediumPriority.length - 5} more medium priority opportunities`);
+            }
+        }
+        console.log(`\n  Total opportunities: ${consolidationOpportunities.length} (${highPriority.length} high, ${mediumPriority.length} medium)`);
+    }
+    // Summary
+    console.log((0, console_chars_1.createDivider)(70, "heavy"));
+    console.log(`${console_chars_1.emoji.chart} Summary: ${errors.length} errors, ${warnings.length} warnings, ${infos.length} info`);
+    console.log(`   Analyzed: ${analyses.length} preflights`);
+    console.log(`   Total regex patterns: ${analyses.reduce((sum, a) => sum + a.regexPatterns.length, 0)}`);
+    console.log(`   Total error codes: ${analyses.reduce((sum, a) => sum + a.errorCodes.length, 0)}`);
+    // Shared pattern adoption stats
+    const usingShared = analyses.filter((a) => a.usesSharedPatterns).length;
+    console.log(`   Shared pattern adoption: ${usingShared}/${analyses.length} (${((usingShared / analyses.length) * 100).toFixed(0)}%)`);
+    if (errors.length === 0) {
+        console.log(`\n${console_chars_1.emoji.success} No critical redundancies detected\n`);
+        process.exit(0);
+    }
+    else {
+        console.log(`\n${console_chars_1.emoji.error} Fix redundancies before continuing\n`);
+        console.log(`${console_chars_1.emoji.hint} Suggestions:`);
+        console.log(`   ${console_chars_1.chars.bullet} Merge preflights with high overlap into consolidated modules`);
+        console.log(`   ${console_chars_1.chars.bullet} Remove duplicate error codes (use unique codes per check)`);
+        console.log(`   ${console_chars_1.chars.bullet} Consider if similar-named preflights should be combined`);
+        console.log("   ${chars.bullet} Run: pnpm preflight:migrate-excludes --apply to fix local excludes");
+        process.exit(1);
+    }
+}
+main().catch((err) => {
+    console.error(`${console_chars_1.emoji.error} Preflight redundancy detection crashed:`, err);
+    process.exit(1);
+});
+//# sourceMappingURL=preflight-redundancy-detection.js.map