@factorypure/client-helpers 1.1.13 → 1.1.15

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
@@ -654,6 +688,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 +743,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 +790,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 +806,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(),
 });
@@ -403,6 +420,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',
@@ -427,6 +445,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 +536,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 +544,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.)
@@ -538,7 +558,9 @@ export class FilterEngine {
             result.hide_reasons = allFilterResults
                 .filter((fr) => fr.severity === FilterSeverity.BLOCK || fr.severity === FilterSeverity.WARNING)
                 .map((fr) => fr.message);
-            result.hide_override_reasons = allFilterResults.filter((fr) => fr.metadata?.isOverride).map((fr) => fr.message);
+            result.hide_override_reasons = allFilterResults
+                .filter((fr) => fr.metadata?.isOverride)
+                .map((fr) => fr.message);
             result.ignore_result = visibilityState === VisibilityState.HIDDEN;
             return result;
         });
@@ -583,8 +605,20 @@ export class FilterEngine {
         if (overridableBlocks.length > 0) {
             return VisibilityState.HIDDEN;
         }
-        // If we have warnings, show with warnings
-        if (warningResults.length > 0) {
+        // Check for warnings that haven't been overridden
+        const nonOverriddenWarnings = warningResults.filter((wr) => {
+            const rule = this.registry.getRule(wr.ruleId);
+            if (!rule || !rule.canBeOverridden)
+                return true;
+            // Check if any override can override this warning
+            const canBeOverridden = overrideResults.some((or) => {
+                const overrideRule = this.registry.getRule(or.ruleId);
+                return overrideRule && rule.overridableBy.includes(overrideRule.id);
+            });
+            return !canBeOverridden; // Still a warning if no override present
+        });
+        // If we have non-overridden warnings, show with warnings
+        if (nonOverriddenWarnings.length > 0) {
             return VisibilityState.VISIBLE_WITH_WARNINGS;
         }
         return VisibilityState.VISIBLE;
@@ -714,6 +748,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
  */
@@ -1218,6 +1301,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());
@@ -1325,7 +1409,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) {
@@ -1340,7 +1424,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.13",
+    "version": "1.1.15",
     "description": "",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",