@empline/preflight 1.1.11 → 1.1.13

package/dist/checks/consolidated/caching-strategy.js

@@ -0,0 +1,725 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Caching Strategy Preflight (NON-BLOCKING)
+ *
+ * Validates caching patterns across the application for optimal performance.
+ * Ensures proper cache configuration, invalidation, and consistency.
+ *
+ * Checks:
+ * 1. HTTP Cache Headers - API routes set appropriate Cache-Control
+ * 2. React Query/SWR Stale Time - Appropriate cache time configuration
+ * 3. Cache Key Consistency - Deterministic, stable query keys
+ * 4. Revalidation Configuration - Next.js ISR/revalidate settings
+ * 5. Cache Invalidation Patterns - Proper invalidation after mutations
+ * 6. Static Asset Caching - next.config.js headers configuration
+ * 7. Browser Storage Patterns - localStorage/sessionStorage usage
+ * 8. Memoization Patterns - useMemo/useCallback for expensive operations
+ *
+ * Usage:
+ *   pnpm preflight:caching-strategy              # All checks
+ *   pnpm preflight:caching-strategy headers      # HTTP cache headers 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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachingStrategyModule = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const console_chars_1 = require("../../utils/console-chars");
+const file_cache_1 = require("../../shared/file-cache");
+class CachingStrategyModule {
+    verbose;
+    constructor(options = {}) {
+        this.verbose = options.verbose || false;
+    }
+    async getTsxFiles() {
+        return file_cache_1.fileCache.getAppAndComponentsTSX();
+    }
+    async getApiRoutes() {
+        const files = await file_cache_1.fileCache.getAppAndComponentsTSX();
+        return files.filter(f => f.includes("/api/") && (f.endsWith("route.ts") || f.endsWith("route.tsx")));
+    }
+    /**
+     * 1. HTTP Cache Headers
+     * Check API routes for appropriate Cache-Control headers
+     */
+    async checkHttpCacheHeaders() {
+        const startTime = Date.now();
+        const issues = [];
+        const apiRoutes = await this.getApiRoutes();
+        for (const file of apiRoutes) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            // Skip if it's a mutation endpoint (POST, PUT, DELETE, PATCH)
+            const hasMutation = /export\s+(?:async\s+)?function\s+(?:POST|PUT|DELETE|PATCH)/i.test(content);
+            const hasGet = /export\s+(?:async\s+)?function\s+GET/i.test(content);
+            if (hasGet && !hasMutation) {
+                // Check for Cache-Control header
+                const hasCacheControl = /Cache-Control|cache-control|headers\.set\(['"']Cache/i.test(content);
+                const hasNextRevalidate = /revalidate\s*[:=]/i.test(content);
+                if (!hasCacheControl && !hasNextRevalidate) {
+                    issues.push({
+                        file,
+                        line: 1,
+                        type: "missing-cache-header",
+                        severity: "info",
+                        message: "GET API route missing Cache-Control header",
+                        suggestion: "Add Cache-Control header: headers.set('Cache-Control', 'public, max-age=60, stale-while-revalidate=300')",
+                    });
+                }
+            }
+            // Check for no-store on dynamic data
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Detect user-specific data without no-store
+                if (/session|currentUser|user\.id|auth/i.test(line) && hasGet) {
+                    const contextBlock = lines.slice(Math.max(0, i - 10), Math.min(i + 10, lines.length)).join("\n");
+                    if (!/no-store|private|max-age=0/i.test(contextBlock)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "user-data-caching",
+                            severity: "warning",
+                            message: "User-specific data may be cached without private/no-store directive",
+                            suggestion: "Add 'Cache-Control: private, no-store' for user-specific endpoints",
+                            snippet: line.trim(),
+                        });
+                        break; // One warning per file
+                    }
+                }
+            }
+        }
+        return {
+            name: "HTTP Cache Headers",
+            passed: issues.filter(i => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 2. React Query/SWR Stale Time
+     * Check for appropriate staleTime/cacheTime configuration
+     */
+    async checkQueryStaleTime() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            // Check for useQuery without staleTime
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Detect useQuery usage
+                if (/useQuery\s*\(/.test(line) || /useQuery\s*</.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 15, lines.length)).join("\n");
+                    // Check if staleTime is configured
+                    if (!/staleTime/i.test(contextBlock)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "missing-stale-time",
+                            severity: "info",
+                            message: "useQuery without explicit staleTime configuration",
+                            suggestion: "Consider adding staleTime to control refetch behavior: { staleTime: 5 * 60 * 1000 }",
+                            snippet: line.trim(),
+                        });
+                    }
+                    // Check for staleTime: 0 (always stale)
+                    if (/staleTime\s*:\s*0[,\s}]/.test(contextBlock)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "zero-stale-time",
+                            severity: "info",
+                            message: "staleTime set to 0 causes unnecessary refetches",
+                            suggestion: "Consider a small staleTime (e.g., 30000) unless real-time data is required",
+                            snippet: line.trim(),
+                        });
+                    }
+                }
+                // Check for useSWR without revalidation config
+                if (/useSWR\s*\(/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 10, lines.length)).join("\n");
+                    if (!/revalidateOnFocus|revalidateOnReconnect|dedupingInterval/i.test(contextBlock)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "swr-no-config",
+                            severity: "info",
+                            message: "useSWR without explicit revalidation configuration",
+                            suggestion: "Consider configuring revalidateOnFocus, dedupingInterval for optimal caching",
+                            snippet: line.trim(),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "React Query/SWR Stale Time",
+            passed: issues.filter(i => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 3. Cache Key Consistency
+     * Ensure query keys are deterministic and stable
+     */
+    async checkCacheKeyConsistency() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for non-deterministic values in query keys
+                if (/queryKey\s*[:=]/.test(line) || /\[\s*['"]/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 5, lines.length)).join("\n");
+                    // Detect Date.now(), Math.random(), new Date() in keys
+                    if (/Date\.now\(\)|Math\.random\(\)|new Date\(\)|uuid\(\)|crypto\.randomUUID/i.test(contextBlock)) {
+                        if (/queryKey|useSWR|useQuery/i.test(contextBlock)) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "non-deterministic-key",
+                                severity: "warning",
+                                message: "Non-deterministic value in cache key causes cache misses",
+                                suggestion: "Use stable, deterministic values for query keys",
+                                snippet: line.trim(),
+                            });
+                        }
+                    }
+                }
+                // Check for object references in query keys (common mistake)
+                if (/queryKey\s*:\s*\[.*\{/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 3, lines.length)).join("\n");
+                    if (!/JSON\.stringify|\.id|\.slug/.test(contextBlock)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "object-in-query-key",
+                            severity: "info",
+                            message: "Object in query key may cause unexpected cache behavior",
+                            suggestion: "Ensure objects in query keys are serializable or use primitive values",
+                            snippet: line.trim(),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Cache Key Consistency",
+            passed: issues.filter(i => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 4. Revalidation Configuration
+     * Check for Next.js ISR and revalidate settings
+     */
+    async checkRevalidationConfig() {
+        const startTime = Date.now();
+        const issues = [];
+        // Check page files for revalidate config
+        const files = await this.getTsxFiles();
+        const pageFiles = files.filter(f => f.includes("/app/") && (f.endsWith("page.tsx") || f.endsWith("page.ts")));
+        for (const file of pageFiles) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            // Check for fetch without revalidate
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (/fetch\s*\(/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 5, lines.length)).join("\n");
+                    // Check if it has next: { revalidate } or cache config
+                    if (!/next\s*:\s*\{|cache\s*:|revalidate/i.test(contextBlock)) {
+                        // Skip if it's a mutation (POST, PUT, etc)
+                        if (!/method\s*:\s*['"](?:POST|PUT|DELETE|PATCH)/i.test(contextBlock)) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "fetch-no-revalidate",
+                                severity: "info",
+                                message: "fetch() without explicit cache/revalidate configuration",
+                                suggestion: "Add { next: { revalidate: 60 } } for ISR or { cache: 'no-store' } for dynamic",
+                                snippet: line.trim(),
+                            });
+                        }
+                    }
+                }
+            }
+            // Check for exported revalidate constant
+            if (/export\s+const\s+dynamic\s*=\s*['"]force-dynamic['"]/.test(content)) {
+                if (!/export\s+const\s+revalidate/.test(content)) {
+                    // This is fine - force-dynamic means no caching
+                }
+            }
+        }
+        // Check for very long revalidate times
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                const revalidateMatch = line.match(/revalidate\s*[:=]\s*(\d+)/);
+                if (revalidateMatch) {
+                    const revalidateTime = parseInt(revalidateMatch[1], 10);
+                    if (revalidateTime > 86400) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "long-revalidate",
+                            severity: "info",
+                            message: `Very long revalidate time (${revalidateTime}s = ${(revalidateTime / 86400).toFixed(1)} days)`,
+                            suggestion: "Consider if data can really be stale for this long",
+                            snippet: line.trim(),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Revalidation Configuration",
+            passed: issues.filter(i => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 5. Cache Invalidation Patterns
+     * Check for proper invalidation after mutations
+     */
+    async checkCacheInvalidation() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            // Track if file uses React Query
+            const usesReactQuery = /useQuery|useMutation|useQueryClient/.test(content);
+            const usesSWR = /useSWR|mutate\s*\(/.test(content);
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for useMutation without onSuccess invalidation
+                if (/useMutation\s*\(/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 20, lines.length)).join("\n");
+                    if (!/invalidateQueries|setQueryData|refetchQueries/.test(contextBlock)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "mutation-no-invalidation",
+                            severity: "warning",
+                            message: "useMutation without cache invalidation may show stale data",
+                            suggestion: "Add onSuccess: () => queryClient.invalidateQueries({ queryKey: [...] })",
+                            snippet: line.trim(),
+                        });
+                    }
+                }
+                // Check for fetch POST/PUT/DELETE without SWR mutate
+                if (usesSWR && /fetch\s*\(/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 10, lines.length)).join("\n");
+                    if (/method\s*:\s*['"](?:POST|PUT|DELETE|PATCH)/.test(contextBlock)) {
+                        // Check surrounding code for mutate call
+                        const surroundingBlock = lines.slice(Math.max(0, i - 5), Math.min(i + 15, lines.length)).join("\n");
+                        if (!/mutate\s*\(|revalidate/.test(surroundingBlock)) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "mutation-no-swr-invalidation",
+                                severity: "info",
+                                message: "Mutation without SWR mutate() may show stale data",
+                                suggestion: "Call mutate() or revalidate after successful mutation",
+                                snippet: line.trim(),
+                            });
+                        }
+                    }
+                }
+                // Check for direct state updates that bypass cache
+                if (usesReactQuery && /setState\s*\(/.test(line)) {
+                    const contextBlock = lines.slice(Math.max(0, i - 5), Math.min(i + 5, lines.length)).join("\n");
+                    if (/queryKey|useQuery/.test(content) && /\.data/.test(contextBlock)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "bypass-cache-update",
+                            severity: "info",
+                            message: "Direct setState may bypass React Query cache",
+                            suggestion: "Consider using queryClient.setQueryData for optimistic updates",
+                            snippet: line.trim(),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Cache Invalidation Patterns",
+            passed: issues.filter(i => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 6. Static Asset Caching
+     * Check next.config.js for proper cache headers
+     */
+    async checkStaticAssetCaching() {
+        const startTime = Date.now();
+        const issues = [];
+        const projectRoot = process.cwd();
+        const nextConfigPaths = [
+            path.join(projectRoot, "next.config.js"),
+            path.join(projectRoot, "next.config.mjs"),
+            path.join(projectRoot, "next.config.ts"),
+        ];
+        let nextConfigPath = null;
+        for (const p of nextConfigPaths) {
+            if (fs.existsSync(p)) {
+                nextConfigPath = p;
+                break;
+            }
+        }
+        if (nextConfigPath) {
+            const content = fs.readFileSync(nextConfigPath, "utf8");
+            const lines = content.split("\n");
+            // Check for custom headers configuration
+            if (!/headers\s*\(\s*\)|async\s+headers\s*\(/.test(content)) {
+                issues.push({
+                    file: nextConfigPath,
+                    line: 1,
+                    type: "no-custom-headers",
+                    severity: "info",
+                    message: "No custom headers() configuration in next.config",
+                    suggestion: "Consider adding cache headers for static assets and API routes",
+                });
+            }
+            // Check for images configuration
+            if (!/images\s*:\s*\{/.test(content)) {
+                issues.push({
+                    file: nextConfigPath,
+                    line: 1,
+                    type: "no-image-config",
+                    severity: "info",
+                    message: "No images configuration for Next.js Image optimization",
+                    suggestion: "Configure images.minimumCacheTTL for image caching",
+                });
+            }
+            else {
+                // Check for minimumCacheTTL
+                if (!/minimumCacheTTL/.test(content)) {
+                    for (let i = 0; i < lines.length; i++) {
+                        if (/images\s*:/.test(lines[i])) {
+                            issues.push({
+                                file: nextConfigPath,
+                                line: i + 1,
+                                type: "no-image-cache-ttl",
+                                severity: "info",
+                                message: "images config without minimumCacheTTL",
+                                suggestion: "Add minimumCacheTTL: 60 (seconds) to cache optimized images",
+                                snippet: lines[i].trim(),
+                            });
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            name: "Static Asset Caching",
+            passed: issues.filter(i => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 7. Browser Storage Patterns
+     * Check localStorage/sessionStorage usage patterns
+     */
+    async checkBrowserStoragePatterns() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for localStorage without try-catch (can fail in SSR or private mode)
+                if (/localStorage\.|sessionStorage\./.test(line)) {
+                    const contextBlock = lines.slice(Math.max(0, i - 3), Math.min(i + 3, lines.length)).join("\n");
+                    if (!/try\s*\{|catch\s*\(|typeof\s+window/.test(contextBlock)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "storage-no-try-catch",
+                            severity: "warning",
+                            message: "localStorage/sessionStorage access without error handling",
+                            suggestion: "Wrap in try-catch - storage can fail in SSR, private browsing, or when quota exceeded",
+                            snippet: line.trim(),
+                        });
+                    }
+                }
+                // Check for storing large objects
+                if (/localStorage\.setItem|sessionStorage\.setItem/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 3, lines.length)).join("\n");
+                    if (/JSON\.stringify\s*\([^)]{50,}/.test(contextBlock)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "large-storage-object",
+                            severity: "info",
+                            message: "Potentially large object being stored in browser storage",
+                            suggestion: "Consider using IndexedDB for large data or implement storage size limits",
+                            snippet: line.trim(),
+                        });
+                    }
+                }
+                // Check for cache expiration patterns
+                if (/localStorage\.getItem/.test(line)) {
+                    const functionBlock = lines.slice(Math.max(0, i - 10), Math.min(i + 10, lines.length)).join("\n");
+                    if (/cache|Cache/.test(functionBlock) && !/expir|ttl|timestamp|Date\.now/i.test(functionBlock)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "cache-no-expiration",
+                            severity: "info",
+                            message: "Cache read without expiration check",
+                            suggestion: "Consider adding TTL/expiration to cached data",
+                            snippet: line.trim(),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Browser Storage Patterns",
+            passed: issues.filter(i => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 8. Memoization Patterns
+     * Check useMemo/useCallback usage for expensive operations
+     */
+    async checkMemoizationPatterns() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for expensive operations without useMemo
+                if (/\.filter\s*\(.*\)\.map\s*\(|\.sort\s*\(.*\)\.filter|\.reduce\s*\(/.test(line)) {
+                    const contextBlock = lines.slice(Math.max(0, i - 3), Math.min(i + 1, lines.length)).join("\n");
+                    if (!/useMemo|useCallback/.test(contextBlock)) {
+                        // Check if it's in render/return path
+                        const beforeBlock = lines.slice(Math.max(0, i - 15), i).join("\n");
+                        if (/return\s*\(|return\s*<|{\s*$/.test(beforeBlock)) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "unmemoized-computation",
+                                severity: "info",
+                                message: "Chained array operations in render without useMemo",
+                                suggestion: "Wrap expensive computations in useMemo to prevent recalculation on every render",
+                                snippet: line.trim().substring(0, 80),
+                            });
+                        }
+                    }
+                }
+                // Check for inline object/array in dependency arrays
+                if (/useMemo\s*\(|useCallback\s*\(|useEffect\s*\(/.test(line)) {
+                    const hookBlock = lines.slice(i, Math.min(i + 10, lines.length)).join("\n");
+                    const depsMatch = hookBlock.match(/\],\s*\[(.*?)\]/s);
+                    if (depsMatch) {
+                        const deps = depsMatch[1];
+                        if (/\{.*\}|\[.*\]/.test(deps) && !/useMemo|useCallback|useRef/.test(deps)) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "inline-dep-object",
+                                severity: "warning",
+                                message: "Inline object/array in dependency array causes infinite re-runs",
+                                suggestion: "Extract inline objects to useMemo or useRef",
+                                snippet: line.trim(),
+                            });
+                        }
+                    }
+                }
+                // Check for useMemo with empty deps but using external values
+                if (/useMemo\s*\(/.test(line)) {
+                    const hookBlock = lines.slice(i, Math.min(i + 8, lines.length)).join("\n");
+                    if (/\],\s*\[\s*\]\s*\)/.test(hookBlock)) {
+                        // Has empty dependency array - check if it references props/state
+                        if (/props\.|state\.|use[A-Z]/.test(hookBlock)) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "empty-deps-with-refs",
+                                severity: "warning",
+                                message: "useMemo with empty deps but referencing props/state - value will be stale",
+                                suggestion: "Add referenced values to the dependency array",
+                                snippet: line.trim(),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            name: "Memoization Patterns",
+            passed: issues.filter(i => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Run all caching strategy checks
+     */
+    async runAll(filter) {
+        const startTime = Date.now();
+        const checkMap = {
+            headers: () => this.checkHttpCacheHeaders(),
+            staletime: () => this.checkQueryStaleTime(),
+            keys: () => this.checkCacheKeyConsistency(),
+            revalidate: () => this.checkRevalidationConfig(),
+            invalidation: () => this.checkCacheInvalidation(),
+            assets: () => this.checkStaticAssetCaching(),
+            storage: () => this.checkBrowserStoragePatterns(),
+            memo: () => this.checkMemoizationPatterns(),
+        };
+        let checksToRun;
+        if (filter && checkMap[filter]) {
+            checksToRun = [checkMap[filter]];
+        }
+        else {
+            checksToRun = Object.values(checkMap);
+        }
+        const checks = [];
+        for (const check of checksToRun) {
+            checks.push(await check());
+        }
+        const summary = {
+            total: checks.length,
+            passed: checks.filter(c => c.passed).length,
+            failed: checks.filter(c => !c.passed).length,
+            errors: checks.reduce((acc, c) => acc + c.issues.filter(i => i.severity === "error").length, 0),
+            warnings: checks.reduce((acc, c) => acc + c.issues.filter(i => i.severity === "warning").length, 0),
+        };
+        return {
+            module: "Caching Strategy",
+            passed: summary.errors === 0,
+            totalDuration: Date.now() - startTime,
+            checks,
+            summary,
+        };
+    }
+}
+exports.CachingStrategyModule = CachingStrategyModule;
+// CLI Entry Point
+async function main() {
+    const args = process.argv.slice(2);
+    const filter = args.find(a => !a.startsWith("-"));
+    const verbose = args.includes("-v") || args.includes("--verbose");
+    console.log((0, console_chars_1.createDivider)());
+    console.log(`${console_chars_1.emoji.rocket} Caching Strategy Preflight`);
+    console.log((0, console_chars_1.createDivider)());
+    const module = new CachingStrategyModule({ verbose });
+    const result = await module.runAll(filter);
+    // Print results
+    for (const check of result.checks) {
+        const icon = check.passed ? console_chars_1.emoji.check : console_chars_1.emoji.warning;
+        console.log(`\n${icon} ${check.name} (${check.duration}ms)`);
+        if (check.issues.length > 0) {
+            const grouped = new Map();
+            for (const issue of check.issues) {
+                const key = issue.type;
+                if (!grouped.has(key))
+                    grouped.set(key, []);
+                grouped.get(key).push(issue);
+            }
+            for (const [type, issues] of grouped) {
+                console.log(`\n  ${type} (${issues.length} occurrences):`);
+                const displayIssues = verbose ? issues : issues.slice(0, 3);
+                for (const issue of displayIssues) {
+                    const relPath = issue.file.replace(process.cwd(), "").replace(/\\/g, "/");
+                    const severityIcon = issue.severity === "error" ? console_chars_1.emoji.error : issue.severity === "warning" ? console_chars_1.emoji.warning : console_chars_1.emoji.info;
+                    console.log(`    ${severityIcon} ${relPath}:${issue.line}`);
+                    console.log(`       ${issue.message}`);
+                    if (issue.snippet) {
+                        console.log(`       ${console_chars_1.emoji.file} ${issue.snippet.substring(0, 60)}${issue.snippet.length > 60 ? "..." : ""}`);
+                    }
+                    console.log(`       ${console_chars_1.emoji.hint} ${issue.suggestion}`);
+                }
+                if (!verbose && issues.length > 3) {
+                    console.log(`    ... and ${issues.length - 3} more (use -v to see all)`);
+                }
+            }
+        }
+    }
+    // Summary
+    console.log((0, console_chars_1.createDivider)());
+    console.log(`\n${console_chars_1.emoji.chart} Summary:`);
+    console.log(`   Checks: ${result.summary.passed}/${result.summary.total} passed`);
+    console.log(`   Errors: ${result.summary.errors}`);
+    console.log(`   Warnings: ${result.summary.warnings}`);
+    console.log(`   Duration: ${result.totalDuration}ms`);
+    if (!result.passed) {
+        console.log(`\n${console_chars_1.emoji.warning} Caching strategy issues detected (non-blocking)`);
+    }
+    else {
+        console.log(`\n${console_chars_1.emoji.check} All caching strategy checks passed!`);
+    }
+    console.log((0, console_chars_1.createDivider)());
+    // Non-blocking - always exit 0
+    process.exit(0);
+}
+main().catch(console.error);
+//# sourceMappingURL=caching-strategy.js.map