@empline/preflight 1.1.11 → 1.1.13

package/dist/checks/consolidated/imports.js

@@ -0,0 +1,977 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Consolidated Import Validation Preflight
+ *
+ * Combines 7 separate import checks into one comprehensive module:
+ * - import-validation (correct import sources)
+ * - import-organization (import order)
+ * - import-source-consistency (@/components/ui vs @supercatch/ui)
+ * - server-only-imports (Prisma/server code in client components) [BLOCKING]
+ * - unused-imports (dead imports)
+ * - missing-imports (undefined references)
+ * - hook-import-validation (custom hooks)
+ *
+ * Usage:
+ *   pnpm preflight:imports              # All import checks
+ *   pnpm preflight:imports validation   # Source validation only
+ *   pnpm preflight:imports organization # Import order only
+ *   pnpm preflight:imports consistency  # @/components/ui consistency
+ *   pnpm preflight:imports server-only  # Server-only imports in client components
+ *   pnpm preflight:imports unused       # Unused imports only
+ *   pnpm preflight:imports missing      # Missing imports only
+ *   pnpm preflight:imports hooks        # Hook imports only
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportsPreflightModule = void 0;
+const fs = __importStar(require("fs"));
+const file_cache_1 = require("../../shared/file-cache");
+const path = __importStar(require("path"));
+const typescript_1 = __importDefault(require("typescript"));
+const console_chars_1 = require("../../utils/console-chars");
+const concurrency_config_1 = require("../../shared/concurrency-config");
+const universal_progress_reporter_1 = require("../system/universal-progress-reporter");
+const findings_writer_1 = require("../../utils/findings-writer");
+const glob_1 = require("glob");
+// Get concurrency from shared config (respects PREFLIGHT_CONCURRENCY env var)
+const concurrencyConfig = (0, concurrency_config_1.getConcurrencyConfig)();
+function emitFindingsFromIssues(issues) {
+    const isFindingIssue = (issue) => issue.severity === "error" || issue.severity === "warning";
+    (0, findings_writer_1.writeFindings)(issues.filter(isFindingIssue).map((i) => ({
+        severity: i.severity,
+        message: i.message,
+        file: String(i.file).replace(/\\/g, "/"),
+        range: {
+            startLine: i.line,
+            startColumn: i.column,
+            endLine: i.endLine,
+            endColumn: i.endColumn,
+        },
+        code: i.type,
+    })));
+}
+function getImportClauseNames(importClause) {
+    if (!importClause)
+        return [];
+    const names = [];
+    if (importClause.name) {
+        names.push(importClause.name.text);
+    }
+    const namedBindings = importClause.namedBindings;
+    if (!namedBindings)
+        return names;
+    if (typescript_1.default.isNamespaceImport(namedBindings)) {
+        names.push(`* as ${namedBindings.name.text}`);
+        return names;
+    }
+    if (typescript_1.default.isNamedImports(namedBindings)) {
+        for (const el of namedBindings.elements) {
+            names.push(el.name.text);
+        }
+    }
+    return names;
+}
+function getLocationForNode(sf, node) {
+    const start = sf.getLineAndCharacterOfPosition(node.getStart(sf));
+    const end = sf.getLineAndCharacterOfPosition(node.getEnd());
+    return {
+        line: start.line + 1,
+        column: start.character + 1,
+        endLine: end.line + 1,
+        endColumn: end.character + 1,
+    };
+}
+function indexToLineCol(text, index) {
+    const clamped = Math.max(0, Math.min(index, text.length));
+    // 1-based line/col
+    let line = 1;
+    let lastLineStart = 0;
+    for (let i = 0; i < clamped; i += 1) {
+        if (text.charCodeAt(i) === 10) {
+            line += 1;
+            lastLineStart = i + 1;
+        }
+    }
+    return { line, col: clamped - lastLineStart + 1 };
+}
+const EXCLUDED_PATTERNS = [
+    "**/node_modules/**",
+    "**/.next/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/*.test.{ts,tsx}",
+    "**/*.spec.{ts,tsx}",
+    "**/*.stories.{ts,tsx}",
+];
+const REACT_HOOKS = new Set([
+    "useState",
+    "useEffect",
+    "useContext",
+    "useReducer",
+    "useCallback",
+    "useMemo",
+    "useRef",
+    "useImperativeHandle",
+    "useLayoutEffect",
+    "useDebugValue",
+    "useDeferredValue",
+    "useTransition",
+    "useId",
+    "useSyncExternalStore",
+]);
+const EXTERNAL_HOOKS = new Set([
+    ...REACT_HOOKS,
+    "useRouter",
+    "usePathname",
+    "useSearchParams",
+    "useParams", // Next.js
+    "useSWR",
+    "useSWRConfig",
+    "useSWRMutation", // SWR
+    "useQuery",
+    "useMutation",
+    "useQueryClient", // React Query
+    "useForm",
+    "useFormContext",
+    "useFieldArray", // React Hook Form
+]);
+const IMPORT_ORDER = {
+    react: 1,
+    thirdParty: 2,
+    componentsUI: 3,
+    components: 4,
+    hooks: 5,
+    lib: 6,
+    app: 7,
+    contexts: 8,
+    types: 9,
+    utils: 10,
+    relative: 11,
+    typeImports: 12,
+};
+// IMPORT CHECK IMPLEMENTATIONS
+class ImportsPreflightModule {
+    verbose;
+    parallel;
+    constructor(options = {}) {
+        this.verbose = options.verbose || false;
+        this.parallel = options.parallel || concurrencyConfig.parallel;
+    }
+    async getFiles(pattern = "**/*.{ts,tsx}") {
+        return (0, glob_1.glob)(pattern, { ignore: EXCLUDED_PATTERNS });
+    }
+    /**
+     * Import Source Validation
+     */
+    async checkImportValidation() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const ext = file.toLowerCase().endsWith(".tsx")
+                ? typescript_1.default.ScriptKind.TSX
+                : file.toLowerCase().endsWith(".jsx")
+                    ? typescript_1.default.ScriptKind.JSX
+                    : file.toLowerCase().endsWith(".js")
+                        ? typescript_1.default.ScriptKind.JS
+                        : typescript_1.default.ScriptKind.TS;
+            const sf = typescript_1.default.createSourceFile(file, content, typescript_1.default.ScriptTarget.Latest, true, ext);
+            const visit = (node) => {
+                if (typescript_1.default.isImportDeclaration(node) && typescript_1.default.isStringLiteral(node.moduleSpecifier)) {
+                    const mod = node.moduleSpecifier.text;
+                    const loc = getLocationForNode(sf, node.moduleSpecifier);
+                    // 1) `import { Card } from '@/components/shared/Card'` should use '@/components/ui'
+                    if (mod === "@/components/shared/Card") {
+                        const names = getImportClauseNames(node.importClause);
+                        if (names.some((n) => n.includes("Card"))) {
+                            issues.push({
+                                file,
+                                line: loc.line,
+                                column: loc.column,
+                                endLine: loc.endLine,
+                                endColumn: loc.endColumn,
+                                type: "wrong-import-source",
+                                severity: "error",
+                                message: "Import Card from '@/components/ui'",
+                                snippet: node.getText(sf).trim().substring(0, 120),
+                            });
+                        }
+                    }
+                    // 2) `import { Button|Badge|Chip } from '@/components/shared/<X>'` should use '@/components/ui'
+                    if (mod === "@/components/shared/Button" ||
+                        mod === "@/components/shared/Badge" ||
+                        mod === "@/components/shared/Chip") {
+                        issues.push({
+                            file,
+                            line: loc.line,
+                            column: loc.column,
+                            endLine: loc.endLine,
+                            endColumn: loc.endColumn,
+                            type: "wrong-import-source",
+                            severity: "error",
+                            message: "Import UI primitives from '@/components/ui'",
+                            snippet: node.getText(sf).trim().substring(0, 120),
+                        });
+                    }
+                }
+                typescript_1.default.forEachChild(node, visit);
+            };
+            visit(sf);
+        }
+        return {
+            name: "Import Source Validation",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Import Source Consistency (@/components/ui vs @supercatch/ui)
+     */
+    async checkImportConsistency() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await file_cache_1.fileCache.getAllCodeFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            // Skip shared implementation files (they should use relative imports internally)
+            const normalizedFile = file.replace(/\\/g, "/");
+            const isSharedImplementation = normalizedFile.includes("components/shared/");
+            const ext = file.toLowerCase().endsWith(".tsx")
+                ? typescript_1.default.ScriptKind.TSX
+                : file.toLowerCase().endsWith(".jsx")
+                    ? typescript_1.default.ScriptKind.JSX
+                    : file.toLowerCase().endsWith(".js")
+                        ? typescript_1.default.ScriptKind.JS
+                        : typescript_1.default.ScriptKind.TS;
+            const sf = typescript_1.default.createSourceFile(file, content, typescript_1.default.ScriptTarget.Latest, true, ext);
+            const visit = (node) => {
+                if (typescript_1.default.isImportDeclaration(node) && typescript_1.default.isStringLiteral(node.moduleSpecifier)) {
+                    const mod = node.moduleSpecifier.text;
+                    const loc = getLocationForNode(sf, node.moduleSpecifier);
+                    // Direct @supercatch/ui imports are forbidden
+                    if (mod === "@supercatch/ui") {
+                        const components = getImportClauseNames(node.importClause);
+                        issues.push({
+                            file,
+                            line: loc.line,
+                            column: loc.column,
+                            endLine: loc.endLine,
+                            endColumn: loc.endColumn,
+                            type: "direct-supercatch-import",
+                            severity: "error",
+                            message: `Direct @supercatch/ui import: ${components.join(", ")}`,
+                            suggestion: `Change to: import { ${components.filter((c) => !c.startsWith("* as")).join(", ")} } from '@/components/ui';
+import * as path from 'path';`,
+                            snippet: node.getText(sf).trim().substring(0, 120),
+                        });
+                    }
+                    // Direct file imports from @/components/ui/<Component> should use the barrel export
+                    // Skip type-only imports as they're valid for getting specific types
+                    if (mod.startsWith("@/components/ui/") && !node.importClause?.isTypeOnly) {
+                        const fileName = mod.slice("@/components/ui/".length);
+                        if (/^[A-Z][a-zA-Z]+$/.test(fileName)) {
+                            // Check if all imports are type imports
+                            const hasValueImports = node.importClause?.namedBindings &&
+                                typescript_1.default.isNamedImports(node.importClause.namedBindings) &&
+                                node.importClause.namedBindings.elements.some((el) => !el.isTypeOnly);
+                            if (hasValueImports) {
+                                const components = getImportClauseNames(node.importClause);
+                                issues.push({
+                                    file,
+                                    line: loc.line,
+                                    column: loc.column,
+                                    endLine: loc.endLine,
+                                    endColumn: loc.endColumn,
+                                    type: "direct-file-import",
+                                    severity: "error",
+                                    message: `Direct file import from @/components/ui/${fileName}`,
+                                    suggestion: `Change to: import { ${components.join(", ")} } from '@/components/ui';
+import * as path from 'path';`,
+                                    snippet: node.getText(sf).trim().substring(0, 120),
+                                });
+                            }
+                        }
+                    }
+                    // Direct top-level imports from @/components/shared/<Component> should use '@/components/shared'
+                    // NOTE: We intentionally only enforce top-level here to avoid touching nested shared imports
+                    // like @/components/shared/integration/IntegrationStepper.
+                    // Skip type-only imports as they're valid for getting specific types
+                    if (!isSharedImplementation &&
+                        mod.startsWith("@/components/shared/") &&
+                        !node.importClause?.isTypeOnly) {
+                        const fileName = mod.slice("@/components/shared/".length);
+                        if (/^[A-Z][a-zA-Z0-9]+$/.test(fileName)) {
+                            // Check if all imports are type imports
+                            const hasValueImports = node.importClause?.namedBindings &&
+                                typescript_1.default.isNamedImports(node.importClause.namedBindings) &&
+                                node.importClause.namedBindings.elements.some((el) => !el.isTypeOnly);
+                            if (hasValueImports) {
+                                const components = getImportClauseNames(node.importClause);
+                                issues.push({
+                                    file,
+                                    line: loc.line,
+                                    column: loc.column,
+                                    endLine: loc.endLine,
+                                    endColumn: loc.endColumn,
+                                    type: "direct-shared-file-import",
+                                    severity: "error",
+                                    message: `Direct file import from @/components/shared/${fileName}`,
+                                    suggestion: `Export ${components.join(", ")} from components/shared/index.ts and import from '@/components/shared' instead.`,
+                                    snippet: node.getText(sf).trim().substring(0, 120),
+                                });
+                            }
+                        }
+                    }
+                }
+                typescript_1.default.forEachChild(node, visit);
+            };
+            visit(sf);
+        }
+        return {
+            name: "Import Source Consistency",
+            passed: issues.length === 0,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Import Organization (order)
+     */
+    async checkImportOrganization() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getFiles("{app,components,lib,hooks,contexts}/**/*.{ts,tsx}");
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const imports = this.extractImportsWithCategory(content);
+            let lastCategory = 0;
+            for (const imp of imports) {
+                if (imp.category < lastCategory) {
+                    issues.push({
+                        file,
+                        line: imp.line,
+                        column: imp.column,
+                        endLine: imp.endLine,
+                        endColumn: imp.endColumn,
+                        type: "import-out-of-order",
+                        severity: "warning",
+                        message: `Import out of order: "${imp.source}" should come earlier`,
+                        snippet: imp.text.substring(0, 80),
+                    });
+                }
+                lastCategory = imp.category;
+            }
+        }
+        return {
+            name: "Import Organization",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    extractImportsWithCategory(content) {
+        const imports = [];
+        const lines = content.split("\n");
+        lines.forEach((line, index) => {
+            if (!line.trim().startsWith("import "))
+                return;
+            const match = line.match(/from\s+['"]([^'"]+)['"]/);
+            if (!match)
+                return;
+            const source = match[1];
+            const sourceIdx = typeof match.index === "number" ? line.indexOf(source, match.index) : line.indexOf(source);
+            const column = sourceIdx >= 0 ? sourceIdx + 1 : undefined;
+            const endColumn = typeof column === "number" ? column + source.length : undefined;
+            let category = IMPORT_ORDER.thirdParty;
+            if (source === "react" || source.startsWith("react/"))
+                category = IMPORT_ORDER.react;
+            else if (source.startsWith("@/components/ui"))
+                category = IMPORT_ORDER.componentsUI;
+            else if (source.startsWith("@/components"))
+                category = IMPORT_ORDER.components;
+            else if (source.startsWith("@/hooks"))
+                category = IMPORT_ORDER.hooks;
+            else if (source.startsWith("@/lib"))
+                category = IMPORT_ORDER.lib;
+            else if (source.startsWith("@/app"))
+                category = IMPORT_ORDER.app;
+            else if (source.startsWith("@/contexts"))
+                category = IMPORT_ORDER.contexts;
+            else if (source.startsWith("@/types"))
+                category = IMPORT_ORDER.types;
+            else if (source.startsWith("./") || source.startsWith("../"))
+                category = IMPORT_ORDER.relative;
+            imports.push({
+                text: line.trim(),
+                line: index + 1,
+                column,
+                endLine: index + 1,
+                endColumn,
+                category,
+                source,
+            });
+        });
+        return imports;
+    }
+    /**
+     * Unused Imports Detection
+     *
+     * Detects imports that are never used in the code.
+     * Handles edge cases:
+     * - Namespace access (MetadataRoute.Robots)
+     * - Type annotations in interfaces (children: ReactNode)
+     * - Type annotations in variable declarations (const x: Type)
+     * - Type parameters in generics (<T extends Type>)
+     */
+    async checkUnusedImports() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getFiles("{app,components,lib,hooks}/**/*.{ts,tsx}");
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const imports = this.extractNamedImports(content);
+            for (const imp of imports) {
+                // Skip invalid import names (e.g., containing special characters)
+                if (!imp.local || /[^a-zA-Z0-9_$]/.test(imp.local))
+                    continue;
+                // Find the end of the import statement block (after all imports)
+                const importBlockEnd = this.findImportBlockEnd(content);
+                const codeAfterImports = importBlockEnd > -1 ? content.slice(importBlockEnd) : content;
+                // Check for various usage patterns
+                const escapedName = imp.local.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                // Simple word boundary check - most reliable for actual usage
+                const wordBoundaryRegex = new RegExp(`\\b${escapedName}\\b`);
+                // Check if the name appears anywhere in the code after the import block
+                if (wordBoundaryRegex.test(codeAfterImports)) {
+                    continue; // It's used, skip
+                }
+                issues.push({
+                    file,
+                    line: imp.line,
+                    column: imp.column,
+                    endLine: imp.endLine,
+                    endColumn: imp.endColumn,
+                    type: "unused-import",
+                    severity: "warning",
+                    message: `Unused import '${imp.local}' from '${imp.module}'`,
+                    suggestion: "Remove unused import",
+                    snippet: imp.snippet,
+                });
+            }
+        }
+        return {
+            name: "Unused Imports",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Find where the import block ends (first non-import, non-empty, non-comment line)
+     */
+    findImportBlockEnd(content) {
+        const lines = content.split("\n");
+        let inMultilineComment = false;
+        let foundImport = false;
+        let position = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const trimmed = line.trim();
+            // Track multiline comments
+            if (trimmed.startsWith("/*"))
+                inMultilineComment = true;
+            if (trimmed.endsWith("*/"))
+                inMultilineComment = false;
+            // Skip comments and empty lines
+            if (inMultilineComment ||
+                trimmed.startsWith("//") ||
+                trimmed.startsWith("*") ||
+                trimmed === "") {
+                position += line.length + 1;
+                continue;
+            }
+            // Skip "use client" / "use server" directives
+            if (trimmed.startsWith('"use ') || trimmed.startsWith("'use ")) {
+                position += line.length + 1;
+                continue;
+            }
+            // Import statement
+            if (trimmed.startsWith("import ")) {
+                foundImport = true;
+                position += line.length + 1;
+                continue;
+            }
+            // First non-import line after we've seen imports
+            if (foundImport) {
+                return position;
+            }
+            position += line.length + 1;
+        }
+        return position;
+    }
+    extractNamedImports(content) {
+        const imports = [];
+        // Only match actual import statements (start of line, allowing whitespace).
+        // This avoids false positives from commented documentation examples like:
+        //   * import { foo } from 'bar';
+        const regex = /^\s*import\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/gm;
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const names = match[1].split(",").map((n) => {
+                const parts = n.trim().split(/\s+as\s+/);
+                return { imported: parts[0].trim(), local: parts[1] ? parts[1].trim() : parts[0].trim() };
+            });
+            const line = content.slice(0, match.index).split("\n").length;
+            names.forEach((n) => {
+                if (!n.local)
+                    return;
+                // Best-effort location for the local identifier on the import line.
+                // We search from the import statement start index.
+                const nameIndex = content.indexOf(n.local, match.index);
+                const loc = nameIndex >= 0 ? indexToLineCol(content, nameIndex) : { line, col: 1 };
+                imports.push({
+                    local: n.local,
+                    module: match[2],
+                    line: loc.line,
+                    column: loc.col,
+                    endLine: loc.line,
+                    endColumn: loc.col + n.local.length,
+                    index: match.index,
+                    snippet: match[0].trim().substring(0, 120),
+                });
+            });
+        }
+        return imports;
+    }
+    /**
+     * Server-Only Imports in Client Components
+     * Detects when client components import server-only modules like Prisma
+     */
+    async checkServerOnlyImports() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getFiles("{app,components,lib,hooks}/**/*.{ts,tsx}");
+        const serverOnlyPatterns = [
+            {
+                pattern: "@/lib/prisma",
+                suggestion: "Move data fetching to server component or API route",
+            },
+            {
+                pattern: "@prisma/client",
+                suggestion: "Move data fetching to server component or API route",
+            },
+            { pattern: "server-only", suggestion: "This module is server-only" },
+            { pattern: "@/lib/auth-server", suggestion: "Use @/lib/auth for client components" },
+            { pattern: "@/lib/auth-server-utils", suggestion: "Use client-safe auth utilities" },
+            // Note: @/lib/listing-utils is now client-safe (Prisma code moved to listing-utils.server.ts)
+            {
+                pattern: "@/lib/listing-utils.server",
+                suggestion: "Use @/lib/listing-utils for client components",
+                clientSafe: "@/lib/listing-utils",
+            },
+        ];
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            // Check if this is a client component
+            const isClientComponent = lines.some((line, index) => index < 10 && line.trim().startsWith('"use client"'));
+            if (!isClientComponent)
+                continue;
+            lines.forEach((line, index) => {
+                const trimmedLine = line.trim();
+                // Skip comments
+                if (trimmedLine.startsWith("//") || trimmedLine.startsWith("*"))
+                    return;
+                // Check for import statements
+                if (trimmedLine.startsWith("import")) {
+                    for (const serverPattern of serverOnlyPatterns) {
+                        // Skip type-only imports (they're safe)
+                        if (trimmedLine.includes("import type") &&
+                            trimmedLine.includes(serverPattern.pattern)) {
+                            continue;
+                        }
+                        // Check for the pattern (but not the client-safe version)
+                        const clientSafe = serverPattern.clientSafe;
+                        if (trimmedLine.includes(serverPattern.pattern) &&
+                            (!clientSafe || !trimmedLine.includes(clientSafe))) {
+                            const colIdx = trimmedLine.indexOf(serverPattern.pattern);
+                            const startColumn = colIdx >= 0 ? colIdx + 1 : undefined;
+                            const endColumn = typeof startColumn === "number"
+                                ? startColumn + serverPattern.pattern.length
+                                : undefined;
+                            issues.push({
+                                file,
+                                line: index + 1,
+                                column: startColumn,
+                                endLine: index + 1,
+                                endColumn,
+                                type: "server-only-import",
+                                severity: "error",
+                                message: `Server-only import "${serverPattern.pattern}" in client component`,
+                                suggestion: serverPattern.suggestion,
+                                snippet: trimmedLine.substring(0, 80),
+                            });
+                        }
+                    }
+                }
+            });
+        }
+        return {
+            name: "Server-Only Imports",
+            passed: issues.length === 0,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Missing Hook Imports
+     */
+    async checkMissingHookImports() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getFiles("{app,components,lib,hooks}/**/*.{ts,tsx}");
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const imports = this.extractAllImportedNames(content);
+            const localHooks = this.extractLocalHooks(content);
+            const cleanContent = this.removeComments(content);
+            const hookPattern = /\b(use[A-Z][a-zA-Z0-9]*)\s*\(/g;
+            let match;
+            while ((match = hookPattern.exec(cleanContent)) !== null) {
+                const hookName = match[1];
+                if (EXTERNAL_HOOKS.has(hookName) || imports.has(hookName) || localHooks.has(hookName))
+                    continue;
+                const line = cleanContent.slice(0, match.index).split("\n").length;
+                issues.push({
+                    file,
+                    line,
+                    type: "missing-hook-import",
+                    severity: "error",
+                    message: `Custom hook '${hookName}' is used but not imported`,
+                    suggestion: `Add: import { ${hookName} } from "@/hooks/${hookName}";
+import * as path from 'path';`,
+                });
+            }
+        }
+        // Deduplicate
+        const seen = new Set();
+        const dedupedIssues = issues.filter((i) => {
+            const key = `${i.file}:${i.message}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+        return {
+            name: "Missing Hook Imports",
+            passed: dedupedIssues.filter((i) => i.severity === "error").length === 0,
+            blocking: true,
+            issues: dedupedIssues,
+            duration: Date.now() - startTime,
+        };
+    }
+    extractAllImportedNames(content) {
+        const names = new Set();
+        const regex = /import\s*\{([^}]+)\}\s*from/g;
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            match[1].split(",").forEach((n) => {
+                const local = n
+                    .trim()
+                    .split(/\s+as\s+/)
+                    .pop()
+                    ?.trim();
+                if (local)
+                    names.add(local);
+            });
+        }
+        return names;
+    }
+    extractLocalHooks(content) {
+        const hooks = new Set();
+        // Standard function declarations: function useHookName(...) or function useHookName<T>(...)
+        const funcRegex = /function\s+(use[A-Z][a-zA-Z0-9]*)(?:<[^>]*>)?\s*\(/g;
+        // Arrow function or const assignment: const useHookName = ...
+        const arrowRegex = /(?:const|let|var)\s+(use[A-Z][a-zA-Z0-9]*)\s*=/g;
+        // require() destructuring: const { useHookName } = require(...)
+        const requireRegex = /const\s*\{\s*([^}]+)\s*\}\s*=\s*require\s*\(/g;
+        // export function (with possible generics): export function useHookName<T>(...)
+        const exportFuncRegex = /export\s+function\s+(use[A-Z][a-zA-Z0-9]*)(?:<[^>]*>)?\s*\(/g;
+        let match;
+        while ((match = funcRegex.exec(content)) !== null)
+            hooks.add(match[1]);
+        while ((match = arrowRegex.exec(content)) !== null)
+            hooks.add(match[1]);
+        while ((match = exportFuncRegex.exec(content)) !== null)
+            hooks.add(match[1]);
+        // Extract hook names from require destructuring
+        while ((match = requireRegex.exec(content)) !== null) {
+            const names = match[1].split(",").map((n) => n.trim());
+            names.forEach((name) => {
+                if (name.match(/^use[A-Z]/))
+                    hooks.add(name);
+            });
+        }
+        return hooks;
+    }
+    removeComments(content) {
+        return content
+            .replace(/\/\/.*$/gm, "")
+            .replace(/\/\*[\s\S]*?\*\//g, "")
+            .replace(/`[^`]*`/g, '""');
+    }
+    /**
+     * Run all import checks
+     */
+    async runAll() {
+        const startTime = Date.now();
+        console.log(`\n${console_chars_1.emoji.package} CONSOLIDATED IMPORT VALIDATION PREFLIGHT`);
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        let checks;
+        console.log(`\n${console_chars_1.emoji.search} Running import checks...\n`);
+        if (this.parallel) {
+            // Run checks in parallel
+            checks = await Promise.all([
+                this.checkImportValidation(),
+                this.checkImportConsistency(),
+                this.checkServerOnlyImports(),
+                this.checkImportOrganization(),
+                this.checkUnusedImports(),
+                this.checkMissingHookImports(),
+            ]);
+        }
+        else {
+            // Sequential execution
+            checks = [];
+            checks.push(await this.checkImportValidation());
+            checks.push(await this.checkImportConsistency());
+            checks.push(await this.checkServerOnlyImports());
+            checks.push(await this.checkImportOrganization());
+            checks.push(await this.checkUnusedImports());
+            checks.push(await this.checkMissingHookImports());
+        }
+        const totalDuration = Date.now() - startTime;
+        const allIssues = checks.flatMap((c) => c.issues);
+        const errors = allIssues.filter((i) => i.severity === "error").length;
+        const warnings = allIssues.filter((i) => i.severity === "warning").length;
+        const blockingFailed = checks.some((c) => c.blocking && !c.passed);
+        const summary = {
+            total: checks.length,
+            passed: checks.filter((c) => c.passed).length,
+            failed: checks.filter((c) => !c.passed).length,
+            errors,
+            warnings,
+        };
+        this.printResults(checks, totalDuration, summary);
+        emitFindingsFromIssues(allIssues);
+        return { module: "imports", passed: !blockingFailed, totalDuration, checks, summary };
+    }
+    printResults(checks, totalDuration, summary) {
+        console.log("\n" + (0, console_chars_1.createDivider)(80, "heavy"));
+        console.log(`${console_chars_1.emoji.chart} IMPORT VALIDATION RESULTS`);
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        checks.forEach((check) => {
+            const icon = check.passed
+                ? `${console_chars_1.emoji.success}`
+                : check.blocking
+                    ? `${console_chars_1.emoji.error}`
+                    : `${console_chars_1.emoji.warning}`;
+            const time = `${(check.duration / 1000).toFixed(1)}s`;
+            const count = check.issues.length > 0 ? ` (${check.issues.length} issues)` : "";
+            const blocking = check.blocking ? " [BLOCKING]" : "";
+            console.log(`${icon} ${check.name.padEnd(35)} ${time.padStart(8)}${count}${blocking}`);
+            // Always show issues for unused imports and import organization (even without verbose)
+            if (check.issues.length > 0 &&
+                (this.verbose || check.name === "Unused Imports" || check.name === "Import Organization")) {
+                const maxToShow = this.verbose ? 5 : 3;
+                check.issues.slice(0, maxToShow).forEach((issue) => {
+                    const sev = issue.severity === "error" ? `${console_chars_1.emoji.error}` : `${console_chars_1.emoji.warning}`;
+                    console.log(`   ${sev} ${issue.file}:${issue.line} - ${issue.message}`);
+                });
+                if (check.issues.length > maxToShow)
+                    console.log(`   ... and ${check.issues.length - maxToShow} more`);
+            }
+        });
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        console.log(`Total Checks: ${summary.total}`);
+        console.log(`${console_chars_1.emoji.success} Passed: ${summary.passed}`);
+        console.log(`${console_chars_1.emoji.error} Failed: ${summary.failed}`);
+        console.log(`${console_chars_1.emoji.stop} Errors: ${summary.errors}`);
+        console.log(`${console_chars_1.emoji.warning}  Warnings: ${summary.warnings}`);
+        console.log(`${console_chars_1.emoji.clock}  Total Time: ${(totalDuration / 1000).toFixed(1)}s`);
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        // Show specific warnings for unused imports and import order
+        const unusedCheck = checks.find((c) => c.name === "Unused Imports");
+        const orderCheck = checks.find((c) => c.name === "Import Organization");
+        if ((unusedCheck && unusedCheck.issues.length > 0) ||
+            (orderCheck && orderCheck.issues.length > 0)) {
+            console.log(`\n${console_chars_1.emoji.warning}  IMPORT WARNINGS DETECTED:`);
+            if (unusedCheck && unusedCheck.issues.length > 0) {
+                console.log(`   ${console_chars_1.chars.bullet} ${unusedCheck.issues.length} unused imports found`);
+                console.log("     Run: pnpm fix:unused-imports (or manually remove)");
+            }
+            if (orderCheck && orderCheck.issues.length > 0) {
+                console.log(`   ${console_chars_1.chars.bullet} ${orderCheck.issues.length} import order issues found`);
+                console.log("     Run: pnpm fix:import-order (ESLint auto-fix)");
+            }
+            console.log("");
+        }
+        console.log(`\n${console_chars_1.emoji.clipboard} Import Best Practices:`);
+        console.log(`  ${console_chars_1.chars.bullet} Import UI from @/components/ui (not @supercatch/ui)`);
+        console.log("  ${chars.bullet} Order: React ${chars.arrow} Third-party → @/components/ui → @/components → @/hooks → @/lib → Relative");
+        console.log(`  ${console_chars_1.chars.bullet} Remove unused imports`);
+        console.log(`  ${console_chars_1.chars.bullet} Import all custom hooks before using`);
+        if (summary.errors === 0) {
+            console.log(`\n${console_chars_1.emoji.success} IMPORT VALIDATION PASSED`);
+            if (summary.warnings > 0) {
+                console.log(`   (${summary.warnings} warnings - consider fixing for cleaner code)`);
+            }
+        }
+        else {
+            console.log(`\n${console_chars_1.emoji.error} IMPORT VALIDATION FAILED`);
+            console.log(`   ${summary.errors} error(s) must be fixed`);
+            console.log(`\n${console_chars_1.emoji.hint} Auto-fix available: pnpm fix:import-consistency`);
+        }
+    }
+}
+exports.ImportsPreflightModule = ImportsPreflightModule;
+// CLI INTERFACE
+async function main() {
+    const reporter = (0, universal_progress_reporter_1.createUniversalProgressReporter)(path.basename(__filename, ".ts"));
+    const args = process.argv.slice(2);
+    const mode = args.find((a) => !a.startsWith("-")) || "all";
+    const verbose = args.includes("--verbose") || args.includes("-v");
+    const parallel = args.includes("--parallel") || args.includes("-p");
+    const module = new ImportsPreflightModule({ verbose, parallel });
+    try {
+        let result;
+        const runSingle = async (name, checkFn) => {
+            console.log(`\n${console_chars_1.emoji.search} Running ${name} check...\n`);
+            const check = await checkFn();
+            // Print results for single check
+            const icon = check.passed
+                ? `${console_chars_1.emoji.success}`
+                : check.blocking
+                    ? `${console_chars_1.emoji.error}`
+                    : `${console_chars_1.emoji.warning}`;
+            const time = `${(check.duration / 1000).toFixed(1)}s`;
+            const count = check.issues.length > 0 ? ` (${check.issues.length} issues)` : "";
+            const blocking = check.blocking ? " [BLOCKING]" : "";
+            console.log((0, console_chars_1.createDivider)(70, "heavy"));
+            console.log(`${icon} ${check.name.padEnd(35)} ${time.padStart(8)}${count}${blocking}`);
+            console.log((0, console_chars_1.createDivider)(70, "heavy"));
+            if (check.issues.length > 0) {
+                console.log("\nIssues found:\n");
+                check.issues.slice(0, 20).forEach((issue) => {
+                    const sev = issue.severity === "error" ? `${console_chars_1.emoji.error}` : `${console_chars_1.emoji.warning}`;
+                    console.log(`${sev} ${issue.file}:${issue.line}`);
+                    console.log(`   ${issue.message}`);
+                    if (issue.suggestion)
+                        console.log(`   ${console_chars_1.emoji.hint} ${issue.suggestion}`);
+                });
+                if (check.issues.length > 20) {
+                    console.log(`\n... and ${check.issues.length - 20} more issues`);
+                }
+                // Show fix commands
+                if (check.name === "Unused Imports") {
+                    console.log(`\n${console_chars_1.emoji.hint} Auto-fix: pnpm fix:unused-imports`);
+                    console.log("   Preview:  pnpm fix:unused-imports --dry-run");
+                }
+                else if (check.name === "Import Organization") {
+                    console.log(`\n${console_chars_1.emoji.hint} Auto-fix: pnpm fix:import-order`);
+                }
+            }
+            emitFindingsFromIssues(check.issues);
+            console.log("");
+            return {
+                module: `imports:${name}`,
+                passed: check.passed,
+                totalDuration: check.duration,
+                checks: [check],
+                summary: {
+                    total: 1,
+                    passed: check.passed ? 1 : 0,
+                    failed: check.passed ? 0 : 1,
+                    errors: check.issues.filter((i) => i.severity === "error").length,
+                    warnings: check.issues.filter((i) => i.severity === "warning").length,
+                },
+            };
+        };
+        switch (mode) {
+            case "validation":
+                result = await runSingle("validation", () => module.checkImportValidation());
+                break;
+            case "consistency":
+                result = await runSingle("consistency", () => module.checkImportConsistency());
+                break;
+            case "server-only":
+                result = await runSingle("server-only", () => module.checkServerOnlyImports());
+                break;
+            case "organization":
+                result = await runSingle("organization", () => module.checkImportOrganization());
+                break;
+            case "unused":
+                result = await runSingle("unused", () => module.checkUnusedImports());
+                break;
+            case "hooks":
+                result = await runSingle("hooks", () => module.checkMissingHookImports());
+                break;
+            case "all":
+            default:
+                result = await module.runAll();
+                break;
+        }
+        process.exit(result.passed ? 0 : 1);
+    }
+    catch (error) {
+        console.error(`${console_chars_1.emoji.error} Fatal error:`, error);
+        process.exit(1);
+    }
+}
+if (require.main === module) {
+    main();
+}
+//# sourceMappingURL=imports.js.map