improve record identification and valuation ability hugely

collection.html

@@ -318,16 +318,17 @@
 
     <!-- Footer -->
     <vinyl-footer></vinyl-footer>
-
     <!-- Components -->
     <script src="components/vinyl-nav.js"></script>
     <script src="components/vinyl-footer.js"></script>
     <script src="components/stat-card.js"></script>
     <script src="components/collection-service.js"></script>
+    <script src="components/enhanced-ocr-service.js"></script>
+    <script src="components/pricecharting-service.js"></script>
     <!-- Main Script -->
     <script src="script.js"></script>
     <script src="collection.js"></script>
-    <script>
+<script>
         feather.replace();
         
         // Ensure showToast is available (it's defined in script.js but may not be loaded yet)

components/enhanced-ocr-service.js

@@ -0,0 +1,455 @@
+// Enhanced OCR Service with multi-provider support and advanced image analysis
+class EnhancedOCRService {
+  constructor() {
+    this.providers = {
+      openai: {
+        name: 'OpenAI',
+        url: 'https://api.openai.com/v1/chat/completions',
+        models: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo']
+      },
+      deepseek: {
+        name: 'DeepSeek',
+        url: 'https://api.deepseek.com/v1/chat/completions',
+        models: ['deepseek-chat', 'deepseek-reasoner']
+      },
+      anthropic: {
+        name: 'Anthropic',
+        url: 'https://api.anthropic.com/v1/messages',
+        models: ['claude-3-opus-20240229', 'claude-3-sonnet-20240229', 'claude-3-haiku-20240307']
+      },
+      google: {
+        name: 'Google Gemini',
+        url: 'https://generativelanguage.googleapis.com/v1beta/models/gemini-pro-vision:generateContent',
+        models: ['gemini-pro-vision']
+      }
+    };
+  }
+
+  getActiveProvider() {
+    const configured = localStorage.getItem('ai_provider') || 'openai';
+    
+    // Check which provider has credentials
+    if (configured === 'deepseek' && localStorage.getItem('deepseek_api_key')) {
+      return { ...this.providers.deepseek, key: localStorage.getItem('deepseek_api_key'), model: localStorage.getItem('deepseek_model') || 'deepseek-chat' };
+    }
+    if (configured === 'anthropic' && localStorage.getItem('anthropic_api_key')) {
+      return { ...this.providers.anthropic, key: localStorage.getItem('anthropic_api_key'), model: localStorage.getItem('anthropic_model') || 'claude-3-sonnet-20240229' };
+    }
+    if (configured === 'google' && localStorage.getItem('google_api_key')) {
+      return { ...this.providers.google, key: localStorage.getItem('google_api_key'), model: 'gemini-pro-vision' };
+    }
+    
+    // Default to OpenAI
+    const openaiKey = localStorage.getItem('openai_api_key');
+    if (openaiKey) {
+      return { ...this.providers.openai, key: openaiKey, model: localStorage.getItem('openai_model') || 'gpt-4o' };
+    }
+    
+    return null;
+  }
+
+  async analyzeRecordImages(imageFiles, options = {}) {
+    const provider = this.getActiveProvider();
+    if (!provider) {
+      throw new Error('No AI provider configured. Please add an API key in Settings.');
+    }
+
+    // Limit number of images to reduce costs
+    const maxImages = options.maxImages || 6;
+    const filesToAnalyze = imageFiles.slice(0, maxImages);
+
+    // Convert all images to base64
+    const base64Images = await Promise.all(
+      filesToAnalyze.map(file => this.fileToBase64Clean(file))
+    );
+
+    // Determine analysis depth
+    const analysisDepth = options.depth || 'standard'; // quick, standard, deep
+
+    const systemPrompt = this.buildSystemPrompt(analysisDepth);
+    const userPrompt = this.buildUserPrompt(filesToAnalyze, options);
+
+    try {
+      let result;
+      
+      switch(provider.name) {
+        case 'OpenAI':
+          result = await this.callOpenAI(provider, systemPrompt, userPrompt, base64Images);
+          break;
+        case 'DeepSeek':
+          result = await this.callDeepSeek(provider, systemPrompt, userPrompt, base64Images);
+          break;
+        case 'Anthropic':
+          result = await this.callAnthropic(provider, systemPrompt, userPrompt, base64Images);
+          break;
+        case 'Google':
+          result = await this.callGoogle(provider, systemPrompt, userPrompt, base64Images);
+          break;
+        default:
+          throw new Error('Unknown provider');
+      }
+
+      // Validate and enhance result
+      return this.validateAndEnhanceResult(result, filesToAnalyze.length);
+
+    } catch (error) {
+      console.error(`${provider.name} Analysis Error:`, error);
+      throw error;
+    }
+  }
+
+  buildSystemPrompt(depth) {
+    const basePrompt = `You are an expert vinyl record identifier and grader with 20+ years experience in record collecting and sales.
+
+Your task is to analyze record photos and extract ALL identifiable information with maximum accuracy.
+
+Return ONLY a JSON object with this exact structure:`;
+
+    const structures = {
+      quick: `{
+  "artist": "string or null",
+  "title": "string or null",
+  "catalogueNumber": "string or null",
+  "label": "string or null", 
+  "year": "number or null",
+  "confidence": "high|medium|low"
+}`,
+
+      standard: `{
+  "artist": "string or null",
+  "title": "string or null",
+  "catalogueNumber": "string or null",
+  "label": "string or null",
+  "year": "number or null",
+  "country": "string or null",
+  "format": "string or null (LP, 12\", 7\", 10\")",
+  "genre": "string or null",
+  "style": "string or null",
+  "conditionEstimate": {
+    "vinyl": "M|NM|VG+|VG|G+|G|F|P",
+    "sleeve": "M|NM|VG+|VG|G+|G|F|P",
+    "confidence": "high|medium|low",
+    "notes": "specific observations about condition"
+  },
+  "pressingInfo": {
+    "matrixA": "string or null",
+    "matrixB": "string or null",
+    "stampers": "string or null",
+    "mother": "string or null",
+    "notes": "other pressing identifiers"
+  },
+  "identifiers": {
+    "barcode": "string or null",
+    "runout": "string or null",
+    "labelCode": "string or null"
+  },
+  "visualFeatures": {
+    "gatefold": boolean,
+    "innerSleeve": boolean,
+    "inserts": boolean,
+    "poster": boolean,
+    "obi": boolean,
+    "hypeSticker": boolean,
+    "shrinkWrap": boolean,
+    "sealed": boolean
+  },
+  "confidence": "high|medium|low",
+  "notes": ["array of observation strings"]
+}`,
+
+      deep: `{
+  "artist": "string or null - full artist name as shown",
+  "title": "string or null - full album title",
+  "fullTitle": "string - complete title including subtitles",
+  "catalogueNumber": "string or null - exactly as printed",
+  "label": "string or null - record label name",
+  "labelCode": "string or null - LC code if visible",
+  "year": "number or null - copyright or release year",
+  "country": "string or null - manufacturing country",
+  "format": "string or null - LP/12\"/7\"/10\" etc",
+  "speed": "33|45|78|null",
+  "genre": ["array of genres"],
+  "style": ["array of styles"],
+  "conditionEstimate": {
+    "vinyl": "M|NM|VG+|VG|G+|G|F|P",
+    "sleeve": "M|NM|VG+|VG|G+|G|F|P",
+    "overall": "M|NM|VG+|VG|G+|G|F|P",
+    "confidence": "high|medium|low",
+    "surfaceNoise": "none|minimal|light|moderate|heavy",
+    "visualDefects": ["list of visible issues"],
+    "playGradeEstimate": "string description"
+  },
+  "pressingInfo": {
+    "matrixA": "complete side A matrix/runout",
+    "matrixB": "complete side B matrix/runout",
+    "stampers": "stamper codes if visible",
+    "mother": "mother codes",
+    "father": "father codes",
+    "lacquerCut": "cutting engineer initials",
+    "pressingPlant": "identified plant if possible",
+    "notes": "any other pressing details"
+  },
+  "identifiers": {
+    "barcode": "UPC/EAN if visible",
+    "runout": "full runout etchings",
+    "labelCode": "LC-xxxx",
+    "rightsSociety": "BIEM, GEMA, ASCAP etc",
+    "priceCode": "inner sleeve price code"
+  },
+  "tracklist": {
+    "sideA": ["inferred or visible tracks"],
+    "sideB": ["inferred or visible tracks"],
+    "totalTracks": number
+  },
+  "visualFeatures": {
+    "gatefold": boolean,
+    "booklet": boolean,
+    "innerSleeve": {
+      "present": boolean,
+      "original": boolean,
+      "printed": boolean,
+      "condition": "description"
+    },
+    "inserts": [{
+      "type": "lyric sheet/poster/etc",
+      "condition": "description"
+    }],
+    "poster": {
+      "present": boolean,
+      "size": "description",
+      "condition": "description"
+    },
+    "obi": {
+      "present": boolean,
+      "condition": "description",
+      "text": "transliterated if Japanese"
+    },
+    "hypeSticker": {
+      "present": boolean,
+      "text": "full sticker text"
+    },
+    "shrinkWrap": boolean,
+    "sealed": boolean,
+    "promo": boolean,
+    "whiteLabel": boolean,
+    "testPressing": boolean
+  },
+  "photoAnalysis": {
+    "shotTypes": ["detected photo types: front/back/label_a/label_b/deadwax/etc"],
+    "missingShots": ["recommended additional photos"],
+    "quality": "assessment of photo clarity"
+  },
+  "confidence": "high|medium|low",
+  "reasoning": "brief explanation of identification process",
+  "notes": ["detailed observations about each photo"]
+}`
+    };
+
+    const instructions = {
+      quick: "Be quick but accurate. Only include clearly readable information.",
+      standard: "Be thorough. Examine all text carefully. For condition, look for scratches, scuffs, ring wear, seam splits. For pressing info, read deadwax/matrix carefully.",
+      deep: "Examine every detail meticulously. Read all small print. Identify press variants by matrix differences. Note all visual features. Assess condition from multiple angles."
+    };
+
+    return `${basePrompt}
+
+${structures[depth]}
+
+INSTRUCTIONS:
+${instructions[depth]}
+
+ACCURACY RULES:
+- Only include information you can clearly read from the images
+- If text is blurry or unclear, use null - do not guess
+- For matrix numbers, transcribe EXACTLY as etched including spaces and symbols
+- For condition, be conservative - better to under-grade than over-grade
+- Confidence should reflect your certainty in the primary identification (artist/title)
+
+CONDITION GRADING GUIDE:
+M (Mint): Perfect, no flaws, possibly sealed
+NM (Near Mint): Like new, minimal signs of handling
+VG+ (Very Good Plus): Minor wear, light surface marks, clean playback
+VG (Very Good): Visible wear, surface marks, some noise
+G+ (Good Plus): Significant wear, audible defects
+G (Good): Major defects, plays through
+F (Fair): Severe damage, barely playable
+P (Poor): Damaged, collectible only`;
+  }
+
+  buildUserPrompt(files, options) {
+    const contexts = {
+      collection: "This record is being catalogued for a personal collection. Accurate identification is important for insurance and organization.",
+      sale: "This record is being prepared for sale. Accurate grading is critical to avoid returns. Conservative estimates preferred.",
+      purchase: "Considering purchasing this record. Need to verify authenticity and assess true condition before buying.",
+      research: "Researching this release for pressing variations and historical details."
+    };
+
+    const context = contexts[options.context] || contexts.collection;
+
+    return `Please analyze these ${files.length} record photo(s).
+
+CONTEXT: ${context}
+
+${options.knownInfo ? `KNOWN INFORMATION (verify against photos): ${JSON.stringify(options.knownInfo)}` : ''}
+
+Analyze each photo carefully and provide complete identification.`;
+  }
+
+  async callOpenAI(provider, systemPrompt, userPrompt, base64Images) {
+    const messages = [
+      { role: 'system', content: systemPrompt },
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: userPrompt },
+          ...base64Images.map(base64 => ({
+            type: 'image_url',
+            image_url: {
+              url: `data:image/jpeg;base64,${base64}`,
+              detail: 'high'
+            }
+          }))
+        ]
+      }
+    ];
+
+    const response = await fetch(provider.url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${provider.key}`
+      },
+      body: JSON.stringify({
+        model: provider.model,
+        messages: messages,
+        max_tokens: 4000,
+        temperature: 0.1
+      })
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error?.message || 'OpenAI request failed');
+    }
+
+    const data = await response.json();
+    return this.extractJSON(data.choices[0].message.content);
+  }
+
+  async callDeepSeek(provider, systemPrompt, userPrompt, base64Images) {
+    // DeepSeek may have different image handling - adjust as needed
+    const messages = [
+      { role: 'system', content: systemPrompt },
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: userPrompt },
+          ...base64Images.map(base64 => ({
+            type: 'image_url',
+            image_url: {
+              url: `data:image/jpeg;base64,${base64}`,
+              detail: 'high'
+            }
+          }))
+        ]
+      }
+    ];
+
+    const response = await fetch(provider.url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${provider.key}`
+      },
+      body: JSON.stringify({
+        model: provider.model,
+        messages: messages,
+        max_tokens: 4000,
+        temperature: 0.1
+      })
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error?.message || 'DeepSeek request failed');
+    }
+
+    const data = await response.json();
+    return this.extractJSON(data.choices[0].message.content);
+  }
+
+  async callAnthropic(provider, systemPrompt, userPrompt, base64Images) {
+    const content = [
+      { type: 'text', text: userPrompt },
+      ...base64Images.map(base64 => ({
+        type: 'image',
+        source: {
+          type: 'base64',
+          media_type: 'image/jpeg',
+          data: base64
+        }
+      }))
+    ];
+
+    const response = await fetch(provider.url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': provider.key,
+        'anthropic-version': '2023-06-01'
+      },
+      body: JSON.stringify({
+        model: provider.model,
+        max_tokens: 4000,
+        system: systemPrompt,
+        messages: [{ role: 'user', content }]
+      })
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error?.message || 'Anthropic request failed');
+    }
+
+    const data = await response.json();
+    return this.extractJSON(data.content[0].text);
+  }
+
+  async callGoogle(provider, systemPrompt, userPrompt, base64Images) {
+    const parts = [
+      { text: `${systemPrompt}\n\n${userPrompt}` },
+      ...base64Images.map(base64 => ({
+        inline_data: {
+          mime_type: 'image/jpeg',
+          data: base64
+        }
+      }))
+    ];
+
+    const response = await fetch(`${provider.url}?key=${provider.key}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        contents: [{ parts }],
+        generationConfig: {
+          temperature: 0.1,
+          maxOutputTokens: 4000
+        }
+      })
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error?.message || 'Google API request failed');
+    }
+
+    const data = await response.json();
+    return this.extractJSON(data.candidates[0].content.parts[0].text);
+  }
+
+  extractJSON(content) {
+    // Try to find JSON in various formats
+    const patterns = [
+      /

components/pricecharting-service.js

@@ -0,0 +1,421 @@
+// PriceCharting API Service for comprehensive market data
+class PriceChartingService {
+  constructor() {
+    this.baseUrl = 'https://www.pricecharting.com/api';
+    // Note: PriceCharting requires an API key for full access
+    // Free tier allows limited requests per day
+  }
+
+  async searchGame(title, console) {
+    try {
+      const response = await fetch(`${this.baseUrl}/product?t=${encodeURIComponent(title)}&c=${encodeURIComponent(console)}`);
+      if (!response.ok) return null;
+      return await response.json();
+    } catch (e) {
+      console.error('PriceCharting search failed:', e);
+      return null;
+    }
+  }
+
+  // Fallback: Use web scraping approach via CORS proxy for vinyl data
+  async searchVinyl(artist, title, catalogNumber) {
+    // Build search query
+    const query = encodeURIComponent(`${artist} ${title} ${catalogNumber || ''} vinyl`.trim());
+    
+    try {
+      // Try multiple data sources in parallel
+      const [discogsData, ebayData, musicBrainzData] = await Promise.allSettled([
+        this.fetchDiscogsMarketData(artist, title, catalogNumber),
+        this.fetchEbaySoldData(artist, title, catalogNumber),
+        this.fetchMusicBrainzData(artist, title, catalogNumber)
+      ]);
+
+      return this.aggregateMarketData({
+        discogs: discogsData.status === 'fulfilled' ? discogsData.value : null,
+        ebay: ebayData.status === 'fulfilled' ? ebayData.value : null,
+        musicBrainz: musicBrainzData.status === 'fulfilled' ? musicBrainzData.value : null
+      });
+    } catch (e) {
+      console.error('Market data aggregation failed:', e);
+      return null;
+    }
+  }
+
+  async fetchDiscogsMarketData(artist, title, catalogNumber) {
+    if (!window.discogsService?.key) return null;
+
+    try {
+      // Search for release
+      let query = `${artist} ${title}`;
+      if (catalogNumber) query += ` ${catalogNumber}`;
+      
+      const searchResponse = await fetch(
+        `https://api.discogs.com/database/search?q=${encodeURIComponent(query)}&type=release&per_page=10`,
+        {
+          headers: {
+            'Authorization': `Discogs key=${window.discogsService.key}, secret=${window.discogsService.secret}`,
+            'User-Agent': 'VinylVaultPro/1.0'
+          }
+        }
+      );
+
+      if (!searchResponse.ok) return null;
+      const searchData = await searchResponse.json();
+
+      if (!searchData.results?.length) return null;
+
+      // Get detailed info for top match
+      const topMatch = searchData.results[0];
+      const detailsResponse = await fetch(
+        `https://api.discogs.com/releases/${topMatch.id}`,
+        {
+          headers: {
+            'Authorization': `Discogs key=${window.discogsService.key}, secret=${window.discogsService.secret}`,
+            'User-Agent': 'VinylVaultPro/1.0'
+          }
+        }
+      );
+
+      if (!detailsResponse.ok) return null;
+      const details = await detailsResponse.json();
+
+      // Fetch marketplace listings for pricing
+      const marketplaceResponse = await fetch(
+        `https://api.discogs.com/marketplace/listings?release_id=${topMatch.id}&per_page=20&sort=price&sort_order=asc`,
+        {
+          headers: {
+            'Authorization': `Discogs key=${window.discogsService.key}, secret=${window.discogsService.secret}`,
+            'User-Agent': 'VinylVaultPro/1.0'
+          }
+        }
+      );
+
+      let marketplaceData = null;
+      if (marketplaceResponse.ok) {
+        marketplaceData = await marketplaceResponse.json();
+      }
+
+      // Calculate statistics from listings
+      const prices = marketplaceData?.listings
+        ?.filter(l => l.original_price?.value)
+        ?.map(l => parseFloat(l.original_price.value)) || [];
+
+      return {
+        source: 'discogs',
+        releaseId: topMatch.id,
+        uri: details.uri,
+        title: details.title,
+        year: details.year,
+        country: details.country,
+        label: details.labels?.[0]?.name,
+        format: details.formats?.[0]?.name,
+        genre: details.genres?.[0],
+        style: details.styles?.[0],
+        tracklist: details.tracklist?.map(t => ({ position: t.position, title: t.title, duration: t.duration })),
+        images: details.images?.map(i => ({ uri: i.uri, type: i.type })),
+        community: {
+          have: details.community?.have,
+          want: details.community?.want,
+          rating: details.community?.rating?.average,
+          votes: details.community?.rating?.count
+        },
+        marketplace: {
+          lowestPrice: prices.length > 0 ? Math.min(...prices) : null,
+          highestPrice: prices.length > 0 ? Math.max(...prices) : null,
+          medianPrice: prices.length > 0 ? this.calculateMedian(prices) : null,
+          averagePrice: prices.length > 0 ? prices.reduce((a, b) => a + b, 0) / prices.length : null,
+          listingCount: prices.length,
+          priceDistribution: this.calculateDistribution(prices)
+        },
+        identifiers: details.identifiers?.map(i => ({ type: i.type, value: i.value })),
+        companies: details.companies?.map(c => ({ name: c.name, entity_type: c.entity_type_name }))
+      };
+    } catch (e) {
+      console.error('Discogs market data fetch failed:', e);
+      return null;
+    }
+  }
+
+  async fetchEbaySoldData(artist, title, catalogNumber) {
+    // Since we can't directly scrape eBay without CORS issues,
+    // we'll use a simulated approach based on Discogs data patterns
+    // In production, you'd use eBay's Partner Network API or Terapeak
+    
+    try {
+      // Check if we have cached eBay data in localStorage
+      const cacheKey = `ebay_${artist}_${title}_${catalogNumber}`.replace(/[^a-z0-9]/gi, '_');
+      const cached = localStorage.getItem(cacheKey);
+      
+      if (cached) {
+        const parsed = JSON.parse(cached);
+        // Cache valid for 24 hours
+        if (Date.now() - parsed.timestamp < 86400000) {
+          return parsed.data;
+        }
+      }
+
+      // Return placeholder structure - real implementation would need eBay API
+      return {
+        source: 'ebay_estimated',
+        note: 'Connect eBay API for real sold data',
+        estimatedSoldRange: { low: null, high: null, median: null }
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+
+  async fetchMusicBrainzData(artist, title, catalogNumber) {
+    try {
+      const query = encodeURIComponent(`artist:${artist} AND recording:${title}`);
+      const response = await fetch(
+        `https://musicbrainz.org/ws/2/release/?query=${query}&fmt=json&limit=5`,
+        {
+          headers: {
+            'User-Agent': 'VinylVaultPro/1.0 (contact@example.com)'
+          }
+        }
+      );
+
+      if (!response.ok) return null;
+      const data = await response.json();
+
+      if (!data.releases?.length) return null;
+
+      const release = data.releases[0];
+      
+      // Fetch detailed release info
+      const detailResponse = await fetch(
+        `https://musicbrainz.org/ws/2/release/${release.id}?inc=artists+labels+recordings&fmt=json`,
+        {
+          headers: {
+            'User-Agent': 'VinylVaultPro/1.0 (contact@example.com)'
+          }
+        }
+      );
+
+      let details = null;
+      if (detailResponse.ok) {
+        details = await detailResponse.json();
+      }
+
+      return {
+        source: 'musicbrainz',
+        id: release.id,
+        title: release.title,
+        date: release.date,
+        country: release.country,
+        barcode: release.barcode,
+        status: release.status,
+        quality: release.quality,
+        packaging: release.packaging,
+        label: release['label-info']?.[0]?.label?.name,
+        catalogNumber: release['label-info']?.[0]?.['catalog-number'],
+        trackCount: details?.media?.[0]?.tracks?.length,
+        formats: details?.media?.map(m => m.format)
+      };
+    } catch (e) {
+      console.error('MusicBrainz fetch failed:', e);
+      return null;
+    }
+  }
+
+  aggregateMarketData(sources) {
+    const result = {
+      sources: [],
+      confidence: 'low',
+      unified: {}
+    };
+
+    // Aggregate basic info with priority: Discogs > MusicBrainz > eBay
+    if (sources.discogs) {
+      result.sources.push('discogs');
+      result.unified = {
+        ...result.unified,
+        artist: sources.discogs.title?.split(' - ')[0],
+        title: sources.discogs.title?.split(' - ')[1] || sources.discogs.title,
+        year: sources.discogs.year,
+        country: sources.discogs.country,
+        label: sources.discogs.label,
+        format: sources.discogs.format,
+        genre: sources.discogs.genre,
+        style: sources.discogs.style,
+        tracklist: sources.discogs.tracklist,
+        images: sources.discogs.images,
+        communityData: sources.discogs.community,
+        identifiers: sources.discogs.identifiers
+      };
+
+      // Pricing from Discogs marketplace
+      if (sources.discogs.marketplace?.listingCount > 0) {
+        result.pricing = {
+          source: 'discogs_marketplace',
+          currency: 'USD', // Discogs uses USD by default
+          currentListings: {
+            lowest: sources.discogs.marketplace.lowestPrice,
+            highest: sources.discogs.marketplace.highestPrice,
+            median: sources.discogs.marketplace.medianPrice,
+            average: sources.discogs.marketplace.averagePrice,
+            count: sources.discogs.marketplace.listingCount
+          },
+          distribution: sources.discogs.marketplace.priceDistribution
+        };
+
+        // Estimate sold prices (typically 15-25% below asking)
+        const discountFactor = 0.8; // Assume 20% negotiation
+        result.pricing.estimatedSold = {
+          low: result.pricing.currentListings.lowest * discountFactor,
+          median: result.pricing.currentListings.median * discountFactor,
+          high: result.pricing.currentListings.highest * discountFactor
+        };
+      }
+    }
+
+    if (sources.musicBrainz) {
+      result.sources.push('musicbrainz');
+      // Fill gaps with MusicBrainz data
+      if (!result.unified.barcode && sources.musicBrainz.barcode) {
+        result.unified.barcode = sources.musicBrainz.barcode;
+      }
+      if (!result.unified.catalogNumber && sources.musicBrainz.catalogNumber) {
+        result.unified.catalogNumber = sources.musicBrainz.catalogNumber;
+      }
+    }
+
+    if (sources.ebay) {
+      result.sources.push('ebay');
+    }
+
+    // Calculate confidence based on data richness
+    if (result.sources.includes('discogs') && result.pricing?.currentListings?.count > 5) {
+      result.confidence = 'high';
+    } else if (result.sources.includes('discogs')) {
+      result.confidence = 'medium';
+    }
+
+    return result;
+  }
+
+  calculateMedian(values) {
+    if (!values.length) return null;
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 !== 0 
+      ? sorted[mid] 
+      : (sorted[mid - 1] + sorted[mid]) / 2;
+  }
+
+  calculateDistribution(prices) {
+    if (!prices.length) return null;
+    
+    const min = Math.min(...prices);
+    const max = Math.max(...prices);
+    const range = max - min;
+    
+    if (range === 0) return { singlePrice: min };
+    
+    // Create 5 buckets
+    const buckets = [];
+    for (let i = 0; i < 5; i++) {
+      const bucketMin = min + (range * i / 5);
+      const bucketMax = min + (range * (i + 1) / 5);
+      const count = prices.filter(p => p >= bucketMin && p < bucketMax).length;
+      buckets.push({
+        range: `£${bucketMin.toFixed(2)} - £${bucketMax.toFixed(2)}`,
+        count,
+        percentage: (count / prices.length * 100).toFixed(1)
+      });
+    }
+    
+    return { min, max, range, buckets };
+  }
+
+  // Advanced valuation algorithm
+  calculateValuation(recordData, marketData, userCondition) {
+    if (!marketData?.pricing?.estimatedSold) {
+      return null;
+    }
+
+    const baseValue = marketData.pricing.estimatedSold.median;
+    
+    // Condition multipliers (industry standard approximations)
+    const conditionMultipliers = {
+      'M': 1.5,    // Mint - sealed or perfect
+      'NM': 1.3,   // Near Mint - played once or twice
+      'VG+': 1.0,  // Very Good Plus - our baseline
+      'VG': 0.7,   // Very Good - visible wear, plays well
+      'G+': 0.5,   // Good Plus - significant wear
+      'G': 0.35,   // Good - major defects
+      'F': 0.2,    // Fair - barely playable
+      'P': 0.1     // Poor - mostly for rare items only
+    };
+
+    const vinylMult = conditionMultipliers[userCondition.vinyl] || 0.7;
+    const sleeveMult = conditionMultipliers[userCondition.sleeve] || 0.7;
+    
+    // Weighted condition adjustment (vinyl matters more than sleeve)
+    const conditionAdjust = (vinylMult * 0.65) + (sleeveMult * 0.35);
+    
+    // Demand factor from community data
+    let demandFactor = 1.0;
+    if (marketData.unified.communityData) {
+      const have = marketData.unified.communityData.have || 1;
+      const want = marketData.unified.communityData.want || 0;
+      const ratio = want / have;
+      
+      if (ratio > 2) demandFactor = 1.3;      // High demand
+      else if (ratio > 1) demandFactor = 1.15; // Above average
+      else if (ratio < 0.3) demandFactor = 0.85; // Low demand
+    }
+
+    // Rarity estimation based on listing count
+    let rarityFactor = 1.0;
+    const listingCount = marketData.pricing?.currentListings?.count;
+    if (listingCount !== undefined) {
+      if (listingCount < 3) rarityFactor = 1.4;      // Very rare
+      else if (listingCount < 10) rarityFactor = 1.2; // Uncommon
+      else if (listingCount > 50) rarityFactor = 0.9; // Common
+    }
+
+    // Year premium for vintage
+    let vintageFactor = 1.0;
+    const year = marketData.unified.year;
+    if (year && year < 1980) vintageFactor = 1.2;
+    else if (year && year < 1990) vintageFactor = 1.1;
+
+    // Calculate final valuation
+    const adjustedValue = baseValue * conditionAdjust * demandFactor * rarityFactor * vintageFactor;
+    
+    // Calculate confidence interval
+    const volatility = marketData.pricing.currentListings 
+      ? (marketData.pricing.currentListings.highest - marketData.pricing.currentListings.lowest) 
+        / marketData.pricing.currentListings.median 
+      : 0.5;
+    
+    const confidenceInterval = {
+      low: adjustedValue * (1 - volatility * 0.5),
+      high: adjustedValue * (1 + volatility * 0.5)
+    };
+
+    return {
+      estimatedValue: Math.round(adjustedValue),
+      confidenceInterval: {
+        low: Math.round(confidenceInterval.low),
+        high: Math.round(confidenceInterval.high)
+      },
+      factors: {
+        condition: conditionAdjust,
+        demand: demandFactor,
+        rarity: rarityFactor,
+        vintage: vintageFactor
+      },
+      methodology: {
+        baseSource: marketData.pricing.source,
+        baseValue: Math.round(baseValue),
+        confidence: marketData.confidence
+      }
+    };
+  }
+}
+
+window.priceChartingService = new PriceChartingService();

index.html

@@ -368,8 +368,10 @@
     <script src="components/vinyl-footer.js"></script>
     <script src="components/stat-card.js"></script>
     <script src="components/ocr-service.js"></script>
+    <script src="components/enhanced-ocr-service.js"></script>
     <script src="components/discogs-service.js"></script>
     <script src="components/deepseek-service.js"></script>
+    <script src="components/pricecharting-service.js"></script>
     
     <!-- Main Script -->
     <script src="script.js"></script>

script.js

@@ -333,7 +333,6 @@ function stopAnalysisProgress() {
     }
     updateAnalysisProgress('Complete!', 100);
 }
-
 async function analyzePhotosWithOCR() {
     const spinner = document.getElementById('uploadSpinner');
     const dropZone = document.getElementById('dropZone');
@@ -345,67 +344,422 @@ async function analyzePhotosWithOCR() {
         // Start progress simulation
         startAnalysisProgressSimulation();
         
-        // Determine which AI service to use
-        const provider = localStorage.getItem('ai_provider') || 'openai';
-        const service = getAIService();
-        
-        // Update API keys
-        if (provider === 'openai') {
-            const apiKey = localStorage.getItem('openai_api_key');
-            if (!apiKey) throw new Error('OpenAI API key not configured');
-            window.ocrService.updateApiKey(apiKey);
-        } else {
-            const apiKey = localStorage.getItem('deepseek_api_key');
-            if (!apiKey) throw new Error('DeepSeek API key not configured');
-            window.deepseekService.updateApiKey(apiKey);
-            window.deepseekService.updateModel(localStorage.getItem('deepseek_model') || 'deepseek-chat');
-        }
-        
-        const result = await service.analyzeRecordImages(uploadedPhotos);
+        // Use enhanced OCR service with deep analysis
+        const result = await window.enhancedOCRService.analyzeRecordImages(uploadedPhotos, {
+            depth: 'deep',
+            context: 'sale',
+            maxImages: 6
+        });
         
         // Complete the progress bar
         stopAnalysisProgress();
-populateFieldsFromOCR(result);
         
-        // Try to fetch additional data from Discogs if available
-        if (result.artist && result.title && window.discogsService) {
-            try {
-                const discogsData = await window.discogsService.searchRelease(
-                    result.artist, 
-                    result.title, 
-                    result.catalogueNumber
-                );
-                if (discogsData) {
-                    populateFieldsFromDiscogs(discogsData);
-                }
-            } catch (e) {
-                console.log('Discogs lookup failed:', e);
-            }
-        }
+        // Populate form fields with enhanced data
+        populateFieldsFromEnhancedOCR(result);
         
-        const confidenceMsg = result.confidence === 'high' ? 'Record identified!' : 
-                             result.confidence === 'medium' ? 'Record found (verify details)' : 
-                             'Partial match found';
+        // Fetch comprehensive market data
+        await fetchComprehensiveMarketData(result);
+        
+        const confidenceMsg = result.confidence === 'high' ? 'Record fully identified with market data!' : 
+                             result.confidence === 'medium' ? 'Record identified - verify details & pricing' : 
+                             'Partial identification - manual review needed';
         showToast(confidenceMsg, result.confidence === 'high' ? 'success' : 'warning');
     } catch (error) {
-        console.error('OCR Error:', error);
-        if (error.message.includes('API key') || error.message.includes('not configured')) {
+        console.error('Enhanced OCR Error:', error);
+        
+        // Fallback to basic OCR service
+        try {
+            showToast('Trying fallback identification...', 'warning');
             const provider = localStorage.getItem('ai_provider') || 'openai';
-            showToast(`Please configure ${provider === 'deepseek' ? 'DeepSeek' : 'OpenAI'} API key in Settings`, 'error');
-        } else {
-            showToast(`Analysis failed: ${error.message}`, 'error');
+            const service = getAIService();
+            
+            if (provider === 'openai') {
+                const apiKey = localStorage.getItem('openai_api_key');
+                if (apiKey) window.ocrService.updateApiKey(apiKey);
+            } else {
+                const apiKey = localStorage.getItem('deepseek_api_key');
+                if (apiKey) {
+                    window.deepseekService.updateApiKey(apiKey);
+                    window.deepseekService.updateModel(localStorage.getItem('deepseek_model') || 'deepseek-chat');
+                }
+            }
+            
+            const result = await service.analyzeRecordImages(uploadedPhotos);
+            populateFieldsFromOCR(result);
+            showToast('Basic identification complete', 'success');
+        } catch (fallbackError) {
+            if (error.message.includes('API key') || error.message.includes('not configured')) {
+                showToast('Please configure an AI API key in Settings', 'error');
+            } else {
+                showToast(`Analysis failed: ${error.message}`, 'error');
+            }
         }
-} finally {
+    } finally {
         stopAnalysisProgress();
-        // Small delay to show 100% before hiding
         setTimeout(() => {
             spinner.classList.add('hidden');
             dropZone.classList.remove('pointer-events-none');
-            // Reset progress for next time
             updateAnalysisProgress('Initializing...', 0);
         }, 300);
     }
 }
+
+async function fetchComprehensiveMarketData(ocrResult) {
+    if (!ocrResult.artist || !ocrResult.title) return;
+    
+    showToast('Fetching market data...', 'success');
+    
+    try {
+        // Use PriceCharting service for comprehensive market data
+        const marketData = await window.priceChartingService.searchVinyl(
+            ocrResult.artist,
+            ocrResult.title,
+            ocrResult.catalogueNumber
+        );
+        
+        if (marketData && marketData.confidence !== 'low') {
+            populateMarketData(marketData, ocrResult);
+        } else {
+            // Fallback to basic Discogs lookup
+            if (window.discogsService?.key && ocrResult.artist && ocrResult.title) {
+                const discogsData = await window.discogsService.searchRelease(
+                    ocrResult.artist,
+                    ocrResult.title,
+                    ocrResult.catalogueNumber
+                );
+                if (discogsData) {
+                    populateFieldsFromDiscogs(discogsData);
+                }
+            }
+        }
+    } catch (e) {
+        console.log('Market data fetch failed:', e);
+    }
+}
+
+function populateFieldsFromEnhancedOCR(data) {
+    // Basic fields
+    const fields = {
+        'artistInput': data.artist,
+        'titleInput': data.title,
+        'catInput': data.catalogueNumber || data.identifiers?.labelCode,
+        'yearInput': data.year
+    };
+
+    let populatedCount = 0;
+    
+    Object.entries(fields).forEach(([fieldId, value]) => {
+        const field = document.getElementById(fieldId);
+        if (field && value && value !== 'null' && value !== 'undefined') {
+            if (!field.value || field.dataset.userModified !== 'true') {
+                field.value = value;
+                field.classList.add('border-green-500', 'bg-green-500/10');
+                setTimeout(() => {
+                    field.classList.remove('border-green-500', 'bg-green-500/10');
+                }, 3000);
+                populatedCount++;
+            }
+        }
+    });
+
+    // Set condition dropdowns if detected
+    if (data.conditionEstimate?.vinyl) {
+        const vinylSelect = document.getElementById('vinylConditionInput');
+        if (vinylSelect && !vinylSelect.dataset.userModified) {
+            const grades = ['M', 'NM', 'VG+', 'VG', 'G+', 'G', 'F', 'P'];
+            const detected = data.conditionEstimate.vinyl.toUpperCase();
+            if (grades.includes(detected)) {
+                vinylSelect.value = detected;
+            }
+        }
+    }
+    
+    if (data.conditionEstimate?.sleeve) {
+        const sleeveSelect = document.getElementById('sleeveConditionInput');
+        if (sleeveSelect && !sleeveSelect.dataset.userModified) {
+            const grades = ['M', 'NM', 'VG+', 'VG', 'G+', 'G', 'F', 'P'];
+            const detected = data.conditionEstimate.sleeve.toUpperCase();
+            if (grades.includes(detected)) {
+                sleeveSelect.value = detected;
+            }
+        }
+    }
+
+    // Store all detected data globally
+    window.detectedData = data;
+    window.detectedLabel = data.label;
+    window.detectedCountry = data.country;
+    window.detectedFormat = data.format;
+    window.detectedGenre = Array.isArray(data.genre) ? data.genre[0] : data.genre;
+    window.detectedStyle = Array.isArray(data.style) ? data.style[0] : data.style;
+    window.detectedCondition = data.conditionEstimate;
+    window.detectedPressingInfo = data.pressingInfo;
+    window.detectedVisualFeatures = data.visualFeatures;
+    window.detectedMatrix = data.matrixNotes || data.pressingInfo?.matrixA;
+
+    // Update UI with comprehensive info
+    updateEnhancedDetectedPanel(data);
+
+    // Scroll to details
+    if (populatedCount > 0) {
+        const quickDetailsSection = document.querySelector('.md\\\\:w-80');
+        if (quickDetailsSection) {
+            setTimeout(() => {
+                quickDetailsSection.scrollIntoView({ behavior: 'smooth', block: 'center' });
+            }, 100);
+        }
+    }
+}
+
+function populateMarketData(marketData, ocrData) {
+    if (!marketData?.unified) return;
+    
+    const unified = marketData.unified;
+    const pricing = marketData.pricing;
+    
+    // Update any missing fields from market data
+    const fields = {
+        'artistInput': unified.artist,
+        'titleInput': unified.title,
+        'catInput': unified.catalogNumber || unified.catalogueNumber,
+        'yearInput': unified.year
+    };
+    
+    Object.entries(fields).forEach(([fieldId, value]) => {
+        const field = document.getElementById(fieldId);
+        if (field && value && (!field.value || field.value === '[Verify]')) {
+            field.value = value;
+            field.classList.add('border-blue-500', 'bg-blue-500/10');
+            setTimeout(() => {
+                field.classList.remove('border-blue-500', 'bg-blue-500/10');
+            }, 3000);
+        }
+    });
+    
+    // Store market pricing for later use
+    window.marketPricing = pricing;
+    window.marketConfidence = marketData.confidence;
+    
+    // Show market data panel
+    updateMarketDataPanel(marketData, ocrData);
+}
+
+function updateEnhancedDetectedPanel(data) {
+    let panel = document.getElementById('detectedInfoPanel');
+    const parent = document.querySelector('#dropZone')?.parentNode;
+    if (!parent) return;
+    
+    if (!panel) {
+        panel = document.createElement('div');
+        panel.id = 'detectedInfoPanel';
+        parent.appendChild(panel);
+    }
+
+    const confidenceColor = data.confidence === 'high' ? 'text-green-400 border-green-500/30 bg-green-500/10' : 
+                           data.confidence === 'medium' ? 'text-yellow-400 border-yellow-500/30 bg-yellow-500/10' : 
+                           'text-orange-400 border-orange-500/30 bg-orange-500/10';
+
+    // Build info sections
+    const basicInfo = [];
+    if (data.label) basicInfo.push(`<span class="text-purple-400">Label:</span> ${data.label}`);
+    if (data.country) basicInfo.push(`<span class="text-purple-400">Country:</span> ${data.country}`);
+    if (data.format) basicInfo.push(`<span class="text-purple-400">Format:</span> ${data.format}${data.speed ? ` @ ${data.speed}rpm` : ''}`);
+    if (data.year) basicInfo.push(`<span class="text-purple-400">Year:</span> ${data.year}`);
+    
+    const genreInfo = [];
+    if (Array.isArray(data.genre)) {
+        genreInfo.push(`<span class="text-cyan-400">Genre:</span> ${data.genre.join(', ')}`);
+    } else if (data.genre) {
+        genreInfo.push(`<span class="text-cyan-400">Genre:</span> ${data.genre}`);
+    }
+    if (Array.isArray(data.style)) {
+        genreInfo.push(`<span class="text-cyan-400">Style:</span> ${data.style.join(', ')}`);
+    } else if (data.style) {
+        genreInfo.push(`<span class="text-cyan-400">Style:</span> ${data.style}`);
+    }
+
+    const conditionInfo = [];
+    if (data.conditionEstimate) {
+        const ce = data.conditionEstimate;
+        conditionInfo.push(`<span class="text-${ce.vinyl === 'NM' || ce.vinyl === 'M' ? 'green' : ce.vinyl === 'VG+' ? 'blue' : 'yellow'}-400">Vinyl:</span> ${ce.vinyl}`);
+        conditionInfo.push(`<span class="text-${ce.sleeve === 'NM' || ce.sleeve === 'M' ? 'green' : ce.sleeve === 'VG+' ? 'blue' : 'yellow'}-400">Sleeve:</span> ${ce.sleeve}`);
+        if (ce.surfaceNoise) {
+            conditionInfo.push(`<span class="text-gray-400">Surface noise:</span> ${ce.surfaceNoise}`);
+        }
+    }
+
+    const pressingInfo = [];
+    if (data.pressingInfo?.matrixA) pressingInfo.push(`<span class="text-pink-400">Side A:</span> ${data.pressingInfo.matrixA}`);
+    if (data.pressingInfo?.matrixB) pressingInfo.push(`<span class="text-pink-400">Side B:</span> ${data.pressingInfo.matrixB}`);
+    if (data.pressingInfo?.stampers) pressingInfo.push(`<span class="text-pink-400">Stampers:</span> ${data.pressingInfo.stampers}`);
+    if (data.pressingInfo?.lacquerCut) pressingInfo.push(`<span class="text-pink-400">Cut by:</span> ${data.pressingInfo.lacquerCut}`);
+
+    const features = [];
+    if (data.visualFeatures) {
+        const vf = data.visualFeatures;
+        if (vf.gatefold) features.push('🏛️ Gatefold');
+        if (vf.innerSleeve) features.push('📄 Inner Sleeve');
+        if (vf.inserts) features.push('📋 Inserts');
+        if (vf.poster) features.push('🖼️ Poster');
+        if (vf.obi) features.push('🇯🇵 OBI Strip');
+        if (vf.hypeSticker) features.push('⭐ Hype Sticker');
+        if (vf.shrinkWrap) features.push('📦 Shrink');
+        if (vf.sealed) features.push('🔒 Sealed');
+    }
+
+    panel.className = `mt-4 p-4 rounded-lg border ${confidenceColor}`;
+
+    panel.innerHTML = `
+        <div class="flex items-center justify-between mb-3">
+            <div class="flex items-center gap-2">
+                <i data-feather="cpu" class="w-5 h-5"></i>
+                <span class="font-medium">AI Deep Analysis (${data.confidence} confidence)</span>
+            </div>
+            ${data._meta?.photosAnalyzed ? `<span class="text-xs opacity-70">${data._meta.photosAnalyzed} photos analyzed</span>` : ''}
+        </div>
+        
+        ${basicInfo.length ? `
+            <div class="grid grid-cols-2 md:grid-cols-4 gap-2 text-sm mb-3">
+                ${basicInfo.map(item => `<div class="text-gray-300">${item}</div>`).join('')}
+            </div>
+        ` : ''}
+        
+        ${genreInfo.length ? `
+            <div class="flex flex-wrap gap-4 text-sm mb-3 pb-3 border-b border-current/20">
+                ${genreInfo.map(item => `<span class="text-gray-300">${item}</span>`).join('')}
+            </div>
+        ` : ''}
+        
+        ${conditionInfo.length ? `
+            <div class="mb-3 pb-3 border-b border-current/20">
+                <p class="text-xs uppercase tracking-wide opacity-70 mb-2">Condition Assessment</p>
+                <div class="flex flex-wrap gap-4 text-sm">
+                    ${conditionInfo.map(item => `<span class="text-gray-300">${item}</span>`).join('')}
+                </div>
+                ${data.conditionEstimate?.notes ? `<p class="text-xs text-gray-400 mt-2 italic">${data.conditionEstimate.notes}</p>` : ''}
+            </div>
+        ` : ''}
+        
+        ${pressingInfo.length ? `
+            <div class="mb-3 pb-3 border-b border-current/20">
+                <p class="text-xs uppercase tracking-wide opacity-70 mb-2">Pressing Information</p>
+                <div class="space-y-1 text-sm font-mono">
+                    ${pressingInfo.map(item => `<div class="text-gray-300">${item}</div>`).join('')}
+                </div>
+            </div>
+        ` : ''}
+        
+        ${features.length ? `
+            <div class="mb-3">
+                <p class="text-xs uppercase tracking-wide opacity-70 mb-2">Included Features</p>
+                <div class="flex flex-wrap gap-2">
+                    ${features.map(f => `<span class="px-2 py-1 bg-surface rounded text-sm">${f}</span>`).join('')}
+                </div>
+            </div>
+        ` : ''}
+        
+        ${data.notes?.length ? `
+            <div class="mt-3 pt-3 border-t border-current/20">
+                <p class="text-xs uppercase tracking-wide opacity-70 mb-2">Observations</p>
+                <ul class="text-xs text-gray-400 space-y-1 list-disc list-inside">
+                    ${data.notes.map(n => `<li>${n}</li>`).join('')}
+                </ul>
+            </div>
+        ` : ''}
+    `;
+    
+    feather.replace();
+}
+
+function updateMarketDataPanel(marketData, ocrData) {
+    // Find or create market data panel
+    let panel = document.getElementById('marketDataPanel');
+    const detectedPanel = document.getElementById('detectedInfoPanel');
+    
+    if (!panel && detectedPanel) {
+        panel = document.createElement('div');
+        panel.id = 'marketDataPanel';
+        detectedPanel.parentNode.insertBefore(panel, detectedPanel.nextSibling);
+    }
+    
+    if (!panel) return;
+    
+    const pricing = marketData.pricing;
+    const unified = marketData.unified;
+    
+    const confidenceClass = marketData.confidence === 'high' ? 'border-green-500/30 bg-green-500/5' :
+                           marketData.confidence === 'medium' ? 'border-yellow-500/30 bg-yellow-500/5' :
+                           'border-gray-500/30 bg-gray-500/5';
+    
+    let pricingHtml = '';
+    if (pricing?.estimatedSold) {
+        pricingHtml = `
+            <div class="grid grid-cols-3 gap-3 mb-3">
+                <div class="text-center p-2 bg-surface rounded">
+                    <p class="text-xs text-gray-500">Low Sold</p>
+                    <p class="text-lg font-bold text-red-400">£${Math.round(pricing.estimatedSold.low)}</p>
+                </div>
+                <div class="text-center p-2 bg-surface rounded border border-primary/30">
+                    <p class="text-xs text-primary">Median Sold</p>
+                    <p class="text-lg font-bold text-primary">£${Math.round(pricing.estimatedSold.median)}</p>
+                </div>
+                <div class="text-center p-2 bg-surface rounded">
+                    <p class="text-xs text-gray-500">High Sold</p>
+                    <p class="text-lg font-bold text-green-400">£${Math.round(pricing.estimatedSold.high)}</p>
+                </div>
+            </div>
+        `;
+    }
+    
+    let listingsHtml = '';
+    if (pricing?.currentListings?.count > 0) {
+        listingsHtml = `
+            <div class="mb-3">
+                <p class="text-xs uppercase tracking-wide text-gray-500 mb-2">Current Market (${pricing.currentListings.count} listings)</p>
+                <div class="flex justify-between text-sm">
+                    <span class="text-gray-400">Range: £${Math.round(pricing.currentListings.lowest)} - £${Math.round(pricing.currentListings.highest)}</span>
+                    <span class="text-gray-400">Avg: £${Math.round(pricing.currentListings.average || pricing.currentListings.median)}</span>
+                </div>
+            </div>
+        `;
+    }
+    
+    let demandHtml = '';
+    if (unified.communityData) {
+        const cd = unified.communityData;
+        const ratio = cd.want && cd.have ? (cd.want / cd.have).toFixed(2) : '?';
+        demandHtml = `
+            <div class="flex gap-4 text-sm mb-3">
+                <span class="text-gray-400"><span class="text-blue-400 font-bold">${cd.have || '?'}</span> have</span>
+                <span class="text-gray-400"><span class="text-green-400 font-bold">${cd.want || '?'}</span> want</span>
+                <span class="text-gray-400">Ratio: <span class="${ratio > 1 ? 'text-green-400' : 'text-yellow-400'} font-bold">${ratio}</span></span>
+                ${cd.rating ? `<span class="text-gray-400">Rating: ⭐ ${cd.rating}/5 (${cd.votes})</span>` : ''}
+            </div>
+        `;
+    }
+    
+    panel.className = `mt-4 p-4 rounded-lg border ${confidenceClass}`;
+    panel.innerHTML = `
+        <div class="flex items-center gap-2 mb-3">
+            <i data-feather="trending-up" class="w-5 h-5 text-primary"></i>
+            <span class="font-medium text-gray-200">Market Intelligence</span>
+            <span class="ml-auto text-xs px-2 py-1 rounded bg-surface text-gray-400">${marketData.sources.join(' + ')}</span>
+        </div>
+        
+        ${pricingHtml}
+        ${listingsHtml}
+        ${demandHtml}
+        
+        ${unified.tracklist ? `
+            <div class="mt-3 pt-3 border-t border-gray-700">
+                <p class="text-xs uppercase tracking-wide text-gray-500 mb-2">Tracklist Verified</p>
+                <p class="text-xs text-gray-400">${unified.tracklist.length} tracks from ${unified.source || 'database'}</p>
+            </div>
+        ` : ''}
+    `;
+    
+    feather.replace();
+}
 function populateFieldsFromDiscogs(discogsData) {
     if (!discogsData) return;