fixes

src/lib/db/trainerScanning.ts

@@ -8,43 +8,60 @@ export async function initializeTrainerScanProgress(imagePaths: string[]): Promi
   const tx = db.transaction([TRAINER_SCAN_STORE], 'readwrite');
   const store = tx.objectStore(TRAINER_SCAN_STORE);
   
+  let processedCount = 0;
+  let skippedCount = 0;
+  
   for (const imagePath of imagePaths) {
-    // 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}`);
-      continue;
-    }
-    
-    const trainerName = pathParts[1]; // "001_Willow_Snap"
-    const imageFile = pathParts[2]; // "image_001.jpg"
-    
-    if (!trainerName || !imageFile) {
-      console.warn(`Skipping path with missing parts: ${imagePath}`);
-      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
-    const existing = await store.get(imagePath);
-    if (!existing) {
-      const progressRecord: Omit<TrainerScanProgress, 'id'> = {
-        imagePath,
-        trainerName,
-        imageIndex,
-        status: 'pending',
-        remoteUrl
-      };
+    try {
+      // 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;
+      }
+      
+      const trainerName = pathParts[1]?.trim(); // "001_Willow_Snap"
+      const imageFile = pathParts[2]?.trim(); // "image_001.jpg"
       
-      await store.add(progressRecord);
+      if (!trainerName || !imageFile || typeof trainerName !== 'string' || typeof imageFile !== 'string') {
+        console.warn(`⚠️ Skipping path with missing or invalid parts: ${imagePath}`, { trainerName, imageFile });
+        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 store.get(imagePath);
+      if (!existing) {
+        const progressRecord: Omit<TrainerScanProgress, 'id'> = {
+          imagePath,
+          trainerName,
+          imageIndex,
+          status: 'pending',
+          remoteUrl
+        };
+        
+        await store.add(progressRecord);
+        processedCount++;
+      } else {
+        // Record exists, don't count as processed but note it
+        processedCount++;
+      }
+    } catch (error) {
+      console.error(`❌ Failed to process path entry: ${imagePath}`, error);
+      skippedCount++;
+      // Continue processing other paths despite this failure
     }
   }
   
+  console.log(`✅ Trainer scan initialization complete: ${processedCount} records processed, ${skippedCount} skipped`);
+  
   await tx.complete;
 }
 

src/lib/services/trainerScanService.ts

@@ -134,6 +134,16 @@ export class TrainerScanService {
     } finally {
       this.isScanning = false;
       this.notifyStateChange({ isScanning: false, currentImage: null, currentTrainer: null });
+      
+      // Log final summary
+      const finalStats = await getScanningStats();
+      console.log(`🏁 Scanning session complete:`, {
+        total: finalStats.total,
+        completed: finalStats.completed,
+        failed: finalStats.failed,
+        pending: finalStats.pending,
+        successRate: finalStats.total > 0 ? Math.round((finalStats.completed / finalStats.total) * 100) + '%' : '0%'
+      });
     }
   }
   
@@ -154,19 +164,28 @@ export class TrainerScanService {
       
       this.notifyStateChange({ 
         currentImage: nextImage.imagePath,
-        currentTrainer: nextImage.trainerName
+        currentTrainer: typeof nextImage.trainerName === 'string' ? nextImage.trainerName : null
       });
       
       try {
         await this.processImage(nextImage.imagePath, nextImage.remoteUrl);
+        console.log(`✅ Successfully processed: ${nextImage.imagePath} (${nextImage.trainerName})`);
         // Add small delay between images to prevent overwhelming the system
         await new Promise(resolve => setTimeout(resolve, 1000));
       } catch (error) {
-        console.error(`Failed to process ${nextImage.imagePath}:`, error);
-        await markImageProcessingFailed(
-          nextImage.imagePath, 
-          error instanceof Error ? error.message : 'Unknown error'
-        );
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`❌ Failed to process ${nextImage.imagePath} (${nextImage.trainerName}):`, {
+          imagePath: nextImage.imagePath,
+          trainerName: nextImage.trainerName,
+          remoteUrl: nextImage.remoteUrl,
+          error: errorMessage,
+          fullError: error
+        });
+        
+        await markImageProcessingFailed(nextImage.imagePath, errorMessage);
+        
+        // Continue to next image - don't let individual failures stop the whole process
+        console.log(`🔄 Continuing to next image despite failure...`);
       }
       
       // Update progress
@@ -179,27 +198,35 @@ export class TrainerScanService {
     await markImageProcessingStarted(imagePath);
     
     try {
+      console.log(`🔄 Processing ${imagePath}: Fetching remote image...`);
       // Fetch remote image
       const imageFile = await this.fetchRemoteImage(remoteUrl, imagePath);
       
+      console.log(`🔄 Processing ${imagePath}: Captioning image...`);
       // Caption the image
       const imageCaption = await this.captionImage(imageFile);
       
+      console.log(`🔄 Processing ${imagePath}: Generating concept...`);
       // Generate monster concept
       const picletConcept = await this.generatePicletConcept(imageCaption);
       
+      console.log(`🔄 Processing ${imagePath}: Generating stats...`);
       // Generate stats
       const picletStats = await this.generatePicletStats(picletConcept);
       
+      console.log(`🔄 Processing ${imagePath}: Generating image prompt...`);
       // Generate image prompt
       const imagePrompt = await this.generateImagePrompt(picletConcept);
       
+      console.log(`🔄 Processing ${imagePath}: Generating monster image...`);
       // Generate monster image
       const picletImageUrl = await this.generateMonsterImage(imagePrompt);
       
+      console.log(`🔄 Processing ${imagePath}: Processing generated image...`);
       // Process generated image (remove background)
       const imageData = await this.processGeneratedImage(picletImageUrl);
       
+      console.log(`🔄 Processing ${imagePath}: Creating piclet instance...`);
       // Create piclet instance
       const generatedData = {
         name: this.extractNameFromConcept(picletConcept),
@@ -218,7 +245,10 @@ export class TrainerScanService {
       await markImageProcessingCompleted(imagePath, savedId);
       
     } catch (error) {
-      throw error; // Re-throw to be caught by processingLoop
+      // Add context about which step failed
+      const enhancedError = new Error(`Failed during processing of ${imagePath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      enhancedError.cause = error;
+      throw enhancedError;
     }
   }