@arela/uploader 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arela/uploader",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "CLI to upload files/directories to Arela",
   "bin": {
     "arela": "./src/index.js"

package/src/index.js

@@ -17,7 +17,7 @@ config();
 const program = new Command();
 
 // Read package.json version at startup
-let packageVersion = '1.0.0'; // fallback
+let packageVersion = '0.2.4'; // fallback
 try {
   const __filename = new URL(import.meta.url).pathname;
   const __dirname = path.dirname(__filename);
@@ -158,8 +158,8 @@ const checkCredentials = async (forceSupabase = false) => {
     if (!supabaseUrl || !supabaseKey || !bucket) {
       console.error(
         '⚠️ Missing credentials. Please set either:\n' +
-          '   - ARELA_API_URL and ARELA_API_TOKEN for API mode, or\n' +
-          '   - SUPABASE_URL, SUPABASE_KEY, and SUPABASE_BUCKET for direct mode',
+        '   - ARELA_API_URL and ARELA_API_TOKEN for API mode, or\n' +
+        '   - SUPABASE_URL, SUPABASE_KEY, and SUPABASE_BUCKET for direct mode',
       );
       process.exit(1);
     }
@@ -774,6 +774,9 @@ const detectPedimentosInDatabase = async (options = {}) => {
   console.log(
     '🔍 Phase 2: Starting PDF detection for pedimento-simplificado documents...',
   );
+  writeLog(
+    '🔍 Phase 2: Starting PDF detection for pedimento-simplificado documents',
+  );
 
   const detectionService = new FileDetectionService();
   const processingBatchSize = parseInt(options.batchSize) || 10; // Smaller batches for file I/O
@@ -786,12 +789,16 @@ const detectPedimentosInDatabase = async (options = {}) => {
   let chunkNumber = 1;
 
   console.log('� Processing PDF files in chunks of 1000 records...');
+  writeLog('📝 Starting PDF detection processing in chunks of 1000 records');
 
   // Process records in chunks of 1000
   while (true) {
     console.log(
       `\n📥 Fetching chunk ${chunkNumber} (records ${offset + 1} to ${offset + queryBatchSize})...`,
     );
+    writeLog(
+      `📥 Fetching chunk ${chunkNumber} (records ${offset + 1} to ${offset + queryBatchSize})`,
+    );
 
     // Fetch next chunk of PDF records
     const { data: pdfRecords, error: queryError } = await supabase
@@ -811,12 +818,18 @@ const detectPedimentosInDatabase = async (options = {}) => {
     // If no records found, we're done
     if (!pdfRecords || pdfRecords.length === 0) {
       console.log(`📝 No more PDF files found. Processing completed.`);
+      writeLog(
+        `📝 No more PDF files found. Processing completed at chunk ${chunkNumber}`,
+      );
       break;
     }
 
     console.log(
       `� Processing chunk ${chunkNumber}: ${pdfRecords.length} PDF records`,
     );
+    writeLog(
+      `📊 Processing chunk ${chunkNumber}: ${pdfRecords.length} PDF records`,
+    );
 
     // Create progress bar for this chunk
     const progressBar = new cliProgress.SingleBar({
@@ -841,6 +854,9 @@ const detectPedimentosInDatabase = async (options = {}) => {
         try {
           // Check if file still exists
           if (!fs.existsSync(record.original_path)) {
+            writeLog(
+              `⚠️ FILE NOT FOUND: ${record.filename} at ${record.original_path}`,
+            );
             updatePromises.push(
               supabase
                 .from('uploader')
@@ -883,6 +899,13 @@ const detectPedimentosInDatabase = async (options = {}) => {
           if (detection.detectedType) {
             chunkDetected++;
             totalDetected++;
+            writeLog(
+              `✅ DETECTED: ${record.filename} -> ${detection.detectedType} | Pedimento: ${detection.detectedPedimento || 'N/A'} | RFC: ${detection.fields?.rfc || 'N/A'}`,
+            );
+          } else {
+            writeLog(
+              `⏭️ NOT DETECTED: ${record.filename} - No pedimento-simplificado pattern found`,
+            );
           }
 
           updatePromises.push(
@@ -893,6 +916,7 @@ const detectPedimentosInDatabase = async (options = {}) => {
             `❌ Error detecting ${record.filename}:`,
             error.message,
           );
+          writeLog(`❌ ERROR detecting ${record.filename}: ${error.message}`);
           chunkErrors++;
           totalErrors++;
 
@@ -930,6 +954,9 @@ const detectPedimentosInDatabase = async (options = {}) => {
     console.log(
       `✅ Chunk ${chunkNumber} completed: ${chunkDetected} detected, ${chunkProcessed} processed, ${chunkErrors} errors`,
     );
+    writeLog(
+      `✅ Chunk ${chunkNumber} completed: ${chunkDetected} detected, ${chunkProcessed} processed, ${chunkErrors} errors`,
+    );
 
     // Move to next chunk
     offset += queryBatchSize;
@@ -940,6 +967,9 @@ const detectPedimentosInDatabase = async (options = {}) => {
       console.log(
         `📝 Reached end of records (chunk had ${pdfRecords.length} records).`,
       );
+      writeLog(
+        `📝 Reached end of records (chunk had ${pdfRecords.length} records)`,
+      );
       break;
     }
 
@@ -950,6 +980,15 @@ const detectPedimentosInDatabase = async (options = {}) => {
   console.log(
     `📊 Phase 2 Summary: ${totalDetected} detected, ${totalProcessed} processed, ${totalErrors} errors`,
   );
+
+  // Write comprehensive log summary
+  writeLog(
+    `📊 PHASE 2 PDF DETECTION COMPLETED - Summary: Detected: ${totalDetected} pedimento-simplificado documents, Processed: ${totalProcessed} PDF files, Errors: ${totalErrors}`,
+  );
+
+  // Ensure logs are flushed
+  flushLogBuffer();
+
   return {
     detectedCount: totalDetected,
     processedCount: totalProcessed,
@@ -1186,6 +1225,37 @@ const processFilesInBatches = async (
             }
           });
 
+          // Update status to "file-uploaded" for successfully uploaded files
+          if (result.uploaded && result.uploaded.length > 0 && supabase) {
+            try {
+              const uploadedFilePaths = result.uploaded
+                .map((upload) => {
+                  const apiFile = apiFiles.find(
+                    (f) =>
+                      f.name === upload.originalName ||
+                      f.originalName === upload.originalName,
+                  );
+                  return apiFile ? apiFile.path : null;
+                })
+                .filter(Boolean);
+
+              if (uploadedFilePaths.length > 0) {
+                await supabase
+                  .from('uploader')
+                  .update({ status: 'file-uploaded' })
+                  .in('original_path', uploadedFilePaths);
+
+                console.log(
+                  `   📝 Updated status to "file-uploaded" for ${uploadedFilePaths.length} files`,
+                );
+              }
+            } catch (error) {
+              console.error(
+                `   ⚠️ Error updating status for uploaded files: ${error.message}`,
+              );
+            }
+          }
+
           result.errors.forEach((error) => {
             writeLog(
               `ERROR: ${error.fileName}: ${error.error} (${error.step})`,
@@ -1266,11 +1336,39 @@ const processFilesInBatches = async (
         if (processedPaths.has(uploadPath)) {
           totalSkipped++;
           writeLog(`SKIPPED: ${file} -> ${uploadPath}`);
+
+          // Update status to "file-uploaded" for skipped files (they already exist)
+          if (supabase) {
+            try {
+              await supabase
+                .from('uploader')
+                .update({ status: 'file-uploaded' })
+                .eq('original_path', file);
+            } catch (error) {
+              console.error(
+                `   ⚠️ Error updating status for skipped file: ${error.message}`,
+              );
+            }
+          }
         } else {
           await uploadToSupabase(file, uploadPath);
           totalUploaded++;
           writeLog(`SUCCESS: ${file} -> ${uploadPath}`);
           processedPaths.add(uploadPath);
+
+          // Update status to "file-uploaded" for successfully uploaded files
+          if (supabase) {
+            try {
+              await supabase
+                .from('uploader')
+                .update({ status: 'file-uploaded' })
+                .eq('original_path', file);
+            } catch (error) {
+              console.error(
+                `   ⚠️ Error updating status for uploaded file: ${error.message}`,
+              );
+            }
+          }
         }
       } catch (error) {
         totalErrors++;
@@ -1333,65 +1431,170 @@ const uploadFilesByRfc = async (options = {}) => {
   console.log(`📋 Target RFCs: ${uploadRfcs.join(', ')}`);
   console.log('🔍 Searching for files to upload...');
 
-  // Step 1: Get all records that match the specified RFCs and have arela_path
-  const { data: rfcRecords, error: rfcError } = await supabase
+  // First, count total files for the RFCs to show filtering effect
+  const { count: totalRfcFiles, error: countError } = await supabase
+    .from('uploader')
+    .select('*', { count: 'exact', head: true })
+    .in('rfc', uploadRfcs)
+    .not('arela_path', 'is', null);
+
+  if (countError) {
+    console.warn('⚠️ Could not count total RFC files:', countError.message);
+  } else {
+    console.log(`📊 Total files for specified RFCs: ${totalRfcFiles || 0}`);
+  }
+
+  // Step 1: Get all pedimento_simplificado records that match the specified RFCs and have arela_path
+  console.log(
+    '🎯 Finding pedimento_simplificado records for specified RFCs...',
+  );
+  const { data: pedimentoRfcRecords, error: pedimentoRfcError } = await supabase
     .from('uploader')
     .select('arela_path')
+    .eq('document_type', 'pedimento_simplificado')
     .in('rfc', uploadRfcs)
     .not('arela_path', 'is', null);
 
-  if (rfcError) {
-    console.error('❌ Error fetching RFC records:', rfcError.message);
+  if (pedimentoRfcError) {
+    console.error(
+      '❌ Error fetching pedimento RFC records:',
+      pedimentoRfcError.message,
+    );
     return { processedCount: 0, uploadedCount: 0, errorCount: 1 };
   }
 
-  if (!rfcRecords || rfcRecords.length === 0) {
-    console.log('ℹ️  No files found for the specified RFCs with arela_path');
+  if (!pedimentoRfcRecords || pedimentoRfcRecords.length === 0) {
     console.log(
-      `   Make sure files for RFCs [${uploadRfcs.join(', ')}] have been processed and have arela_path values`,
+      'ℹ️  No pedimento_simplificado records found for the specified RFCs with arela_path',
     );
     return { processedCount: 0, uploadedCount: 0, errorCount: 0 };
   }
 
-  // Step 2: Get unique arela_paths from the RFC matches
-  const uniqueArelaPaths = [...new Set(rfcRecords.map((r) => r.arela_path))];
+  // Get unique arela_paths from pedimento records
+  const uniqueArelaPaths = [
+    ...new Set(pedimentoRfcRecords.map((r) => r.arela_path)),
+  ];
   console.log(
-    `� Found ${uniqueArelaPaths.length} unique arela_path(s) for the specified RFCs`,
+    `📋 Found ${pedimentoRfcRecords.length} pedimento records with ${uniqueArelaPaths.length} unique arela_paths for specified RFCs`,
   );
 
-  // Step 3: Get ALL files that have these arela_paths (including supporting documents)
-  // Use pagination to ensure we get all files, regardless of count
-  let allRelatedFiles = [];
-  let hasMore = true;
-  let offset = 0;
-  const queryBatchSize = 1000;
+  // Step 2: Get all files with these arela_paths that haven't been uploaded yet
+  let rfcRecords = [];
+  const chunkSize = 50;
 
-  console.log('📥 Fetching all related files (with pagination)...');
+  for (let i = 0; i < uniqueArelaPaths.length; i += chunkSize) {
+    const pathChunk = uniqueArelaPaths.slice(i, i + chunkSize);
 
-  while (hasMore) {
-    const { data: batch, error: queryError } = await supabase
+    const { data: chunkFiles, error: chunkError } = await supabase
       .from('uploader')
-      .select('id, original_path, arela_path, filename, rfc, document_type')
-      .in('arela_path', uniqueArelaPaths)
-      .not('original_path', 'is', null)
-      .range(offset, offset + queryBatchSize - 1);
+      .select('arela_path')
+      .in('arela_path', pathChunk)
+      .neq('status', 'file-uploaded')
+      .not('arela_path', 'is', null);
 
-    if (queryError) {
-      console.error('❌ Error fetching related files:', queryError.message);
+    if (chunkError) {
+      console.error(
+        '❌ Error fetching files for arela_paths chunk:',
+        chunkError.message,
+      );
       return { processedCount: 0, uploadedCount: 0, errorCount: 1 };
     }
 
-    if (!batch || batch.length === 0) {
-      hasMore = false;
+    if (chunkFiles && chunkFiles.length > 0) {
+      rfcRecords = rfcRecords.concat(chunkFiles);
+    }
+  }
+
+  if (!rfcRecords || rfcRecords.length === 0) {
+    if (totalRfcFiles && totalRfcFiles > 0) {
+      console.log(
+        `ℹ️  All ${totalRfcFiles} files for the specified RFCs are already uploaded (status: file-uploaded)`,
+      );
+      console.log('   No new files to upload.');
     } else {
-      allRelatedFiles = allRelatedFiles.concat(batch);
-      offset += queryBatchSize;
+      console.log('ℹ️  No files found for the specified RFCs with arela_path');
+      console.log(
+        `   Make sure files for RFCs [${uploadRfcs.join(', ')}] have been processed and have arela_path values`,
+      );
+    }
+    return { processedCount: 0, uploadedCount: 0, errorCount: 0 };
+  }
+
+  // Show filtering effect
+  const uploadableArelaPaths = [
+    ...new Set(rfcRecords.map((r) => r.arela_path)),
+  ];
+  const skipped = (totalRfcFiles || 0) - rfcRecords.length;
+  if (skipped > 0) {
+    console.log(
+      `📊 Found ${rfcRecords.length} files ready for upload (${skipped} already uploaded, skipped)`,
+    );
+  } else {
+    console.log(`📊 Found ${rfcRecords.length} files ready for upload`);
+  }
+
+  console.log(
+    `🎯 Found ${uploadableArelaPaths.length} unique arela_path(s) with files ready for upload`,
+  );
 
-      // If we got less than queryBatchSize, we've reached the end
-      if (batch.length < queryBatchSize) {
+  // Step 3: Get ALL files that have these arela_paths (including supporting documents)
+  // Process arela_paths in smaller chunks to avoid URI length limits
+  let allRelatedFiles = [];
+  const arelaPathChunkSize = 50; // Process 50 arela_paths at a time to avoid URI limits
+  const queryBatchSize = 1000;
+
+  console.log(
+    '📥 Fetching all related files (processing arela_paths in chunks to avoid URI limits)...',
+  );
+
+  // Process arela_paths in chunks
+  for (let i = 0; i < uploadableArelaPaths.length; i += arelaPathChunkSize) {
+    const arelaPathChunk = uploadableArelaPaths.slice(
+      i,
+      i + arelaPathChunkSize,
+    );
+    console.log(
+      `   Processing arela_path chunk ${Math.floor(i / arelaPathChunkSize) + 1}/${Math.ceil(uploadableArelaPaths.length / arelaPathChunkSize)} (${arelaPathChunk.length} paths)`,
+    );
+
+    // For each chunk of arela_paths, use pagination to get all related files
+    let hasMore = true;
+    let offset = 0;
+
+    while (hasMore) {
+      const { data: batch, error: queryError } = await supabase
+        .from('uploader')
+        .select('id, original_path, arela_path, filename, rfc, document_type')
+        .in('arela_path', arelaPathChunk)
+        .not('original_path', 'is', null)
+        .neq('status', 'file-uploaded')
+        .range(offset, offset + queryBatchSize - 1);
+
+      if (queryError) {
+        console.error(
+          `❌ Error fetching related files for chunk ${Math.floor(i / arelaPathChunkSize) + 1}:`,
+          queryError.message,
+        );
+        return { processedCount: 0, uploadedCount: 0, errorCount: 1 };
+      }
+
+      if (!batch || batch.length === 0) {
         hasMore = false;
+      } else {
+        allRelatedFiles = allRelatedFiles.concat(batch);
+        offset += queryBatchSize;
+
+        // If we got less than queryBatchSize, we've reached the end for this chunk
+        if (batch.length < queryBatchSize) {
+          hasMore = false;
+        }
       }
     }
+
+    // Small delay between chunks to avoid overwhelming the database
+    if (i + arelaPathChunkSize < uploadableArelaPaths.length) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
   }
 
   if (!allRelatedFiles || allRelatedFiles.length === 0) {
@@ -1400,7 +1603,7 @@ const uploadFilesByRfc = async (options = {}) => {
   }
 
   console.log(
-    `📁 Found ${allRelatedFiles.length} total files to upload (including supporting documents)`,
+    `📁 Found ${allRelatedFiles.length} total files to upload (including supporting documents, excluding already uploaded)`,
   );
 
   // Group by RFC and arela_path for better organization
@@ -1560,8 +1763,8 @@ const uploadFilesByRfc = async (options = {}) => {
           // Set folder structure for this group - concatenate custom prefix with arela_path
           const folderStructure = options.folderStructure
             ? `${options.folderStructure}/${arelaPath}`
-                .replace(/\/+/g, '/')
-                .replace(/\/$/, '')
+              .replace(/\/+/g, '/')
+              .replace(/\/$/, '')
             : arelaPath;
           pathFormData.append('folderStructure', folderStructure);
           pathFormData.append('autoDetect', 'true');
@@ -1616,6 +1819,23 @@ const uploadFilesByRfc = async (options = {}) => {
                 `     📁 Files organized: ${result.stats.organizedCount}`,
               );
             }
+
+            // Update status to "file-uploaded" for successfully uploaded files
+            try {
+              const uploadedFilePaths = pathFiles.map((file) => file.path);
+              await supabase
+                .from('uploader')
+                .update({ status: 'file-uploaded' })
+                .in('original_path', uploadedFilePaths);
+
+              console.log(
+                `     📝 Updated status to "file-uploaded" for ${uploadedFilePaths.length} files`,
+              );
+            } catch (error) {
+              console.error(
+                `     ⚠️ Error updating status for uploaded files: ${error.message}`,
+              );
+            }
           } else {
             console.error(`     ❌ Upload failed for ${folderStructure}:`);
             if (result.errors && result.errors.length > 0) {
@@ -1626,6 +1846,42 @@ const uploadFilesByRfc = async (options = {}) => {
             totalErrors += pathFiles.length;
           }
 
+          // Handle files that already exist (usually indicated in result.uploaded or result.skipped)
+          if (result.uploaded && result.uploaded.length > 0) {
+            try {
+              const alreadyUploadedPaths = result.uploaded
+                .filter(
+                  (upload) =>
+                    upload.status === 'already_exists' || upload.alreadyExists,
+                )
+                .map((upload) => {
+                  // Find the corresponding file path from pathFiles
+                  const matchingFile = pathFiles.find(
+                    (f) =>
+                      f.name === upload.fileName ||
+                      f.name === upload.originalName,
+                  );
+                  return matchingFile ? matchingFile.path : null;
+                })
+                .filter(Boolean);
+
+              if (alreadyUploadedPaths.length > 0) {
+                await supabase
+                  .from('uploader')
+                  .update({ status: 'file-uploaded' })
+                  .in('original_path', alreadyUploadedPaths);
+
+                console.log(
+                  `     📝 Updated status to "file-uploaded" for ${alreadyUploadedPaths.length} already existing files`,
+                );
+              }
+            } catch (error) {
+              console.error(
+                `     ⚠️ Error updating status for already existing files: ${error.message}`,
+              );
+            }
+          }
+
           // Small delay between path groups
           await new Promise((resolve) => setTimeout(resolve, 100));
         }
@@ -1675,6 +1931,7 @@ const propagateArelaPath = async (options = {}) => {
   }
 
   console.log('🔍 Finding pedimento_simplificado records with arela_path...');
+  writeLog('🔍 Starting arela_path propagation process');
 
   // Get all pedimento_simplificado records that have arela_path
   const { data: pedimentoRecords, error: pedimentoError } = await supabase
@@ -1693,12 +1950,16 @@ const propagateArelaPath = async (options = {}) => {
 
   if (!pedimentoRecords || pedimentoRecords.length === 0) {
     console.log('ℹ️  No pedimento_simplificado records with arela_path found');
+    writeLog('ℹ️  No pedimento_simplificado records with arela_path found');
     return { processedCount: 0, updatedCount: 0, errorCount: 0 };
   }
 
   console.log(
     `📋 Found ${pedimentoRecords.length} pedimento records with arela_path`,
   );
+  writeLog(
+    `📋 Found ${pedimentoRecords.length} pedimento records with arela_path to process`,
+  );
 
   let totalProcessed = 0;
   let totalUpdated = 0;
@@ -1730,6 +1991,9 @@ const propagateArelaPath = async (options = {}) => {
 
       console.log(`\n🔍 Processing: ${pedimento.filename}`);
       console.log(`   📁 Base path: ${basePath}`);
+      writeLog(
+        `🔍 Processing pedimento: ${pedimento.filename} | Base path: ${basePath}`,
+      );
 
       // Extract folder part from existing arela_path by removing the filename
       const existingPath = pedimento.arela_path;
@@ -1761,12 +2025,16 @@ const propagateArelaPath = async (options = {}) => {
 
       if (!relatedFiles || relatedFiles.length === 0) {
         console.log(`   ℹ️  No related files found needing arela_path update`);
+        writeLog(`ℹ️  No related files found for ${pedimento.filename}`);
         continue;
       }
 
       console.log(
         `   📄 Found ${relatedFiles.length} related files to update:`,
       );
+      writeLog(
+        `📄 Found ${relatedFiles.length} related files to update for ${pedimento.filename}`,
+      );
 
       // Show first 10 files, then indicate if there are more
       const filesToShow = relatedFiles.slice(0, 10);
@@ -1833,9 +2101,15 @@ const propagateArelaPath = async (options = {}) => {
         console.error(
           `❌ ${batchErrors} batch(es) failed for ${pedimento.filename}`,
         );
+        writeLog(
+          `❌ ${batchErrors} batch(es) failed for ${pedimento.filename}`,
+        );
         totalErrors++;
       } else {
         console.log(`   🎯 Successfully updated ${batchUpdated} related files`);
+        writeLog(
+          `✅ Successfully updated ${batchUpdated} related files for ${pedimento.filename} -> ${folderArelaPath}`,
+        );
         totalUpdated += batchUpdated;
       }
     } catch (error) {
@@ -1843,6 +2117,7 @@ const propagateArelaPath = async (options = {}) => {
         `❌ Error processing ${pedimento.filename}:`,
         error.message,
       );
+      writeLog(`❌ Error processing ${pedimento.filename}: ${error.message}`);
       totalErrors++;
     }
 
@@ -1866,6 +2141,14 @@ const propagateArelaPath = async (options = {}) => {
   console.log(`   ❌ Errors: ${totalErrors}`);
   console.log(`${'='.repeat(60)}\n`);
 
+  // Write comprehensive log summary
+  writeLog(
+    `🎯 ARELA PATH PROPAGATION COMPLETED - Summary: Processed: ${totalProcessed} pedimento records, Updated: ${totalUpdated} related files, Errors: ${totalErrors}`,
+  );
+
+  // Ensure logs are flushed
+  flushLogBuffer();
+
   return {
     processedCount: totalProcessed,
     updatedCount: totalUpdated,
@@ -1873,10 +2156,135 @@ const propagateArelaPath = async (options = {}) => {
   };
 };
 
+/**
+ * Helper function to query files that need to be uploaded
+ * These are files that have been detected but not yet uploaded
+ * Uses the same RFC filtering logic as uploadFilesByRfc for consistency
+ */
+const getFilesReadyForUpload = async (options = {}) => {
+  if (!supabase) {
+    throw new Error('Supabase client not initialized');
+  }
+
+  console.log('🔍 Querying files ready for upload...');
+
+  // Check if UPLOAD_RFCS is configured
+  if (!uploadRfcs || uploadRfcs.length === 0) {
+    console.log(
+      'ℹ️  No UPLOAD_RFCS configured. Please set UPLOAD_RFCS environment variable to see files ready for upload.',
+    );
+    console.log(
+      '   Example: UPLOAD_RFCS="RFC123456789|RFC987654321|RFC555444333"',
+    );
+    return [];
+  }
+
+  console.log(`🎯 Using RFC filter: ${uploadRfcs.join(', ')}`);
+
+  // Step 1: Find pedimento_simplificado documents for the specified RFCs that have arela_path
+  console.log(
+    '🎯 Finding pedimento_simplificado documents for specified RFCs with arela_path...',
+  );
+  const { data: pedimentoRecords, error: pedimentoError } = await supabase
+    .from('uploader')
+    .select('arela_path')
+    .eq('document_type', 'pedimento_simplificado')
+    .in('rfc', uploadRfcs)
+    .not('arela_path', 'is', null);
+
+  if (pedimentoError) {
+    throw new Error(
+      `Error querying pedimento_simplificado records: ${pedimentoError.message}`,
+    );
+  }
+
+  if (!pedimentoRecords || pedimentoRecords.length === 0) {
+    console.log('ℹ️  No pedimento_simplificado records with arela_path found');
+    return [];
+  }
+
+  // Get unique arela_paths
+  const uniqueArelaPaths = [
+    ...new Set(pedimentoRecords.map((r) => r.arela_path)),
+  ];
+  console.log(
+    `📋 Found ${pedimentoRecords.length} pedimento records with ${uniqueArelaPaths.length} unique arela_paths`,
+  );
+
+  // Step 2: Find all related files with these arela_paths that haven't been uploaded yet
+  console.log('🔍 Finding all related files that need to be uploaded...');
+
+  // Process arela_paths in chunks to avoid URI length limits
+  let allReadyFiles = [];
+  const chunkSize = 50;
+
+  for (let i = 0; i < uniqueArelaPaths.length; i += chunkSize) {
+    const pathChunk = uniqueArelaPaths.slice(i, i + chunkSize);
+
+    const { data: chunkFiles, error: chunkError } = await supabase
+      .from('uploader')
+      .select(
+        'id, original_path, arela_path, filename, rfc, document_type, status',
+      )
+      .in('arela_path', pathChunk)
+      .neq('status', 'file-uploaded')
+      .not('original_path', 'is', null);
+
+    if (chunkError) {
+      throw new Error(
+        `Error querying files for arela_paths chunk: ${chunkError.message}`,
+      );
+    }
+
+    if (chunkFiles && chunkFiles.length > 0) {
+      allReadyFiles = allReadyFiles.concat(chunkFiles);
+    }
+  }
+
+  const readyFiles = allReadyFiles;
+
+  console.log(`📋 Found ${readyFiles?.length || 0} files ready for upload`);
+
+  if (readyFiles && readyFiles.length > 0) {
+    // Group by document type for summary
+    const byDocType = readyFiles.reduce((acc, file) => {
+      const docType = file.document_type || 'Unknown';
+      acc[docType] = (acc[docType] || 0) + 1;
+      return acc;
+    }, {});
+
+    console.log('📊 Files by document type:');
+    for (const [docType, count] of Object.entries(byDocType)) {
+      console.log(`   ${docType}: ${count} files`);
+    }
+
+    // Group by RFC
+    const byRfc = readyFiles.reduce((acc, file) => {
+      const rfc = file.rfc || 'No RFC';
+      acc[rfc] = (acc[rfc] || 0) + 1;
+      return acc;
+    }, {});
+
+    console.log('📊 Files by RFC:');
+    for (const [rfc, count] of Object.entries(byRfc)) {
+      console.log(`   ${rfc}: ${count} files`);
+    }
+  }
+
+  return readyFiles || [];
+};
+
 program
   .name('arela-uploader')
   .description(
-    'CLI to upload folders to Arela API or Supabase Storage with automatic processing',
+    'CLI to upload folders to Arela API or Supabase Storage with automatic processing\n\n' +
+    'Status workflow:\n' +
+    '  fs-stats → detected → file-uploaded\n' +
+    '  ├─ Phase 1: --stats-only (collects filesystem stats, status: fs-stats)\n' +
+    '  ├─ Phase 2: --detect-pdfs (detects document types, status: detected)\n' +
+    '  ├─ Phase 3: --propagate-arela-path (organizes files by pedimento)\n' +
+    '  └─ Phase 4: --upload-by-rfc (uploads files, status: file-uploaded)\n\n' +
+    'Use --query-ready-files to see files ready for upload (status: detected with arela_path)',
   )
   .option('-v, --version', 'output the version number')
   .option('-p, --prefix <prefix>', 'Prefix path in bucket', '')
@@ -1927,6 +2335,10 @@ program
     '--run-all-phases',
     'Run all 4 phases in sequence: stats → detect → propagate → upload',
   )
+  .option(
+    '--query-ready-files',
+    'Query and display files that are ready for upload (have been detected but not uploaded)',
+  )
   .action(async (options) => {
     if (options.version) {
       console.log(packageVersion);
@@ -1948,6 +2360,25 @@ program
       return;
     }
 
+    // Handle query-ready-files option
+    if (options.queryReadyFiles) {
+      await checkCredentials(true); // Force Supabase mode
+
+      const readyFiles = await getFilesReadyForUpload();
+
+      if (readyFiles.length === 0) {
+        console.log('ℹ️  No files are currently ready for upload');
+        console.log(
+          '   Tip: Run --detect-pdfs and --propagate-arela-path first to prepare files for upload',
+        );
+      } else {
+        console.log(`\n📋 ${readyFiles.length} files are ready for upload!`);
+        console.log('   Use --upload-by-rfc to upload them to Arela API');
+      }
+
+      return;
+    }
+
     // Handle run-all-phases option
     if (options.runAllPhases) {
       console.log('🚀 Starting all 4 phases in sequence...');