@factorypure/client-helpers 1.1.14 → 1.1.16

package/dist/index.d.ts

@@ -506,6 +506,30 @@ export declare const immersiveScrapeResultsSchema: z.ZodObject<{
             normalized: z.ZodString;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    ai_extracted_sku: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    ai_extracted_brand: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    ai_best_match_sku: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    ai_alternate_match_skus: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    ai_extraction_confidence: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    ai_extraction_reasoning: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    ai_extraction_quality: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>>>;
+    ai_extraction_method: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        openai: "openai";
+        regex_fallback: "regex_fallback";
+        cached: "cached";
+        none: "none";
+    }>>>;
+    ai_processed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    listing_hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    ai_unique_skus_found: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>>;
+    ai_most_common_sku: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    ai_sku_confidence_avg: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    ai_high_quality_listing_count: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    ai_total_listing_count: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     inline_link: z.ZodOptional<z.ZodNull>;
     delivery: z.ZodOptional<z.ZodNull>;
 }, z.core.$strip>;
@@ -576,6 +600,15 @@ export declare const globalScrapeOptionsSchema: z.ZodObject<{
     scam_sources: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
 export type GlobalScrapeOptionsType = z.infer<typeof globalScrapeOptionsSchema>;
+/**
+ * AI Comparison result data structure
+ */
+export type ComparisonMapType = Record<string, Record<string, {
+    is_match: number;
+    sufficient_info: number;
+    result_description: string;
+    compared_at: string;
+}>>;
 /**
  * Context provided to filter rules during evaluation
  */
@@ -593,6 +626,7 @@ export type FilterContext<T = ScrapeResultsType | ImmersiveScrapeResultsType> =
     variantScrapeOptions: VariantScrapeOptionsType;
     vendorScrapeOptions: VendorScrapeOptionsType;
     globalScrapeOptions: GlobalScrapeOptionsType;
+    comparisonMap?: ComparisonMapType;
 };
 /**
  * Base interface for filter rules
@@ -645,6 +679,7 @@ export declare const HIDE_REASONS: {
     DUPLICATE: string;
     SEARCH_EXCLUSION: string;
     CALCULATED_SKU_MISMATCH: string;
+    AI_SKU_MISMATCH: string;
     CRITICAL_SPEC_MISMATCH: string;
     MANUALLY_IGNORED: string;
     MANUALLY_EXCLUDED: string;
@@ -654,6 +689,7 @@ export declare const HIDE_REASONS: {
     VENDOR_EXCLUSION: string;
     CALCULATED_BRAND_MISMATCH: string;
     SCAM_SOURCE_EXCLUSION: string;
+    AI_COMPARISON_MISMATCH: string;
 };
 export declare const HIDE_OVERRIDE_REASONS: {
     SKU_MATCH: string;
@@ -708,7 +744,7 @@ export declare class FilterEngine {
     /**
      * Evaluate rules for a batch of results
      */
-    evaluateBatch<T extends ScrapeResultsType | ImmersiveScrapeResultsType>(results: T[], variant: FilterContext<T>['variant'], variantScrapeOptions: VariantScrapeOptionsType, vendorScrapeOptions: VendorScrapeOptionsType, globalScrapeOptions: GlobalScrapeOptionsType): T[];
+    evaluateBatch<T extends ScrapeResultsType | ImmersiveScrapeResultsType>(results: T[], variant: FilterContext<T>['variant'], variantScrapeOptions: VariantScrapeOptionsType, vendorScrapeOptions: VendorScrapeOptionsType, globalScrapeOptions: GlobalScrapeOptionsType, comparisonMap?: ComparisonMapType): T[];
     /**
      * Calculate visibility state based on filter results
      */
@@ -755,7 +791,7 @@ export declare function createCustomFilterRule(config: {
  * Filter scrape results using the new rule-based engine
  * This provides more flexibility and better extensibility than the legacy filterScrapeResults
  */
-export declare const filterScrapeResultsV2: <T extends ScrapeResultsType | ImmersiveScrapeResultsType>({ scrapeResults, variant, variantScrapeOptions, vendorScrapeOptions, globalScrapeOptions, filterConfig, customRules, }: {
+export declare const filterScrapeResultsV2: <T extends ScrapeResultsType | ImmersiveScrapeResultsType>({ scrapeResults, variant, variantScrapeOptions, vendorScrapeOptions, globalScrapeOptions, filterConfig, customRules, comparisonMap, }: {
     scrapeResults: T[];
     variant: {
         id: number;
@@ -771,6 +807,7 @@ export declare const filterScrapeResultsV2: <T extends ScrapeResultsType | Immer
     globalScrapeOptions: GlobalScrapeOptionsType;
     filterConfig?: FilterConfiguration;
     customRules?: FilterRule[];
+    comparisonMap?: ComparisonMapType;
 }) => T[];
 export declare const filterScrapeResults: <T extends ScrapeResultsType | ImmersiveScrapeResultsType>({ scrapeResults, variant, variantScrapeOptions, vendorScrapeOptions, globalScrapeOptions, }: {
     scrapeResults: T[];

package/dist/index.js

@@ -331,6 +331,23 @@ export const immersiveScrapeResultsSchema = z.object({
     brand: z.string().nullable(),
     company_id: z.number().nullable(),
     regexUnitResults: z.nullable(regexUnitResultsSchema),
+    // AI extraction fields (per store listing)
+    ai_extracted_sku: z.string().nullable().optional(),
+    ai_extracted_brand: z.string().nullable().optional(),
+    ai_best_match_sku: z.string().nullable().optional(),
+    ai_alternate_match_skus: z.array(z.string()).nullable().optional(),
+    ai_extraction_confidence: z.number().nullable().optional(),
+    ai_extraction_reasoning: z.string().nullable().optional(),
+    ai_extraction_quality: z.enum(['high', 'medium', 'low']).nullable().optional(),
+    ai_extraction_method: z.enum(['openai', 'regex_fallback', 'cached', 'none']).nullable().optional(),
+    ai_processed_at: z.string().nullable().optional(),
+    listing_hash: z.string().nullable().optional(),
+    // AI aggregate fields (from variant_scrape_found_product_ids)
+    ai_unique_skus_found: z.record(z.string(), z.number()).nullable().optional(),
+    ai_most_common_sku: z.string().nullable().optional(),
+    ai_sku_confidence_avg: z.number().nullable().optional(),
+    ai_high_quality_listing_count: z.number().nullable().optional(),
+    ai_total_listing_count: z.number().nullable().optional(),
     inline_link: z.null().optional(),
     delivery: z.null().optional(),
 });
@@ -394,6 +411,7 @@ export const HIDE_REASONS = {
     DUPLICATE: 'Duplicate',
     SEARCH_EXCLUSION: 'Search Exclusion',
     CALCULATED_SKU_MISMATCH: 'Calculated SKU Mismatch',
+    AI_SKU_MISMATCH: 'AI SKU Mismatch',
     CRITICAL_SPEC_MISMATCH: 'Critical Spec Mismatch',
     MANUALLY_IGNORED: 'Manually ignored',
     MANUALLY_EXCLUDED: 'Manually excluded',
@@ -403,6 +421,7 @@ export const HIDE_REASONS = {
     VENDOR_EXCLUSION: 'Vendor Exclusion',
     CALCULATED_BRAND_MISMATCH: 'Calculated Brand Mismatch',
     SCAM_SOURCE_EXCLUSION: 'Scam Source Exclusion',
+    AI_COMPARISON_MISMATCH: 'AI Comparison Mismatch',
 };
 export const HIDE_OVERRIDE_REASONS = {
     SKU_MATCH: 'SKU Match',
@@ -419,6 +438,7 @@ const HIDE_ALWAYS_MAP = {
     [HIDE_REASONS.DUPLICATE]: true,
     [HIDE_REASONS.SEARCH_EXCLUSION]: false,
     [HIDE_REASONS.CALCULATED_SKU_MISMATCH]: false,
+    [HIDE_REASONS.AI_SKU_MISMATCH]: false,
     [HIDE_REASONS.CRITICAL_SPEC_MISMATCH]: false,
     [HIDE_REASONS.MANUALLY_IGNORED]: true,
     [HIDE_REASONS.MANUALLY_EXCLUDED]: true,
@@ -427,6 +447,7 @@ const HIDE_ALWAYS_MAP = {
     [HIDE_REASONS.SKIP_SKU]: false,
     [HIDE_REASONS.VENDOR_EXCLUSION]: false,
     [HIDE_REASONS.SCAM_SOURCE_EXCLUSION]: true,
+    [HIDE_REASONS.AI_COMPARISON_MISMATCH]: false,
 };
 export const TOO_CHEAP_MULTIPLIER = 0.75;
 export const TOO_EXPENSIVE_MULTIPLIER = 1.15;
@@ -517,7 +538,7 @@ export class FilterEngine {
     /**
      * Evaluate rules for a batch of results
      */
-    evaluateBatch(results, variant, variantScrapeOptions, vendorScrapeOptions, globalScrapeOptions) {
+    evaluateBatch(results, variant, variantScrapeOptions, vendorScrapeOptions, globalScrapeOptions, comparisonMap) {
         return results.map((result) => {
             const context = {
                 result,
@@ -525,6 +546,7 @@ export class FilterEngine {
                 variantScrapeOptions,
                 vendorScrapeOptions,
                 globalScrapeOptions,
+                comparisonMap,
             };
             const filterResults = this.evaluateResult(context);
             // Merge with existing filter_results from batch processing (duplicates, search exclusions, etc.)
@@ -728,6 +750,55 @@ class CompetitorExclusionRule {
         return null;
     }
 }
+/**
+ * Rule for filtering AI comparison mismatches
+ */
+class AIComparisonMismatchRule {
+    id = 'ai_comparison_mismatch';
+    name = 'AI Comparison Mismatch';
+    description = 'Filters results where AI comparison determined the listing does not match the variant';
+    severity = FilterSeverity.BLOCK;
+    priority = 85;
+    enabled = true;
+    canBeOverridden = true;
+    overridableBy = ['sku_match', 'calculated_sku_match', 'alt_sku_match'];
+    evaluate(context) {
+        // Only applies to results with listing_hash (primarily immersive results)
+        const result = context.result;
+        if (!result.listing_hash || !context.comparisonMap) {
+            return null;
+        }
+        const variantId = String(context.variant.id);
+        const listingHash = result.listing_hash;
+        // Check if we have comparison data for this variant and listing
+        const variantComparisons = context.comparisonMap[variantId];
+        if (!variantComparisons) {
+            return null;
+        }
+        const comparison = variantComparisons[listingHash];
+        if (!comparison) {
+            return null;
+        }
+        // Only filter confirmed mismatches (is_match = 0 AND sufficient_info = 1)
+        // Allow results where we don't have sufficient info to compare
+        if (comparison.is_match === 0 && comparison.sufficient_info === 1) {
+            return {
+                ruleId: this.id,
+                severity: this.severity,
+                message: HIDE_REASONS.AI_COMPARISON_MISMATCH,
+                metadata: {
+                    listingHash,
+                    isMatch: comparison.is_match,
+                    sufficientInfo: comparison.sufficient_info,
+                    resultDescription: comparison.result_description,
+                    comparedAt: comparison.compared_at,
+                },
+                timestamp: new Date().toISOString(),
+            };
+        }
+        return null;
+    }
+}
 /**
  * Rule for filtering duplicates
  */
@@ -1023,6 +1094,49 @@ class CalculatedSkuMismatchRule {
         };
     }
 }
+/**
+ * Rule for AI SKU mismatches
+ */
+class AISkuMismatchRule {
+    id = 'ai_sku_mismatch';
+    name = 'AI SKU Mismatch';
+    description = 'Filters results with mismatched AI extracted SKUs';
+    severity = FilterSeverity.WARNING;
+    priority = 30;
+    enabled = true;
+    canBeOverridden = true;
+    overridableBy = ['sku_match', 'calculated_sku_match', 'alt_sku_match'];
+    evaluate(context) {
+        const result = context.result;
+        if (!result.ai_extracted_sku) {
+            return null;
+        }
+        const aiSkuLower = result.ai_extracted_sku.toLowerCase();
+        const variantSkuLower = context.variant.sku.toLowerCase();
+        // Check if AI extracted SKU matches variant SKU
+        if (aiSkuLower === variantSkuLower) {
+            return null;
+        }
+        // Check if AI extracted SKU matches any SKU alternates
+        const skuAlternates = context.variantScrapeOptions.sku_alternates || [];
+        const matchesAlternate = skuAlternates.some((alt) => alt.toLowerCase() === aiSkuLower);
+        if (matchesAlternate) {
+            return null;
+        }
+        // If no match found, trigger the rule
+        return {
+            ruleId: this.id,
+            severity: this.severity,
+            message: HIDE_REASONS.AI_SKU_MISMATCH,
+            metadata: {
+                aiSku: result.ai_extracted_sku,
+                variantSku: context.variant.sku,
+                skuAlternates: skuAlternates,
+            },
+            timestamp: new Date().toISOString(),
+        };
+    }
+}
 /**
  * Rule for critical spec mismatches
  */
@@ -1232,6 +1346,7 @@ export function createDefaultFilterRegistry() {
     registry.registerRule(new LowPriceOutlierRule());
     registry.registerRule(new DateOutlierRule());
     registry.registerRule(new CompetitorExclusionRule());
+    registry.registerRule(new AIComparisonMismatchRule());
     registry.registerRule(new DuplicateRule());
     registry.registerRule(new SearchExclusionRule());
     registry.registerRule(new SkipSkuRule());
@@ -1241,6 +1356,7 @@ export function createDefaultFilterRegistry() {
     registry.registerRule(new BrandMismatchRule());
     registry.registerRule(new OutOfStockRule());
     registry.registerRule(new CalculatedSkuMismatchRule());
+    registry.registerRule(new AISkuMismatchRule());
     registry.registerRule(new CriticalSpecMismatchRule());
     registry.registerRule(new RefurbishedUsedRule());
     // Register override rules
@@ -1339,7 +1455,7 @@ export function createCustomFilterRule(config) {
  * Filter scrape results using the new rule-based engine
  * This provides more flexibility and better extensibility than the legacy filterScrapeResults
  */
-export const filterScrapeResultsV2 = ({ scrapeResults, variant, variantScrapeOptions, vendorScrapeOptions, globalScrapeOptions, filterConfig, customRules, }) => {
+export const filterScrapeResultsV2 = ({ scrapeResults, variant, variantScrapeOptions, vendorScrapeOptions, globalScrapeOptions, filterConfig, customRules, comparisonMap, }) => {
     const registry = createDefaultFilterRegistry();
     // Register custom rules if provided
     if (customRules) {
@@ -1354,7 +1470,7 @@ export const filterScrapeResultsV2 = ({ scrapeResults, variant, variantScrapeOpt
     let results = handleDuplicatesV2(scrapeResults);
     results = handleSearchExclusionsV2(results, variantScrapeOptions, variant, registry);
     // Evaluate all other rules
-    results = engine.evaluateBatch(results, variant, variantScrapeOptions, vendorScrapeOptions, globalScrapeOptions);
+    results = engine.evaluateBatch(results, variant, variantScrapeOptions, vendorScrapeOptions, globalScrapeOptions, comparisonMap);
     return results;
 };
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@factorypure/client-helpers",
-    "version": "1.1.14",
+    "version": "1.1.16",
     "description": "",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",