@empline/preflight 1.1.11 → 1.1.13

package/dist/checks/core/supercatch.js

@@ -0,0 +1,750 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * SuperCatch Business Logic Preflight Checks
+ * Validates SuperCatch-specific business rules and patterns
+ */
+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 });
+const console_chars_1 = require("../../utils/console-chars");
+const file_scanner_1 = require("../../utils/file-scanner");
+const preflight_runner_1 = require("../../utils/preflight-runner");
+async function runSuperCatchPreflights() {
+    const runner = new preflight_runner_1.PreflightRunner(true);
+    const scanner = new file_scanner_1.FileScanner();
+    // Card Data Validation (from card-data.ts)
+    runner.addCheck((0, preflight_runner_1.createCheck)("Card Data Structure", "Validate card data models and required fields", async () => {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        // Check Prisma schema for card-related models
+        const schemaFiles = await scanner.findFiles(/prisma\/schema\.prisma$/);
+        if (schemaFiles.length === 0) {
+            errors.push("Prisma schema file not found");
+            return { passed: false, errors, warnings };
+        }
+        const content = await scanner.readFileContent(schemaFiles[0].path);
+        if (!content) {
+            errors.push("Could not read Prisma schema");
+            return { passed: false, errors, warnings };
+        }
+        // Check for required card fields
+        const requiredFields = [
+            "cardName",
+            "cardNumber",
+            "year",
+            "brand",
+            "featured",
+            "graded",
+            "category",
+        ];
+        for (const field of requiredFields) {
+            if (!content.includes(field)) {
+                errors.push(`Required field missing from schema: ${field}`);
+            }
+            else {
+                info.push(`${console_chars_1.chars.check} ${field} field present`);
+            }
+        }
+        // Check for League enum
+        if (!content.includes("enum League")) {
+            errors.push("League enum not defined in schema");
+        }
+        else {
+            info.push("${chars.check} League enum found");
+        }
+        // Check for Sport enum
+        if (!content.includes("enum Sport")) {
+            errors.push("Sport enum not defined in schema");
+        }
+        else {
+            info.push("✓ Sport enum found");
+        }
+        // Check for CardMasterCatalog model (now split into catalogSportsCards, catalogTcgCards, etc.)
+        const catalogModels = [
+            "catalogSportsCards",
+            "catalogTcgCards",
+            "catalogNonSportsCards",
+            "catalogAutographs",
+            "catalogTickets",
+            "catalogVideoGames",
+        ];
+        let foundCatalogModels = 0;
+        for (const model of catalogModels) {
+            if (content.includes(`model ${model}`)) {
+                foundCatalogModels++;
+                info.push(`${console_chars_1.chars.check} ${model} model found`);
+            }
+        }
+        if (foundCatalogModels === 0) {
+            errors.push("No catalog models found (expected catalogSportsCards, catalogTcgCards, etc.)");
+        }
+        else {
+            info.push(`${console_chars_1.chars.check} Found ${foundCatalogModels} catalog models`);
+        }
+        // Check for TCG-specific fields
+        const tcgFields = [
+            "hp", // Pokemon
+            "manaCost", // Magic
+            "attack", // Yu-Gi-Oh
+            "externalProductId", // Marketplace integration
+        ];
+        for (const field of tcgFields) {
+            if (!content.includes(field)) {
+                warnings.push(`TCG field not found: ${field} - May be intentional if not implementing yet`);
+            }
+            else {
+                info.push(`${console_chars_1.chars.check} TCG field found: ${field}`);
+            }
+        }
+        // Check for VideoGame model (now catalogVideoGames)
+        if (!content.includes("model catalogVideoGames")) {
+            warnings.push("catalogVideoGames model not found - Video game support may not be implemented");
+        }
+        else {
+            info.push("${chars.check} catalogVideoGames model found");
+        }
+        // Check for grading fields
+        if (!content.includes("psaGrade") || !content.includes("bgsGrade")) {
+            warnings.push("Grading fields (psaGrade, bgsGrade) should be present");
+        }
+        else {
+            info.push("✓ Grading fields found");
+        }
+        return { passed: errors.length === 0, errors, warnings, info };
+    }));
+    // Listing Workflow Validation
+    runner.addCheck((0, preflight_runner_1.createCheck)("Listing Workflow Integrity", "Validate iron-clad listing creation workflow", async () => {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        // Check for listing creation API
+        const listingApiFiles = await scanner.findFiles(/app\/api\/listings.*route\.(ts|js)$/);
+        for (const file of listingApiFiles) {
+            const content = await scanner.readFileContent(file.path);
+            if (!content)
+                continue;
+            // Check for proper DRAFT status creation
+            if (content.includes("DRAFT") || content.includes("listingStatus")) {
+                info.push(`${console_chars_1.chars.check} ${file.name} handles listing status`);
+            }
+            // Check for duplicate prevention
+            if (content.includes("findOrCreateCardCatalog") ||
+                content.includes("duplicate") ||
+                content.includes("conflict")) {
+                info.push(`${console_chars_1.chars.check} ${file.name} includes duplicate prevention`);
+            }
+            else {
+                warnings.push(`${file.relativePath} may lack duplicate prevention`);
+            }
+            // Check for admin approval workflow
+            if (content.includes("admin") || content.includes("approval")) {
+                info.push(`${console_chars_1.chars.check} ${file.name} includes admin workflow`);
+            }
+        }
+        // Check for admin listing management
+        const adminFiles = await scanner.findFiles(/app\/admin\/listings.*\.(ts|tsx)$/);
+        if (adminFiles.length > 0) {
+            info.push(`${console_chars_1.chars.check} Found ${adminFiles.length} admin listing management files`);
+        }
+        else {
+            warnings.push("No admin listing management interface found");
+        }
+        return { passed: errors.length === 0, errors, warnings, info };
+    }));
+    // AI Recognition System
+    runner.addCheck((0, preflight_runner_1.createCheck)("AI Recognition System", "Validate AI card recognition and caching system", async () => {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        // Check for recognition API
+        const recognitionFiles = await scanner.findFiles(/app\/api\/cards\/identify.*route\.(ts|js)$/);
+        for (const file of recognitionFiles) {
+            const content = await scanner.readFileContent(file.path);
+            if (!content)
+                continue;
+            // Check for cache implementation
+            if (content.includes("cache") || content.includes("metadataCache")) {
+                info.push(`${console_chars_1.chars.check} ${file.name} includes caching system`);
+            }
+            else {
+                warnings.push(`${file.relativePath} may lack caching for cost optimization`);
+            }
+            // Check for multiple recognition methods
+            if (content.includes("vision") && content.includes("ocr")) {
+                info.push(`${console_chars_1.chars.check} ${file.name} uses hybrid recognition approach`);
+            }
+            // Check for cost optimization
+            if (content.includes("cost") || content.includes("savings")) {
+                info.push(`${console_chars_1.chars.check} ${file.name} includes cost tracking`);
+            }
+        }
+        // Check for hash collision prevention
+        const hashFiles = await scanner.findFiles(/lib.*hash.*\.(ts|js)$/);
+        if (hashFiles.length > 0) {
+            info.push(`${console_chars_1.chars.check} Found ${hashFiles.length} hash-related files`);
+            for (const file of hashFiles) {
+                const content = await scanner.readFileContent(file.path);
+                if (!content)
+                    continue;
+                if (content.includes("collision") || content.includes("duplicate")) {
+                    info.push(`${console_chars_1.chars.check} ${file.name} includes collision prevention`);
+                }
+            }
+        }
+        else {
+            warnings.push("No hash collision prevention files found");
+        }
+        return { passed: errors.length === 0, errors, warnings, info };
+    }));
+    // Category System Validation
+    runner.addCheck((0, preflight_runner_1.createCheck)("Category System", "Validate hierarchical category system implementation", async () => {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        // Check for category utilities
+        const categoryFiles = await scanner.findFiles(/lib.*category.*\.(ts|js)$/);
+        for (const file of categoryFiles) {
+            const content = await scanner.readFileContent(file.path);
+            if (!content)
+                continue;
+            // Check for URL to DB category mapping
+            if (content.includes("urlCategoryToDbCategory") ||
+                content.includes("dbCategoryToUrlCategory")) {
+                info.push(`${console_chars_1.chars.check} ${file.name} includes category mapping functions`);
+            }
+            // Check for hierarchical categories
+            if (content.includes("SPORTS_CARDS") ||
+                content.includes("TRADING_CARD_GAMES") ||
+                content.includes("VIDEO_GAMES")) {
+                info.push(`${console_chars_1.chars.check} ${file.name} includes main category definitions`);
+            }
+        }
+        // Check for category routes
+        const categoryRoutes = await scanner.findFiles(/app\/.*\[category\].*page\.(ts|tsx)$/);
+        if (categoryRoutes.length > 0) {
+            info.push(`${console_chars_1.chars.check} Found ${categoryRoutes.length} category route files`);
+            for (const file of categoryRoutes) {
+                const content = await scanner.readFileContent(file.path);
+                if (!content)
+                    continue;
+                // Check for Next.js 15 params handling
+                if (content.includes("await params")) {
+                    info.push(`${console_chars_1.chars.check} ${file.name} uses Next.js 15 params pattern`);
+                }
+                else {
+                    warnings.push(`${file.relativePath} may not use Next.js 15 params pattern`);
+                }
+            }
+        }
+        else {
+            warnings.push("No category route files found");
+        }
+        return { passed: errors.length === 0, errors, warnings, info };
+    }));
+    // Collection Management (from collection.ts)
+    runner.addCheck((0, preflight_runner_1.createCheck)("Collection Management", "Validate user collection tracking system", async () => {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        // Check for collection models in schema
+        const schemaFiles = await scanner.findFiles(/prisma\/schema\.prisma$/);
+        if (schemaFiles.length === 0) {
+            errors.push("Prisma schema file not found");
+            return { passed: false, errors, warnings };
+        }
+        const content = await scanner.readFileContent(schemaFiles[0].path);
+        if (!content) {
+            errors.push("Could not read Prisma schema");
+            return { passed: false, errors, warnings };
+        }
+        // Check for Collection model (now userCollections)
+        if (!content.includes("model userCollections {")) {
+            // Collections may be implemented differently or not yet
+            warnings.push("userCollections model not found in schema - collections may use different implementation");
+        }
+        else {
+            info.push("${chars.check} userCollections model found");
+        }
+        // Check for CollectionItem model (now userCollectionItems)
+        if (!content.includes("model userCollectionItems {")) {
+            // Collection items may be implemented differently
+            warnings.push("userCollectionItems model not found - collection items may use different implementation");
+        }
+        else {
+            info.push("✓ userCollectionItems model found");
+        }
+        // Check for WishlistItem model (now userWishlistItems)
+        if (!content.includes("model userWishlistItems {")) {
+            // Wishlist may be implemented differently
+            warnings.push("userWishlistItems model not found - wishlist may use different implementation");
+        }
+        else {
+            info.push("✓ userWishlistItems model found");
+        }
+        // Check for required fields
+        const requiredFields = ["collectionId", "sportsCardCatalogId", "quantity", "acquiredDate"];
+        for (const field of requiredFields) {
+            if (!content.includes(field)) {
+                warnings.push(`Collection field not found: ${field}`);
+            }
+            else {
+                info.push(`${console_chars_1.chars.check} Collection field found: ${field}`);
+            }
+        }
+        // Check for collection API endpoints
+        const collectionFiles = await scanner.findFiles(/app\/api.*collection.*route\.(ts|js)$/);
+        if (collectionFiles.length > 0) {
+            info.push(`${console_chars_1.chars.check} Found ${collectionFiles.length} collection API endpoints`);
+        }
+        else {
+            warnings.push("No collection API endpoints found");
+        }
+        return { passed: errors.length === 0, errors, warnings, info };
+    }));
+    // Marketplace Integration (from marketplace.ts)
+    runner.addCheck((0, preflight_runner_1.createCheck)("Marketplace Integration", "Validate multi-platform marketplace features", async () => {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        // Check schema for marketplace models
+        const schemaFiles = await scanner.findFiles(/prisma\/schema\.prisma$/);
+        if (schemaFiles.length === 0) {
+            errors.push("Prisma schema file not found");
+            return { passed: false, errors, warnings };
+        }
+        const content = await scanner.readFileContent(schemaFiles[0].path);
+        if (!content) {
+            errors.push("Could not read Prisma schema");
+            return { passed: false, errors, warnings };
+        }
+        // Check for Listing model (now coreListings)
+        if (!content.includes("model coreListings {")) {
+            errors.push("coreListings model not found in schema");
+        }
+        else {
+            info.push("${chars.check} coreListings model found");
+        }
+        // Check for Condition enum (eBay mapping)
+        if (!content.includes("enum Condition {")) {
+            errors.push("Condition enum not found - needed for eBay mapping");
+        }
+        else {
+            info.push("✓ Condition enum found");
+        }
+        // Check for ProductType enum
+        if (!content.includes("enum ProductType {")) {
+            warnings.push("ProductType enum not found - polymorphic listings may not work");
+        }
+        else {
+            info.push("✓ ProductType enum found");
+        }
+        // Check for order management
+        const orderFiles = await scanner.findFiles(/app\/api.*order.*route\.(ts|js)$/);
+        if (orderFiles.length > 0) {
+            info.push(`${console_chars_1.chars.check} Found ${orderFiles.length} order management endpoints`);
+        }
+        else {
+            warnings.push("No order management endpoints found");
+        }
+        // Check for seller management
+        const sellerFiles = await scanner.findFiles(/app\/seller.*\.(ts|tsx)$/);
+        if (sellerFiles.length > 0) {
+            info.push(`${console_chars_1.chars.check} Found ${sellerFiles.length} seller interface files`);
+        }
+        else {
+            warnings.push("No seller interface files found");
+        }
+        // Check for admin management
+        const adminFiles = await scanner.findFiles(/app\/admin.*\.(ts|tsx)$/);
+        if (adminFiles.length > 0) {
+            info.push(`${console_chars_1.chars.check} Found ${adminFiles.length} admin interface files`);
+        }
+        else {
+            warnings.push("No admin interface files found");
+        }
+        return { passed: errors.length === 0, errors, warnings, info };
+    }));
+    // Grading Validation (from grading.ts)
+    runner.addCheck((0, preflight_runner_1.createCheck)("Card Grading System", "Validate PSA, BGS, WATA grading implementation", async () => {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        const schemaFiles = await scanner.findFiles(/prisma\/schema\.prisma$/);
+        if (schemaFiles.length === 0) {
+            errors.push("Prisma schema file not found");
+            return { passed: false, errors, warnings };
+        }
+        const content = await scanner.readFileContent(schemaFiles[0].path);
+        if (!content) {
+            errors.push("Could not read Prisma schema");
+            return { passed: false, errors, warnings };
+        }
+        // Check for grading fields
+        if (!content.includes("psaGrade")) {
+            errors.push("psaGrade field not found - PSA grading not implemented");
+        }
+        else {
+            info.push("${chars.check} PSA grading field found");
+        }
+        if (!content.includes("bgsGrade")) {
+            errors.push("bgsGrade field not found - BGS grading not implemented");
+        }
+        else {
+            info.push("✓ BGS grading field found");
+        }
+        if (!content.includes("wataGrade")) {
+            warnings.push("wataGrade field not found - WATA grading for video games not implemented");
+        }
+        else {
+            info.push("✓ WATA grading field found");
+        }
+        // Check for CardGraded enum
+        if (!content.includes("enum CardGraded")) {
+            errors.push("CardGraded enum not found");
+        }
+        else {
+            info.push("✓ CardGraded enum found");
+        }
+        return { passed: errors.length === 0, errors, warnings, info };
+    }));
+    // AI Recognition System (from ai-recognition.ts)
+    runner.addCheck((0, preflight_runner_1.createCheck)("AI Recognition Configuration", "Validate OpenAI API configuration for card recognition", async () => {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        // Detect CI/build environment (Vercel, GitHub Actions, etc.)
+        const isCI = process.env.CI === "true" ||
+            process.env.VERCEL === "1" ||
+            process.env.GITHUB_ACTIONS === "true" ||
+            process.env.NODE_ENV === "production";
+        // Check OpenAI API key
+        if (!process.env.OPENAI_API_KEY) {
+            if (isCI) {
+                // In CI/build, missing env vars are warnings (they're set at runtime)
+                warnings.push("OPENAI_API_KEY not available during build (expected - set at runtime)");
+            }
+            else {
+                errors.push("Missing OPENAI_API_KEY environment variable");
+            }
+        }
+        else if (process.env.OPENAI_API_KEY.startsWith("sk-") &&
+            process.env.OPENAI_API_KEY.length < 40) {
+            warnings.push("OPENAI_API_KEY appears to be invalid (too short)");
+        }
+        else {
+            info.push("✓ OPENAI_API_KEY is configured");
+        }
+        // Check for AI descriptor fields in schema
+        const schemaFiles = await scanner.findFiles(/prisma\/schema\.prisma$/);
+        if (schemaFiles.length > 0) {
+            const content = await scanner.readFileContent(schemaFiles[0].path);
+            if (content) {
+                if (!content.includes("aiDescriptor")) {
+                    warnings.push("aiDescriptor field not found - AI recognition may not be fully implemented");
+                }
+                else {
+                    info.push("✓ aiDescriptor field found");
+                }
+                if (!content.includes("ocrText")) {
+                    warnings.push("ocrText field not found - OCR text matching may not be implemented");
+                }
+                else {
+                    info.push("✓ ocrText field found");
+                }
+            }
+        }
+        return { passed: errors.length === 0, errors, warnings, info };
+    }));
+    // Integration Enum Validation
+    runner.addCheck((0, preflight_runner_1.createCheck)("Integration Enum Validation", "Validate that WooCommerce and CSV integrations use correct enum values", async () => {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        try {
+            // Import and run the integration enum validation
+            const { validateIntegrationEnums } = await Promise.resolve().then(() => __importStar(require("../specialized/validate-integration-enums")));
+            const success = await validateIntegrationEnums();
+            if (success) {
+                info.push("✓ All integration files use correct enum values");
+            }
+            else {
+                errors.push("Integration files contain invalid enum values");
+            }
+        }
+        catch (error) {
+            // This is a non-critical check - if the module can't be loaded, just warn
+            warnings.push(`Could not validate integration enums: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return { passed: errors.length === 0, errors, warnings, info };
+    }));
+    // WooCommerce Image Management Validation
+    runner.addCheck((0, preflight_runner_1.createCheck)("WooCommerce Image Management", "Validate WooCommerce image move functionality and R2 folder structure", async () => {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        // Check image management system
+        const imageManagementFiles = await scanner.findFiles(/lib\/image-management\.(ts|js)$/);
+        for (const file of imageManagementFiles) {
+            const content = await scanner.readFileContent(file.path);
+            if (!content)
+                continue;
+            // Check for enhanced URL extraction
+            if (content.includes(".r2.dev/")) {
+                info.push(`${console_chars_1.chars.check} ${file.name} handles R2 dev URLs`);
+            }
+            else {
+                warnings.push(`${file.relativePath} may not handle R2 dev URLs correctly`);
+            }
+            // Check for move operation (not copy)
+            if (content.includes("DeleteObjectCommand")) {
+                info.push(`${console_chars_1.chars.check} ${file.name} implements proper move operation (copy + delete)`);
+            }
+            else {
+                errors.push(`${file.relativePath} does not implement move operation - images will be duplicated`);
+            }
+            // Check for source folder detection
+            if (content.includes("sourceFolder")) {
+                info.push(`${console_chars_1.chars.check} ${file.name} includes source folder detection`);
+            }
+            else {
+                warnings.push(`${file.relativePath} lacks source folder detection for debugging`);
+            }
+            // Check for SEO metadata
+            if (content.includes("alt-text") && content.includes("caption")) {
+                info.push(`${console_chars_1.chars.check} ${file.name} applies SEO metadata to moved images`);
+            }
+            else {
+                warnings.push(`${file.relativePath} may not apply proper SEO metadata`);
+            }
+        }
+        // Check WooCommerce import service
+        const wooCommerceFiles = await scanner.findFiles(/lib\/woocommerce-import-service\.(ts|js)$/);
+        for (const file of wooCommerceFiles) {
+            const content = await scanner.readFileContent(file.path);
+            if (!content)
+                continue;
+            // Check for correct folder usage
+            if (content.includes('"woocommerce-imports"')) {
+                info.push(`${console_chars_1.chars.check} ${file.name} uses correct woocommerce-imports folder`);
+            }
+            else {
+                errors.push(`${file.relativePath} does not use woocommerce-imports folder`);
+            }
+            // Check for proper error handling
+            if (content.includes("imageResult.failed")) {
+                info.push(`${console_chars_1.chars.check} ${file.name} handles image upload failures gracefully`);
+            }
+            else {
+                warnings.push(`${file.relativePath} may lack proper image upload error handling`);
+            }
+        }
+        // Check admin approval system
+        const adminApprovalFiles = await scanner.findFiles(/app\/api\/admin\/listings\/approve\/route\.(ts|js)$/);
+        for (const file of adminApprovalFiles) {
+            const content = await scanner.readFileContent(file.path);
+            if (!content)
+                continue;
+            // Check for image move integration
+            if (content.includes("moveApprovedListingImages")) {
+                info.push(`${console_chars_1.chars.check} ${file.name} moves images during approval`);
+            }
+            else {
+                errors.push(`${file.relativePath} does not move images during approval`);
+            }
+            // Check for image URL updates
+            if (content.includes("newImageUrls")) {
+                info.push(`${console_chars_1.chars.check} ${file.name} updates listing URLs after move`);
+            }
+            else {
+                errors.push(`${file.relativePath} does not update listing URLs after move`);
+            }
+            // Check for SEO metadata storage
+            if (content.includes("imageAltTexts") && content.includes("imageCaptions")) {
+                info.push(`${console_chars_1.chars.check} ${file.name} stores SEO metadata in database`);
+            }
+            else {
+                warnings.push(`${file.relativePath} may not store SEO metadata in database`);
+            }
+        }
+        // Check R2 configuration
+        // Detect CI/build environment
+        const isCIEnv = process.env.CI === "true" ||
+            process.env.VERCEL === "1" ||
+            process.env.GITHUB_ACTIONS === "true" ||
+            process.env.NODE_ENV === "production";
+        const requiredR2Vars = [
+            "R2_ACCOUNT_ID",
+            "R2_ACCESS_KEY_ID",
+            "R2_SECRET_ACCESS_KEY",
+            "R2_BUCKET_NAME",
+        ];
+        const missingR2Vars = requiredR2Vars.filter((varName) => !process.env[varName]);
+        if (missingR2Vars.length === 0) {
+            info.push("${chars.check} All required R2 environment variables are configured");
+        }
+        else if (isCIEnv) {
+            info.push(`R2 environment variables not available during build (expected - set at runtime)`);
+        }
+        else {
+            warnings.push(`Missing R2 environment variables: ${missingR2Vars.join(", ")} (expected in development)`);
+        }
+        return { passed: errors.length === 0, errors, warnings, info };
+    }));
+    // WooCommerce Integration UI Validation
+    runner.addCheck((0, preflight_runner_1.createCheck)("WooCommerce Integration UI", "Validate WooCommerce integration includes all product types and uses correct imports", async () => {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        // Check that modular template system exists
+        const templateDir = "lib/woocommerce-templates";
+        const templateDirExists = await scanner.fileExists(templateDir);
+        if (!templateDirExists) {
+            errors.push(`Template directory missing: ${templateDir}`);
+            return { passed: false, errors, warnings };
+        }
+        // Check that all required template files exist
+        const expectedTemplates = [
+            "sports-card-template.ts",
+            "non-sports-card-template.ts",
+            "trading-card-game-template.ts",
+            "video-game-template.ts",
+            "autograph-template.ts",
+            "ticket-template.ts",
+            "index.ts",
+        ];
+        for (const template of expectedTemplates) {
+            const templatePath = `${templateDir}/${template}`;
+            const exists = await scanner.fileExists(templatePath);
+            if (!exists) {
+                errors.push(`Missing template file: ${templatePath}`);
+            }
+            else {
+                info.push(`${console_chars_1.chars.check} Template file exists: ${template}`);
+            }
+        }
+        // Check that index.ts exports all required product types
+        const indexPath = `${templateDir}/index.ts`;
+        const indexExists = await scanner.fileExists(indexPath);
+        if (indexExists) {
+            const indexContent = await scanner.readFileContent(indexPath);
+            if (indexContent) {
+                const requiredProductTypes = [
+                    "SPORTS_CARD",
+                    "NONSPORTS_CARD",
+                    "TCG_CARD",
+                    "VIDEO_GAME",
+                    "AUTOGRAPH",
+                    "TICKET",
+                ];
+                for (const productType of requiredProductTypes) {
+                    if (indexContent.includes(`"${productType}"`)) {
+                        info.push(`${console_chars_1.chars.check} Product type available: ${productType}`);
+                    }
+                    else {
+                        errors.push(`Missing product type in index.ts: ${productType}`);
+                    }
+                }
+                // Check that getSupercatchFields handles all product types
+                for (const productType of requiredProductTypes) {
+                    if (indexContent.includes(`case "${productType}":`)) {
+                        info.push(`${console_chars_1.chars.check} getSupercatchFields handles: ${productType}`);
+                    }
+                    else {
+                        errors.push(`Missing case in getSupercatchFields: ${productType}`);
+                    }
+                }
+            }
+        }
+        // Check that WooCommerce integration files use correct imports
+        const filesToCheck = [
+            "app/admin/integrations/woocommerce/page.tsx",
+            "app/api/admin/integrations/woocommerce/test-templates/route.ts",
+        ];
+        for (const filePath of filesToCheck) {
+            const exists = await scanner.fileExists(filePath);
+            if (exists) {
+                const content = await scanner.readFileContent(filePath);
+                if (content) {
+                    // Check for old import pattern (should not exist)
+                    if (content.includes('from "@/lib/woocommerce-templates"') &&
+                        !content.includes('from "@/lib/woocommerce-templates/index"')) {
+                        errors.push(`${filePath} uses old import pattern - should import "@/lib/woocommerce-templates/index"`);
+                    }
+                    // Check for correct import pattern
+                    if (content.includes('from "@/lib/woocommerce-templates/index"')) {
+                        info.push(`${console_chars_1.chars.check} ${filePath} uses correct modular import`);
+                    }
+                    else if (content.includes("getSupercatchFields") ||
+                        content.includes("productTypes")) {
+                        warnings.push(`${filePath} may need to import modular template system`);
+                    }
+                }
+            }
+            else {
+                warnings.push(`File not found: ${filePath}`);
+            }
+        }
+        // Check that old template file redirects to new system
+        const oldTemplatePath = "lib/woocommerce-templates.ts";
+        const oldExists = await scanner.fileExists(oldTemplatePath);
+        if (oldExists) {
+            const oldContent = await scanner.readFileContent(oldTemplatePath);
+            if (oldContent) {
+                if (oldContent.includes("DEPRECATED") &&
+                    oldContent.includes('from "./woocommerce-templates/index"')) {
+                    info.push("${chars.check} Old template file properly redirects to new system");
+                }
+                else {
+                    errors.push(`Old template file (${oldTemplatePath}) should redirect to new modular system`);
+                }
+            }
+        }
+        return { passed: errors.length === 0, errors, warnings, info };
+    }));
+    const result = await runner.runAll();
+    if (!result.passed) {
+        console.log(`\n${console_chars_1.emoji.bell} SuperCatch business logic preflight checks failed!`);
+        process.exit(1);
+    }
+    console.log(`\n${console_chars_1.emoji.target} All SuperCatch business logic preflight checks passed!`);
+    return result;
+}
+// Run if called directly
+if (require.main === module) {
+    runSuperCatchPreflights().catch(console.error);
+}
+exports.default = runSuperCatchPreflights;
+//# sourceMappingURL=supercatch.js.map