@arela/uploader 0.2.12 → 0.3.0

package/.env.template

@@ -63,6 +63,72 @@ MAX_CONCURRENT_SOURCES=2
 # MAX_CONCURRENT_SOURCES=1
 # BATCH_DELAY=100
 
+# =============================================================================
+# WATCH MODE CONFIGURATION
+# =============================================================================
+
+# Habilitar watch mode (true/false)
+WATCH_ENABLED=false
+
+# Configuración de directorios a observar (formato JSON)
+# Cada directorio puede tener su propia folderStructure para organizar en el bucket
+# Formato: {"ruta/directorio1":"estructura-1","ruta/directorio2":"estructura-2"}
+# 
+# IMPORTANTE: El folderStructure se usa en el comando:
+# upload --upload-by-rfc --folder-structure <estructura>
+# 
+# Ejemplo:
+WATCH_DIRECTORY_CONFIGS={"../../Documents/2022":"estructura-2022","../../Documents/2023":"estructura-2023"}
+
+# DEPRECATED: Configuración antigua (se mantiene para compatibilidad hacia atrás)
+# WATCH_DIRECTORIES=/ruta/carpeta1,/ruta/carpeta2
+
+# Estrategia de upload (opciones: individual|batch|full-structure)
+# - individual: Sube solo el archivo modificado más reciente
+# - batch: Sube un lote de N archivos recientes
+# - full-structure: Sube la estructura completa de carpetas
+WATCH_STRATEGY=batch
+
+# Debouncing en milisegundos (esperar entre eventos antes de procesar)
+WATCH_DEBOUNCE_MS=1000
+
+# Tamaño de batch para strategy batch
+WATCH_BATCH_SIZE=10
+
+# Usar polling en lugar de eventos nativos del filesystem
+# Útil para sistemas de archivos remotos o NFS
+WATCH_USE_POLLING=false
+
+# Interval de polling en milisegundos (solo si WATCH_USE_POLLING=true)
+WATCH_POLL_INTERVAL=100
+
+# Umbral de estabilidad en ms (esperar a que el archivo deje de cambiar)
+WATCH_STABILITY_THRESHOLD=300
+
+# Patrones a ignorar (separados por coma, se usan como regex)
+WATCH_IGNORE_PATTERNS=*.tmp,*.bak,*.swp
+
+# Detección automática de tipos de documento
+WATCH_AUTO_DETECT=false
+
+# Organización automática de archivos
+WATCH_AUTO_ORGANIZE=false
+
+# =============================================================================
+# WATCH MODE - AUTOMATIC PROCESSING PIPELINE
+# =============================================================================
+# 
+# El pipeline automático ejecuta la siguiente secuencia cuando se detecta un archivo nuevo:
+# 1. Stats Collection   → stats --stats-only (recopila información del archivo)
+# 2. PDF Detection      → detect --detect-pdfs (identifica pedimentos simplificados)
+# 3. Path Propagation   → detect --propagate-arela-path (propaga a documentos relacionados)
+# 4. RFC Upload         → upload --upload-by-rfc --folder-structure (sube con estructura)
+#
+# El pipeline se habilita automáticamente en watch mode y usa la folderStructure
+# definida para cada WATCH_DIRECTORY_CONFIGS
+#
+# Para deshabilitar en CLI, usa: arela watch --no-auto-processing
+
 # =============================================================================
 # LOGGING AND MONITORING
 # =============================================================================

package/.vscode/settings.json

@@ -0,0 +1 @@
+{}

package/README.md

@@ -84,6 +84,12 @@ arela --upload-by-rfc        # Phase 4: Upload by RFC
 - 📋 **Upload files by specific RFC values**
 - 🔍 **Propagate arela_path from pedimento documents to related files**
 - ⚡ **4-Phase optimized workflow for maximum performance**
+- 👁️ **Watch Mode** ⭐ NEW - Monitor directories for changes and upload automatically
+  - Multiple watch strategies (batch, individual, full-structure)
+  - Debounce and polling support
+  - Auto-processing pipeline
+  - Dry-run mode for testing
+  - Pattern-based file ignoring
 
 ## Installation
 
@@ -97,78 +103,125 @@ npm install -g @arela/uploader
 
 ```bash
 # Run all phases automatically (most efficient)
-arela --run-all-phases --batch-size 20
+arela upload --run-all-phases --batch-size 20
 
 # Or run phases individually for fine-grained control
-arela --stats-only                    # Phase 1: Filesystem stats only
-arela --detect-pdfs --batch-size 10   # Phase 2: PDF detection
-arela --propagate-arela-path          # Phase 3: Path propagation
-arela --upload-by-rfc --batch-size 5  # Phase 4: RFC-based upload
+arela stats                           # Phase 1: Filesystem stats only
+arela detect                          # Phase 2: PDF detection
+arela detect --propagate-arela-path   # Phase 3: Path propagation
+arela upload --upload-by-rfc          # Phase 4: RFC-based upload
 ```
 
-### Traditional Single-Phase Upload (Legacy)
+### Available Commands
 
-#### Basic Upload with Auto-Processing (API Mode)
+#### 1. **upload** - Upload files to Arela
 ```bash
-arela --batch-size 10 -c 5
-```
+# Basic upload with auto-processing (API Mode)
+arela upload --batch-size 10
 
-### Upload with Auto-Detection of Year/Pedimento
-```bash
-arela --auto-detect-structure --batch-size 10 -c 5
-```
+# Upload with auto-detection of year/pedimento from file paths
+arela upload --auto-detect-structure --batch-size 10
 
-### Upload with Custom Folder Structure
-```bash
-arela --folder-structure "2024/4023260" --batch-size 10 -c 5
+# Upload with custom folder structure
+arela upload --folder-structure "2024/4023260" --batch-size 10
+
+# Upload to Supabase directly (skip API)
+arela upload --force-supabase --prefix "my-folder"
+
+# Upload files by specific RFC values
+arela upload --upload-by-rfc --batch-size 5
+
+# Upload RFC files with custom folder prefix
+arela upload --upload-by-rfc --folder-structure "palco" --batch-size 5
+
+# Upload RFC files with nested folder structure
+arela upload --upload-by-rfc --folder-structure "2024/Q1/processed" --batch-size 15
+
+# Upload with performance statistics
+arela upload --batch-size 10 --show-stats
+
+# Upload with client path tracking
+arela upload --client-path "/client/documents" --batch-size 10
 ```
 
-### Upload with Directory Structure Preservation
+#### 2. **stats** - Collect file statistics without uploading
 ```bash
-arela --batch-size 10 -c 5 --preserve-structure
+# Collect filesystem statistics only (Phase 1)
+arela stats --batch-size 10
+
+# Stats with custom folder organization
+arela stats --folder-structure "2023/3019796" --batch-size 10
+
+# Stats with client path tracking
+arela stats --client-path "/client/documents" --batch-size 10
 ```
 
-### Upload to Supabase Directly (Skip API)
+#### 3. **detect** - Run document detection and path propagation
 ```bash
-arela --force-supabase -p "my-folder"
+# Run PDF detection on existing database records (Phase 2)
+arela detect --batch-size 10
+
+# Propagate arela_path from pedimento records to related files (Phase 3)
+arela detect --propagate-arela-path
 ```
 
-### Upload Files by Specific RFC Values
+#### 4. **watch** - Monitor directories and upload automatically ⭐ NEW
 ```bash
-# Upload all files associated with specific RFCs
-arela --upload-by-rfc --batch-size 5
+# Watch directories for changes with automatic upload
+arela watch --directories "/path/to/watch1,/path/to/watch2"
 
-# Upload RFC files with custom folder prefix
-arela --upload-by-rfc --folder-structure "palco" --batch-size 5
+# Watch with custom upload strategy (default: batch)
+arela watch --directories "/path/to/watch" --strategy individual
+arela watch --directories "/path/to/watch" --strategy full-structure
 
-# Upload RFC files with nested folder structure
-arela --upload-by-rfc --folder-structure "2024/client1/pedimentos" --batch-size 5
-```
+# Watch with custom debounce delay (default: 1000ms)
+arela watch --directories "/path/to/watch" --debounce 2000
 
-### Propagate Arela Path from Pedimentos to Related Files
-```bash
-# Copy arela_path from pedimento_simplificado records to related files
-arela --propagate-arela-path
+# Watch with automatic 4-step pipeline
+arela watch --directories "/path/to/watch" --auto-processing --batch-size 10
+
+# Watch with polling instead of native file system events
+arela watch --directories "/path/to/watch" --poll 5000
+
+# Watch with pattern ignoring
+arela watch --directories "/path/to/watch" --ignore "node_modules,*.log,*.tmp"
+
+# Watch in dry-run mode (simulate without uploading)
+arela watch --directories "/path/to/watch" --dry-run
+
+# Watch with verbose logging
+arela watch --directories "/path/to/watch" --verbose
 ```
 
-### Stats-Only Mode (No Upload)
+**Watch Strategies:**
+- `batch` **(default)**: Groups files and uploads periodically
+- `individual`: Uploads each file immediately as it changes
+- `full-structure`: Preserves directory structure during upload
+
+#### 5. **query** - Query database for file status
 ```bash
-# Only process file stats and insert to database, don't upload
-arela --stats-only --folder-structure "2023/3019796"
+# Show files ready for upload
+arela query --ready-files
 ```
 
-### Upload with Performance Statistics
+#### 6. **config** - Show current configuration
 ```bash
-arela --batch-size 10 -c 5 --show-stats
+# Display all configuration settings
+arela config
 ```
 
-### Upload with Client Path Tracking
+### Legacy Syntax (Still Supported)
+
+The old flag-based syntax is still supported for backward compatibility:
+
 ```bash
-arela --client-path "/client/documents" --batch-size 10 -c 5
+# These are equivalent to the commands above
+arela --stats-only                    # Same as: arela stats
+arela --detect-pdfs                   # Same as: arela detect
+arela --propagate-arela-path          # Same as: arela detect --propagate-arela-path
+arela --upload-by-rfc                 # Same as: arela upload --upload-by-rfc
 ```
 
-### Options
-
 #### Phase Control
 - `--stats-only`: **Phase 1** - Only collect filesystem stats (no file reading)
 - `--detect-pdfs`: **Phase 2** - Process PDF files for pedimento-simplificado detection
@@ -176,26 +229,49 @@ arela --client-path "/client/documents" --batch-size 10 -c 5
 - `--upload-by-rfc`: **Phase 4** - Upload files based on RFC values from UPLOAD_RFCS
 - `--run-all-phases`: **All Phases** - Run complete optimized workflow
 
-#### Performance & Configuration
-- `-c, --concurrency <number>`: Files per batch for processing (default: 10)
-- `--batch-size <number>`: API batch size (default: 10)
-- `--show-stats`: Show detailed processing statistics
+#### Global Options (all commands)
+- `-v, --verbose`: Enable verbose logging
+- `--clear-log`: Clear the log file before starting
+- `-h, --help`: Display help information
+- `--version`: Display version number
 
-#### Upload Configuration
-- `-p, --prefix <prefix>`: Prefix path in bucket (default: "")
-- `-b, --bucket <bucket>`: Bucket name override
-- `--force-supabase`: Force direct Supabase upload (skip API)
-- `--no-auto-detect`: Disable automatic file detection (API mode only)
-- `--no-auto-organize`: Disable automatic file organization (API mode only)
-- `--preserve-structure`: **Preserve original directory structure when using auto-organize**
-- `--folder-structure <structure>`: **Custom folder structure** (e.g., "2024/4023260" or "cliente1/pedimentos")
-- `--auto-detect-structure`: **Automatically detect year/pedimento from file paths**
+#### Upload Command Options
+- `-b, --batch-size <size>`: API batch size (default: 10)
+- `--folder-structure <structure>`: Custom folder structure (e.g., "2024/4023260")
 - `--client-path <path>`: Client path for metadata tracking
+- `--auto-detect-structure`: Automatically detect year/pedimento from file paths
+- `--auto-detect`: Enable automatic document type detection
+- `--auto-organize`: Enable automatic file organization
+- `--force-supabase`: Force direct Supabase upload (skip API)
+- `--skip-processed`: Skip files already processed
+- `--show-stats`: Show performance statistics
+- `--upload-by-rfc`: Upload files based on RFC values from UPLOAD_RFCS
+- `--run-all-phases`: Run all processing phases sequentially
 
-#### Legacy Options
-- `--no-detect`: Disable document type detection in stats-only mode
-- `-v, --version`: Display version number
-- `-h, --help`: Display help information
+#### Stats Command Options
+- `-b, --batch-size <size>`: Batch size for processing (default: 10)
+- `--client-path <path>`: Client path for metadata tracking
+- `--show-stats`: Show performance statistics
+
+#### Detect Command Options
+- `-b, --batch-size <size>`: Batch size for PDF detection (default: 10)
+- `--propagate-arela-path`: Propagate arela_path from pedimento records to related files
+
+#### Watch Command Options
+- `-d, --directories <paths>`: **Comma-separated directories to watch** (required)
+- `-s, --strategy <strategy>`: Upload strategy (default: batch)
+  - `batch`: Groups files and uploads periodically
+  - `individual`: Uploads each file immediately
+  - `full-structure`: Preserves directory structure
+- `--debounce <ms>`: Debounce delay in milliseconds (default: 1000)
+- `-b, --batch-size <size>`: Batch size for uploads (default: 10)
+- `--poll <ms>`: Use polling instead of native file system events (interval in ms)
+- `--ignore <patterns>`: Comma-separated patterns to ignore
+- `--auto-detect`: Enable automatic document type detection
+- `--auto-organize`: Enable automatic file organization
+- `--auto-processing`: Enable automatic 4-step pipeline (stats, detect, propagate, upload)
+- `--dry-run`: Simulate changes without uploading
+- `--verbose`: Enable verbose logging
 
 ## Environment Variables
 

package/SUPABASE_UPLOAD_FIX.md

@@ -0,0 +1,157 @@
+# Supabase Upload Issue Fix
+
+## Problem Description
+
+When running the CLI with `upload --force-supabase`, the logs displayed that files were being uploaded successfully, but no files appeared in the Supabase bucket.
+
+## Root Cause
+
+The issue was in `/src/commands/UploadCommand.js` in the `#processFile` method. The code was **silently ignoring upload failures** from Supabase:
+
+```javascript
+// ❌ BEFORE - Upload result was ignored
+if (uploadService.getServiceName() === 'Arela API') {
+  result = await uploadService.upload([fileObject], { ...options, uploadPath });
+} else {
+  // Supabase direct upload
+  await uploadService.upload([fileObject], { uploadPath });
+  // Result ignored! No error checking!
+}
+
+logger.info(`SUCCESS: ${path.basename(filePath)} -> ${uploadPath}`);
+```
+
+Even if the Supabase upload failed and returned `{ success: false, error: "..." }`, the code would:
+1. Ignore the error
+2. Log "SUCCESS" 
+3. Continue processing
+
+This created the illusion that files were being uploaded when they weren't.
+
+## Changes Made
+
+### 1. Fixed Error Handling in `UploadCommand.js`
+
+**File:** `/src/commands/UploadCommand.js`
+
+Now properly captures and validates the Supabase upload result:
+
+```javascript
+// ✅ AFTER - Upload result is captured and validated
+if (uploadService.getServiceName() === 'Arela API') {
+  result = await uploadService.upload([fileObject], { ...options, uploadPath });
+} else {
+  // Supabase direct upload
+  const uploadResult = await uploadService.upload([fileObject], { uploadPath });
+  
+  // Check if upload was successful
+  if (!uploadResult.success) {
+    throw new Error(`Supabase upload failed: ${uploadResult.error}`);
+  }
+  
+  result = { successCount: 1 };
+}
+```
+
+### 2. Enhanced Logging in `SupabaseUploadService.js`
+
+**File:** `/src/services/upload/SupabaseUploadService.js`
+
+Added detailed logging to help diagnose upload issues:
+
+#### Connection Initialization
+```javascript
+console.log(`🔌 Connecting to Supabase: ${appConfig.supabase.url}`);
+console.log(`📦 Using bucket: ${this.bucket}`);
+console.log(`🧪 Testing bucket access...`);
+console.log(`✅ Successfully connected to Supabase bucket: ${this.bucket}`);
+```
+
+#### Upload Operations
+```javascript
+if (error) {
+  console.error(`❌ Supabase upload failed for ${normalizedPath}:`, error.message);
+  return { success: false, error: error.message };
+}
+
+console.log(`✅ Supabase upload successful: ${normalizedPath}`);
+```
+
+#### Better Error Messages
+```javascript
+if (!appConfig.supabase.url || !appConfig.supabase.key || !this.bucket) {
+  const missing = [];
+  if (!appConfig.supabase.url) missing.push('SUPABASE_URL');
+  if (!appConfig.supabase.key) missing.push('SUPABASE_KEY');
+  if (!this.bucket) missing.push('SUPABASE_BUCKET');
+  throw new Error(`Missing Supabase configuration: ${missing.join(', ')}`);
+}
+```
+
+## Expected Behavior After Fix
+
+### On Successful Upload
+```
+🔌 Connecting to Supabase: https://your-project.supabase.co
+📦 Using bucket: your-bucket-name
+🧪 Testing bucket access...
+✅ Successfully connected to Supabase bucket: your-bucket-name
+✅ Supabase upload successful: 2023/2000601/file.xml
+```
+
+### On Failed Upload
+```
+❌ Supabase upload failed for 2023/2000601/file.xml: [error details]
+Error: Supabase upload failed: [error details]
+```
+
+### On Configuration Error
+```
+Error: Missing Supabase configuration: SUPABASE_URL, SUPABASE_KEY
+```
+
+## Common Issues to Check
+
+If uploads still fail after this fix, check:
+
+1. **Environment Variables**
+   ```bash
+   echo $SUPABASE_URL
+   echo $SUPABASE_KEY  # Should be anon or service_role key
+   echo $SUPABASE_BUCKET
+   ```
+
+2. **Bucket Permissions**
+   - Check if the bucket exists in Supabase Storage
+   - Verify the API key has write permissions to the bucket
+   - Check bucket policies (public vs private)
+
+3. **Network/Firewall**
+   - Ensure the server can reach Supabase (check firewall rules)
+   - Test connection: `curl https://your-project.supabase.co`
+
+4. **File Size Limits**
+   - Check Supabase storage limits for your plan
+   - Verify file sizes are within allowed limits
+
+5. **Path Format**
+   - Ensure paths don't contain invalid characters
+   - Paths are normalized (forward slashes only)
+
+## Testing the Fix
+
+Run the upload command with verbose logging:
+
+```bash
+arela upload --force-supabase -v
+```
+
+You should now see:
+- Clear connection status messages
+- Per-file upload success/failure messages
+- Proper error messages if uploads fail
+- Accurate success/error counts in the summary
+
+## Migration Notes
+
+No database migrations required. This is a code-only fix that improves error handling and logging.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arela/uploader",
-  "version": "0.2.12",
+  "version": "0.3.0",
   "description": "CLI to upload files/directories to Arela",
   "bin": {
     "arela": "./src/index.js"
@@ -29,6 +29,7 @@
   "homepage": "https://github.com/inspiraCode/arela-uploader#readme",
   "dependencies": {
     "@supabase/supabase-js": "2.49.4",
+    "chokidar": "^4.0.3",
     "cli-progress": "3.12.0",
     "commander": "13.1.0",
     "dotenv": "16.5.0",
@@ -43,4 +44,4 @@
     "@trivago/prettier-plugin-sort-imports": "5.2.2",
     "prettier": "3.5.3"
   }
-}
+}

package/scripts/cleanup-ds-store.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+
+/**
+ * cleanup-ds-store.js
+ * Remove .DS_Store and other system file records from the uploader table
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import logger from './src/services/LoggingService.js';
+import { databaseService } from './src/services/DatabaseService.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+console.log('\n╔════════════════════════════════════════════════════════════════╗');
+console.log('║         Cleaning System Files from Uploader Table             ║');
+console.log('╚════════════════════════════════════════════════════════════════╝\n');
+
+async function cleanupSystemFiles() {
+  try {
+    const supabase = await databaseService.getSupabaseClient();
+
+    // System file patterns to remove
+    const systemFiles = [
+      '.DS_Store',
+      'Thumbs.db',
+      'desktop.ini',
+      '.directory',
+    ];
+
+    let totalDeleted = 0;
+
+    for (const fileName of systemFiles) {
+      console.log(`\n🔍 Searching for ${fileName}...`);
+      
+      // Find records with this filename
+      const { data: records, error: selectError } = await supabase
+        .from('uploader')
+        .select('*')
+        .eq('filename', fileName);
+
+      if (selectError) {
+        console.error(`❌ Error searching for ${fileName}: ${selectError.message}`);
+        continue;
+      }
+
+      if (!records || records.length === 0) {
+        console.log(`   ✓ No records found for ${fileName}`);
+        continue;
+      }
+
+      console.log(`   Found ${records.length} record(s) for ${fileName}`);
+      
+      // Get the IDs to delete
+      const idsToDelete = records.map(r => r.id);
+      
+      // Delete records
+      const { error: deleteError } = await supabase
+        .from('uploader')
+        .delete()
+        .in('id', idsToDelete);
+
+      if (deleteError) {
+        console.error(`   ❌ Error deleting: ${deleteError.message}`);
+        continue;
+      }
+
+      console.log(`   ✅ Deleted ${records.length} record(s)`);
+      totalDeleted += records.length;
+    }
+
+    // Also delete any records with original_path containing .DS_Store
+    console.log(`\n🔍 Searching for records with .DS_Store in path...`);
+    const { data: pathRecords, error: pathError } = await supabase
+      .from('uploader')
+      .select('*')
+      .ilike('original_path', '%.DS_Store%');
+
+    if (!pathError && pathRecords && pathRecords.length > 0) {
+      console.log(`   Found ${pathRecords.length} record(s)`);
+      const idsToDelete = pathRecords.map(r => r.id);
+      
+      const { error: deleteError } = await supabase
+        .from('uploader')
+        .delete()
+        .in('id', idsToDelete);
+
+      if (!deleteError) {
+        console.log(`   ✅ Deleted ${pathRecords.length} record(s)`);
+        totalDeleted += pathRecords.length;
+      } else {
+        console.error(`   ❌ Error deleting: ${deleteError.message}`);
+      }
+    }
+
+    console.log('\n╔════════════════════════════════════════════════════════════════╗');
+    console.log(`║  ✅ Cleanup Complete: Deleted ${totalDeleted} system file record(s)                  ║`);
+    console.log('╚════════════════════════════════════════════════════════════════╝\n');
+
+    process.exit(0);
+  } catch (error) {
+    console.error('\n❌ ERROR');
+    console.error(error.message);
+    process.exit(1);
+  }
+}
+
+cleanupSystemFiles();

package/scripts/cleanup-system-files.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+/**
+ * cleanup-system-files.js
+ * Remove system files (.DS_Store, etc) from the uploader table
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+console.log('\n╔════════════════════════════════════════════════════════════════╗');
+console.log('║           Cleaning System Files from Database                  ║');
+console.log('╚════════════════════════════════════════════════════════════════╝\n');
+
+try {
+  const databaseService = (await import('./src/services/DatabaseService.js')).default;
+  const supabase = await databaseService.getSupabaseClient();
+
+  // System file patterns to remove
+  const systemFilePatterns = ['.DS_Store', '__pycache__', '.pyc', '.swp', '.swo', 'Thumbs.db', 'desktop.ini'];
+
+  console.log('🔍 Searching for system files...\n');
+
+  let totalRemoved = 0;
+
+  for (const pattern of systemFilePatterns) {
+    const { data: records, error } = await supabase
+      .from('uploader')
+      .select('id, filename')
+      .ilike('filename', `%${pattern}%`);
+
+    if (!error && records && records.length > 0) {
+      console.log(`📝 Found ${records.length} record(s) with "${pattern}"`);
+      records.forEach(r => {
+        console.log(`   - ID: ${r.id}, Filename: ${r.filename}`);
+      });
+
+      // Delete them
+      const ids = records.map(r => r.id);
+      const { error: deleteError } = await supabase
+        .from('uploader')
+        .delete()
+        .in('id', ids);
+
+      if (!deleteError) {
+        console.log(`   ✅ Deleted ${records.length} record(s)\n`);
+        totalRemoved += records.length;
+      } else {
+        console.log(`   ❌ Error deleting records: ${deleteError.message}\n`);
+      }
+    }
+  }
+
+  console.log('╔════════════════════════════════════════════════════════════════╗');
+  console.log(`║                    ✅ CLEANUP COMPLETED                        ║`);
+  console.log(`║                                                                ║`);
+  console.log(`║  Total system files removed: ${totalRemoved}`);
+  console.log('╚════════════════════════════════════════════════════════════════╝\n');
+
+  process.exit(0);
+} catch (error) {
+  console.error('\n❌ CLEANUP FAILED');
+  console.error(error.message);
+  console.error(error.stack);
+  process.exit(1);
+}