@empline/preflight 1.0.20

package/dist/checks/ai/recognition-pipeline-validation.js

@@ -0,0 +1,808 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Recognition Pipeline Validation Preflight
+ *
+ * Validates the card recognition pipeline follows best practices:
+ * 1. Cache-first pattern (Core Rule #3)
+ * 2. Enhancement integration order
+ * 3. Error handling and fallbacks
+ * 4. Cost optimization patterns
+ * 5. Database model consistency
+ * 6. Type safety for recognition results
+ * 7. Timeout protection (Vercel function limits)
+ * 8. Graceful degradation patterns
+ * 9. Metrics and monitoring integration
+ * 10. API route security (rate limiting, abuse prevention)
+ * 11. Batch processing patterns
+ * 12. Learning system feedback loop
+ *
+ * BLOCKING: Fails build if critical patterns are violated
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tags = exports.description = exports.blocking = exports.category = exports.name = exports.id = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const console_chars_1 = require("../../utils/console-chars");
+// Check metadata
+exports.id = "ai/recognition-pipeline-validation";
+exports.name = "Recognition Pipeline Validation";
+exports.category = "ai";
+exports.blocking = false;
+exports.description = "Recognition Pipeline Validation Preflight";
+exports.tags = ["ai", "validation"];
+const issues = [];
+// Recognition pipeline files to validate
+const RECOGNITION_FILES = [
+    "lib/api/cards/identify/index.ts",
+    "lib/api/cards/identify/recognition-engine.ts",
+    "lib/api/cards/identify/cache-manager.ts",
+    "lib/recognition-enhancements.ts",
+    "lib/image-quality-scoring.ts",
+    "lib/seller-learning.ts",
+    "lib/sequential-card-detection.ts",
+    "lib/back-image-ocr.ts",
+    "lib/parallel-vision-fallback.ts",
+    "lib/weighted-feedback-learning.ts",
+    "lib/set-completion-tracking.ts",
+    "lib/batch-processing-worker.ts",
+    "lib/metadata-cache.ts",
+    "lib/vision-service.ts",
+];
+// API routes that need security validation
+const RECOGNITION_API_ROUTES = [
+    "app/api/cards/identify/route.ts",
+    "app/api/cards/quality-check/route.ts",
+    "app/api/recognition/feedback/route.ts",
+    "app/api/cards/batch-submit/route.ts",
+];
+// Enhancement modules that must be imported in the main pipeline
+const REQUIRED_ENHANCEMENTS = [
+    "runPreRecognitionEnhancements",
+    "runPostRecognitionEnhancements",
+    "maybeRunParallelFallback",
+    "getSellerPromptAddition",
+    // quickImageQualityCheck is optional - used in batch processing, not main pipeline
+];
+// Patterns that indicate cache-first violation
+const CACHE_VIOLATION_PATTERNS = [
+    {
+        pattern: /recognizeWithGPTVision\s*\([^)]+\)(?!.*checkCache)/s,
+        message: "GPT Vision called without prior cache check",
+        rule: "CACHE_FIRST",
+    },
+    {
+        pattern: /visionService\.recognize(?!.*cache)/is,
+        message: "Vision service called without cache check",
+        rule: "CACHE_FIRST",
+    },
+];
+// Required error handling patterns
+const ERROR_HANDLING_PATTERNS = [
+    {
+        pattern: /try\s*\{[\s\S]*?recognizeWith[\s\S]*?\}\s*catch/,
+        required: true,
+        message: "Recognition calls must be wrapped in try-catch",
+        rule: "ERROR_HANDLING",
+    },
+    {
+        pattern: /logger\.(warn|error)\s*\(/,
+        required: true,
+        message: "Recognition errors must be logged",
+        rule: "ERROR_LOGGING",
+    },
+];
+// Cost optimization patterns
+const COST_PATTERNS = [
+    {
+        pattern: /costMonitor\.canAffordOperation/,
+        required: true,
+        files: ["lib/api/cards/identify/index.ts"],
+        message: "Cost check required before AI operations",
+        rule: "COST_CHECK",
+    },
+    {
+        pattern: /trackRecognitionCost/,
+        required: true,
+        files: ["lib/api/cards/identify/index.ts"],
+        message: "Cost tracking required after recognition",
+        rule: "COST_TRACKING",
+    },
+];
+// Enhancement integration order validation
+const ENHANCEMENT_ORDER = [
+    { name: "pre_recognition_enhancements", before: "gpt_vision" },
+    { name: "gpt_vision_analysis", before: "post_recognition" },
+    { name: "post_recognition_enhancements", before: "parallel_fallback" },
+    { name: "parallel_vision_fallback", before: "web_scraping" },
+];
+function validateFile(filePath) {
+    const fullPath = node_path_1.default.join(process.cwd(), filePath);
+    if (!node_fs_1.default.existsSync(fullPath)) {
+        issues.push({
+            file: filePath,
+            line: 0,
+            rule: "FILE_EXISTS",
+            severity: "error",
+            message: `Required recognition file missing: ${filePath}`,
+            suggestion: "Ensure all recognition pipeline files exist",
+        });
+        return;
+    }
+    const content = node_fs_1.default.readFileSync(fullPath, "utf-8");
+    const lines = content.split("\n");
+    // Check for cache-first violations in main pipeline
+    if (filePath.includes("identify/index.ts")) {
+        validateCacheFirst(filePath, content, lines);
+        validateEnhancementOrder(filePath, content, lines);
+        validateEnhancementImports(filePath, content);
+        validateCostPatterns(filePath, content, lines);
+        validateTimeoutProtection(filePath, content);
+        validateMetricsIntegration(filePath, content);
+        validateApiRouteSecurity(filePath, content);
+    }
+    // Check error handling in all recognition files
+    validateErrorHandling(filePath, content, lines);
+    // Check type safety
+    validateTypeSafety(filePath, content, lines);
+    // Check for hardcoded confidence thresholds
+    validateConfidenceThresholds(filePath, content, lines);
+    // Check graceful degradation
+    validateGracefulDegradation(filePath, content);
+    // Check batch processing patterns
+    validateBatchProcessing(filePath, content);
+    // Check learning feedback loop
+    validateLearningFeedback(filePath, content);
+}
+function validateCacheFirst(filePath, content, lines) {
+    // Ensure cache check happens before AI calls
+    const cacheCheckIndex = content.indexOf("checkCache");
+    const gptVisionIndex = content.indexOf("recognizeWithGPTVision");
+    if (gptVisionIndex !== -1 && cacheCheckIndex !== -1) {
+        if (gptVisionIndex < cacheCheckIndex) {
+            const lineNum = content.substring(0, gptVisionIndex).split("\n").length;
+            issues.push({
+                file: filePath,
+                line: lineNum,
+                rule: "CACHE_FIRST",
+                severity: "error",
+                message: "GPT Vision called before cache check - violates Core Rule #3",
+                suggestion: "Always check cache before calling AI services",
+            });
+        }
+    }
+    // Check for raw hash check (first line of defense)
+    if (!content.includes("rawHash") || !content.includes("RAW HASH")) {
+        issues.push({
+            file: filePath,
+            line: 1,
+            rule: "RAW_HASH_CHECK",
+            severity: "warning",
+            message: "Raw hash check not found - missing first line of cache defense",
+            suggestion: "Add raw hash check before any image processing",
+        });
+    }
+}
+function validateEnhancementOrder(filePath, content, lines) {
+    const stepPositions = {};
+    // Find positions of each enhancement step
+    for (const step of ENHANCEMENT_ORDER) {
+        const index = content.indexOf(`addStep("${step.name}"`);
+        if (index !== -1) {
+            stepPositions[step.name] = index;
+        }
+    }
+    // Validate order
+    for (const step of ENHANCEMENT_ORDER) {
+        if (stepPositions[step.name] !== undefined && stepPositions[step.before] !== undefined) {
+            if (stepPositions[step.name] > stepPositions[step.before]) {
+                const lineNum = content.substring(0, stepPositions[step.name]).split("\n").length;
+                issues.push({
+                    file: filePath,
+                    line: lineNum,
+                    rule: "ENHANCEMENT_ORDER",
+                    severity: "error",
+                    message: `Enhancement step "${step.name}" must come before "${step.before}"`,
+                    suggestion: "Follow the correct enhancement integration order",
+                });
+            }
+        }
+    }
+}
+function validateEnhancementImports(filePath, content) {
+    for (const enhancement of REQUIRED_ENHANCEMENTS) {
+        if (!content.includes(enhancement)) {
+            issues.push({
+                file: filePath,
+                line: 1,
+                rule: "ENHANCEMENT_IMPORT",
+                severity: "warning",
+                message: `Missing enhancement function: ${enhancement}`,
+                suggestion: `Import ${enhancement} from recognition-enhancements.ts`,
+            });
+        }
+    }
+}
+function validateCostPatterns(filePath, content, lines) {
+    for (const pattern of COST_PATTERNS) {
+        if (pattern.files && !pattern.files.includes(filePath))
+            continue;
+        const hasPattern = pattern.pattern.test(content);
+        if (pattern.required && !hasPattern) {
+            issues.push({
+                file: filePath,
+                line: 1,
+                rule: pattern.rule,
+                severity: "error",
+                message: pattern.message,
+                suggestion: "Add cost monitoring to prevent budget overruns",
+            });
+        }
+    }
+}
+function validateErrorHandling(filePath, content, lines) {
+    // Check for unhandled async operations in recognition code
+    const asyncCalls = content.match(/await\s+\w+\(/g) || [];
+    const tryCatchBlocks = content.match(/try\s*\{/g) || [];
+    // Recognition files should have robust error handling
+    if (asyncCalls.length > 5 && tryCatchBlocks.length < 2) {
+        issues.push({
+            file: filePath,
+            line: 1,
+            rule: "ERROR_HANDLING",
+            severity: "warning",
+            message: "Multiple async calls with insufficient error handling",
+            suggestion: "Wrap async operations in try-catch blocks",
+        });
+    }
+    // Check for logger usage in catch blocks
+    if (content.includes("catch") && !content.includes("logger.")) {
+        issues.push({
+            file: filePath,
+            line: 1,
+            rule: "ERROR_LOGGING",
+            severity: "warning",
+            message: "Catch blocks should log errors",
+            suggestion: "Use logger.warn or logger.error in catch blocks",
+        });
+    }
+}
+function validateTypeSafety(filePath, content, lines) {
+    // Check for unsafe type assertions in recognition results
+    const unsafePatterns = [
+        { pattern: /as\s+any(?!\s*\))/, message: "Unsafe 'as any' cast" },
+        { pattern: /\!\s*\./, message: "Non-null assertion on property access" },
+    ];
+    for (const { pattern, message } of unsafePatterns) {
+        const matches = content.match(new RegExp(pattern, "g")) || [];
+        if (matches.length > 3) {
+            issues.push({
+                file: filePath,
+                line: 1,
+                rule: "TYPE_SAFETY",
+                severity: "warning",
+                message: `Multiple ${message} found (${matches.length} occurrences)`,
+                suggestion: "Use proper type guards instead of unsafe casts",
+            });
+        }
+    }
+    // Check for CardRecognitionResult type usage
+    if (filePath.includes("recognition") && !content.includes("CardRecognitionResult")) {
+        issues.push({
+            file: filePath,
+            line: 1,
+            rule: "TYPE_CONSISTENCY",
+            severity: "info",
+            message: "Consider using CardRecognitionResult type for consistency",
+            suggestion: "Import and use CardRecognitionResult from metadata-cache",
+        });
+    }
+}
+function validateConfidenceThresholds(filePath, content, lines) {
+    // Check for hardcoded confidence values that should be configurable
+    const hardcodedConfidence = content.match(/confidence\s*[<>=]+\s*0\.\d+/g) || [];
+    if (hardcodedConfidence.length > 5) {
+        issues.push({
+            file: filePath,
+            line: 1,
+            rule: "CONFIDENCE_CONFIG",
+            severity: "info",
+            message: `Multiple hardcoded confidence thresholds (${hardcodedConfidence.length})`,
+            suggestion: "Consider using configurable thresholds from env or constants",
+        });
+    }
+}
+// NEW: Timeout protection validation
+function validateTimeoutProtection(filePath, content) {
+    if (!filePath.includes("identify/index.ts"))
+        return;
+    // Check for timeout bailout pattern
+    if (!content.includes("isApproachingTimeout") && !content.includes("EARLY_BAILOUT")) {
+        issues.push({
+            file: filePath,
+            line: 1,
+            rule: "TIMEOUT_PROTECTION",
+            severity: "error",
+            message: "Missing timeout bailout protection for Vercel function limits",
+            suggestion: "Add isApproachingTimeout() checks before long operations",
+        });
+    }
+    // Check for timeout constants
+    if (!content.includes("VERCEL_TIMEOUT") && !content.includes("BAILOUT_MS")) {
+        issues.push({
+            file: filePath,
+            line: 1,
+            rule: "TIMEOUT_CONSTANTS",
+            severity: "warning",
+            message: "Missing timeout constants for function limits",
+            suggestion: "Define VERCEL_TIMEOUT_MS and EARLY_BAILOUT_MS constants",
+        });
+    }
+}
+// NEW: Graceful degradation validation
+function validateGracefulDegradation(filePath, content) {
+    if (!filePath.includes("identify") && !filePath.includes("recognition"))
+        return;
+    // Check for fallback patterns
+    const hasFallback = content.includes("Fallback") || content.includes("fallback") || content.includes("OCRFallback");
+    if (!hasFallback && filePath.includes("index.ts")) {
+        issues.push({
+            file: filePath,
+            line: 1,
+            rule: "GRACEFUL_DEGRADATION",
+            severity: "warning",
+            message: "No fallback mechanism detected for recognition failures",
+            suggestion: "Add OCR fallback or manual entry fallback for failed recognition",
+        });
+    }
+    // Check for partial result handling
+    if (filePath.includes("index.ts") && !content.includes("partial")) {
+        issues.push({
+            file: filePath,
+            line: 1,
+            rule: "PARTIAL_RESULTS",
+            severity: "info",
+            message: "Consider handling partial results on timeout",
+            suggestion: "Return partial recognition results when approaching timeout",
+        });
+    }
+}
+// NEW: Metrics and monitoring validation
+function validateMetricsIntegration(filePath, content) {
+    if (!filePath.includes("identify/index.ts"))
+        return;
+    // Check for metrics recording
+    if (!content.includes("recognitionMonitor") && !content.includes("metrics")) {
+        issues.push({
+            file: filePath,
+            line: 1,
+            rule: "METRICS_RECORDING",
+            severity: "warning",
+            message: "Missing metrics recording for recognition operations",
+            suggestion: "Add recognitionMonitor.recordMetrics() for observability",
+        });
+    }
+    // Check for diagnostics
+    if (!content.includes("diagnostics") && !content.includes("DiagnosticInfo")) {
+        issues.push({
+            file: filePath,
+            line: 1,
+            rule: "DIAGNOSTICS",
+            severity: "info",
+            message: "Missing diagnostic information collection",
+            suggestion: "Add diagnostics object to track processing steps",
+        });
+    }
+}
+// NEW: API route security validation
+function validateApiRouteSecurity(filePath, content) {
+    // Check for abuse prevention
+    if (filePath.includes("identify") &&
+        !content.includes("abusePreventionSystem") &&
+        !content.includes("abuse")) {
+        issues.push({
+            file: filePath,
+            line: 1,
+            rule: "ABUSE_PREVENTION",
+            severity: "warning",
+            message: "Missing abuse prevention check for recognition API",
+            suggestion: "Add imageAbusePreventionSystem.canUserUploadImage() check",
+        });
+    }
+    // Check for scan allowance (rate limiting)
+    if (filePath.includes("identify/index.ts")) {
+        if (!content.includes("checkStoreScanAllowance") && !content.includes("checkAiScanAllowance")) {
+            issues.push({
+                file: filePath,
+                line: 1,
+                rule: "SCAN_ALLOWANCE",
+                severity: "warning",
+                message: "Missing scan allowance check for billing/rate limiting",
+                suggestion: "Add checkStoreScanAllowance or checkAiScanAllowance before AI calls",
+            });
+        }
+    }
+}
+// NEW: Batch processing validation
+function validateBatchProcessing(filePath, content) {
+    if (!filePath.includes("batch"))
+        return;
+    // Check for concurrency control
+    if (!content.includes("pLimit") && !content.includes("concurrency")) {
+        issues.push({
+            file: filePath,
+            line: 1,
+            rule: "BATCH_CONCURRENCY",
+            severity: "warning",
+            message: "Missing concurrency control in batch processing",
+            suggestion: "Use pLimit or similar to control parallel processing",
+        });
+    }
+    // Check for batch context tracking
+    if (!content.includes("batchContext") && !content.includes("analyzeBatchContext")) {
+        issues.push({
+            file: filePath,
+            line: 1,
+            rule: "BATCH_CONTEXT",
+            severity: "info",
+            message: "Consider using batch context for sequential card detection",
+            suggestion: "Track recognized cards for pattern detection across batch",
+        });
+    }
+    // Check for email notification on completion
+    if (!content.includes("sendLatestTemplateEmail") && !content.includes("emailSent")) {
+        issues.push({
+            file: filePath,
+            line: 1,
+            rule: "BATCH_NOTIFICATION",
+            severity: "info",
+            message: "Consider sending email notification on batch completion",
+            suggestion: "Notify users when batch processing completes",
+        });
+    }
+}
+// NEW: Learning system feedback loop validation
+function validateLearningFeedback(filePath, content) {
+    // Check seller learning integration
+    if (filePath.includes("identify/index.ts")) {
+        if (!content.includes("recordSellerRecognition") && !content.includes("sellerLearning")) {
+            issues.push({
+                file: filePath,
+                line: 1,
+                rule: "SELLER_LEARNING",
+                severity: "info",
+                message: "Consider recording seller recognition patterns",
+                suggestion: "Call recordSellerRecognition() to improve future recognition",
+            });
+        }
+    }
+    // Check feedback route for weighted learning
+    if (filePath.includes("feedback")) {
+        if (!content.includes("applyWeightedCorrection") && !content.includes("weightedFeedback")) {
+            issues.push({
+                file: filePath,
+                line: 1,
+                rule: "WEIGHTED_FEEDBACK",
+                severity: "info",
+                message: "Consider using weighted feedback for corrections",
+                suggestion: "Apply weighted corrections based on user reliability",
+            });
+        }
+    }
+}
+// NEW: Validate recognition API routes exist and have proper structure
+function validateApiRoutes() {
+    for (const routePath of RECOGNITION_API_ROUTES) {
+        const fullPath = node_path_1.default.join(process.cwd(), routePath);
+        if (!node_fs_1.default.existsSync(fullPath)) {
+            // Only warn for optional routes
+            if (routePath.includes("quality-check") || routePath.includes("batch-submit")) {
+                issues.push({
+                    file: routePath,
+                    line: 0,
+                    rule: "API_ROUTE_EXISTS",
+                    severity: "info",
+                    message: `Optional API route not found: ${routePath}`,
+                    suggestion: "Consider adding this route for full enhancement support",
+                });
+            }
+            continue;
+        }
+        const content = node_fs_1.default.readFileSync(fullPath, "utf-8");
+        // Check for POST handler
+        if (!content.includes("export async function POST")) {
+            issues.push({
+                file: routePath,
+                line: 1,
+                rule: "API_HANDLER",
+                severity: "warning",
+                message: "Missing POST handler in recognition API route",
+                suggestion: "Add export async function POST(request: NextRequest)",
+            });
+        }
+        // Check for request validation
+        if (!content.includes("request.json()") && !content.includes("await request")) {
+            issues.push({
+                file: routePath,
+                line: 1,
+                rule: "REQUEST_VALIDATION",
+                severity: "warning",
+                message: "Missing request body parsing",
+                suggestion: "Parse and validate request body with proper error handling",
+            });
+        }
+    }
+}
+function validateDatabaseModels() {
+    const schemaPath = node_path_1.default.join(process.cwd(), "prisma/schema.prisma");
+    if (!node_fs_1.default.existsSync(schemaPath)) {
+        issues.push({
+            file: "prisma/schema.prisma",
+            line: 0,
+            rule: "SCHEMA_EXISTS",
+            severity: "error",
+            message: "Prisma schema not found",
+            suggestion: "Ensure prisma/schema.prisma exists",
+        });
+        return;
+    }
+    const schema = node_fs_1.default.readFileSync(schemaPath, "utf-8");
+    // Check for required recognition enhancement models
+    const requiredModels = [
+        "SystemSellerLearning",
+        "SystemImageQualityLog",
+        "SystemBatchPatterns",
+        "RecognitionFeedback",
+    ];
+    for (const model of requiredModels) {
+        if (!schema.includes(`model ${model}`)) {
+            issues.push({
+                file: "prisma/schema.prisma",
+                line: 1,
+                rule: "MODEL_EXISTS",
+                severity: "error",
+                message: `Required model missing: ${model}`,
+                suggestion: `Add ${model} model to schema for recognition enhancements`,
+            });
+        }
+    }
+    // Check RecognitionFeedback has enhancement columns
+    const feedbackMatch = schema.match(/model RecognitionFeedback \{[\s\S]*?\}/);
+    if (feedbackMatch) {
+        const feedbackModel = feedbackMatch[0];
+        const requiredFields = ["correctionWeight", "appliedToLearning", "recognitionMethod"];
+        for (const field of requiredFields) {
+            if (!feedbackModel.includes(field)) {
+                issues.push({
+                    file: "prisma/schema.prisma",
+                    line: 1,
+                    rule: "MODEL_FIELD",
+                    severity: "warning",
+                    message: `RecognitionFeedback missing field: ${field}`,
+                    suggestion: "Add weighted feedback learning fields to RecognitionFeedback",
+                });
+            }
+        }
+    }
+}
+function validateEnhancementModules() {
+    const enhancementFiles = [
+        { file: "lib/image-quality-scoring.ts", exports: ["analyzeImageQuality", "quickQualityCheck"] },
+        { file: "lib/seller-learning.ts", exports: ["getSellerContext", "recordSellerRecognition"] },
+        {
+            file: "lib/sequential-card-detection.ts",
+            exports: ["analyzeBatchContext", "applyBatchContextToCard"],
+        },
+        { file: "lib/back-image-ocr.ts", exports: ["extractBackImageData"] },
+        {
+            file: "lib/parallel-vision-fallback.ts",
+            exports: ["recognizeWithParallelFallback", "shouldRunParallel"],
+        },
+        { file: "lib/weighted-feedback-learning.ts", exports: ["applyWeightedCorrection"] },
+        { file: "lib/set-completion-tracking.ts", exports: ["checkSetRelevance"] },
+        {
+            file: "lib/multi-language-ocr.ts",
+            exports: ["detectCardLanguage", "enhanceWithMultiLanguageOCR", "buildMultiLanguagePrompt"],
+        },
+    ];
+    for (const { file, exports } of enhancementFiles) {
+        const fullPath = node_path_1.default.join(process.cwd(), file);
+        if (!node_fs_1.default.existsSync(fullPath)) {
+            issues.push({
+                file,
+                line: 0,
+                rule: "ENHANCEMENT_MODULE",
+                severity: "error",
+                message: `Enhancement module missing: ${file}`,
+                suggestion: "Create the enhancement module with required exports",
+            });
+            continue;
+        }
+        const content = node_fs_1.default.readFileSync(fullPath, "utf-8");
+        for (const exportName of exports) {
+            if (!content.includes(`export`) || !content.includes(exportName)) {
+                issues.push({
+                    file,
+                    line: 1,
+                    rule: "ENHANCEMENT_EXPORT",
+                    severity: "error",
+                    message: `Missing export: ${exportName}`,
+                    suggestion: `Export ${exportName} from ${file}`,
+                });
+            }
+        }
+    }
+}
+function validateIntegrationModule() {
+    const integrationPath = node_path_1.default.join(process.cwd(), "lib/recognition-enhancements.ts");
+    if (!node_fs_1.default.existsSync(integrationPath)) {
+        issues.push({
+            file: "lib/recognition-enhancements.ts",
+            line: 0,
+            rule: "INTEGRATION_MODULE",
+            severity: "error",
+            message: "Recognition enhancements integration module missing",
+            suggestion: "Create lib/recognition-enhancements.ts to coordinate all enhancements",
+        });
+        return;
+    }
+    const content = node_fs_1.default.readFileSync(integrationPath, "utf-8");
+    // Check all enhancement imports
+    const requiredImports = [
+        "image-quality-scoring",
+        "seller-learning",
+        "sequential-card-detection",
+        "back-image-ocr",
+        "parallel-vision-fallback",
+        "weighted-feedback-learning",
+        "set-completion-tracking",
+        "multi-language-ocr",
+    ];
+    for (const importName of requiredImports) {
+        if (!content.includes(importName)) {
+            issues.push({
+                file: "lib/recognition-enhancements.ts",
+                line: 1,
+                rule: "INTEGRATION_IMPORT",
+                severity: "warning",
+                message: `Missing import from: ${importName}`,
+                suggestion: "Import all enhancement modules in the integration file",
+            });
+        }
+    }
+}
+function generateReport() {
+    console.log(`\n${console_chars_1.emoji.robot} RECOGNITION PIPELINE VALIDATION`);
+    console.log((0, console_chars_1.createDivider)(80, "heavy"));
+    if (issues.length === 0) {
+        console.log(`${console_chars_1.emoji.success} Recognition pipeline follows all best practices`);
+        return;
+    }
+    // Group by severity
+    const errors = issues.filter((i) => i.severity === "error");
+    const warnings = issues.filter((i) => i.severity === "warning");
+    const infos = issues.filter((i) => i.severity === "info");
+    if (errors.length > 0) {
+        console.log(`\n${console_chars_1.emoji.error} CRITICAL ISSUES (${errors.length})`);
+        console.log((0, console_chars_1.createDivider)(70, "heavy"));
+        for (const issue of errors) {
+            console.log(`${console_chars_1.emoji.error} ${issue.file}:${issue.line}`);
+            console.log(`   [${issue.rule}] ${issue.message}`);
+            console.log(`   ${console_chars_1.emoji.hint} ${issue.suggestion}`);
+        }
+    }
+    if (warnings.length > 0) {
+        console.log(`\n${console_chars_1.emoji.warning} WARNINGS (${warnings.length})`);
+        console.log((0, console_chars_1.createDivider)(70, "heavy"));
+        for (const issue of warnings.slice(0, 10)) {
+            console.log(`${console_chars_1.emoji.warning} ${issue.file}:${issue.line}`);
+            console.log(`   [${issue.rule}] ${issue.message}`);
+            console.log(`   ${console_chars_1.emoji.hint} ${issue.suggestion}`);
+        }
+        if (warnings.length > 10) {
+            console.log(`   ... and ${warnings.length - 10} more warnings`);
+        }
+    }
+    if (infos.length > 0) {
+        console.log(`\n${console_chars_1.emoji.hint} SUGGESTIONS (${infos.length})`);
+        console.log((0, console_chars_1.createDivider)(70, "heavy"));
+        for (const issue of infos.slice(0, 5)) {
+            console.log(`${console_chars_1.emoji.hint} ${issue.file}: ${issue.message}`);
+        }
+    }
+    // Summary
+    console.log(`\n${console_chars_1.emoji.stats} SUMMARY`);
+    console.log((0, console_chars_1.createDivider)(70, "heavy"));
+    console.log(`   ${console_chars_1.chars.bullet} Errors: ${errors.length}`);
+    console.log(`   ${console_chars_1.chars.bullet} Warnings: ${warnings.length}`);
+    console.log(`   ${console_chars_1.chars.bullet} Suggestions: ${infos.length}`);
+}
+function generateBestPracticesReminder() {
+    console.log(`\n${console_chars_1.emoji.book} RECOGNITION PIPELINE BEST PRACTICES`);
+    console.log((0, console_chars_1.createDivider)(80, "heavy"));
+    console.log(`
+${console_chars_1.emoji.target} Core Rule #3: Cache First, AI Last
+   ${console_chars_1.chars.bullet} Always check raw hash before any processing
+   ${console_chars_1.chars.bullet} Check processed image hash before AI calls
+   ${console_chars_1.chars.bullet} 80%+ cache hit rate target saves $19,200/year
+
+${console_chars_1.emoji.lightning} Enhancement Integration Order:
+   1. Pre-recognition: Quality check, seller context
+   2. GPT Vision analysis
+   3. Post-recognition: Batch context, back OCR, set tracking
+   4. Parallel fallback (for low confidence)
+   5. Web scraping enhancement
+
+${console_chars_1.emoji.lock} Cost Protection:
+   ${console_chars_1.chars.bullet} Check costMonitor.canAffordOperation before AI
+   ${console_chars_1.chars.bullet} Track all recognition costs
+   ${console_chars_1.chars.bullet} Respect daily/monthly limits
+
+${console_chars_1.emoji.testTube} Error Handling:
+   ${console_chars_1.chars.bullet} Wrap all async operations in try-catch
+   ${console_chars_1.chars.bullet} Log errors with context
+   ${console_chars_1.chars.bullet} Provide graceful fallbacks
+
+${console_chars_1.emoji.clock} Timeout Protection:
+   ${console_chars_1.chars.bullet} Check isApproachingTimeout() before long operations
+   ${console_chars_1.chars.bullet} Return partial results on timeout (don't crash)
+   ${console_chars_1.chars.bullet} Vercel limit: 120s, bail at 100s
+
+${console_chars_1.emoji.shield} Security & Rate Limiting:
+   ${console_chars_1.chars.bullet} Check abuse prevention before processing
+   ${console_chars_1.chars.bullet} Validate scan allowance (store/user limits)
+   ${console_chars_1.chars.bullet} Increment usage after successful recognition
+
+${console_chars_1.emoji.stats} Metrics & Monitoring:
+   ${console_chars_1.chars.bullet} Record metrics with recognitionMonitor
+   ${console_chars_1.chars.bullet} Track processing steps in diagnostics
+   ${console_chars_1.chars.bullet} Log cache hit rates and costs
+
+${console_chars_1.emoji.brain} Learning System:
+   ${console_chars_1.chars.bullet} Record seller patterns for future recognition
+   ${console_chars_1.chars.bullet} Apply weighted corrections from user feedback
+   ${console_chars_1.chars.bullet} Use batch context for sequential detection
+`);
+}
+async function main() {
+    console.log(`${console_chars_1.emoji.rocket} Starting Recognition Pipeline Validation...`);
+    console.log((0, console_chars_1.createDivider)(80, "heavy"));
+    // Validate all recognition files
+    for (const file of RECOGNITION_FILES) {
+        console.log(`${console_chars_1.emoji.search} Validating ${file}...`);
+        validateFile(file);
+    }
+    // Validate API routes
+    console.log(`${console_chars_1.emoji.api} Validating API routes...`);
+    validateApiRoutes();
+    // Validate database models
+    console.log(`${console_chars_1.emoji.database} Validating database models...`);
+    validateDatabaseModels();
+    // Validate enhancement modules
+    console.log(`${console_chars_1.emoji.gear} Validating enhancement modules...`);
+    validateEnhancementModules();
+    // Validate integration module
+    console.log(`${console_chars_1.emoji.link} Validating integration module...`);
+    validateIntegrationModule();
+    // Generate report
+    generateReport();
+    generateBestPracticesReminder();
+    // Exit with error if critical issues found
+    const errors = issues.filter((i) => i.severity === "error");
+    if (errors.length > 0) {
+        console.log(`\n${console_chars_1.emoji.bell} BUILD BLOCKED: ${errors.length} critical issues found`);
+        process.exit(1);
+    }
+    console.log(`\n${console_chars_1.emoji.success} Recognition pipeline validation passed`);
+    process.exit(0);
+}
+if (require.main === module) {
+    main().catch((error) => {
+        console.error(`${console_chars_1.emoji.error} Recognition pipeline validation failed:`, error);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=recognition-pipeline-validation.js.map