@empline/preflight 1.1.11 → 1.1.13

package/dist/checks/specialized/shared-components-migration.js

@@ -0,0 +1,1288 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Shared Components Migration Check (Enhanced)
+ *
+ * Prevents reversion to old patterns by detecting:
+ *
+ * ERRORS (blocking):
+ * - MUI imports (@mui/material, @mui/icons-material, @emotion)
+ * - Banned libraries (react-icons, heroicons, fortawesome, lodash, moment)
+ *
+ * WARNINGS (should fix):
+ * - Duplicate hook implementations
+ * - Duplicate utility functions
+ * - TypeScript 'any' type usage (except types/, mocks, configs)
+ * - Console statements in components
+ * - Empty catch blocks
+ * - Accessibility issues (missing alt, click on non-interactive)
+ * - Deprecated component usage
+ *
+ * INFO (suggestions with --info):
+ * - Inline patterns that should use shared components
+ * - Loading/skeleton patterns
+ * - Dialog/modal patterns
+ * - Table patterns with sorting/pagination
+ * - Form patterns with many fields
+ * - Date formatting patterns
+ * - Price display patterns
+ * - Performance patterns (inline handlers, missing keys)
+ * - TODO/FIXME comments
+ * - Hardcoded URLs
+ * - Magic numbers
+ *
+ * Run: pnpm preflight:shared-components
+ *
+ * Options:
+ *   --verbose, -v     Show all warnings (not just errors)
+ *   --report          Output JSON report for CI integration
+ *   --info            Show info-level suggestions
+ *   --fix             Auto-fix issues where possible:
+ *                     - Adds preflight-ignore comments for 'any' type
+ *                     - Removes console.log statements
+ *                     - Adds missing imports
+ *
+ * Ignore patterns:
+ *   // preflight-ignore - Ignore next line
+ *   // preflight-ignore-file - Ignore entire file (must be at top)
+ *   // preflight-ignore-next-N - Ignore next N lines
+ *
+ * Auto-fix types:
+ *   - remove-line: Removes the entire line
+ *   - replace-line: Replaces the line with new content
+ *   - replace-import: Replaces an import statement
+ *   - add-import: Adds a new import statement
+ *   - remove-console: Removes console.log/debug/info statements
+ *   - add-preflight-ignore: Adds a preflight-ignore comment
+ */
+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.SharedComponentsChecker = exports.tags = exports.description = exports.blocking = exports.category = exports.name = exports.id = void 0;
+const fs = __importStar(require("fs"));
+const file_cache_1 = require("../../shared/file-cache");
+const path = __importStar(require("path"));
+const console_chars_1 = require("../../utils/console-chars");
+// Check metadata
+exports.id = "specialized/shared-components-migration";
+exports.name = "Shared Components Migration";
+exports.category = "specialized";
+exports.blocking = true;
+exports.description = "Shared Components Migration Check (Enhanced)";
+exports.tags = ["specialized", "database"];
+// CONFIGURATION
+// MUI is BANNED - all imports should use @/components/ui or @/components/shared
+const BANNED_IMPORT_PATTERNS = [
+    { pattern: /@mui\/material/, message: "MUI Material is banned", replacement: "@/components/ui" },
+    { pattern: /@mui\/icons-material/, message: "MUI Icons are banned", replacement: "lucide-react" },
+    { pattern: /@mui\/lab/, message: "MUI Lab is banned", replacement: "@/components/ui" },
+    {
+        pattern: /@mui\/x-/,
+        message: "MUI X components are banned",
+        replacement: "@/components/shared",
+    },
+    {
+        pattern: /@emotion\//,
+        message: "Emotion (MUI styling) is banned",
+        replacement: "Tailwind CSS",
+    },
+    // Other banned icon libraries
+    { pattern: /react-icons\//, message: "react-icons is banned", replacement: "lucide-react" },
+    { pattern: /@heroicons\//, message: "Heroicons is banned", replacement: "lucide-react" },
+    { pattern: /@fortawesome\//, message: "Font Awesome is banned", replacement: "lucide-react" },
+    // Banned utility libraries (use native JS or shared utils)
+    { pattern: /^lodash$/, message: "lodash is banned", replacement: "native JS or @/lib/utils" },
+    { pattern: /lodash\//, message: "lodash is banned", replacement: "native JS or @/lib/utils" },
+    { pattern: /^moment$/, message: "moment.js is banned", replacement: "date-fns or native Date" },
+];
+// Deprecated components that should not be used (from shared/index.ts comments)
+// Note: Some are re-exported as aliases (e.g., PriceDisplay -> UnifiedPriceDisplay)
+// Only flag if importing from wrong location or using truly deprecated names
+const DEPRECATED_COMPONENTS = [
+    { name: "SkeletonLoader", replacement: "UnifiedSkeleton", checkImportPath: true },
+    {
+        name: "ToastProvider",
+        replacement: "StatusProvider from @/components/shared/status",
+        checkImportPath: false,
+    },
+    {
+        name: "useToast",
+        replacement: "useStatus from @/components/shared/status",
+        checkImportPath: false,
+    },
+    // These are aliases in shared/index.ts, so only flag if imported from wrong place
+    // { name: "PriceDisplay", replacement: "UnifiedPriceDisplay" }, // Alias exists, skip
+    { name: "Modal", replacement: "UnifiedDialog from @/components/shared", checkImportPath: false },
+    { name: "DataTable", replacement: "EnhancedDataTable", checkImportPath: true },
+    { name: "PageHeader", replacement: "UnifiedPageHeader", checkImportPath: true },
+    { name: "SimilarItems", replacement: "RelatedItems (server-rendered)", checkImportPath: false },
+    { name: "ActionBanner", replacement: "UnifiedStatus position='banner'", checkImportPath: false },
+    { name: "ImageUploadZone", replacement: "UnifiedFileInterface", checkImportPath: false },
+    { name: "FloatingActionButton", replacement: "removed (dead code)", checkImportPath: false },
+];
+// Hooks that should use shared implementations
+const SHARED_HOOKS = [
+    "useToggle",
+    "useDisclosure",
+    "useLocalStorage",
+    "useForm",
+    "useAsync",
+    "useCopyToClipboard",
+    "useMediaQuery",
+    "useClickOutside",
+    "usePagination",
+    "useDebounce",
+    "useThrottle",
+    "useIntersectionObserver",
+    "useWindowSize",
+];
+// Utilities that should use shared implementations
+const SHARED_UTILITIES = [
+    "unique",
+    "groupBy",
+    "chunk",
+    "sortBy",
+    "capitalize",
+    "slugify",
+    "camelCase",
+    "formatCurrency",
+    "formatDate",
+    "formatFileSize",
+    "formatNumber",
+    "formatPercent",
+    "isValidEmail",
+    "validatePassword",
+    "isRequired",
+    "truncate",
+    "debounce",
+    "throttle",
+];
+// Inline patterns that indicate code smell
+const INLINE_PATTERNS_TO_CHECK = [
+    {
+        pattern: /className="[^"]*flex[^"]*items-center[^"]*gap-[^"]*"/,
+        context: "StatusChip",
+        message: "Flex row with gap pattern (possible status display)",
+        suggestion: "Consider StatusIconChip or LabelValuePair from @/components/shared",
+        severity: "info",
+    },
+    {
+        pattern: /\bawait\s+fetch\s*\(/,
+        context: "useQuery",
+        message: "Direct fetch call in component",
+        suggestion: "Consider using React Query or a custom hook for data fetching",
+        severity: "info",
+    },
+];
+// Files/patterns to always exclude
+const EXCLUDED_PATTERNS = [
+    "**/node_modules/**",
+    "**/.next/**",
+    "**/dist/**",
+    "**/build/**",
+    "components/shared/**",
+    "components/ui/**",
+    "hooks/**",
+    "lib/utils/**",
+    "packages/**",
+    "scripts/**",
+    "tests/**",
+    "**/*.test.{ts,tsx}",
+    "**/*.spec.{ts,tsx}",
+    "**/*.stories.{ts,tsx}",
+];
+// Files where 'any' type is acceptable (type definitions, mocks, configs)
+const ANY_TYPE_ALLOWED_PATTERNS = [
+    /^types[\/\\]/,
+    /^__mocks__[\/\\]/,
+    /\.config\.(ts|js)$/,
+    /\.d\.ts$/,
+    /prisma[\/\\].*\.ts$/,
+    /docs[\/\\]code-examples[\/\\]/, // Documentation examples
+];
+// CHECKER CLASS
+class SharedComponentsChecker {
+    issues = [];
+    options;
+    stats = {
+        filesChecked: 0,
+        errors: 0,
+        warnings: 0,
+        info: 0,
+        ignoredFiles: 0,
+        ignoredLines: 0,
+        fixesApplied: 0,
+        fixesFailed: 0,
+    };
+    fileIgnoreCache = new Map();
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async check() {
+        console.log(`${console_chars_1.emoji.search} Checking for shared component usage...\n`);
+        const files = await file_cache_1.fileCache.getAllTsTsx();
+        for (const file of files) {
+            await this.checkFile(file);
+        }
+        this.calculateStats();
+        // Apply fixes if --fix flag is set
+        if (this.options.fix) {
+            await this.applyFixes();
+        }
+        this.printResults();
+        if (this.options.report) {
+            this.outputJsonReport();
+        }
+        return {
+            passed: this.stats.errors === 0,
+            issues: this.issues,
+            stats: this.stats,
+        };
+    }
+    async checkFile(filePath) {
+        const content = fs.readFileSync(filePath, "utf-8");
+        const lines = content.split("\n");
+        // Check for file-level ignore
+        const firstLines = lines.slice(0, 10).join("\n");
+        if (firstLines.includes("preflight-ignore-file")) {
+            this.stats.ignoredFiles++;
+            return;
+        }
+        this.stats.filesChecked++;
+        // Build ignore line cache for this file
+        this.buildIgnoreCache(filePath, lines);
+        lines.forEach((line, index) => {
+            const lineNumber = index + 1;
+            // Skip ignored lines
+            if (this.isLineIgnored(filePath, lineNumber)) {
+                this.stats.ignoredLines++;
+                return;
+            }
+            // Run all checks
+            this.checkMUIImports(line, lineNumber, filePath);
+            this.checkDuplicateHooks(line, lineNumber, filePath);
+            this.checkDuplicateUtilities(line, lineNumber, filePath);
+            this.checkInlinePatterns(line, lineNumber, filePath, lines);
+            this.checkLoadingPatterns(line, lineNumber, filePath, lines);
+            this.checkDatePatterns(line, lineNumber, filePath);
+            this.checkPricePatterns(line, lineNumber, filePath);
+            this.checkDialogPatterns(line, lineNumber, filePath, lines);
+            this.checkSkeletonPatterns(line, lineNumber, filePath, lines);
+            this.checkTablePatterns(line, lineNumber, filePath, lines);
+            this.checkFormPatterns(line, lineNumber, filePath, lines);
+            this.checkCodeQuality(line, lineNumber, filePath, lines);
+            this.checkDeprecatedComponents(line, lineNumber, filePath);
+            this.checkDateFnsUsage(line, lineNumber, filePath);
+            this.checkAccessibility(line, lineNumber, filePath);
+            this.checkPerformancePatterns(line, lineNumber, filePath, lines);
+        });
+    }
+    // IGNORE HANDLING
+    buildIgnoreCache(filePath, lines) {
+        const ignoredLines = new Set();
+        lines.forEach((line, index) => {
+            // Check for inline ignore comment
+            if (line.includes("preflight-ignore")) {
+                // Ignore current line and next line
+                ignoredLines.add(index + 1);
+                ignoredLines.add(index + 2);
+                // Also check for range ignore (preflight-ignore-next-5)
+                const rangeMatch = line.match(/preflight-ignore-next-(\d+)/);
+                if (rangeMatch) {
+                    const count = parseInt(rangeMatch[1], 10);
+                    for (let i = 1; i <= count; i++) {
+                        ignoredLines.add(index + 1 + i);
+                    }
+                }
+            }
+        });
+        this.fileIgnoreCache.set(filePath, ignoredLines);
+    }
+    isLineIgnored(filePath, lineNumber) {
+        const ignoredLines = this.fileIgnoreCache.get(filePath);
+        if (!ignoredLines)
+            return false;
+        // Check if this line or any of the previous 3 lines have ignore
+        for (let i = 0; i <= 3; i++) {
+            if (ignoredLines.has(lineNumber - i)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // CHECK METHODS
+    checkMUIImports(line, lineNumber, filePath) {
+        // Check for ANY banned import patterns (MUI, Emotion, etc.)
+        for (const banned of BANNED_IMPORT_PATTERNS) {
+            if (banned.pattern.test(line)) {
+                this.addIssue({
+                    file: filePath,
+                    line: lineNumber,
+                    type: "error", // MUI imports are ERRORS, not warnings
+                    category: "banned-import",
+                    message: banned.message,
+                    suggestion: `Use ${banned.replacement} instead`,
+                });
+            }
+        }
+    }
+    checkDuplicateHooks(line, lineNumber, filePath) {
+        const hookMatch = line.match(/(?:export\s+)?(?:const|function)\s+(use[A-Z]\w+)/);
+        if (hookMatch) {
+            const hookName = hookMatch[1];
+            if (SHARED_HOOKS.includes(hookName)) {
+                this.addIssue({
+                    file: filePath,
+                    line: lineNumber,
+                    type: "warning",
+                    category: "duplicate-hook",
+                    message: `Duplicate hook implementation: ${hookName}`,
+                    suggestion: `Import ${hookName} from @/hooks instead`,
+                });
+            }
+        }
+    }
+    checkDuplicateUtilities(line, lineNumber, filePath) {
+        const utilMatch = line.match(/(?:export\s+)?(?:const|function)\s+(\w+)\s*[=:]/);
+        if (utilMatch) {
+            const utilName = utilMatch[1];
+            if (SHARED_UTILITIES.includes(utilName)) {
+                // Skip false positives
+                if (this.isFalsePositiveUtility(line, utilName, filePath)) {
+                    return;
+                }
+                this.addIssue({
+                    file: filePath,
+                    line: lineNumber,
+                    type: "warning",
+                    category: "duplicate-utility",
+                    message: `Duplicate utility function: ${utilName}`,
+                    suggestion: `Import ${utilName} from @/lib/utils instead`,
+                    autoFixable: true,
+                });
+            }
+        }
+    }
+    isFalsePositiveUtility(line, utilName, filePath) {
+        // Skip variable assignments (not function definitions)
+        if (line.includes("=") && !line.includes("=>") && !line.includes("function")) {
+            return true;
+        }
+        // Skip streaming decoder chunks
+        if (utilName === "chunk" && line.includes("decoder.decode")) {
+            return true;
+        }
+        // Skip loop variables
+        if (line.includes("const chunk = buffer.slice")) {
+            return true;
+        }
+        // Skip object properties
+        if (line.includes("{") && !line.includes("function") && !line.includes("=>")) {
+            return true;
+        }
+        // Skip if already importing from shared utils
+        const fileContent = fs.readFileSync(filePath, "utf-8");
+        if (fileContent.includes(`import { ${utilName}`) && fileContent.includes("@/lib/utils")) {
+            return true;
+        }
+        // Skip component-specific formatters
+        if (line.startsWith("const ") && !line.includes("export")) {
+            if (line.includes("(value") || line.includes("(dateString") || line.includes("(amount")) {
+                return true;
+            }
+        }
+        return false;
+    }
+    checkInlinePatterns(line, lineNumber, filePath, lines) {
+        const getNextLines = (count) => {
+            return lines.slice(lineNumber, lineNumber + count).join("\n");
+        };
+        const getPrevLines = (count) => {
+            return lines.slice(Math.max(0, lineNumber - count - 1), lineNumber - 1).join("\n");
+        };
+        // Balance card pattern (colored icon background + currency value)
+        if (line.match(/bg-(green|orange|red|blue)-100/) && !filePath.includes("BalanceStatCard")) {
+            const nextLines = getNextLines(10);
+            if (nextLines.includes("formatCurrency") || nextLines.includes('variant="h4"')) {
+                this.addIssue({
+                    file: filePath,
+                    line: lineNumber,
+                    type: "warning",
+                    category: "inline-pattern",
+                    message: "Inline balance card pattern detected (colored icon bg + currency)",
+                    suggestion: "Use BalanceStatCard from @/components/shared for consistent finance cards",
+                });
+            }
+        }
+        // Status icon + chip combo pattern
+        if ((line.includes("getStatusIcon") || line.match(/\{.*Icon.*size=\{16\}/)) &&
+            !filePath.includes("StatusIconChip")) {
+            const nextLines = getNextLines(3);
+            if (nextLines.includes("StatusChip")) {
+                this.addIssue({
+                    file: filePath,
+                    line: lineNumber,
+                    type: "warning",
+                    category: "inline-pattern",
+                    message: "Status icon + StatusChip combo pattern detected",
+                    suggestion: "Use StatusIconChip from @/components/shared which auto-detects icons",
+                });
+            }
+        }
+        // Compact stat card pattern (caption label + h5 value)
+        if (line.includes('variant="caption"') && line.includes('color="text.secondary"')) {
+            const nextLines = getNextLines(3);
+            if (nextLines.includes('variant="h5"') && nextLines.includes('fontWeight="bold"')) {
+                const prevLines = getPrevLines(5);
+                if (prevLines.includes("CardContent") && prevLines.includes("p-4")) {
+                    this.addIssue({
+                        file: filePath,
+                        line: lineNumber,
+                        type: "warning",
+                        category: "inline-pattern",
+                        message: "Compact stat card pattern detected (caption + h5 bold)",
+                        suggestion: "Use CompactStatCard from @/components/shared for consistent stat display",
+                    });
+                }
+            }
+        }
+        // Pagination logic
+        if (line.includes("useState") && (line.includes("page") || line.includes("Page"))) {
+            const nextLines = getNextLines(5);
+            if (nextLines.includes("setPage") && nextLines.includes("totalPages")) {
+                this.addIssue({
+                    file: filePath,
+                    line: lineNumber,
+                    type: "info",
+                    category: "inline-pattern",
+                    message: "Inline pagination state detected",
+                    suggestion: "Consider using usePagination hook from @/hooks",
+                });
+            }
+        }
+        // Toggle logic
+        if (line.match(/const\s+\[is\w+,\s*set\w+\]\s*=\s*useState<boolean>/)) {
+            this.addIssue({
+                file: filePath,
+                line: lineNumber,
+                type: "info",
+                category: "inline-pattern",
+                message: "Boolean state detected",
+                suggestion: "Consider using useToggle or useDisclosure hook from @/hooks",
+            });
+        }
+        // Copy to clipboard
+        if (line.includes("navigator.clipboard.writeText")) {
+            this.addIssue({
+                file: filePath,
+                line: lineNumber,
+                type: "warning",
+                category: "inline-pattern",
+                message: "Direct clipboard API usage detected",
+                suggestion: "Use useCopyToClipboard hook from @/hooks for better UX",
+            });
+        }
+        // Currency formatting inline
+        if (line.match(/toLocaleString\(['"]en-US['"],\s*{\s*style:\s*['"]currency['"]/)) {
+            this.addIssue({
+                file: filePath,
+                line: lineNumber,
+                type: "warning",
+                category: "inline-pattern",
+                message: "Inline currency formatting detected",
+                suggestion: "Use formatCurrency from @/lib/utils/format",
+                autoFixable: true,
+            });
+        }
+        // Email validation
+        if (line.match(/\/\^[^\/]*@[^\/]*\$\//)) {
+            this.addIssue({
+                file: filePath,
+                line: lineNumber,
+                type: "info",
+                category: "inline-pattern",
+                message: "Inline email regex detected",
+                suggestion: "Use isValidEmail from @/lib/utils",
+            });
+        }
+    }
+    checkLoadingPatterns(line, lineNumber, filePath, lines) {
+        // Loading spinner with animate-spin
+        if (line.includes("animate-spin") &&
+            (line.includes("RefreshCw") || line.includes("Loader") || line.includes("Spinner"))) {
+            // Check if it's a standalone loading indicator (not part of a button)
+            const prevLines = lines.slice(Math.max(0, lineNumber - 3), lineNumber).join("\n");
+            if (!prevLines.includes("<Button") && !prevLines.includes("LoadingButton")) {
+                this.addIssue({
+                    file: filePath,
+                    line: lineNumber,
+                    type: "info",
+                    category: "loading-pattern",
+                    message: "Inline loading spinner detected",
+                    suggestion: "Consider using LoadingState from @/components/shared for consistent loading UI",
+                });
+            }
+        }
+        // CircularProgress usage
+        if (line.includes("<CircularProgress") && !filePath.includes("LoadingState")) {
+            this.addIssue({
+                file: filePath,
+                line: lineNumber,
+                type: "info",
+                category: "loading-pattern",
+                message: "CircularProgress detected",
+                suggestion: "Consider using LoadingState from @/components/shared for consistent loading UI",
+            });
+        }
+    }
+    checkDatePatterns(line, lineNumber, filePath) {
+        // toLocaleString for dates
+        if (line.match(/\.toLocaleString\(\)/) ||
+            line.match(/\.toLocaleDateString\(\)/) ||
+            line.match(/\.toLocaleTimeString\(\)/)) {
+            // Skip if it's in a comment
+            if (line.trim().startsWith("//") || line.trim().startsWith("*")) {
+                return;
+            }
+            this.addIssue({
+                file: filePath,
+                line: lineNumber,
+                type: "info",
+                category: "date-pattern",
+                message: "Inline date formatting detected",
+                suggestion: "Consider using formatDate from @/lib/utils/format for consistent date display",
+            });
+        }
+        // new Date().toISOString() for display
+        if (line.includes("new Date(") && line.includes("toISOString()")) {
+            this.addIssue({
+                file: filePath,
+                line: lineNumber,
+                type: "info",
+                category: "date-pattern",
+                message: "ISO date string for display detected",
+                suggestion: "Use formatDate from @/lib/utils/format for user-friendly dates",
+            });
+        }
+    }
+    checkPricePatterns(line, lineNumber, filePath) {
+        // Inline price display with $ symbol
+        if (line.match(/\$\{.*\.toFixed\(2\)\}/) || line.match(/\$\s*\{.*price/i)) {
+            this.addIssue({
+                file: filePath,
+                line: lineNumber,
+                type: "info",
+                category: "price-pattern",
+                message: "Inline price display detected",
+                suggestion: "Use UnifiedPriceDisplay from @/components/shared for consistent pricing",
+            });
+        }
+        // Manual price formatting
+        if (line.match(/\.toFixed\(2\)/) && (line.includes("price") || line.includes("amount"))) {
+            this.addIssue({
+                file: filePath,
+                line: lineNumber,
+                type: "info",
+                category: "price-pattern",
+                message: "Manual price formatting detected",
+                suggestion: "Use formatCurrency from @/lib/utils/format",
+            });
+        }
+    }
+    checkDialogPatterns(line, lineNumber, filePath, lines) {
+        // useState for dialog open state + conditional rendering
+        if (line.match(/const\s+\[(open|isOpen|showModal|dialogOpen)/)) {
+            const nextLines = lines.slice(lineNumber, lineNumber + 30).join("\n");
+            // Check if there's a Dialog/Modal being conditionally rendered
+            if (nextLines.includes("<Dialog") ||
+                nextLines.includes("<Modal") ||
+                nextLines.includes("&& (")) {
+                // Skip if already using UnifiedDialog
+                if (nextLines.includes("UnifiedDialog") || nextLines.includes("useDialog")) {
+                    return;
+                }
+                this.addIssue({
+                    file: filePath,
+                    line: lineNumber,
+                    type: "info",
+                    category: "dialog-pattern",
+                    message: "Manual dialog state management detected",
+                    suggestion: "Consider using UnifiedDialog with useDialog hook from @/components/shared for consistent dialogs",
+                });
+            }
+        }
+    }
+    checkSkeletonPatterns(line, lineNumber, filePath, lines) {
+        // Multiple Skeleton components in sequence
+        if (line.includes("<Skeleton") && !filePath.includes("UnifiedSkeleton")) {
+            const nextLines = lines.slice(lineNumber, lineNumber + 5).join("\n");
+            const skeletonCount = (nextLines.match(/<Skeleton/g) || []).length;
+            if (skeletonCount >= 3) {
+                this.addIssue({
+                    file: filePath,
+                    line: lineNumber,
+                    type: "info",
+                    category: "skeleton-pattern",
+                    message: "Multiple skeleton components detected",
+                    suggestion: "Use UnifiedSkeleton presets (SkeletonCard, SkeletonList, etc.) from @/components/shared",
+                });
+            }
+        }
+    }
+    checkTablePatterns(line, lineNumber, filePath, lines) {
+        // Table with sorting/pagination state
+        if (line.includes("<Table") && !filePath.includes("EnhancedDataTable")) {
+            const fileContent = lines.join("\n");
+            // Check for sorting state
+            const hasSorting = fileContent.includes("sortBy") ||
+                fileContent.includes("sortDirection") ||
+                fileContent.includes("orderBy");
+            // Check for pagination
+            const hasPagination = fileContent.includes("currentPage") ||
+                fileContent.includes("pageSize") ||
+                fileContent.includes("totalPages");
+            // Check for selection
+            const hasSelection = fileContent.includes("selectedRows") || fileContent.includes("selectedIds");
+            if (hasSorting && hasPagination) {
+                this.addIssue({
+                    file: filePath,
+                    line: lineNumber,
+                    type: "info",
+                    category: "table-pattern",
+                    message: "Table with sorting and pagination detected",
+                    suggestion: "Consider using EnhancedDataTable from @/components/shared for built-in sorting, pagination, and selection",
+                });
+            }
+            else if (hasSelection) {
+                this.addIssue({
+                    file: filePath,
+                    line: lineNumber,
+                    type: "info",
+                    category: "table-pattern",
+                    message: "Table with row selection detected",
+                    suggestion: "Consider using EnhancedDataTable from @/components/shared for built-in selection",
+                });
+            }
+        }
+    }
+    checkFormPatterns(line, lineNumber, filePath, lines) {
+        // Multiple TextField/Input components in sequence
+        if (line.includes("<TextField") || line.includes("<Input")) {
+            const nextLines = lines.slice(lineNumber, lineNumber + 20).join("\n");
+            const fieldCount = (nextLines.match(/<TextField/g) || []).length + (nextLines.match(/<Input/g) || []).length;
+            if (fieldCount >= 5) {
+                // Check if using FormBuilder
+                const fileContent = lines.join("\n");
+                if (!fileContent.includes("FormBuilder") && !fileContent.includes("useForm")) {
+                    this.addIssue({
+                        file: filePath,
+                        line: lineNumber,
+                        type: "info",
+                        category: "form-pattern",
+                        message: "Multiple form fields detected",
+                        suggestion: "Consider using FormBuilder from @/components/shared for dynamic form generation",
+                    });
+                }
+            }
+        }
+    }
+    checkCodeQuality(line, lineNumber, filePath, lines) {
+        // Skip non-component files for some checks
+        const isComponentFile = filePath.endsWith(".tsx");
+        const isApiRoute = filePath.includes("/api/");
+        // Console.log in production code (warning for components, info for API routes)
+        if (line.match(/console\.(log|debug|info)\s*\(/) && !line.includes("// eslint-disable")) {
+            // Skip if it's in a catch block or error handler
+            const prevLines = lines.slice(Math.max(0, lineNumber - 3), lineNumber).join("\n");
+            if (!prevLines.includes("catch") && !prevLines.includes("error")) {
+                this.addIssue({
+                    file: filePath,
+                    line: lineNumber,
+                    type: isComponentFile ? "warning" : "info",
+                    category: "code-quality",
+                    message: "Console statement detected",
+                    suggestion: "Use logger from @/lib/debug-logger for structured logging",
+                    autoFixable: true,
+                    fixData: { type: "remove-console" },
+                });
+            }
+        }
+        // Empty catch blocks
+        if (line.match(/catch\s*\([^)]*\)\s*{\s*}/) || line.match(/catch\s*{\s*}/)) {
+            this.addIssue({
+                file: filePath,
+                line: lineNumber,
+                type: "warning",
+                category: "code-quality",
+                message: "Empty catch block detected",
+                suggestion: "Handle errors properly or use logger.error() to log them",
+            });
+        }
+        // Hardcoded API URLs
+        if (line.match(/['"]https?:\/\/[^'"]+['"]/) && !filePath.includes("constants")) {
+            // Skip common allowed patterns
+            if (!line.includes("localhost") &&
+                !line.includes("example.com") &&
+                !line.includes("placeholder") &&
+                !line.includes("schema.org") &&
+                !line.includes("w3.org") &&
+                !line.includes("googleapis.com") // Common external APIs
+            ) {
+                this.addIssue({
+                    file: filePath,
+                    line: lineNumber,
+                    type: "info",
+                    category: "code-quality",
+                    message: "Hardcoded URL detected",
+                    suggestion: "Consider moving to environment variables or constants file",
+                });
+            }
+        }
+        // Magic numbers (only in component files)
+        if (isComponentFile && !isApiRoute) {
+            // Look for standalone numbers that aren't common values
+            const magicNumberMatch = line.match(/[^a-zA-Z0-9_](\d{3,})[^a-zA-Z0-9_]/);
+            if (magicNumberMatch) {
+                const num = parseInt(magicNumberMatch[1], 10);
+                // Skip common values like 100, 200, 300, 400, 500, 1000, etc.
+                const commonValues = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 1024, 2048];
+                if (!commonValues.includes(num) && num > 100) {
+                    // Skip if it's in a className (Tailwind)
+                    if (!line.includes("className") && !line.includes("style")) {
+                        this.addIssue({
+                            file: filePath,
+                            line: lineNumber,
+                            type: "info",
+                            category: "code-quality",
+                            message: `Magic number ${num} detected`,
+                            suggestion: "Consider extracting to a named constant for clarity",
+                        });
+                    }
+                }
+            }
+        }
+        // Inline styles (should use Tailwind or CSS modules)
+        if (isComponentFile && line.match(/style=\{\{[^}]+\}\}/)) {
+            // Skip if it's a dynamic style that can't be done with Tailwind
+            if (!line.includes("width:") &&
+                !line.includes("height:") &&
+                !line.includes("transform") &&
+                !line.includes("--") // CSS variables
+            ) {
+                this.addIssue({
+                    file: filePath,
+                    line: lineNumber,
+                    type: "info",
+                    category: "code-quality",
+                    message: "Inline style object detected",
+                    suggestion: "Prefer Tailwind classes or CSS modules for styling",
+                });
+            }
+        }
+        // TODO/FIXME comments (info level)
+        if (line.match(/\/\/\s*(TODO|FIXME|HACK|XXX):/i)) {
+            this.addIssue({
+                file: filePath,
+                line: lineNumber,
+                type: "info",
+                category: "code-quality",
+                message: "TODO/FIXME comment detected",
+                suggestion: "Consider creating a ticket to track this work",
+            });
+        }
+        // any type usage (skip files where it's acceptable)
+        // Match: `: any`, `<any>`, `as any` (with word boundary to avoid "has any")
+        if (line.match(/:\s*any\b/) || line.match(/<any>/) || line.match(/\bas\s+any\b/)) {
+            // Skip comments
+            if (line.trim().startsWith("//") ||
+                line.trim().startsWith("*") ||
+                line.trim().startsWith("/*")) {
+                return;
+            }
+            // Skip if previous line has eslint-disable comment for any
+            const prevLine = lines[lineNumber - 2] || "";
+            if (prevLine.includes("eslint-disable") && prevLine.includes("any")) {
+                return;
+            }
+            // Skip if line itself has eslint-disable inline
+            if (line.includes("eslint-disable")) {
+                return;
+            }
+            // Check if this file is in the allowed list
+            const isAllowed = ANY_TYPE_ALLOWED_PATTERNS.some((pattern) => pattern.test(filePath));
+            if (!isAllowed) {
+                this.addIssue({
+                    file: filePath,
+                    line: lineNumber,
+                    type: "warning",
+                    category: "code-quality",
+                    message: "TypeScript 'any' type detected",
+                    suggestion: "Use proper typing or 'unknown' with type guards",
+                    autoFixable: true,
+                    fixData: { type: "add-preflight-ignore" },
+                });
+            }
+        }
+        // Non-null assertion (!)
+        if (line.match(/\w+!\./)) {
+            this.addIssue({
+                file: filePath,
+                line: lineNumber,
+                type: "info",
+                category: "code-quality",
+                message: "Non-null assertion (!) detected",
+                suggestion: "Consider using optional chaining (?.) or proper null checks",
+            });
+        }
+    }
+    checkDeprecatedComponents(line, lineNumber, filePath) {
+        // Check for imports of deprecated components from @/components/shared
+        if (line.includes("@/components/shared") ||
+            line.includes("from './") ||
+            line.includes('from "../')) {
+            for (const deprecated of DEPRECATED_COMPONENTS) {
+                // Match import { DeprecatedName } or import { DeprecatedName, ... }
+                const importPattern = new RegExp(`\\b${deprecated.name}\\b`);
+                if (importPattern.test(line) && line.includes("import")) {
+                    // Skip if it's the replacement being imported
+                    if (line.includes(deprecated.replacement.split(" ")[0])) {
+                        continue;
+                    }
+                    this.addIssue({
+                        file: filePath,
+                        line: lineNumber,
+                        type: "warning",
+                        category: "deprecated-component",
+                        message: `Deprecated component: ${deprecated.name}`,
+                        suggestion: `Use ${deprecated.replacement} instead`,
+                    });
+                }
+            }
+        }
+    }
+    checkDateFnsUsage(line, lineNumber, filePath) {
+        // Check for direct date-fns imports
+        if (line.match(/from\s+['"]date-fns['"]/)) {
+            // Skip if it's in a utility file that wraps date-fns
+            if (filePath.includes("lib/utils") || filePath.includes("lib/format")) {
+                return;
+            }
+            this.addIssue({
+                file: filePath,
+                line: lineNumber,
+                type: "info",
+                category: "date-pattern",
+                message: "Direct date-fns import detected",
+                suggestion: "Consider using formatDate/formatRelativeTime from @/lib/utils/format for consistency",
+            });
+        }
+    }
+    checkAccessibility(line, lineNumber, filePath) {
+        // Only check component files
+        if (!filePath.endsWith(".tsx"))
+            return;
+        // Image without alt
+        if (line.match(/<img\s/) && !line.includes("alt=")) {
+            this.addIssue({
+                file: filePath,
+                line: lineNumber,
+                type: "warning",
+                category: "accessibility",
+                message: "Image without alt attribute",
+                suggestion: 'Add alt text for accessibility (use alt="" for decorative images)',
+            });
+        }
+        // Button without type
+        if (line.match(/<button\s/) && !line.includes("type=")) {
+            this.addIssue({
+                file: filePath,
+                line: lineNumber,
+                type: "info",
+                category: "accessibility",
+                message: "Button without explicit type attribute",
+                suggestion: 'Add type="button" or type="submit" to prevent form submission issues',
+            });
+        }
+        // onClick on non-interactive element without role
+        if (line.match(/onClick=\{/) && line.match(/<(div|span|p)\s/) && !line.includes("role=")) {
+            this.addIssue({
+                file: filePath,
+                line: lineNumber,
+                type: "warning",
+                category: "accessibility",
+                message: "Click handler on non-interactive element without role",
+                suggestion: 'Add role="button" and tabIndex={0} for keyboard accessibility, or use <button>',
+            });
+        }
+        // Form input without label association
+        if (line.match(/<(input|select|textarea)\s/) &&
+            !line.includes("aria-label") &&
+            !line.includes("id=")) {
+            this.addIssue({
+                file: filePath,
+                line: lineNumber,
+                type: "info",
+                category: "accessibility",
+                message: "Form input may lack label association",
+                suggestion: "Add aria-label or associate with <label htmlFor>",
+            });
+        }
+    }
+    checkPerformancePatterns(line, lineNumber, filePath, lines) {
+        // Only check component files
+        if (!filePath.endsWith(".tsx"))
+            return;
+        // Large array map without key
+        if (line.match(/\.map\s*\(\s*\([^)]*\)\s*=>\s*[(<]/) && !line.includes("key=")) {
+            // Check next few lines for key
+            const nextLines = lines.slice(lineNumber, lineNumber + 3).join("\n");
+            if (!nextLines.includes("key=")) {
+                this.addIssue({
+                    file: filePath,
+                    line: lineNumber,
+                    type: "info",
+                    category: "performance",
+                    message: "Array map may be missing key prop",
+                    suggestion: "Add key prop to mapped elements for React reconciliation",
+                });
+            }
+        }
+        // Inline object/array in JSX props (causes re-renders)
+        if (line.match(/\s(style|sx)=\{\{/) && !line.includes("useMemo")) {
+            // Skip simple cases
+            if (!line.match(/\{\{[^}]{50,}\}\}/)) {
+                return; // Skip short inline styles
+            }
+            this.addIssue({
+                file: filePath,
+                line: lineNumber,
+                type: "info",
+                category: "performance",
+                message: "Complex inline style object may cause re-renders",
+                suggestion: "Extract to useMemo or move outside component",
+            });
+        }
+        // Anonymous function in JSX event handler (common but worth noting for hot paths)
+        if (line.match(/on[A-Z]\w+=\{\s*\(\)\s*=>\s*\{/)) {
+            // Only flag if it looks like a complex handler
+            const nextLines = lines.slice(lineNumber, lineNumber + 5).join("\n");
+            if (nextLines.includes("await") ||
+                nextLines.includes("fetch") ||
+                nextLines.includes("setState")) {
+                this.addIssue({
+                    file: filePath,
+                    line: lineNumber,
+                    type: "info",
+                    category: "performance",
+                    message: "Inline async handler in JSX",
+                    suggestion: "Consider extracting to useCallback for memoized components",
+                });
+            }
+        }
+    }
+    // AUTO-FIX
+    async applyFixes() {
+        const fixableIssues = this.issues.filter((i) => i.autoFixable && i.fixData);
+        if (fixableIssues.length === 0) {
+            console.log(`\n${console_chars_1.emoji.hint} No auto-fixable issues found.\n`);
+            return;
+        }
+        console.log(`\n${console_chars_1.emoji.warning} Applying ${fixableIssues.length} auto-fixes...\n`);
+        // Group fixes by file to apply them efficiently
+        const fixesByFile = new Map();
+        for (const issue of fixableIssues) {
+            const existing = fixesByFile.get(issue.file) || [];
+            existing.push(issue);
+            fixesByFile.set(issue.file, existing);
+        }
+        let fixesApplied = 0;
+        let fixesFailed = 0;
+        for (const [filePath, issues] of fixesByFile) {
+            try {
+                const result = await this.applyFixesToFile(filePath, issues);
+                fixesApplied += result.applied;
+                fixesFailed += result.failed;
+            }
+            catch (error) {
+                console.log(`  ${console_chars_1.emoji.error} Failed to fix ${filePath}: ${error}`);
+                fixesFailed += issues.length;
+            }
+        }
+        this.stats.fixesApplied = fixesApplied;
+        this.stats.fixesFailed = fixesFailed;
+        console.log(`\n${console_chars_1.emoji.success} Fixes applied: ${fixesApplied}`);
+        if (fixesFailed > 0) {
+            console.log(`${console_chars_1.emoji.error} Fixes failed: ${fixesFailed}`);
+        }
+    }
+    async applyFixesToFile(filePath, issues) {
+        let content = fs.readFileSync(filePath, "utf-8");
+        const lines = content.split("\n");
+        let applied = 0;
+        let failed = 0;
+        // Sort issues by line number descending so we can modify from bottom to top
+        // This prevents line number shifts from affecting subsequent fixes
+        const sortedIssues = [...issues].sort((a, b) => b.line - a.line);
+        for (const issue of sortedIssues) {
+            if (!issue.fixData) {
+                failed++;
+                continue;
+            }
+            try {
+                const lineIndex = issue.line - 1;
+                switch (issue.fixData.type) {
+                    case "remove-line":
+                        lines.splice(lineIndex, 1);
+                        console.log(`  ${console_chars_1.emoji.success} Removed line ${issue.line} in ${filePath}`);
+                        applied++;
+                        break;
+                    case "replace-line":
+                        if (issue.fixData.replacement !== undefined) {
+                            lines[lineIndex] = issue.fixData.replacement;
+                            console.log(`  ${console_chars_1.emoji.success} Replaced line ${issue.line} in ${filePath}`);
+                            applied++;
+                        }
+                        else {
+                            failed++;
+                        }
+                        break;
+                    case "replace-import":
+                        if (issue.fixData.replacement !== undefined) {
+                            lines[lineIndex] = issue.fixData.replacement;
+                            console.log(`  ${console_chars_1.emoji.success} Replaced import at line ${issue.line} in ${filePath}`);
+                            applied++;
+                        }
+                        else {
+                            failed++;
+                        }
+                        break;
+                    case "add-import":
+                        if (issue.fixData.importName && issue.fixData.importPath) {
+                            // Find the last import line
+                            let lastImportIndex = -1;
+                            for (let i = 0; i < lines.length; i++) {
+                                if (lines[i].startsWith("import ") || lines[i].match(/^import\s*{/)) {
+                                    lastImportIndex = i;
+                                }
+                                import { createUniversalProgressReporter } from "../system/universal-progress-reporter";
+                            }
+                            const newImport = `import { ${issue.fixData.importName} } from "${issue.fixData.importPath}";`;
+                            if (lastImportIndex >= 0) {
+                                lines.splice(lastImportIndex + 1, 0, newImport);
+                            }
+                            else {
+                                // No imports found, add at top after "use client" if present
+                                const useClientIndex = lines.findIndex((l) => l.includes('"use client"'));
+                                lines.splice(useClientIndex >= 0 ? useClientIndex + 1 : 0, 0, newImport);
+                            }
+                            console.log(`  ${console_chars_1.emoji.success} Added import for ${issue.fixData.importName} in ${filePath}`);
+                            applied++;
+                        }
+                        else {
+                            failed++;
+                        }
+                        break;
+                    case "remove-console":
+                        // Remove console.log/debug/info statements
+                        const consoleLine = lines[lineIndex];
+                        if (consoleLine.match(/^\s*console\.(log|debug|info)\s*\(/)) {
+                            // Check if it's a single-line console statement
+                            if (consoleLine.includes(");")) {
+                                lines.splice(lineIndex, 1);
+                                console.log(`  ${console_chars_1.emoji.success} Removed console statement at line ${issue.line} in ${filePath}`);
+                                applied++;
+                            }
+                            else {
+                                // Multi-line console - just comment it out for safety
+                                lines[lineIndex] = `// ${consoleLine} // TODO: Remove this console statement`;
+                                console.log(`  ${console_chars_1.emoji.warning} Commented out console at line ${issue.line} in ${filePath} (multi-line)`);
+                                applied++;
+                            }
+                        }
+                        else {
+                            failed++;
+                        }
+                        break;
+                    case "add-preflight-ignore":
+                        // Add a preflight-ignore comment above the line
+                        const indent = lines[lineIndex].match(/^(\s*)/)?.[1] || "";
+                        lines.splice(lineIndex, 0, `${indent}// preflight-ignore - Auto-added`);
+                        console.log(`  ${console_chars_1.emoji.success} Added preflight-ignore at line ${issue.line} in ${filePath}`);
+                        applied++;
+                        break;
+                    default:
+                        console.log(`  ${console_chars_1.emoji.warning} Unknown fix type: ${issue.fixData.type}`);
+                        failed++;
+                }
+            }
+            catch (error) {
+                console.log(`  ${console_chars_1.emoji.error} Failed to apply fix at line ${issue.line}: ${error}`);
+                failed++;
+            }
+        }
+        // Write the modified content back
+        if (applied > 0) {
+            fs.writeFileSync(filePath, lines.join("\n"));
+        }
+        return { applied, failed };
+    }
+    // HELPERS
+    addIssue(issue) {
+        // Skip info issues unless --info flag is set
+        if (issue.type === "info" && !this.options.showInfo) {
+            return;
+        }
+        this.issues.push(issue);
+    }
+    calculateStats() {
+        this.stats.errors = this.issues.filter((i) => i.type === "error").length;
+        this.stats.warnings = this.issues.filter((i) => i.type === "warning").length;
+        this.stats.info = this.issues.filter((i) => i.type === "info").length;
+    }
+    // OUTPUT
+    printResults() {
+        if (this.issues.length === 0) {
+            console.log(`${console_chars_1.emoji.success} All files use shared components correctly\n`);
+            console.log(`  Files checked: ${this.stats.filesChecked}`);
+            console.log(`  Files ignored: ${this.stats.ignoredFiles}`);
+            console.log(`  Lines ignored: ${this.stats.ignoredLines}`);
+            return;
+        }
+        const errors = this.issues.filter((i) => i.type === "error");
+        const warnings = this.issues.filter((i) => i.type === "warning");
+        const infos = this.issues.filter((i) => i.type === "info");
+        // Group issues by category
+        const byCategory = new Map();
+        this.issues.forEach((issue) => {
+            const existing = byCategory.get(issue.category) || [];
+            existing.push(issue);
+            byCategory.set(issue.category, existing);
+        });
+        if (errors.length > 0) {
+            console.log(`\n${console_chars_1.emoji.error} ERRORS (must fix):\n`);
+            this.printIssueGroup(errors);
+        }
+        if (warnings.length > 0 && this.options.verbose) {
+            console.log(`\n${console_chars_1.emoji.warning} WARNINGS (should fix):\n`);
+            this.printIssueGroup(warnings);
+        }
+        if (infos.length > 0 && this.options.showInfo) {
+            console.log(`\n${console_chars_1.emoji.hint} INFO (suggestions):\n`);
+            this.printIssueGroup(infos);
+        }
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        console.log(`\nSummary:`);
+        console.log(`  Files checked: ${this.stats.filesChecked}`);
+        console.log(`  Files ignored: ${this.stats.ignoredFiles}`);
+        console.log(`  Lines ignored: ${this.stats.ignoredLines}`);
+        if (this.stats.fixesApplied !== undefined) {
+            console.log(`\nAuto-fix results:`);
+            console.log(`  ${console_chars_1.emoji.success} Fixes applied: ${this.stats.fixesApplied}`);
+            if (this.stats.fixesFailed && this.stats.fixesFailed > 0) {
+                console.log(`  ${console_chars_1.emoji.error} Fixes failed: ${this.stats.fixesFailed}`);
+            }
+        }
+        console.log(`\nIssues by severity:`);
+        console.log(`  ${console_chars_1.emoji.error} Errors: ${errors.length}`);
+        console.log(`  ${console_chars_1.emoji.warning} Warnings: ${warnings.length}`);
+        console.log(`  ${console_chars_1.emoji.hint} Info: ${infos.length}`);
+        // Show auto-fixable count if not in fix mode
+        if (!this.options.fix) {
+            const fixableCount = this.issues.filter((i) => i.autoFixable).length;
+            if (fixableCount > 0) {
+                console.log(`\n  ${console_chars_1.emoji.hint} ${fixableCount} issues are auto-fixable with --fix`);
+            }
+        }
+        console.log(`\nIssues by category:`);
+        byCategory.forEach((issues, category) => {
+            console.log(`  ${category}: ${issues.length}`);
+        });
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        if (errors.length > 0) {
+            console.log(`\n${console_chars_1.emoji.error} SHARED COMPONENTS CHECK FAILED`);
+            console.log("   Fix errors to maintain consistency\n");
+        }
+        else if (warnings.length > 0) {
+            console.log(`\n${console_chars_1.emoji.success} SHARED COMPONENTS CHECK PASSED (with warnings)`);
+            console.log("   Run with --verbose to see warnings\n");
+        }
+        else {
+            console.log(`\n${console_chars_1.emoji.success} SHARED COMPONENTS CHECK PASSED\n`);
+        }
+    }
+    printIssueGroup(issues) {
+        issues.forEach((issue) => {
+            console.log(`  ${issue.file}:${issue.line}`);
+            console.log(`    [${issue.category}] ${issue.message}`);
+            if (issue.suggestion) {
+                console.log(`    ${console_chars_1.emoji.hint} ${issue.suggestion}`);
+            }
+            if (issue.autoFixable) {
+                console.log(`    ${console_chars_1.emoji.success} Auto-fixable with --fix`);
+            }
+            console.log();
+        });
+    }
+    outputJsonReport() {
+        const report = {
+            timestamp: new Date().toISOString(),
+            passed: this.stats.errors === 0,
+            stats: this.stats,
+            issues: this.issues,
+            categories: [...new Set(this.issues.map((i) => i.category))],
+        };
+        const reportPath = path.join(process.cwd(), "shared-component-report.json");
+        fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+        console.log(`\n${console_chars_1.emoji.success} JSON report written to: ${reportPath}`);
+    }
+}
+exports.SharedComponentsChecker = SharedComponentsChecker;
+// MAIN
+async function main() {
+    const reporter = createUniversalProgressReporter(exports.name);
+    const args = process.argv.slice(2);
+    const options = {
+        verbose: args.includes("--verbose") || args.includes("-v"),
+        report: args.includes("--report"),
+        fix: args.includes("--fix"),
+        showInfo: args.includes("--info"),
+    };
+    const checker = new SharedComponentsChecker(options);
+    const result = await checker.check();
+    process.exit(result.passed ? 0 : 1);
+}
+if (require.main === module) {
+    main();
+}
+//# sourceMappingURL=shared-components-migration.js.map