less logs

src/lib/db/trainerScanning.ts

@@ -3,114 +3,76 @@ import type { TrainerScanProgress } from './schema';
 
 // Initialize trainer scan progress records from paths
 export async function initializeTrainerScanProgress(imagePaths: string[]): Promise<void> {
-  try {
-    console.log('🔍 initializeTrainerScanProgress: Starting with', imagePaths.length, 'paths');
-    console.log('🔍 initializeTrainerScanProgress: First few paths:', imagePaths.slice(0, 3));
-    
-    let processedCount = 0;
-    let skippedCount = 0;
-    
-    for (let i = 0; i < imagePaths.length; i++) {
-      const imagePath = imagePaths[i];
-      try {
-        console.log(`🔍 initializeTrainerScanProgress: Processing path ${i}: "${imagePath}" (type: ${typeof imagePath})`);
-        
-        if (typeof imagePath !== 'string') {
-          console.error(`❌ initializeTrainerScanProgress: Path at index ${i} is not a string:`, imagePath);
-          skippedCount++;
-          continue;
-        }
-        
-        // Extract trainer name and image index from path
-        // Format: "trainer_images/001_Willow_Snap/image_001.jpg"
-        console.log(`🔍 initializeTrainerScanProgress: Splitting path: "${imagePath}"`);
-        const pathParts = imagePath.split('/');
-        console.log(`🔍 initializeTrainerScanProgress: Path parts:`, pathParts);
-        
-        if (pathParts.length < 3) {
-          console.warn(`⚠️ Skipping invalid path format: ${imagePath} (length: ${pathParts.length})`);
-          skippedCount++;
-          continue;
-        }
-        
-        const rawTrainerName = pathParts[1];
-        const rawImageFile = pathParts[2];
-        console.log(`🔍 initializeTrainerScanProgress: Raw parts - trainer: "${rawTrainerName}" (${typeof rawTrainerName}), image: "${rawImageFile}" (${typeof rawImageFile})`);
-        
-        const trainerName = rawTrainerName?.trim?.(); // Safe call with optional chaining
-        const imageFile = rawImageFile?.trim?.(); // Safe call with optional chaining
-        console.log(`🔍 initializeTrainerScanProgress: Trimmed parts - trainer: "${trainerName}" (${typeof trainerName}), image: "${imageFile}" (${typeof imageFile})`);
-        
-        if (!trainerName || !imageFile || typeof trainerName !== 'string' || typeof imageFile !== 'string') {
-          console.warn(`⚠️ Skipping path with missing or invalid parts: ${imagePath}`, { 
-            trainerName, 
-            imageFile, 
-            trainerType: typeof trainerName, 
-            imageType: typeof imageFile 
-          });
-          skippedCount++;
-          continue;
-        }
-        
-        console.log(`🔍 initializeTrainerScanProgress: Matching image file: "${imageFile}"`);
-        const imageMatch = imageFile.match(/image_(\d+)\.jpg/);
-        const imageIndex = imageMatch ? parseInt(imageMatch[1]) : 1;
-        console.log(`🔍 initializeTrainerScanProgress: Image index: ${imageIndex}`);
-        
-        const remoteUrl = `https://huggingface.co/datasets/Fraser/piclets/resolve/main/${imagePath}`;
-        console.log(`🔍 initializeTrainerScanProgress: Remote URL: ${remoteUrl}`);
-        
-        // Check if this path already exists to avoid duplicates (using Dexie syntax)
-        console.log(`🔍 initializeTrainerScanProgress: Checking for existing record...`);
-        const existing = await db.trainerScanProgress.get(imagePath);
-        console.log(`🔍 initializeTrainerScanProgress: Existing record:`, existing ? 'found' : 'not found');
-        
-        if (!existing) {
-          const progressRecord: Omit<TrainerScanProgress, 'id'> = {
-            imagePath,
-            trainerName,
-            imageIndex,
-            status: 'pending',
-            remoteUrl
-          };
-          
-          console.log(`🔍 initializeTrainerScanProgress: Adding record:`, progressRecord);
-          await db.trainerScanProgress.add(progressRecord);
-          console.log(`🔍 initializeTrainerScanProgress: Record added successfully`);
-          processedCount++;
-        } else {
-          // Record exists, don't count as processed but note it
-          processedCount++;
-        }
-        
-        // Log progress every 100 items
-        if (i % 100 === 0) {
-          console.log(`🔍 initializeTrainerScanProgress: Progress: ${i}/${imagePaths.length} (${Math.round((i/imagePaths.length)*100)}%)`);
-        }
-        
-      } catch (error) {
-        console.error(`❌ Failed to process path entry at index ${i}: "${imagePath}"`, error);
-        console.error('❌ Error details:', {
-          message: error instanceof Error ? error.message : 'Unknown error',
-          stack: error instanceof Error ? error.stack : 'No stack trace',
-          pathValue: imagePath,
-          pathType: typeof imagePath
-        });
+  let processedCount = 0;
+  let skippedCount = 0;
+  
+  for (let i = 0; i < imagePaths.length; i++) {
+    const imagePath = imagePaths[i];
+    try {
+      if (typeof imagePath !== 'string') {
+        console.error(`❌ Path at index ${i} is not a string:`, imagePath, typeof imagePath);
+        skippedCount++;
+        continue;
+      }
+      
+      // Extract trainer name and image index from path
+      // Format: "trainer_images/001_Willow_Snap/image_001.jpg"
+      const pathParts = imagePath.split('/');
+      
+      if (pathParts.length < 3) {
+        console.warn(`⚠️ Skipping invalid path format: ${imagePath}`);
         skippedCount++;
-        // Continue processing other paths despite this failure
+        continue;
       }
+      
+      const trainerName = pathParts[1]?.trim();
+      const imageFile = pathParts[2]?.trim();
+      
+      if (!trainerName || !imageFile) {
+        console.warn(`⚠️ Skipping path with missing parts: ${imagePath}`);
+        skippedCount++;
+        continue;
+      }
+      
+      const imageMatch = imageFile.match(/image_(\d+)\.jpg/);
+      const imageIndex = imageMatch ? parseInt(imageMatch[1]) : 1;
+      const remoteUrl = `https://huggingface.co/datasets/Fraser/piclets/resolve/main/${imagePath}`;
+      
+      // Check if this path already exists to avoid duplicates
+      const existing = await db.trainerScanProgress.get(imagePath);
+      
+      if (!existing) {
+        const progressRecord: Omit<TrainerScanProgress, 'id'> = {
+          imagePath,
+          trainerName,
+          imageIndex,
+          status: 'pending',
+          remoteUrl
+        };
+        
+        await db.trainerScanProgress.add(progressRecord);
+        processedCount++;
+      } else {
+        processedCount++;
+      }
+      
+      // Log progress every 500 items instead of every 100
+      if (i % 500 === 0 && i > 0) {
+        console.log(`Progress: ${i}/${imagePaths.length} (${Math.round((i/imagePaths.length)*100)}%)`);
+      }
+      
+    } catch (error) {
+      console.error(`❌ ERROR processing path ${i}: "${imagePath}"`, error);
+      if (error instanceof Error && error.message.includes('replace')) {
+        console.error('❌ REPLACE ERROR FOUND at path:', imagePath);
+        console.error('❌ Path parts:', imagePath.split('/'));
+        console.error('❌ Full error:', error);
+      }
+      skippedCount++;
     }
-    
-    console.log(`✅ Trainer scan initialization complete: ${processedCount} records processed, ${skippedCount} skipped`);
-    
-  } catch (error) {
-    console.error('❌ initializeTrainerScanProgress: Fatal error during initialization:', error);
-    console.error('❌ initializeTrainerScanProgress: Error details:', {
-      message: error instanceof Error ? error.message : 'Unknown error',
-      stack: error instanceof Error ? error.stack : 'No stack trace'
-    });
-    throw error;
   }
+  
+  console.log(`✅ Initialization complete: ${processedCount} processed, ${skippedCount} skipped`);
 }
 
 // Get next pending image to process
@@ -177,86 +139,75 @@ export async function getScanningStats(): Promise<{
   completed: number;
   failed: number;
 }> {
-  const tx = db.transaction([TRAINER_SCAN_STORE], 'readonly');
-  const store = tx.objectStore(TRAINER_SCAN_STORE);
-  
-  const stats = {
-    total: 0,
-    pending: 0,
-    processing: 0,
-    completed: 0,
-    failed: 0
-  };
-  
-  let cursor = await store.openCursor();
-  while (cursor) {
-    stats.total++;
-    const status = cursor.value.status;
-    stats[status]++;
-    cursor = await cursor.continue();
+  try {
+    const [total, pending, processing, completed, failed] = await Promise.all([
+      db.trainerScanProgress.count(),
+      db.trainerScanProgress.where('status').equals('pending').count(),
+      db.trainerScanProgress.where('status').equals('processing').count(),
+      db.trainerScanProgress.where('status').equals('completed').count(),
+      db.trainerScanProgress.where('status').equals('failed').count(),
+    ]);
+    
+    return {
+      total,
+      pending,
+      processing,
+      completed,
+      failed
+    };
+  } catch (error) {
+    console.error('❌ Failed to get scanning stats:', error);
+    return {
+      total: 0,
+      pending: 0,
+      processing: 0,
+      completed: 0,
+      failed: 0
+    };
   }
-  
-  return stats;
 }
 
 // Get all completed scans for a specific trainer
 export async function getCompletedScansForTrainer(trainerName: string): Promise<TrainerScanProgress[]> {
-  const tx = db.transaction([TRAINER_SCAN_STORE], 'readonly');
-  const store = tx.objectStore(TRAINER_SCAN_STORE);
-  
-  const results: TrainerScanProgress[] = [];
-  let cursor = await store.openCursor();
-  
-  while (cursor) {
-    const record = cursor.value;
-    if (record.trainerName === trainerName && record.status === 'completed') {
-      results.push(record);
-    }
-    cursor = await cursor.continue();
+  try {
+    return await db.trainerScanProgress
+      .where('trainerName').equals(trainerName)
+      .and(record => record.status === 'completed')
+      .toArray();
+  } catch (error) {
+    console.error(`❌ Failed to get completed scans for trainer ${trainerName}:`, error);
+    return [];
   }
-  
-  return results;
 }
 
 // Reset all failed scans back to pending (for retry)
 export async function resetFailedScans(): Promise<number> {
-  const tx = db.transaction([TRAINER_SCAN_STORE], 'readwrite');
-  const store = tx.objectStore(TRAINER_SCAN_STORE);
-  
-  let resetCount = 0;
-  let cursor = await store.openCursor();
-  
-  while (cursor) {
-    if (cursor.value.status === 'failed') {
-      const updated = {
-        ...cursor.value,
-        status: 'pending' as const,
+  try {
+    const failedRecords = await db.trainerScanProgress.where('status').equals('failed').toArray();
+    
+    for (const record of failedRecords) {
+      await db.trainerScanProgress.update(record.imagePath, {
+        status: 'pending',
         errorMessage: undefined,
         startedAt: undefined,
         completedAt: undefined
-      };
-      await cursor.update(updated);
-      resetCount++;
+      });
     }
-    cursor = await cursor.continue();
+    
+    return failedRecords.length;
+  } catch (error) {
+    console.error('❌ Failed to reset failed scans:', error);
+    return 0;
   }
-  
-  await tx.complete;
-  return resetCount;
 }
 
 // Get current processing status (for resuming interrupted sessions)
 export async function getCurrentProcessingImage(): Promise<TrainerScanProgress | null> {
-  const tx = db.transaction([TRAINER_SCAN_STORE], 'readonly');
-  const store = tx.objectStore(TRAINER_SCAN_STORE);
-  
-  let cursor = await store.openCursor();
-  while (cursor) {
-    if (cursor.value.status === 'processing') {
-      return cursor.value;
-    }
-    cursor = await cursor.continue();
+  try {
+    const processingRecord = await db.trainerScanProgress.where('status').equals('processing').first();
+    return processingRecord || null;
+  } catch (error) {
+    console.error('❌ Failed to get current processing image:', error);
+    return null;
   }
-  
-  return null;
 }

src/lib/services/trainerScanService.ts

@@ -76,63 +76,30 @@ export class TrainerScanService {
   // Initialize scanning database with image paths from file
   async initializeFromFile(): Promise<void> {
     try {
-      console.log('🔍 TrainerScanService: Starting initializeFromFile...');
-      
       const response = await fetch('/trainer_image_paths.txt');
       if (!response.ok) {
         throw new Error(`Failed to fetch trainer_image_paths.txt: ${response.statusText}`);
       }
       
-      console.log('🔍 TrainerScanService: Successfully fetched trainer_image_paths.txt');
-      
       const content = await response.text();
       if (!content) {
         throw new Error('trainer_image_paths.txt is empty');
       }
       
-      console.log(`🔍 TrainerScanService: File content length: ${content.length}`);
-      console.log(`🔍 TrainerScanService: First 200 chars: ${content.substring(0, 200)}`);
-      
-      const lines = content.trim().split('\n');
-      console.log(`🔍 TrainerScanService: Split into ${lines.length} lines`);
-      
-      const imagePaths = lines
-        .map((path, index) => {
-          console.log(`🔍 TrainerScanService: Processing line ${index}: "${path}" (type: ${typeof path})`);
-          if (typeof path !== 'string') {
-            console.warn(`🔍 TrainerScanService: Line ${index} is not a string:`, path);
-            return '';
-          }
-          const trimmed = path.trim();
-          console.log(`🔍 TrainerScanService: Line ${index} trimmed: "${trimmed}"`);
-          return trimmed;
-        })
-        .filter((path, index) => {
-          const isValid = path.length > 0;
-          console.log(`🔍 TrainerScanService: Line ${index} valid: ${isValid}`);
-          return isValid;
-        });
+      const imagePaths = content.trim().split('\n')
+        .map(path => typeof path === 'string' ? path.trim() : '')
+        .filter(path => path.length > 0);
       
-      console.log(`🔍 TrainerScanService: Loaded ${imagePaths.length} trainer image paths`);
-      console.log(`🔍 TrainerScanService: First 5 paths:`, imagePaths.slice(0, 5));
+      console.log(`Loaded ${imagePaths.length} trainer image paths`);
       
       if (imagePaths.length === 0) {
         throw new Error('No valid image paths found in trainer_image_paths.txt');
       }
       
-      console.log('🔍 TrainerScanService: About to call initializeTrainerScanProgress...');
       await initializeTrainerScanProgress(imagePaths);
-      console.log('🔍 TrainerScanService: initializeTrainerScanProgress completed successfully');
-      
-      console.log('🔍 TrainerScanService: About to get current state...');
-      const currentState = await this.getCurrentState();
-      console.log('🔍 TrainerScanService: Got current state:', currentState);
-      
-      this.notifyStateChange(currentState);
-      console.log('🔍 TrainerScanService: initializeFromFile completed successfully');
+      this.notifyStateChange(await this.getCurrentState());
     } catch (error) {
-      console.error('❌ TrainerScanService: Failed to initialize trainer scan progress:', error);
-      console.error('❌ TrainerScanService: Error stack:', error instanceof Error ? error.stack : 'No stack trace');
+      console.error('Failed to initialize trainer scan progress:', error);
       throw new Error('Failed to load trainer image paths');
     }
   }