@ucptools/validator 1.0.0 → 1.1.0

package/{src/feed-analyzer/feed-analyzer.ts → dist/feed-analyzer/feed-analyzer.js}

@@ -1,726 +1,856 @@
-/**
- * Product Feed Quality Analyzer
- * Deep analysis of product data quality for AI agent visibility
- */
-
-import type {
-    ProductData,
-    ProductOffer,
-    ProductAnalysis,
-    QualityCheck,
-    FeedAnalysisResult,
-    FeedAnalysisInput,
-    CategoryScores,
-    Recommendation,
-    FeedSummary,
-    GtinValidation,
-    CheckCategory,
-} from './types.js';
-
-import {
-    QUALITY_CHECKS,
-    VALID_AVAILABILITY_VALUES,
-    CATEGORY_WEIGHTS,
-    GRADE_THRESHOLDS,
-} from './types.js';
-
-/**
- * Default maximum products to analyze
- */
-const DEFAULT_MAX_PRODUCTS = 50;
-
-/**
- * Minimum description length considered "good"
- */
-const MIN_DESCRIPTION_LENGTH = 50;
-
-/**
- * Validate a GTIN/UPC/EAN identifier
- */
-export function validateGtin(gtin: string): GtinValidation {
-    if (!gtin || typeof gtin !== 'string') {
-        return { isValid: false, error: 'GTIN is empty or not a string' };
-    }
-
-    // Remove any spaces or dashes
-    const cleaned = gtin.replace(/[\s-]/g, '');
-
-    // Check if it's all digits
-    if (!/^\d+$/.test(cleaned)) {
-        return { isValid: false, error: 'GTIN must contain only digits' };
-    }
-
-    const length = cleaned.length;
-
-    // Determine type based on length
-    let type: GtinValidation['type'];
-    switch (length) {
-        case 8:
-            type = 'GTIN-8';
-            break;
-        case 12:
-            type = 'UPC';
-            break;
-        case 13:
-            type = 'EAN';
-            break;
-        case 14:
-            type = 'GTIN-14';
-            break;
-        default:
-            return { isValid: false, error: `Invalid GTIN length: ${length}. Expected 8, 12, 13, or 14 digits` };
-    }
-
-    // Validate check digit
-    if (!validateGtinCheckDigit(cleaned)) {
-        return { isValid: false, type, error: 'Invalid check digit' };
-    }
-
-    return { isValid: true, type };
-}
-
-/**
- * Validate GTIN check digit using modulo 10 algorithm
- */
-function validateGtinCheckDigit(gtin: string): boolean {
-    const digits = gtin.split('').map(Number);
-    const checkDigit = digits.pop()!;
-
-    let sum = 0;
-    const multipliers = gtin.length === 13 || gtin.length === 8
-        ? [1, 3] // EAN-13, GTIN-8
-        : [3, 1]; // UPC-12, GTIN-14
-
-    for (let i = 0; i < digits.length; i++) {
-        sum += digits[i] * multipliers[i % 2];
-    }
-
-    const calculatedCheck = (10 - (sum % 10)) % 10;
-    return calculatedCheck === checkDigit;
-}
-
-/**
- * Extract products from HTML content
- */
-export function extractProductsFromHtml(html: string): ProductData[] {
-    const products: ProductData[] = [];
-
-    // Find all JSON-LD script tags
-    const jsonLdRegex = /<script[^>]*type\s*=\s*["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
-    let match;
-
-    while ((match = jsonLdRegex.exec(html)) !== null) {
-        try {
-            const jsonContent = match[1].trim();
-            const data = JSON.parse(jsonContent);
-
-            // Handle single object or array
-            const items = Array.isArray(data) ? data : [data];
-
-            for (const item of items) {
-                // Check if it's a Product
-                if (item['@type'] === 'Product') {
-                    products.push(item as ProductData);
-                }
-                // Check for @graph containing products
-                else if (item['@graph'] && Array.isArray(item['@graph'])) {
-                    for (const graphItem of item['@graph']) {
-                        if (graphItem['@type'] === 'Product') {
-                            products.push(graphItem as ProductData);
-                        }
-                    }
-                }
-                // Check for ItemList containing products
-                else if (item['@type'] === 'ItemList' && item.itemListElement) {
-                    const listItems = Array.isArray(item.itemListElement)
-                        ? item.itemListElement
-                        : [item.itemListElement];
-                    for (const listItem of listItems) {
-                        if (listItem.item && listItem.item['@type'] === 'Product') {
-                            products.push(listItem.item as ProductData);
-                        } else if (listItem['@type'] === 'Product') {
-                            products.push(listItem as ProductData);
-                        }
-                    }
-                }
-            }
-        } catch {
-            // Skip invalid JSON
-            continue;
-        }
-    }
-
-    return products;
-}
-
-/**
- * Get the primary offer from a product
- */
-function getPrimaryOffer(product: ProductData): ProductOffer | undefined {
-    if (!product.offers) return undefined;
-
-    if (Array.isArray(product.offers)) {
-        return product.offers[0];
-    }
-
-    return product.offers;
-}
-
-/**
- * Get image count from product data
- */
-function getImageCount(product: ProductData): number {
-    if (!product.image) return 0;
-
-    if (typeof product.image === 'string') return 1;
-
-    if (Array.isArray(product.image)) {
-        return product.image.length;
-    }
-
-    return 1;
-}
-
-/**
- * Get brand name from product
- */
-function getBrandName(product: ProductData): string | undefined {
-    if (!product.brand) return undefined;
-
-    if (typeof product.brand === 'string') return product.brand;
-
-    return product.brand.name;
-}
-
-/**
- * Get any GTIN value from product
- */
-function getGtin(product: ProductData): string | undefined {
-    return product.gtin || product.gtin13 || product.gtin12 || product.gtin14 || product.gtin8;
-}
-
-/**
- * Analyze a single product
- */
-export function analyzeProduct(product: ProductData): ProductAnalysis {
-    const issues: QualityCheck[] = [];
-    const offer = getPrimaryOffer(product);
-    const brandName = getBrandName(product);
-    const gtin = getGtin(product);
-    const imageCount = getImageCount(product);
-    const descriptionLength = product.description?.length || 0;
-
-    // Build attributes object
-    const attributes = {
-        hasName: Boolean(product.name && product.name.trim()),
-        hasDescription: Boolean(product.description && product.description.trim()),
-        hasSku: Boolean(product.sku),
-        hasGtin: Boolean(gtin),
-        hasBrand: Boolean(brandName),
-        hasImage: imageCount > 0,
-        hasPrice: offer?.price !== undefined && offer?.price !== null,
-        hasAvailability: Boolean(offer?.availability),
-        hasCategory: Boolean(product.category),
-        descriptionLength,
-        imageCount,
-    };
-
-    // Completeness checks
-    if (!attributes.hasName) {
-        issues.push(createIssue('missing-name', product.name));
-    }
-
-    if (!attributes.hasDescription) {
-        issues.push(createIssue('missing-description', product.name));
-    } else if (descriptionLength < MIN_DESCRIPTION_LENGTH) {
-        issues.push(createIssue('short-description', product.name, `Description is only ${descriptionLength} characters`));
-    }
-
-    if (!attributes.hasBrand) {
-        issues.push(createIssue('missing-brand', product.name));
-    }
-
-    // Identifier checks
-    if (!attributes.hasSku) {
-        issues.push(createIssue('missing-sku', product.name));
-    }
-
-    if (!attributes.hasGtin) {
-        issues.push(createIssue('missing-gtin', product.name));
-    } else {
-        const gtinValidation = validateGtin(gtin!);
-        if (!gtinValidation.isValid) {
-            issues.push(createIssue('invalid-gtin', product.name, gtinValidation.error));
-        }
-    }
-
-    // Image checks
-    if (!attributes.hasImage) {
-        issues.push(createIssue('missing-image', product.name));
-    } else if (imageCount === 1) {
-        issues.push(createIssue('single-image', product.name));
-    }
-
-    // Pricing checks
-    if (!offer) {
-        issues.push(createIssue('missing-price', product.name));
-    } else {
-        if (!offer.price && offer.price !== 0) {
-            issues.push(createIssue('missing-price', product.name));
-        } else {
-            const price = typeof offer.price === 'string' ? parseFloat(offer.price) : offer.price;
-            if (isNaN(price)) {
-                issues.push(createIssue('invalid-price', product.name, `Price value: "${offer.price}"`));
-            }
-        }
-
-        if (!offer.priceCurrency) {
-            issues.push(createIssue('missing-currency', product.name));
-        }
-    }
-
-    // Availability checks
-    if (!attributes.hasAvailability) {
-        issues.push(createIssue('missing-availability', product.name));
-    } else if (offer?.availability && !VALID_AVAILABILITY_VALUES.includes(offer.availability)) {
-        issues.push(createIssue('invalid-availability', product.name, `Value: "${offer.availability}"`));
-    }
-
-    // Category checks
-    if (!attributes.hasCategory) {
-        issues.push(createIssue('missing-category', product.name));
-    }
-
-    // Calculate product score
-    const score = calculateProductScore(attributes);
-
-    return {
-        name: product.name || 'Unknown Product',
-        url: product.url,
-        sku: product.sku,
-        score,
-        issues,
-        attributes,
-    };
-}
-
-/**
- * Create a quality check issue
- */
-function createIssue(checkId: string, productName?: string, details?: string): QualityCheck {
-    const checkDef = QUALITY_CHECKS[checkId];
-
-    return {
-        id: checkId,
-        name: checkDef.name,
-        category: checkDef.category,
-        passed: false,
-        severity: checkDef.severity,
-        message: checkDef.description,
-        details,
-        affectedProducts: productName ? [productName] : undefined,
-    };
-}
-
-/**
- * Calculate product score based on attributes
- */
-function calculateProductScore(attributes: ProductAnalysis['attributes']): number {
-    let score = 0;
-    const weights = {
-        hasName: 15,
-        hasDescription: 10,
-        hasSku: 5,
-        hasGtin: 10,
-        hasBrand: 10,
-        hasImage: 15,
-        hasPrice: 20,
-        hasAvailability: 5,
-        hasCategory: 5,
-        descriptionQuality: 5,
-    };
-
-    if (attributes.hasName) score += weights.hasName;
-    if (attributes.hasDescription) score += weights.hasDescription;
-    if (attributes.hasSku) score += weights.hasSku;
-    if (attributes.hasGtin) score += weights.hasGtin;
-    if (attributes.hasBrand) score += weights.hasBrand;
-    if (attributes.hasImage) score += weights.hasImage;
-    if (attributes.hasPrice) score += weights.hasPrice;
-    if (attributes.hasAvailability) score += weights.hasAvailability;
-    if (attributes.hasCategory) score += weights.hasCategory;
-
-    // Bonus for good description length
-    if (attributes.descriptionLength >= MIN_DESCRIPTION_LENGTH) {
-        score += weights.descriptionQuality;
-    }
-
-    return Math.min(100, score);
-}
-
-/**
- * Calculate category scores from product analyses
- */
-function calculateCategoryScores(products: ProductAnalysis[]): CategoryScores {
-    if (products.length === 0) {
-        return {
-            completeness: 0,
-            identifiers: 0,
-            images: 0,
-            pricing: 0,
-            descriptions: 0,
-            categories: 0,
-            availability: 0,
-        };
-    }
-
-    const totals = products.reduce(
-        (acc, p) => {
-            // Completeness: name, brand
-            acc.completeness += (p.attributes.hasName ? 50 : 0) + (p.attributes.hasBrand ? 50 : 0);
-
-            // Identifiers: SKU, GTIN
-            acc.identifiers += (p.attributes.hasSku ? 50 : 0) + (p.attributes.hasGtin ? 50 : 0);
-
-            // Images
-            acc.images += p.attributes.hasImage ? (p.attributes.imageCount > 1 ? 100 : 70) : 0;
-
-            // Pricing
-            acc.pricing += p.attributes.hasPrice ? 100 : 0;
-
-            // Descriptions
-            if (p.attributes.hasDescription) {
-                acc.descriptions += p.attributes.descriptionLength >= MIN_DESCRIPTION_LENGTH ? 100 : 60;
-            }
-
-            // Categories
-            acc.categories += p.attributes.hasCategory ? 100 : 0;
-
-            // Availability
-            acc.availability += p.attributes.hasAvailability ? 100 : 0;
-
-            return acc;
-        },
-        { completeness: 0, identifiers: 0, images: 0, pricing: 0, descriptions: 0, categories: 0, availability: 0 }
-    );
-
-    const count = products.length;
-    return {
-        completeness: Math.round(totals.completeness / count),
-        identifiers: Math.round(totals.identifiers / count),
-        images: Math.round(totals.images / count),
-        pricing: Math.round(totals.pricing / count),
-        descriptions: Math.round(totals.descriptions / count),
-        categories: Math.round(totals.categories / count),
-        availability: Math.round(totals.availability / count),
-    };
-}
-
-/**
- * Calculate overall score from category scores
- */
-function calculateOverallScore(categoryScores: CategoryScores): number {
-    let weightedSum = 0;
-    let totalWeight = 0;
-
-    for (const [category, score] of Object.entries(categoryScores)) {
-        const weight = CATEGORY_WEIGHTS[category as CheckCategory];
-        weightedSum += score * weight;
-        totalWeight += weight;
-    }
-
-    return Math.round(weightedSum / totalWeight);
-}
-
-/**
- * Calculate agent visibility score
- * This is a specialized score focusing on what AI agents need most
- */
-function calculateAgentVisibilityScore(summary: FeedSummary): number {
-    if (summary.totalProducts === 0) return 0;
-
-    const total = summary.totalProducts;
-
-    // Critical factors for AI agents (weighted heavily)
-    const criticalScore =
-        ((summary.withName / total) * 30) +
-        ((summary.withPrice / total) * 30) +
-        ((summary.withImages / total) * 20);
-
-    // Important factors
-    const importantScore =
-        ((summary.withDescription / total) * 10) +
-        ((summary.withGtin / total) * 5) +
-        ((summary.withAvailability / total) * 5);
-
-    return Math.round(criticalScore + importantScore);
-}
-
-/**
- * Get grade from score
- */
-function getGrade(score: number): FeedAnalysisResult['grade'] {
-    if (score >= GRADE_THRESHOLDS.A) return 'A';
-    if (score >= GRADE_THRESHOLDS.B) return 'B';
-    if (score >= GRADE_THRESHOLDS.C) return 'C';
-    if (score >= GRADE_THRESHOLDS.D) return 'D';
-    return 'F';
-}
-
-/**
- * Generate recommendations based on analysis
- */
-function generateRecommendations(summary: FeedSummary, issues: QualityCheck[]): Recommendation[] {
-    const recommendations: Recommendation[] = [];
-    const total = summary.totalProducts;
-
-    if (total === 0) return recommendations;
-
-    // Missing prices - critical
-    const missingPrices = total - summary.withPrice;
-    if (missingPrices > 0) {
-        recommendations.push({
-            priority: 'high',
-            category: 'pricing',
-            title: 'Add Missing Prices',
-            description: `${missingPrices} products are missing price information. AI agents cannot complete purchases without prices.`,
-            impact: 'Critical - Products without prices cannot be purchased through AI agents',
-            affectedCount: missingPrices,
-        });
-    }
-
-    // Missing images - critical
-    const missingImages = total - summary.withImages;
-    if (missingImages > 0) {
-        recommendations.push({
-            priority: 'high',
-            category: 'images',
-            title: 'Add Product Images',
-            description: `${missingImages} products are missing images. Visual product information is essential for AI shopping.`,
-            impact: 'High - Products without images are less likely to be recommended',
-            affectedCount: missingImages,
-        });
-    }
-
-    // Missing names - critical
-    const missingNames = total - summary.withName;
-    if (missingNames > 0) {
-        recommendations.push({
-            priority: 'high',
-            category: 'completeness',
-            title: 'Add Product Names',
-            description: `${missingNames} products are missing names. This is required for product identification.`,
-            impact: 'Critical - Products cannot be identified without names',
-            affectedCount: missingNames,
-        });
-    }
-
-    // Missing GTIN - medium priority
-    const missingGtin = total - summary.withGtin;
-    if (missingGtin > 0 && missingGtin / total > 0.5) {
-        recommendations.push({
-            priority: 'medium',
-            category: 'identifiers',
-            title: 'Add Global Identifiers (GTIN/UPC/EAN)',
-            description: `${missingGtin} products are missing global identifiers. These enable cross-platform product matching.`,
-            impact: 'Medium - Improves product matching across AI platforms',
-            affectedCount: missingGtin,
-        });
-    }
-
-    // Missing descriptions - medium priority
-    const missingDescriptions = total - summary.withDescription;
-    if (missingDescriptions > 0 && missingDescriptions / total > 0.3) {
-        recommendations.push({
-            priority: 'medium',
-            category: 'descriptions',
-            title: 'Add Product Descriptions',
-            description: `${missingDescriptions} products are missing descriptions. Good descriptions help AI agents understand and recommend products.`,
-            impact: 'Medium - Better descriptions improve AI recommendations',
-            affectedCount: missingDescriptions,
-        });
-    }
-
-    // Short descriptions
-    if (summary.averageDescriptionLength < MIN_DESCRIPTION_LENGTH && summary.withDescription > 0) {
-        recommendations.push({
-            priority: 'low',
-            category: 'descriptions',
-            title: 'Improve Description Length',
-            description: `Average description length is ${Math.round(summary.averageDescriptionLength)} characters. Aim for at least ${MIN_DESCRIPTION_LENGTH} characters.`,
-            impact: 'Low - Longer descriptions provide more context for AI agents',
-            affectedCount: summary.withDescription,
-        });
-    }
-
-    // Missing availability
-    const missingAvailability = total - summary.withAvailability;
-    if (missingAvailability > 0 && missingAvailability / total > 0.3) {
-        recommendations.push({
-            priority: 'medium',
-            category: 'availability',
-            title: 'Add Availability Status',
-            description: `${missingAvailability} products are missing availability information.`,
-            impact: 'Medium - Availability helps AI agents make informed purchase decisions',
-            affectedCount: missingAvailability,
-        });
-    }
-
-    // Sort by priority
-    const priorityOrder = { high: 0, medium: 1, low: 2 };
-    recommendations.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
-
-    return recommendations;
-}
-
-/**
- * Aggregate issues across all products
- */
-function aggregateIssues(products: ProductAnalysis[]): QualityCheck[] {
-    const issueMap = new Map<string, QualityCheck>();
-
-    for (const product of products) {
-        for (const issue of product.issues) {
-            const existing = issueMap.get(issue.id);
-            if (existing) {
-                // Aggregate affected products
-                if (issue.affectedProducts && existing.affectedProducts) {
-                    existing.affectedProducts.push(...issue.affectedProducts);
-                }
-            } else {
-                issueMap.set(issue.id, { ...issue, affectedProducts: [...(issue.affectedProducts || [])] });
-            }
-        }
-    }
-
-    return Array.from(issueMap.values());
-}
-
-/**
- * Calculate feed summary statistics
- */
-function calculateSummary(products: ProductAnalysis[]): FeedSummary {
-    const total = products.length;
-
-    if (total === 0) {
-        return {
-            totalProducts: 0,
-            withName: 0,
-            withDescription: 0,
-            withSku: 0,
-            withGtin: 0,
-            withBrand: 0,
-            withImages: 0,
-            withPrice: 0,
-            withAvailability: 0,
-            withCategory: 0,
-            averageDescriptionLength: 0,
-            averageImageCount: 0,
-        };
-    }
-
-    const summary = products.reduce(
-        (acc, p) => {
-            if (p.attributes.hasName) acc.withName++;
-            if (p.attributes.hasDescription) acc.withDescription++;
-            if (p.attributes.hasSku) acc.withSku++;
-            if (p.attributes.hasGtin) acc.withGtin++;
-            if (p.attributes.hasBrand) acc.withBrand++;
-            if (p.attributes.hasImage) acc.withImages++;
-            if (p.attributes.hasPrice) acc.withPrice++;
-            if (p.attributes.hasAvailability) acc.withAvailability++;
-            if (p.attributes.hasCategory) acc.withCategory++;
-            acc.totalDescriptionLength += p.attributes.descriptionLength;
-            acc.totalImageCount += p.attributes.imageCount;
-            return acc;
-        },
-        {
-            withName: 0,
-            withDescription: 0,
-            withSku: 0,
-            withGtin: 0,
-            withBrand: 0,
-            withImages: 0,
-            withPrice: 0,
-            withAvailability: 0,
-            withCategory: 0,
-            totalDescriptionLength: 0,
-            totalImageCount: 0,
-        }
-    );
-
-    return {
-        totalProducts: total,
-        withName: summary.withName,
-        withDescription: summary.withDescription,
-        withSku: summary.withSku,
-        withGtin: summary.withGtin,
-        withBrand: summary.withBrand,
-        withImages: summary.withImages,
-        withPrice: summary.withPrice,
-        withAvailability: summary.withAvailability,
-        withCategory: summary.withCategory,
-        averageDescriptionLength: summary.totalDescriptionLength / total,
-        averageImageCount: summary.totalImageCount / total,
-    };
-}
-
-/**
- * Analyze product feed from raw product data
- */
-export function analyzeProductFeed(
-    products: ProductData[],
-    url: string,
-    maxProducts: number = DEFAULT_MAX_PRODUCTS,
-    includeProductDetails: boolean = true
-): FeedAnalysisResult {
-    const productsToAnalyze = products.slice(0, maxProducts);
-    const productAnalyses = productsToAnalyze.map(analyzeProduct);
-
-    const summary = calculateSummary(productAnalyses);
-    const categoryScores = calculateCategoryScores(productAnalyses);
-    const overallScore = calculateOverallScore(categoryScores);
-    const agentVisibilityScore = calculateAgentVisibilityScore(summary);
-    const issues = aggregateIssues(productAnalyses);
-    const recommendations = generateRecommendations(summary, issues);
-
-    // Get top issues (most impactful)
-    const topIssues = issues
-        .filter(i => i.severity === 'critical' || i.severity === 'warning')
-        .sort((a, b) => {
-            const severityOrder = { critical: 0, warning: 1, info: 2 };
-            return severityOrder[a.severity] - severityOrder[b.severity];
-        })
-        .slice(0, 5);
-
-    return {
-        url,
-        analyzedAt: new Date().toISOString(),
-        productsFound: products.length,
-        productsAnalyzed: productsToAnalyze.length,
-        overallScore,
-        agentVisibilityScore,
-        grade: getGrade(overallScore),
-        categoryScores,
-        issues,
-        topIssues,
-        products: includeProductDetails ? productAnalyses : [],
-        recommendations,
-        summary,
-    };
-}
-
-/**
- * Analyze a product feed from HTML content
- */
-export function analyzeProductFeedFromHtml(
-    html: string,
-    url: string,
-    options: Partial<FeedAnalysisInput> = {}
-): FeedAnalysisResult {
-    const products = extractProductsFromHtml(html);
-    const maxProducts = options.maxProducts ?? DEFAULT_MAX_PRODUCTS;
-    const includeProductDetails = options.includeProductDetails ?? true;
-
-    return analyzeProductFeed(products, url, maxProducts, includeProductDetails);
-}
+"use strict";
+/**
+ * Product Feed Quality Analyzer
+ * Deep analysis of product data quality for AI agent visibility
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateGtin = validateGtin;
+exports.extractProductsFromHtml = extractProductsFromHtml;
+exports.analyzeProduct = analyzeProduct;
+exports.analyzeProductFeed = analyzeProductFeed;
+exports.analyzeProductFeedFromHtml = analyzeProductFeedFromHtml;
+const types_js_1 = require("./types.js");
+/**
+ * Default maximum products to analyze
+ */
+const DEFAULT_MAX_PRODUCTS = 50;
+/**
+ * Minimum description length considered "good"
+ */
+const MIN_DESCRIPTION_LENGTH = 50;
+/**
+ * Validate a GTIN/UPC/EAN identifier
+ */
+function validateGtin(gtin) {
+    if (!gtin || typeof gtin !== 'string') {
+        return { isValid: false, error: 'GTIN is empty or not a string' };
+    }
+    // Remove any spaces or dashes
+    const cleaned = gtin.replace(/[\s-]/g, '');
+    // Check if it's all digits
+    if (!/^\d+$/.test(cleaned)) {
+        return { isValid: false, error: 'GTIN must contain only digits' };
+    }
+    const length = cleaned.length;
+    // Determine type based on length
+    let type;
+    switch (length) {
+        case 8:
+            type = 'GTIN-8';
+            break;
+        case 12:
+            type = 'UPC';
+            break;
+        case 13:
+            type = 'EAN';
+            break;
+        case 14:
+            type = 'GTIN-14';
+            break;
+        default:
+            return { isValid: false, error: `Invalid GTIN length: ${length}. Expected 8, 12, 13, or 14 digits` };
+    }
+    // Validate check digit
+    if (!validateGtinCheckDigit(cleaned)) {
+        return { isValid: false, type, error: 'Invalid check digit' };
+    }
+    return { isValid: true, type };
+}
+/**
+ * Validate GTIN check digit using modulo 10 algorithm
+ */
+function validateGtinCheckDigit(gtin) {
+    const digits = gtin.split('').map(Number);
+    const checkDigit = digits.pop();
+    let sum = 0;
+    const multipliers = gtin.length === 13 || gtin.length === 8
+        ? [1, 3] // EAN-13, GTIN-8
+        : [3, 1]; // UPC-12, GTIN-14
+    for (let i = 0; i < digits.length; i++) {
+        sum += digits[i] * multipliers[i % 2];
+    }
+    const calculatedCheck = (10 - (sum % 10)) % 10;
+    return calculatedCheck === checkDigit;
+}
+/**
+ * Extract products from HTML content
+ */
+function extractProductsFromHtml(html) {
+    const products = [];
+    // Find all JSON-LD script tags
+    const jsonLdRegex = /<script[^>]*type\s*=\s*["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+    let match;
+    while ((match = jsonLdRegex.exec(html)) !== null) {
+        try {
+            const jsonContent = match[1].trim();
+            const data = JSON.parse(jsonContent);
+            // Handle single object or array
+            const items = Array.isArray(data) ? data : [data];
+            for (const item of items) {
+                // Check if it's a Product
+                if (item['@type'] === 'Product') {
+                    products.push(item);
+                }
+                // Check for @graph containing products
+                else if (item['@graph'] && Array.isArray(item['@graph'])) {
+                    for (const graphItem of item['@graph']) {
+                        if (graphItem['@type'] === 'Product') {
+                            products.push(graphItem);
+                        }
+                    }
+                }
+                // Check for ItemList containing products
+                else if (item['@type'] === 'ItemList' && item.itemListElement) {
+                    const listItems = Array.isArray(item.itemListElement)
+                        ? item.itemListElement
+                        : [item.itemListElement];
+                    for (const listItem of listItems) {
+                        if (listItem.item && listItem.item['@type'] === 'Product') {
+                            products.push(listItem.item);
+                        }
+                        else if (listItem['@type'] === 'Product') {
+                            products.push(listItem);
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip invalid JSON
+            continue;
+        }
+    }
+    return products;
+}
+/**
+ * Get the primary offer from a product
+ */
+function getPrimaryOffer(product) {
+    if (!product.offers)
+        return undefined;
+    if (Array.isArray(product.offers)) {
+        return product.offers[0];
+    }
+    return product.offers;
+}
+/**
+ * Get image count from product data
+ */
+function getImageCount(product) {
+    if (!product.image)
+        return 0;
+    if (typeof product.image === 'string')
+        return 1;
+    if (Array.isArray(product.image)) {
+        return product.image.length;
+    }
+    return 1;
+}
+/**
+ * Get brand name from product
+ */
+function getBrandName(product) {
+    if (!product.brand)
+        return undefined;
+    if (typeof product.brand === 'string')
+        return product.brand;
+    return product.brand.name;
+}
+/**
+ * Get any GTIN value from product
+ */
+function getGtin(product) {
+    return product.gtin || product.gtin13 || product.gtin12 || product.gtin14 || product.gtin8;
+}
+/**
+ * Analyze a single product
+ */
+function analyzeProduct(product) {
+    const issues = [];
+    const offer = getPrimaryOffer(product);
+    const brandName = getBrandName(product);
+    const gtin = getGtin(product);
+    const imageCount = getImageCount(product);
+    const descriptionLength = product.description?.length || 0;
+    // Build attributes object
+    const attributes = {
+        hasName: Boolean(product.name && product.name.trim()),
+        hasDescription: Boolean(product.description && product.description.trim()),
+        hasSku: Boolean(product.sku),
+        hasGtin: Boolean(gtin),
+        hasBrand: Boolean(brandName),
+        hasImage: imageCount > 0,
+        hasPrice: offer?.price !== undefined && offer?.price !== null,
+        hasAvailability: Boolean(offer?.availability),
+        hasCategory: Boolean(product.category),
+        descriptionLength,
+        imageCount,
+    };
+    // Completeness checks
+    if (!attributes.hasName) {
+        issues.push(createIssue('missing-name', product.name));
+    }
+    if (!attributes.hasDescription) {
+        issues.push(createIssue('missing-description', product.name));
+    }
+    else if (descriptionLength < MIN_DESCRIPTION_LENGTH) {
+        issues.push(createIssue('short-description', product.name, `Description is only ${descriptionLength} characters`));
+    }
+    if (!attributes.hasBrand) {
+        issues.push(createIssue('missing-brand', product.name));
+    }
+    // Identifier checks
+    if (!attributes.hasSku) {
+        issues.push(createIssue('missing-sku', product.name));
+    }
+    if (!attributes.hasGtin) {
+        issues.push(createIssue('missing-gtin', product.name));
+    }
+    else {
+        const gtinValidation = validateGtin(gtin);
+        if (!gtinValidation.isValid) {
+            issues.push(createIssue('invalid-gtin', product.name, gtinValidation.error));
+        }
+    }
+    // Image checks
+    if (!attributes.hasImage) {
+        issues.push(createIssue('missing-image', product.name));
+    }
+    else if (imageCount === 1) {
+        issues.push(createIssue('single-image', product.name));
+    }
+    // Pricing checks
+    if (!offer) {
+        issues.push(createIssue('missing-price', product.name));
+    }
+    else {
+        if (!offer.price && offer.price !== 0) {
+            issues.push(createIssue('missing-price', product.name));
+        }
+        else {
+            const price = typeof offer.price === 'string' ? parseFloat(offer.price) : offer.price;
+            if (isNaN(price)) {
+                issues.push(createIssue('invalid-price', product.name, `Price value: "${offer.price}"`));
+            }
+        }
+        if (!offer.priceCurrency) {
+            issues.push(createIssue('missing-currency', product.name));
+        }
+    }
+    // Availability checks
+    if (!attributes.hasAvailability) {
+        issues.push(createIssue('missing-availability', product.name));
+    }
+    else if (offer?.availability && !types_js_1.VALID_AVAILABILITY_VALUES.includes(offer.availability)) {
+        issues.push(createIssue('invalid-availability', product.name, `Value: "${offer.availability}"`));
+    }
+    // Category checks
+    if (!attributes.hasCategory) {
+        issues.push(createIssue('missing-category', product.name));
+    }
+    // ACP-specific checks
+    if (product.name && product.name.length > 150) {
+        issues.push(createIssue('acp-title-too-long', product.name, `Title is ${product.name.length} characters (ACP limit: 150)`));
+    }
+    if (product.description && product.description.length > 5000) {
+        issues.push(createIssue('acp-description-too-long', product.name, `Description is ${product.description.length} characters (ACP limit: 5000)`));
+    }
+    // Calculate product score
+    const score = calculateProductScore(attributes);
+    return {
+        name: product.name || 'Unknown Product',
+        url: product.url,
+        sku: product.sku,
+        score,
+        issues,
+        attributes,
+    };
+}
+/**
+ * Create a quality check issue
+ */
+function createIssue(checkId, productName, details) {
+    const checkDef = types_js_1.QUALITY_CHECKS[checkId];
+    return {
+        id: checkId,
+        name: checkDef.name,
+        category: checkDef.category,
+        passed: false,
+        severity: checkDef.severity,
+        message: checkDef.description,
+        details,
+        affectedProducts: productName ? [productName] : undefined,
+    };
+}
+/**
+ * Calculate product score based on attributes
+ */
+function calculateProductScore(attributes) {
+    let score = 0;
+    const weights = {
+        hasName: 15,
+        hasDescription: 10,
+        hasSku: 5,
+        hasGtin: 10,
+        hasBrand: 10,
+        hasImage: 15,
+        hasPrice: 20,
+        hasAvailability: 5,
+        hasCategory: 5,
+        descriptionQuality: 5,
+    };
+    if (attributes.hasName)
+        score += weights.hasName;
+    if (attributes.hasDescription)
+        score += weights.hasDescription;
+    if (attributes.hasSku)
+        score += weights.hasSku;
+    if (attributes.hasGtin)
+        score += weights.hasGtin;
+    if (attributes.hasBrand)
+        score += weights.hasBrand;
+    if (attributes.hasImage)
+        score += weights.hasImage;
+    if (attributes.hasPrice)
+        score += weights.hasPrice;
+    if (attributes.hasAvailability)
+        score += weights.hasAvailability;
+    if (attributes.hasCategory)
+        score += weights.hasCategory;
+    // Bonus for good description length
+    if (attributes.descriptionLength >= MIN_DESCRIPTION_LENGTH) {
+        score += weights.descriptionQuality;
+    }
+    return Math.min(100, score);
+}
+/**
+ * Calculate category scores from product analyses
+ */
+function calculateCategoryScores(products) {
+    if (products.length === 0) {
+        return {
+            completeness: 0,
+            identifiers: 0,
+            images: 0,
+            pricing: 0,
+            descriptions: 0,
+            categories: 0,
+            availability: 0,
+        };
+    }
+    const totals = products.reduce((acc, p) => {
+        // Completeness: name, brand
+        acc.completeness += (p.attributes.hasName ? 50 : 0) + (p.attributes.hasBrand ? 50 : 0);
+        // Identifiers: SKU, GTIN
+        acc.identifiers += (p.attributes.hasSku ? 50 : 0) + (p.attributes.hasGtin ? 50 : 0);
+        // Images
+        acc.images += p.attributes.hasImage ? (p.attributes.imageCount > 1 ? 100 : 70) : 0;
+        // Pricing
+        acc.pricing += p.attributes.hasPrice ? 100 : 0;
+        // Descriptions
+        if (p.attributes.hasDescription) {
+            acc.descriptions += p.attributes.descriptionLength >= MIN_DESCRIPTION_LENGTH ? 100 : 60;
+        }
+        // Categories
+        acc.categories += p.attributes.hasCategory ? 100 : 0;
+        // Availability
+        acc.availability += p.attributes.hasAvailability ? 100 : 0;
+        return acc;
+    }, { completeness: 0, identifiers: 0, images: 0, pricing: 0, descriptions: 0, categories: 0, availability: 0 });
+    const count = products.length;
+    return {
+        completeness: Math.round(totals.completeness / count),
+        identifiers: Math.round(totals.identifiers / count),
+        images: Math.round(totals.images / count),
+        pricing: Math.round(totals.pricing / count),
+        descriptions: Math.round(totals.descriptions / count),
+        categories: Math.round(totals.categories / count),
+        availability: Math.round(totals.availability / count),
+    };
+}
+/**
+ * Calculate overall score from category scores
+ */
+function calculateOverallScore(categoryScores) {
+    let weightedSum = 0;
+    let totalWeight = 0;
+    for (const [category, score] of Object.entries(categoryScores)) {
+        const weight = types_js_1.CATEGORY_WEIGHTS[category];
+        weightedSum += score * weight;
+        totalWeight += weight;
+    }
+    return Math.round(weightedSum / totalWeight);
+}
+/**
+ * Calculate agent visibility score (legacy - kept for compatibility)
+ * This is a specialized score focusing on what AI agents need most
+ */
+function calculateAgentVisibilityScore(summary) {
+    if (summary.totalProducts === 0)
+        return 0;
+    const total = summary.totalProducts;
+    // Critical factors for AI agents (weighted heavily)
+    const criticalScore = ((summary.withName / total) * 30) +
+        ((summary.withPrice / total) * 30) +
+        ((summary.withImages / total) * 20);
+    // Important factors
+    const importantScore = ((summary.withDescription / total) * 10) +
+        ((summary.withGtin / total) * 5) +
+        ((summary.withAvailability / total) * 5);
+    return Math.round(criticalScore + importantScore);
+}
+/**
+ * Calculate new additive score breakdown
+ *
+ * Scoring Model (0-100, additive):
+ * - Core Data: 40 pts max (name 15, price 15, availability 10)
+ * - Product Media: 25 pts max (has images 15, multiple images 10)
+ * - Identifiers: 20 pts max (SKU 10, GTIN 10)
+ * - Descriptions: 15 pts max (has description 10, good length 5)
+ */
+function calculateScoreBreakdown(summary, products) {
+    const total = summary.totalProducts;
+    // Zero state: no products = 0 score
+    if (total === 0) {
+        return {
+            coreData: {
+                score: 0,
+                maxScore: 40,
+                status: 'No products found - nothing to sell',
+                details: {
+                    hasName: { score: 0, percent: 0 },
+                    hasPrice: { score: 0, percent: 0 },
+                    hasAvailability: { score: 0, percent: 0 },
+                },
+            },
+            productMedia: {
+                score: 0,
+                maxScore: 25,
+                status: 'No products to analyze',
+                details: {
+                    hasImages: { score: 0, percent: 0 },
+                    multipleImages: { score: 0, percent: 0 },
+                },
+            },
+            identifiers: {
+                score: 0,
+                maxScore: 20,
+                status: 'No products to analyze',
+                details: {
+                    hasSku: { score: 0, percent: 0 },
+                    hasGtin: { score: 0, percent: 0 },
+                },
+            },
+            descriptions: {
+                score: 0,
+                maxScore: 15,
+                status: 'No products to analyze',
+                details: {
+                    hasDescription: { score: 0, percent: 0 },
+                    goodLength: { score: 0, percent: 0 },
+                },
+            },
+            total: 0,
+            maxTotal: 100,
+        };
+    }
+    // Calculate percentages
+    const namePercent = Math.round((summary.withName / total) * 100);
+    const pricePercent = Math.round((summary.withPrice / total) * 100);
+    const availabilityPercent = Math.round((summary.withAvailability / total) * 100);
+    const imagesPercent = Math.round((summary.withImages / total) * 100);
+    const skuPercent = Math.round((summary.withSku / total) * 100);
+    const gtinPercent = Math.round((summary.withGtin / total) * 100);
+    const descriptionPercent = Math.round((summary.withDescription / total) * 100);
+    // Count products with multiple images
+    const withMultipleImages = products.filter(p => p.attributes.imageCount > 1).length;
+    const multipleImagesPercent = Math.round((withMultipleImages / total) * 100);
+    // Count products with good description length
+    const withGoodDescription = products.filter(p => p.attributes.descriptionLength >= MIN_DESCRIPTION_LENGTH).length;
+    const goodDescriptionPercent = Math.round((withGoodDescription / total) * 100);
+    // Core Data scoring (40 max)
+    const nameScore = Math.round((summary.withName / total) * 15);
+    const priceScore = Math.round((summary.withPrice / total) * 15);
+    const availabilityScore = Math.round((summary.withAvailability / total) * 10);
+    const coreDataScore = nameScore + priceScore + availabilityScore;
+    // Product Media scoring (25 max)
+    const hasImagesScore = Math.round((summary.withImages / total) * 15);
+    const multipleImagesScore = Math.round((withMultipleImages / total) * 10);
+    const productMediaScore = hasImagesScore + multipleImagesScore;
+    // Identifiers scoring (20 max)
+    const skuScore = Math.round((summary.withSku / total) * 10);
+    const gtinScore = Math.round((summary.withGtin / total) * 10);
+    const identifiersScore = skuScore + gtinScore;
+    // Descriptions scoring (15 max)
+    const hasDescriptionScore = Math.round((summary.withDescription / total) * 10);
+    const goodLengthScore = Math.round((withGoodDescription / total) * 5);
+    const descriptionsScore = hasDescriptionScore + goodLengthScore;
+    // Generate status messages
+    const coreDataStatus = generateCoreDataStatus(namePercent, pricePercent, availabilityPercent);
+    const productMediaStatus = generateMediaStatus(imagesPercent, multipleImagesPercent);
+    const identifiersStatus = generateIdentifiersStatus(skuPercent, gtinPercent);
+    const descriptionsStatus = generateDescriptionsStatus(descriptionPercent, goodDescriptionPercent, summary.averageDescriptionLength);
+    const totalScore = coreDataScore + productMediaScore + identifiersScore + descriptionsScore;
+    return {
+        coreData: {
+            score: coreDataScore,
+            maxScore: 40,
+            status: coreDataStatus,
+            details: {
+                hasName: { score: nameScore, percent: namePercent },
+                hasPrice: { score: priceScore, percent: pricePercent },
+                hasAvailability: { score: availabilityScore, percent: availabilityPercent },
+            },
+        },
+        productMedia: {
+            score: productMediaScore,
+            maxScore: 25,
+            status: productMediaStatus,
+            details: {
+                hasImages: { score: hasImagesScore, percent: imagesPercent },
+                multipleImages: { score: multipleImagesScore, percent: multipleImagesPercent },
+            },
+        },
+        identifiers: {
+            score: identifiersScore,
+            maxScore: 20,
+            status: identifiersStatus,
+            details: {
+                hasSku: { score: skuScore, percent: skuPercent },
+                hasGtin: { score: gtinScore, percent: gtinPercent },
+            },
+        },
+        descriptions: {
+            score: descriptionsScore,
+            maxScore: 15,
+            status: descriptionsStatus,
+            details: {
+                hasDescription: { score: hasDescriptionScore, percent: descriptionPercent },
+                goodLength: { score: goodLengthScore, percent: goodDescriptionPercent },
+            },
+        },
+        total: totalScore,
+        maxTotal: 100,
+    };
+}
+/**
+ * Generate status message for core data
+ */
+function generateCoreDataStatus(namePercent, pricePercent, availabilityPercent) {
+    if (namePercent >= 95 && pricePercent >= 95 && availabilityPercent >= 90) {
+        return 'Excellent - All products have complete core data';
+    }
+    const issues = [];
+    if (namePercent < 95)
+        issues.push(`${100 - namePercent}% missing names`);
+    if (pricePercent < 95)
+        issues.push(`${100 - pricePercent}% missing prices`);
+    if (availabilityPercent < 90)
+        issues.push(`${100 - availabilityPercent}% missing availability`);
+    if (issues.length === 0) {
+        return `${namePercent}% with name, ${pricePercent}% with price, ${availabilityPercent}% with availability`;
+    }
+    return issues.join(', ');
+}
+/**
+ * Generate status message for product media
+ */
+function generateMediaStatus(imagesPercent, multipleImagesPercent) {
+    if (imagesPercent >= 95 && multipleImagesPercent >= 80) {
+        return `All products have images (${multipleImagesPercent}% have multiple)`;
+    }
+    if (imagesPercent < 80) {
+        return `${100 - imagesPercent}% of products missing images`;
+    }
+    return `${imagesPercent}% have images, ${multipleImagesPercent}% have multiple images`;
+}
+/**
+ * Generate status message for identifiers
+ */
+function generateIdentifiersStatus(skuPercent, gtinPercent) {
+    if (skuPercent >= 90 && gtinPercent >= 80) {
+        return `Strong identifiers - ${skuPercent}% SKUs, ${gtinPercent}% GTINs`;
+    }
+    if (gtinPercent < 50) {
+        return `${100 - gtinPercent}% missing GTINs for cross-platform matching`;
+    }
+    return `${skuPercent}% have SKUs, ${gtinPercent}% have GTINs`;
+}
+/**
+ * Generate status message for descriptions
+ */
+function generateDescriptionsStatus(descPercent, goodLengthPercent, avgLength) {
+    if (descPercent >= 95 && goodLengthPercent >= 80) {
+        return `Strong descriptions (avg ${Math.round(avgLength)} chars)`;
+    }
+    if (descPercent < 70) {
+        return `${100 - descPercent}% of products missing descriptions`;
+    }
+    if (goodLengthPercent < 50) {
+        return `Short descriptions (avg ${Math.round(avgLength)} chars) - aim for 50+`;
+    }
+    return `${descPercent}% have descriptions (avg ${Math.round(avgLength)} chars)`;
+}
+/**
+ * Get grade from score
+ */
+function getGrade(score) {
+    if (score >= types_js_1.GRADE_THRESHOLDS.A)
+        return 'A';
+    if (score >= types_js_1.GRADE_THRESHOLDS.B)
+        return 'B';
+    if (score >= types_js_1.GRADE_THRESHOLDS.C)
+        return 'C';
+    if (score >= types_js_1.GRADE_THRESHOLDS.D)
+        return 'D';
+    return 'F';
+}
+/**
+ * Generate recommendations based on analysis
+ */
+function generateRecommendations(summary, issues) {
+    const recommendations = [];
+    const total = summary.totalProducts;
+    if (total === 0)
+        return recommendations;
+    // Missing prices - critical
+    const missingPrices = total - summary.withPrice;
+    if (missingPrices > 0) {
+        recommendations.push({
+            priority: 'high',
+            category: 'pricing',
+            title: 'Add Missing Prices',
+            description: `${missingPrices} products are missing price information. AI agents cannot complete purchases without prices.`,
+            impact: 'Critical - Products without prices cannot be purchased through AI agents',
+            affectedCount: missingPrices,
+        });
+    }
+    // Missing images - critical
+    const missingImages = total - summary.withImages;
+    if (missingImages > 0) {
+        recommendations.push({
+            priority: 'high',
+            category: 'images',
+            title: 'Add Product Images',
+            description: `${missingImages} products are missing images. Visual product information is essential for AI shopping.`,
+            impact: 'High - Products without images are less likely to be recommended',
+            affectedCount: missingImages,
+        });
+    }
+    // Missing names - critical
+    const missingNames = total - summary.withName;
+    if (missingNames > 0) {
+        recommendations.push({
+            priority: 'high',
+            category: 'completeness',
+            title: 'Add Product Names',
+            description: `${missingNames} products are missing names. This is required for product identification.`,
+            impact: 'Critical - Products cannot be identified without names',
+            affectedCount: missingNames,
+        });
+    }
+    // Missing GTIN - medium priority
+    const missingGtin = total - summary.withGtin;
+    if (missingGtin > 0 && missingGtin / total > 0.5) {
+        recommendations.push({
+            priority: 'medium',
+            category: 'identifiers',
+            title: 'Add Global Identifiers (GTIN/UPC/EAN)',
+            description: `${missingGtin} products are missing global identifiers. These enable cross-platform product matching.`,
+            impact: 'Medium - Improves product matching across AI platforms',
+            affectedCount: missingGtin,
+        });
+    }
+    // Missing descriptions - medium priority
+    const missingDescriptions = total - summary.withDescription;
+    if (missingDescriptions > 0 && missingDescriptions / total > 0.3) {
+        recommendations.push({
+            priority: 'medium',
+            category: 'descriptions',
+            title: 'Add Product Descriptions',
+            description: `${missingDescriptions} products are missing descriptions. Good descriptions help AI agents understand and recommend products.`,
+            impact: 'Medium - Better descriptions improve AI recommendations',
+            affectedCount: missingDescriptions,
+        });
+    }
+    // Short descriptions
+    if (summary.averageDescriptionLength < MIN_DESCRIPTION_LENGTH && summary.withDescription > 0) {
+        recommendations.push({
+            priority: 'low',
+            category: 'descriptions',
+            title: 'Improve Description Length',
+            description: `Average description length is ${Math.round(summary.averageDescriptionLength)} characters. Aim for at least ${MIN_DESCRIPTION_LENGTH} characters.`,
+            impact: 'Low - Longer descriptions provide more context for AI agents',
+            affectedCount: summary.withDescription,
+        });
+    }
+    // Missing availability
+    const missingAvailability = total - summary.withAvailability;
+    if (missingAvailability > 0 && missingAvailability / total > 0.3) {
+        recommendations.push({
+            priority: 'medium',
+            category: 'availability',
+            title: 'Add Availability Status',
+            description: `${missingAvailability} products are missing availability information.`,
+            impact: 'Medium - Availability helps AI agents make informed purchase decisions',
+            affectedCount: missingAvailability,
+        });
+    }
+    // Sort by priority
+    const priorityOrder = { high: 0, medium: 1, low: 2 };
+    recommendations.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+    return recommendations;
+}
+/**
+ * Aggregate issues across all products
+ */
+function aggregateIssues(products) {
+    const issueMap = new Map();
+    for (const product of products) {
+        for (const issue of product.issues) {
+            const existing = issueMap.get(issue.id);
+            if (existing) {
+                // Aggregate affected products
+                if (issue.affectedProducts && existing.affectedProducts) {
+                    existing.affectedProducts.push(...issue.affectedProducts);
+                }
+            }
+            else {
+                issueMap.set(issue.id, { ...issue, affectedProducts: [...(issue.affectedProducts || [])] });
+            }
+        }
+    }
+    return Array.from(issueMap.values());
+}
+/**
+ * Calculate feed summary statistics
+ */
+function calculateSummary(products) {
+    const total = products.length;
+    if (total === 0) {
+        return {
+            totalProducts: 0,
+            withName: 0,
+            withDescription: 0,
+            withSku: 0,
+            withGtin: 0,
+            withBrand: 0,
+            withImages: 0,
+            withPrice: 0,
+            withAvailability: 0,
+            withCategory: 0,
+            averageDescriptionLength: 0,
+            averageImageCount: 0,
+        };
+    }
+    const summary = products.reduce((acc, p) => {
+        if (p.attributes.hasName)
+            acc.withName++;
+        if (p.attributes.hasDescription)
+            acc.withDescription++;
+        if (p.attributes.hasSku)
+            acc.withSku++;
+        if (p.attributes.hasGtin)
+            acc.withGtin++;
+        if (p.attributes.hasBrand)
+            acc.withBrand++;
+        if (p.attributes.hasImage)
+            acc.withImages++;
+        if (p.attributes.hasPrice)
+            acc.withPrice++;
+        if (p.attributes.hasAvailability)
+            acc.withAvailability++;
+        if (p.attributes.hasCategory)
+            acc.withCategory++;
+        acc.totalDescriptionLength += p.attributes.descriptionLength;
+        acc.totalImageCount += p.attributes.imageCount;
+        return acc;
+    }, {
+        withName: 0,
+        withDescription: 0,
+        withSku: 0,
+        withGtin: 0,
+        withBrand: 0,
+        withImages: 0,
+        withPrice: 0,
+        withAvailability: 0,
+        withCategory: 0,
+        totalDescriptionLength: 0,
+        totalImageCount: 0,
+    });
+    return {
+        totalProducts: total,
+        withName: summary.withName,
+        withDescription: summary.withDescription,
+        withSku: summary.withSku,
+        withGtin: summary.withGtin,
+        withBrand: summary.withBrand,
+        withImages: summary.withImages,
+        withPrice: summary.withPrice,
+        withAvailability: summary.withAvailability,
+        withCategory: summary.withCategory,
+        averageDescriptionLength: summary.totalDescriptionLength / total,
+        averageImageCount: summary.totalImageCount / total,
+    };
+}
+/**
+ * Analyze product feed from raw product data
+ */
+function analyzeProductFeed(products, url, maxProducts = DEFAULT_MAX_PRODUCTS, includeProductDetails = true) {
+    const productsToAnalyze = products.slice(0, maxProducts);
+    const productAnalyses = productsToAnalyze.map(analyzeProduct);
+    const summary = calculateSummary(productAnalyses);
+    const categoryScores = calculateCategoryScores(productAnalyses);
+    const score_breakdown = calculateScoreBreakdown(summary, productAnalyses);
+    const overallScore = score_breakdown.total; // Use additive score as primary
+    const agentVisibilityScore = overallScore; // Kept for backwards compatibility
+    const issues = aggregateIssues(productAnalyses);
+    const recommendations = generateRecommendations(summary, issues);
+    // Get top issues (most impactful)
+    const topIssues = issues
+        .filter(i => i.severity === 'critical' || i.severity === 'warning')
+        .sort((a, b) => {
+        const severityOrder = { critical: 0, warning: 1, info: 2 };
+        return severityOrder[a.severity] - severityOrder[b.severity];
+    })
+        .slice(0, 5);
+    // ACP feed compliance summary
+    const acpTitleOk = productAnalyses.filter(p => !p.issues.some(i => i.id === 'acp-title-too-long')).length;
+    const acpDescOk = productAnalyses.filter(p => !p.issues.some(i => i.id === 'acp-description-too-long')).length;
+    const acpIssueCount = productAnalyses.reduce((count, p) => count + p.issues.filter(i => i.id === 'acp-title-too-long' || i.id === 'acp-description-too-long').length, 0);
+    const acp_compliance = {
+        title_length_ok: acpTitleOk,
+        description_length_ok: acpDescOk,
+        has_gtin: summary.withGtin,
+        has_currency: productAnalyses.filter(p => p.attributes.hasPrice).length, // currency required with price
+        total: productAnalyses.length,
+        acp_issues: acpIssueCount,
+    };
+    return {
+        url,
+        analyzedAt: new Date().toISOString(),
+        productsFound: products.length,
+        productsAnalyzed: productsToAnalyze.length,
+        overallScore,
+        agentVisibilityScore,
+        grade: getGrade(overallScore),
+        score_breakdown,
+        categoryScores, // Legacy - kept for compatibility
+        issues,
+        topIssues,
+        products: includeProductDetails ? productAnalyses : [],
+        recommendations,
+        summary,
+        acp_compliance,
+    };
+}
+/**
+ * Analyze a product feed from HTML content
+ */
+function analyzeProductFeedFromHtml(html, url, options = {}) {
+    const products = extractProductsFromHtml(html);
+    const maxProducts = options.maxProducts ?? DEFAULT_MAX_PRODUCTS;
+    const includeProductDetails = options.includeProductDetails ?? true;
+    return analyzeProductFeed(products, url, maxProducts, includeProductDetails);
+}
+//# sourceMappingURL=feed-analyzer.js.map