LOGS

.gitignore

@@ -31,3 +31,6 @@ trainer_captions*
 trainer_images
 trainer_piclets*
 trainer_personas.csv
+pokemon_stat_calculation.md
+POKEMON_STATS_AND_LEVELING.md
+*.py

battle_system_design.md

@@ -197,7 +197,6 @@ All battle effects are built from these atomic operations:
 ```json
 {
   "type": "counter",
-  "counterType": "physical" | "special" | "any",
   "strength": "weak" | "normal" | "strong"
 }
 ```
@@ -1627,9 +1626,8 @@ Types correspond to photographed objects in the real world:
         {
           "if": {"properties": {"type": {"const": "counter"}}},
           "then": {
-            "required": ["counterType", "strength"],
+            "required": ["strength"],
             "properties": {
-              "counterType": {"type": "string", "enum": ["physical", "special", "any"]},
               "strength": {"type": "string", "enum": ["weak", "normal", "strong"]}
             }
           }

src/lib/db/trainerScanning.ts

@@ -1,68 +1,127 @@
 import { db } from './index';
 import type { TrainerScanProgress } from './schema';
 
-const TRAINER_SCAN_STORE = 'trainerScanProgress';
-
 // Initialize trainer scan progress records from paths
 export async function initializeTrainerScanProgress(imagePaths: string[]): Promise<void> {
-  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) {
-    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"
-      
-      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
-        };
+  try {
+    console.log('🔍 initializeTrainerScanProgress: Starting with', imagePaths.length, 'paths');
+    console.log('🔍 initializeTrainerScanProgress: First few paths:', imagePaths.slice(0, 3));
+    
+    console.log('🔍 initializeTrainerScanProgress: Creating transaction...');
+    const tx = db.transaction([TRAINER_SCAN_STORE], 'readwrite');
+    console.log('🔍 initializeTrainerScanProgress: Transaction created');
+    
+    const store = tx.objectStore(TRAINER_SCAN_STORE);
+    console.log('🔍 initializeTrainerScanProgress: Got object store');
+    
+    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;
+        }
         
-        await store.add(progressRecord);
-        processedCount++;
-      } else {
-        // Record exists, don't count as processed but note it
-        processedCount++;
+        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
+        console.log(`🔍 initializeTrainerScanProgress: Checking for existing record...`);
+        const existing = await store.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 store.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
+        });
+        skippedCount++;
+        // Continue processing other paths despite this failure
       }
-    } 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`);
+    
+    console.log('🔍 initializeTrainerScanProgress: Completing transaction...');
+    await tx.complete;
+    console.log('🔍 initializeTrainerScanProgress: Transaction completed successfully');
+    
+  } 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(`✅ Trainer scan initialization complete: ${processedCount} records processed, ${skippedCount} skipped`);
-  
-  await tx.complete;
 }
 
 // Get next pending image to process

src/lib/services/trainerScanService.ts

@@ -76,29 +76,63 @@ 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');
       }
       
-      const imagePaths = content.trim().split('\n')
-        .map(path => typeof path === 'string' ? path.trim() : '')
-        .filter(path => path.length > 0);
-      console.log(`Loaded ${imagePaths.length} trainer image paths`);
+      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;
+        });
+      
+      console.log(`🔍 TrainerScanService: Loaded ${imagePaths.length} trainer image paths`);
+      console.log(`🔍 TrainerScanService: First 5 paths:`, imagePaths.slice(0, 5));
       
       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);
-      this.notifyStateChange(await this.getCurrentState());
+      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');
     } catch (error) {
-      console.error('Failed to initialize trainer scan progress:', error);
+      console.error('❌ TrainerScanService: Failed to initialize trainer scan progress:', error);
+      console.error('❌ TrainerScanService: Error stack:', error instanceof Error ? error.stack : 'No stack trace');
       throw new Error('Failed to load trainer image paths');
     }
   }