dependency-change-report 1.0.3 → 1.0.5

package/lib/generate-html.mjs

@@ -423,7 +423,7 @@ const generateHtml = (report) => {
     ${errorsSection}
     
     <footer>
-      Generated by deep-depends-report
+      Generated by dependency-change-report
     </footer>
   </div>
 </body>

package/lib/index.mjs

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 
-import { spawn } from 'child_process';
 import { mkdir, writeFile, readFile, rm } from 'fs/promises';
 import { join, basename } from 'path';
 import { fileURLToPath } from 'url';
@@ -8,11 +7,103 @@ import { dirname } from 'path';
 import semver from 'semver';
 import os from 'os';
 import https from 'https';
+import { execa } from 'execa';
+import cliProgress from 'cli-progress';
+import PQueue from 'p-queue';
+
+const time_10min = 10 * 60 * 1000; // 10 minutes in milliseconds
+const time_5min = 5 * 60 * 1000; // 5 minutes in milliseconds
+const time_2min = 2 * 60 * 1000; // 2 minutes in milliseconds
+const time_1min = 60 * 1000; // 1 minute in milliseconds
+
+// Global cleanup state
+let globalCleanupState = {
+  multibar: null,
+  tempDirs: new Set(),
+  isShuttingDown: false
+};
 
 // Get the current directory
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+/**
+ * Setup signal handlers for graceful shutdown
+ */
+const setupSignalHandlers = () => {
+  const cleanup = async (signal) => {
+    if (globalCleanupState.isShuttingDown) {
+      return;
+    }
+    
+    globalCleanupState.isShuttingDown = true;
+    console.log(`\n\n🛑 Received ${signal}, cleaning up...`);
+    
+    // Stop progress bars and restore cursor
+    if (globalCleanupState.multibar) {
+      try {
+        globalCleanupState.multibar.stop();
+      } catch (error) {
+        // Ignore errors during cleanup
+      }
+    }
+    
+    // Restore cursor and clear any progress bar artifacts
+    process.stdout.write('\x1b[?25h'); // Show cursor
+    process.stdout.write('\x1b[0m');   // Reset colors
+    
+    // Clean up temporary directories
+    const cleanupPromises = Array.from(globalCleanupState.tempDirs).map(async (dir) => {
+      try {
+        await rm(dir, { recursive: true, force: true });
+        console.log(`🗑️  Cleaned up: ${dir}`);
+      } catch (error) {
+        console.warn(`⚠️  Failed to clean up ${dir}: ${error.message}`);
+      }
+    });
+    
+    if (cleanupPromises.length > 0) {
+      console.log(`🧹 Cleaning up ${cleanupPromises.length} temporary directories...`);
+      await Promise.all(cleanupPromises);
+    }
+    
+    console.log('✅ Cleanup complete');
+    process.exit(signal === 'SIGTERM' ? 0 : 1);
+  };
+  
+  // Handle various termination signals
+  process.on('SIGINT', () => cleanup('SIGINT'));   // Ctrl+C
+  process.on('SIGTERM', () => cleanup('SIGTERM')); // Termination request
+  process.on('SIGHUP', () => cleanup('SIGHUP'));   // Terminal closed
+  
+  // Handle uncaught exceptions and unhandled rejections
+  process.on('uncaughtException', async (error) => {
+    console.error('\n💥 Uncaught Exception:', error);
+    await cleanup('uncaughtException');
+  });
+  
+  process.on('unhandledRejection', async (reason, promise) => {
+    console.error('\n💥 Unhandled Rejection at:', promise, 'reason:', reason);
+    await cleanup('unhandledRejection');
+  });
+};
+
+/**
+ * Register a temporary directory for cleanup
+ * @param {string} dir - Directory path to register for cleanup
+ */
+const registerTempDir = (dir) => {
+  globalCleanupState.tempDirs.add(dir);
+};
+
+/**
+ * Unregister a temporary directory from cleanup (when manually cleaned)
+ * @param {string} dir - Directory path to unregister
+ */
+const unregisterTempDir = (dir) => {
+  globalCleanupState.tempDirs.delete(dir);
+};
+
 /**
  * Execute a command and return its output
  * @param {string} command - The command to execute
@@ -21,109 +112,29 @@ const __dirname = dirname(__filename);
  * @param {number} timeout - Timeout in milliseconds (default: 5 minutes)
  * @returns {Promise<string>} - Command output
  */
-const executeCommand = (command, args, cwd, timeout = 300000) => {
-  return new Promise((resolve, reject) => {
-    const childProcess = spawn(command, args, { 
+const executeCommand = async (command, args, cwd, timeout = time_5min) => {
+  try {
+    const result = await execa(command, args, {
       cwd,
-      detached: false,
-      stdio: ['pipe', 'pipe', 'pipe']
+      timeout,
+      cleanup: true,
+      killSignal: 'SIGTERM',
+      forceKillAfterTimeout: 5000, // Force kill after 5 seconds if SIGTERM doesn't work
+      stdio: 'pipe'
     });
-    let stdout = '';
-    let stderr = '';
-    let isResolved = false;
-    let timeoutId = null;
-
-    // Cleanup function to remove all listeners and clear timeout
-    const cleanup = () => {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-        timeoutId = null;
-      }
-      
-      // Remove all listeners to prevent memory leaks and hanging
-      childProcess.removeAllListeners();
-      
-      // Ensure streams are properly closed
-      if (childProcess.stdout) {
-        childProcess.stdout.removeAllListeners();
-      }
-      if (childProcess.stderr) {
-        childProcess.stderr.removeAllListeners();
-      }
-    };
-
-    // Kill process function
-    const killProcess = () => {
-      try {
-        // Just kill the process directly, don't try process group
-        childProcess.kill('SIGTERM');
-        
-        // If SIGTERM doesn't work after a short delay, use SIGKILL
-        setTimeout(() => {
-          try {
-            if (!childProcess.killed) {
-              childProcess.kill('SIGKILL');
-            }
-          } catch (e) {
-            // Process might already be dead
-          }
-        }, 1000);
-      } catch (e) {
-        // Process might already be dead
-      }
-    };
-
-    // Set up timeout with proper cleanup
-    timeoutId = setTimeout(() => {
-      if (!isResolved) {
-        isResolved = true;
-        killProcess();
-        cleanup();
-        reject(new Error(`Command timed out after ${timeout}ms: ${command} ${args.join(' ')}`));
-      }
-    }, timeout);
-
-    // Handle stdout data
-    if (childProcess.stdout) {
-      childProcess.stdout.on('data', (data) => {
-        stdout += data.toString();
-      });
-    }
-
-    // Handle stderr data
-    if (childProcess.stderr) {
-      childProcess.stderr.on('data', (data) => {
-        stderr += data.toString();
-      });
+    
+    return result.stdout;
+  } catch (error) {
+    if (error.timedOut) {
+      throw new Error(`Command timed out after ${timeout}ms: ${command} ${args.join(' ')}`);
+    } else if (error.killed) {
+      throw new Error(`Command was killed: ${command} ${args.join(' ')}`);
+    } else if (error.exitCode !== 0) {
+      throw new Error(`Command failed with code ${error.exitCode}: ${error.stderr}`);
+    } else {
+      throw error;
     }
-
-    // Handle process close (preferred over exit)
-    childProcess.on('close', (code, signal) => {
-      if (!isResolved) {
-        isResolved = true;
-        cleanup();
-        
-        if (signal) {
-          reject(new Error(`Command was killed with signal ${signal}: ${command} ${args.join(' ')}`));
-        } else if (code !== 0) {
-          console.warn(`Warning: Command ${command} ${args.join(' ')} failed with code ${code}`);
-          console.warn(`Error: ${stderr}`);
-          reject(new Error(`Command failed with code ${code}: ${stderr}`));
-        } else {
-          resolve(stdout);
-        }
-      }
-    });
-
-    // Handle process errors
-    childProcess.on('error', (error) => {
-      if (!isResolved) {
-        isResolved = true;
-        cleanup();
-        reject(error);
-      }
-    });
-  });
+  }
 };
 
 /**
@@ -135,13 +146,19 @@ const executeCommand = (command, args, cwd, timeout = 300000) => {
  */
 const cloneRepo = async (repoUrl, ref, targetDir) => {
   try {
-    console.log(`Cloning ${repoUrl} at ${ref} into ${targetDir}...`);
+    // Use shallow clone with depth=1 and single-branch for faster cloning
     // Use --quiet to avoid printing credentials in logs
-    await executeCommand('git', ['clone', '--quiet', repoUrl, targetDir]);
-    await executeCommand('git', ['checkout', ref], targetDir);
+    // 2 minute timeout for very large repositories
+    await executeCommand('git', ['clone', '--quiet', '--depth=1', '--single-branch', '--branch', ref, repoUrl, targetDir], undefined, time_2min);
   } catch (error) {
-    console.warn(`Warning: Failed to clone or checkout repository: ${error.message}`);
-    throw error;
+    // If shallow clone with specific branch fails, try traditional approach
+    try {
+      // Full clone with 5 minute timeout for very large repos
+      await executeCommand('git', ['clone', '--quiet', repoUrl, targetDir], undefined, time_5min);
+      await executeCommand('git', ['checkout', ref], targetDir, time_1min);
+    } catch (fallbackError) {
+      throw fallbackError;
+    }
   }
 };
 
@@ -152,10 +169,8 @@ const cloneRepo = async (repoUrl, ref, targetDir) => {
  */
 const installDependencies = async (dir) => {
   try {
-    console.log(`Installing dependencies in ${dir}...`);
     await executeCommand('npm', ['install'], dir);
   } catch (error) {
-    console.warn(`Warning: Failed to install dependencies: ${error.message}`);
     throw error;
   }
 };
@@ -168,7 +183,6 @@ const installDependencies = async (dir) => {
  */
 const getDependencies = async (dir, namespace = null) => {
   try {
-    console.log(`Getting dependency list from ${dir}...`);
     const output = await executeCommand('npm', ['ls', '--all', '--omit=dev', '--json'], dir);
     const dependencies = JSON.parse(output).dependencies || {};
     
@@ -214,7 +228,7 @@ const getDependencies = async (dir, namespace = null) => {
                   }
                 }
               } catch (err) {
-                console.warn(`Warning: Could not read package.json for nested dependency ${nestedName}: ${err.message}`);
+                // Silently skip nested dependencies we can't read
               }
             }
           }
@@ -225,13 +239,13 @@ const getDependencies = async (dir, namespace = null) => {
           }
         }
       } catch (err) {
-        console.warn(`Warning: Could not read package.json for ${name}: ${err.message}`);
+        // Silently skip dependencies we can't read
       }
     }
     
     return dependencies;
   } catch (error) {
-    console.warn(`Warning: Failed to get dependencies: ${error.message}`);
+    // Silently return empty object if we can't get dependencies
     // Return empty object if we can't get dependencies
     return {};
   }
@@ -246,34 +260,26 @@ const getDependencies = async (dir, namespace = null) => {
  */
 const getGitHubActionsStatus = async (repoUrl, version, commitSha = null) => {
   try {
-    console.log(`[CI] Checking GitHub Actions for ${repoUrl} at version ${version}`);
-    
     // Check if it's a GitHub repository
     if (!repoUrl.includes('github.com')) {
-      console.log(`[CI] Not a GitHub repository: ${repoUrl}`);
       return null;
     }
     
     // Extract owner and repo from URL
     const match = repoUrl.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
     if (!match) {
-      console.log(`[CI] Could not extract owner/repo from URL: ${repoUrl}`);
       return null;
     }
     
     const [, owner, repo] = match;
-    console.log(`[CI] Extracted GitHub repo: ${owner}/${repo}`);
     
     // Use provided commit SHA or try to resolve it
-    if (commitSha) {
-      console.log(`[CI] Using provided commit SHA: ${commitSha.substring(0, 7)}`);
-    } else {
-      console.log(`[CI] No commit SHA provided, trying to resolve version ${version} via GitHub API`);
+    if (!commitSha) {
       
       // Try to get commit SHA from GitHub API for the tag/ref
+      
       try {
         const refUrl = `https://api.github.com/repos/${owner}/${repo}/git/refs/tags/${version}`;
-        console.log(`[CI] Requesting tag info: ${refUrl}`);
         const refData = await makeGitHubApiRequest(refUrl);
         
         if (refData && refData.object) {
@@ -304,7 +310,6 @@ const getGitHubActionsStatus = async (repoUrl, version, commitSha = null) => {
       }
       
       if (!commitSha) {
-        console.warn(`[CI] Could not find commit SHA for ${owner}/${repo} at version ${version}`);
         return {
           status: 'unknown',
           error: 'Could not find commit SHA for version'
@@ -314,19 +319,15 @@ const getGitHubActionsStatus = async (repoUrl, version, commitSha = null) => {
     
     // Get workflow runs for the commit
     const runsUrl = `https://api.github.com/repos/${owner}/${repo}/actions/runs?head_sha=${commitSha}`;
-    console.log(`[CI] Requesting workflow runs: ${runsUrl}`);
     const runsData = await makeGitHubApiRequest(runsUrl);
     
     if (!runsData || !runsData.workflow_runs || runsData.workflow_runs.length === 0) {
-      console.log(`[CI] No workflow runs found for ${owner}/${repo} at commit ${commitSha.substring(0, 7)}`);
       return {
         status: 'no_workflows',
         message: 'No GitHub Actions workflows found for this commit'
       };
     }
     
-    console.log(`[CI] Found ${runsData.workflow_runs.length} workflow runs for ${owner}/${repo}`);
-    
     // Analyze the workflow runs
     const runs = runsData.workflow_runs;
     const latestRun = runs[0]; // Most recent run
@@ -396,7 +397,6 @@ const getGitHubActionsStatus = async (repoUrl, version, commitSha = null) => {
     };
     
   } catch (error) {
-    console.warn(`Warning: Could not get GitHub Actions status for ${repoUrl} at ${version}: ${error.message}`);
     return {
       status: 'error',
       error: error.message
@@ -487,7 +487,6 @@ const getRepositoryUrl = async (packageDir) => {
     
     return null;
   } catch (error) {
-    console.warn(`Warning: Could not get repository URL for ${packageDir}: ${error.message}`);
     return null;
   }
 };
@@ -501,18 +500,23 @@ const getRepositoryUrl = async (packageDir) => {
  * @returns {Promise<Array>} - Array of commit objects
  */
 const getCommitHistory = async (repoUrl, oldVersion, newVersion, reposDir) => {
+  let tempDir = null;
+  
   try {
     // Create a directory for the repository within the repos directory
     const packageName = basename(repoUrl, '.git');
-    const tempDir = join(reposDir, `${packageName}-history`);
+    tempDir = join(reposDir, `${packageName}-history`);
     await mkdir(tempDir, { recursive: true });
     
+    // Register this temp directory for cleanup
+    registerTempDir(tempDir);
+    
     // Clone the repository with optimizations for faster cloning
-    console.log(`Cloning ${repoUrl} into ${tempDir} to get commit history...`);
     // Use --quiet to avoid printing credentials in logs
     // Use --depth=1 and --single-branch for faster cloning, then fetch what we need
     try {
-      await executeCommand('git', ['clone', '--quiet', '--depth=1', '--single-branch', repoUrl, tempDir], undefined, 120000); // 2 minute timeout for clone
+      // 2 minute timeout for very large repositories
+      await executeCommand('git', ['clone', '--quiet', '--depth=1', '--single-branch', repoUrl, tempDir], undefined, time_2min);
     } catch (error) {
       // If the repository doesn't exist or can't be accessed, throw a more specific error
       if (error.message.includes("Repository not found") || 
@@ -525,9 +529,9 @@ const getCommitHistory = async (repoUrl, oldVersion, newVersion, reposDir) => {
     
     // Fetch all tags to ensure we have the version references
     try {
-      await executeCommand('git', ['fetch', '--tags', '--force', '--unshallow'], tempDir, 60000); // 1 minute timeout
+      // 2 minute timeout for fetching tags from large repositories
+      await executeCommand('git', ['fetch', '--tags', '--force', '--unshallow'], tempDir, time_2min);
     } catch (error) {
-      console.warn(`Warning: Failed to fetch tags: ${error.message}`);
       // Continue without tags if fetch fails
     }
     
@@ -545,9 +549,8 @@ const getCommitHistory = async (repoUrl, oldVersion, newVersion, reposDir) => {
     const checkRef = async (ref) => {
       // Make sure we're in the right directory and have fetched everything
       try {
-        await executeCommand('git', ['fetch', '--all'], tempDir, 60000); // 1 minute timeout
+        await executeCommand('git', ['fetch', '--all'], tempDir, time_1min); // 1 minute timeout
       } catch (error) {
-        console.warn(`Warning: Failed to fetch all refs: ${error.message}`);
         // Continue without full fetch
       }
       
@@ -568,7 +571,6 @@ const getCommitHistory = async (repoUrl, oldVersion, newVersion, reposDir) => {
       for (const pattern of uniquePatterns) {
         try {
           const result = await executeCommand('git', ['rev-parse', '--verify', pattern], tempDir);
-          console.log(`Found reference ${ref} as ${pattern}`);
           return { ref: pattern, hash: result.trim() };
         } catch (error) {
           // Continue to next pattern
@@ -583,8 +585,6 @@ const getCommitHistory = async (repoUrl, oldVersion, newVersion, reposDir) => {
     // Find commit with version bump
     const findVersionCommit = async (version) => {
       try {
-        console.log(`Looking for commit that bumps version to ${version}...`);
-        
         // Look for version in commit messages (common patterns)
         const patterns = [
           `version bump to ${version}`,
@@ -605,7 +605,6 @@ const getCommitHistory = async (repoUrl, oldVersion, newVersion, reposDir) => {
             );
             
             if (result.trim()) {
-              console.log(`Found commit for version ${version} using pattern: ${pattern}`);
               return { ref: version, hash: result.trim() };
             }
           } catch (e) {
@@ -622,7 +621,6 @@ const getCommitHistory = async (repoUrl, oldVersion, newVersion, reposDir) => {
           );
           
           if (result.trim()) {
-            console.log(`Found commit that changes package.json version to ${version}`);
             return { ref: version, hash: result.trim() };
           }
         } catch (e) {
@@ -631,7 +629,6 @@ const getCommitHistory = async (repoUrl, oldVersion, newVersion, reposDir) => {
         
         return null;
       } catch (error) {
-        console.warn(`Error finding version commit: ${error.message}`);
         return null;
       }
     };
@@ -642,18 +639,15 @@ const getCommitHistory = async (repoUrl, oldVersion, newVersion, reposDir) => {
     
     // If direct references not found, try to find commits with version bumps
     if (!resolvedOldRef) {
-      console.log(`Reference ${oldVersion} not found directly, looking for version bump commit...`);
       resolvedOldRef = await findVersionCommit(oldVersion);
     }
     
     if (!resolvedNewRef) {
-      console.log(`Reference ${newVersion} not found directly, looking for version bump commit...`);
       resolvedNewRef = await findVersionCommit(newVersion);
     }
     
     // If still no references found, try to get all tags and find closest matches
     if (!resolvedOldRef || !resolvedNewRef) {
-      console.log('Trying to find closest version matches from available tags...');
       try {
         const tagsOutput = await executeCommand('git', ['tag', '-l'], tempDir);
         const availableTags = tagsOutput.split('\n').filter(tag => tag.trim());
@@ -669,7 +663,6 @@ const getCommitHistory = async (repoUrl, oldVersion, newVersion, reposDir) => {
             try {
               const result = await executeCommand('git', ['rev-parse', '--verify', oldMatch], tempDir);
               resolvedOldRef = { ref: oldMatch, hash: result.trim() };
-              console.log(`Found closest match for ${oldVersion}: ${oldMatch}`);
             } catch (e) {
               // Continue to fallback
             }
@@ -687,20 +680,18 @@ const getCommitHistory = async (repoUrl, oldVersion, newVersion, reposDir) => {
             try {
               const result = await executeCommand('git', ['rev-parse', '--verify', newMatch], tempDir);
               resolvedNewRef = { ref: newMatch, hash: result.trim() };
-              console.log(`Found closest match for ${newVersion}: ${newMatch}`);
             } catch (e) {
               // Continue to fallback
             }
           }
         }
       } catch (error) {
-        console.warn(`Warning: Failed to get available tags: ${error.message}`);
+        // Continue to fallback
       }
     }
     
     // Last resort: if we can't find specific versions, use default branch for newer and first commit for older
     if (!resolvedOldRef && !resolvedNewRef) {
-      console.warn(`Warning: Could not find references for both ${oldVersion} and ${newVersion}. Using first and latest commits instead.`);
       try {
         // Get the first commit
         const firstCommit = await executeCommand('git', ['rev-list', '--max-parents=0', 'HEAD'], tempDir);
@@ -709,40 +700,27 @@ const getCommitHistory = async (repoUrl, oldVersion, newVersion, reposDir) => {
         // Get the latest commit on default branch
         const latestCommit = await executeCommand('git', ['rev-parse', 'HEAD'], tempDir);
         resolvedNewRef = { ref: 'latest-commit', hash: latestCommit.trim() };
-        
-        console.log(`Using first commit (${resolvedOldRef.hash.substring(0, 7)}) and latest commit (${resolvedNewRef.hash.substring(0, 7)}) as fallback`);
       } catch (error) {
-        console.warn(`Warning: Failed to get first and latest commits: ${error.message}`);
         return [];
       }
     } else if (!resolvedOldRef) {
-      console.warn(`Warning: Could not find reference for ${oldVersion}. Using first commit instead.`);
       try {
         // Get the first commit
         const firstCommit = await executeCommand('git', ['rev-list', '--max-parents=0', 'HEAD'], tempDir);
         resolvedOldRef = { ref: 'first-commit', hash: firstCommit.trim() };
-        console.log(`Using first commit (${resolvedOldRef.hash.substring(0, 7)}) as fallback for ${oldVersion}`);
       } catch (error) {
-        console.warn(`Warning: Failed to get first commit: ${error.message}`);
         return [];
       }
     } else if (!resolvedNewRef) {
-      console.warn(`Warning: Could not find reference for ${newVersion}. Using latest commit instead.`);
       try {
         // Get the latest commit on default branch
         const latestCommit = await executeCommand('git', ['rev-parse', 'HEAD'], tempDir);
         resolvedNewRef = { ref: 'latest-commit', hash: latestCommit.trim() };
-        console.log(`Using latest commit (${resolvedNewRef.hash.substring(0, 7)}) as fallback for ${newVersion}`);
       } catch (error) {
-        console.warn(`Warning: Failed to get latest commit: ${error.message}`);
         return [];
       }
     }
     
-    // Get commit history between versions
-    // Format: hash,author,date,message
-    console.log(`Getting commits between ${resolvedOldRef.ref} (${resolvedOldRef.hash.substring(0, 7)}) and ${resolvedNewRef.ref} (${resolvedNewRef.hash.substring(0, 7)})...`);
-    
     // Check if the order is correct (older should come before newer)
     try {
       // Try to determine which commit came first
@@ -758,13 +736,11 @@ const getCommitHistory = async (repoUrl, oldVersion, newVersion, reposDir) => {
       
       if (mergeBase.trim() === resolvedNewRef.hash.trim()) {
         // Order is reversed, swap them
-        console.log('Detected reversed version order, swapping references...');
         const temp = resolvedOldRef;
         resolvedOldRef = resolvedNewRef;
         resolvedNewRef = temp;
       }
     } catch (error) {
-      console.warn(`Warning: Could not determine commit order: ${error.message}`);
       // Continue with original order
     }
     
@@ -776,17 +752,14 @@ const getCommitHistory = async (repoUrl, oldVersion, newVersion, reposDir) => {
         tempDir
       );
     } catch (error) {
-      console.warn(`Warning: Failed to get commit log: ${error.message}`);
       // Try with a different approach - get all commits and filter
       try {
-        console.log('Trying alternative approach to get commit history...');
         output = await executeCommand(
           'git',
           ['log', '--pretty=format:%H,%an,%ad,%s'],
           tempDir
         );
       } catch (e) {
-        console.warn(`Warning: Alternative approach also failed: ${e.message}`);
         return [];
       }
     }
@@ -805,11 +778,22 @@ const getCommitHistory = async (repoUrl, oldVersion, newVersion, reposDir) => {
       });
     
     // Clean up
-    await rm(tempDir, { recursive: true, force: true });
+    if (tempDir) {
+      await rm(tempDir, { recursive: true, force: true });
+      unregisterTempDir(tempDir);
+    }
     
     return commits;
   } catch (error) {
-    console.warn(`Warning: Could not get commit history for ${repoUrl} between ${oldVersion} and ${newVersion}: ${error.message}`);
+    // Clean up on error
+    if (tempDir) {
+      try {
+        await rm(tempDir, { recursive: true, force: true });
+        unregisterTempDir(tempDir);
+      } catch (cleanupError) {
+        // Ignore cleanup errors
+      }
+    }
     return [];
   }
 };
@@ -830,12 +814,9 @@ const getPackageLockChanges = async (olderVersionDir, newerVersionDir) => {
       await readFile(oldLockPath);
       await readFile(newLockPath);
     } catch (error) {
-      console.log('package-lock.json not found in one or both versions, skipping lock file analysis');
       return { changedPackages: [], packageVersions: {} };
     }
     
-    console.log('Found package-lock.json in both versions, analyzing changes...');
-    
     // Read and parse both lock files
     const oldLock = JSON.parse(await readFile(oldLockPath, 'utf8'));
     const newLock = JSON.parse(await readFile(newLockPath, 'utf8'));
@@ -882,14 +863,12 @@ const getPackageLockChanges = async (olderVersionDir, newerVersionDir) => {
       }
     }
     
-    console.log(`Found ${changedPackages.size} packages with changes in package-lock.json`);
     return { 
       changedPackages: Array.from(changedPackages), 
       packageVersions 
     };
     
   } catch (error) {
-    console.warn(`Warning: Failed to analyze package-lock.json changes: ${error.message}`);
     return { changedPackages: [], packageVersions: {} };
   }
 };
@@ -949,107 +928,220 @@ const extractFromDependencies = (dependencies, packages) => {
 };
 
 /**
- * Get changelog and CI status for upgraded dependencies
- * @param {Array} upgradedDeps - Array of upgraded dependencies
+ * Process a single dependency for changelog and CI status with progress updates
+ * @param {Object} dep - Dependency object
  * @param {string} newerVersionDir - Directory of the newer version
  * @param {string} reposDir - Repository directory
- * @returns {Promise<Object>} - Object mapping package names to changelogs and CI status
+ * @param {Object} multibar - CLI multi progress bar instance
+ * @param {number} maxNameLength - Maximum name length for consistent padding
+ * @returns {Promise<Object>} - Object with changelog, error, and CI status
  */
-const getChangelogs = async (upgradedDeps, newerVersionDir, reposDir) => {
+const processSingleDependency = async (dep, newerVersionDir, reposDir, multibar, maxNameLength) => {
+  const result = {
+    name: dep.name,
+    changelog: null,
+    error: null,
+    ciStatus: null
+  };
+  
+  // Format the name with consistent padding, truncating if necessary
+  let displayName = dep.name;
+  if (displayName.length > maxNameLength) {
+    displayName = displayName.substring(0, maxNameLength - 3) + '...';
+  }
+  displayName = displayName.padEnd(maxNameLength);
+  
+  // Create individual progress bar for this dependency
+  const depBar = multibar.create(100, 0, { name: displayName, status: 'Starting...' });
+  
+  depBar.update(10, { status: 'Getting repo URL...' });
+  const packageDir = join(newerVersionDir, 'node_modules', dep.name);
+  const repoUrl = await getRepositoryUrl(packageDir);
+  
+  if (!repoUrl) {
+    depBar.update(100, { status: '❌ No repo URL' });
+    result.error = {
+      repoUrl: null,
+      oldVersion: dep.oldVersion,
+      newVersion: dep.newVersion,
+      error: "No repository URL found"
+    };
+    return result;
+  }
+  
+  depBar.update(20, { status: 'Cleaning repo URL...' });
+  
+  // Clean the repository URL and convert to git URL for authentication
+  let cleanRepoUrl = repoUrl.replace(/^git\+/, '');
+  
+  // Remove .git extension if present (we'll add it back later if needed)
+  cleanRepoUrl = cleanRepoUrl.replace(/\.git$/, '');
+  
+  // Handle GitHub shorthand (github:user/repo)
+  if (cleanRepoUrl.match(/^(github|gitlab|bitbucket):/)) {
+    cleanRepoUrl = `git@github.com:${cleanRepoUrl.split(':')[1]}`;
+  }
+  // Convert https GitHub URLs to git URLs
+  else if (cleanRepoUrl.match(/^https?:\/\/github\.com\//)) {
+    cleanRepoUrl = `git@github.com:${cleanRepoUrl.replace(/^https?:\/\/github\.com\//, '')}`;
+  }
+  // Handle git:// protocol URLs
+  else if (cleanRepoUrl.match(/^git:\/\/github\.com\//)) {
+    cleanRepoUrl = `git@github.com:${cleanRepoUrl.replace(/^git:\/\/github\.com\//, '')}`;
+  }
+  // Ensure URL is in the correct format for GitHub
+  else if (!cleanRepoUrl.match(/^git@github\.com:/)) {
+    // If it's not already in the git@github.com format, try to convert it
+    const parts = cleanRepoUrl.split('/');
+    const repoName = parts.pop();
+    const orgName = parts.pop();
+    if (orgName && repoName) {
+      cleanRepoUrl = `git@github.com:${orgName}/${repoName}`;
+    }
+  }
+  
+  // Add .git extension if not present
+  if (!cleanRepoUrl.endsWith('.git')) {
+    cleanRepoUrl += '.git';
+  }
+  
+  depBar.update(30, { status: 'Getting commits...' });
+  
+  let commits = [];
+  try {
+    commits = await getCommitHistory(cleanRepoUrl, dep.oldVersion, dep.newVersion, reposDir);
+    if (commits.length > 0) {
+      depBar.update(70, { status: `Found ${commits.length} commits` });
+      result.changelog = {
+        repoUrl: cleanRepoUrl,
+        oldVersion: dep.oldVersion,
+        newVersion: dep.newVersion,
+        commits
+      };
+    } else {
+      depBar.update(70, { status: '⚠️ No commits found' });
+      result.error = {
+        repoUrl: cleanRepoUrl,
+        oldVersion: dep.oldVersion,
+        newVersion: dep.newVersion,
+        error: "No commits found between versions"
+      };
+    }
+  } catch (error) {
+    depBar.update(70, { status: '❌ Commit error' });
+    result.error = {
+      repoUrl: cleanRepoUrl,
+      oldVersion: dep.oldVersion,
+      newVersion: dep.newVersion,
+      error: error.message
+    };
+  }
+  
+  // Get GitHub Actions status for the new version
+  depBar.update(80, { status: 'Getting CI status...' });
+  try {
+    const best = commits.length > 0 ? commits[0].hash : null;
+    const actionsStatus = await getGitHubActionsStatus(cleanRepoUrl, dep.newVersion, best);
+    if (actionsStatus) {
+      result.ciStatus = actionsStatus;
+      depBar.update(100, { status: `✅ Complete (CI: ${actionsStatus.status})` });
+    } else {
+      depBar.update(100, { status: '✅ Complete (no CI)' });
+    }
+  } catch (error) {
+    // Silently ignore CI status errors
+    depBar.update(100, { status: '✅ Complete (CI error)' });
+  }
+  
+  return result;
+};
+
+/**
+ * Process dependencies in parallel with concurrency limit using a proper queue
+ * @param {Array} dependencies - Array of dependencies to process
+ * @param {string} newerVersionDir - Directory of the newer version
+ * @param {string} reposDir - Repository directory
+ * @param {number} concurrency - Maximum number of concurrent operations
+ * @returns {Promise<Object>} - Object with changelogs, errors, and CI status
+ */
+const processInParallel = async (dependencies, newerVersionDir, reposDir, concurrency = 5) => {
   const changelogs = {};
   const errors = {};
   const ciStatus = {};
   
-  for (const dep of upgradedDeps) {
-    const packageDir = join(newerVersionDir, 'node_modules', dep.name);
-    const repoUrl = await getRepositoryUrl(packageDir);
-    
-    if (repoUrl) {
-      // Clean the repository URL and convert to git URL for authentication
-      let cleanRepoUrl = repoUrl.replace(/^git\+/, '');
-      
-      // Remove .git extension if present (we'll add it back later if needed)
-      cleanRepoUrl = cleanRepoUrl.replace(/\.git$/, '');
-      
-      // Handle GitHub shorthand (github:user/repo)
-      if (cleanRepoUrl.match(/^(github|gitlab|bitbucket):/)) {
-        cleanRepoUrl = `git@github.com:${cleanRepoUrl.split(':')[1]}`;
-      }
-      // Convert https GitHub URLs to git URLs
-      else if (cleanRepoUrl.match(/^https?:\/\/github\.com\//)) {
-        cleanRepoUrl = `git@github.com:${cleanRepoUrl.replace(/^https?:\/\/github\.com\//, '')}`;
-      }
-      // Handle git:// protocol URLs
-      else if (cleanRepoUrl.match(/^git:\/\/github\.com\//)) {
-        cleanRepoUrl = `git@github.com:${cleanRepoUrl.replace(/^git:\/\/github\.com\//, '')}`;
-      }
-      // Ensure URL is in the correct format for GitHub
-      else if (!cleanRepoUrl.match(/^git@github\.com:/)) {
-        // If it's not already in the git@github.com format, try to convert it
-        const parts = cleanRepoUrl.split('/');
-        const repoName = parts.pop();
-        const orgName = parts.pop();
-        if (orgName && repoName) {
-          cleanRepoUrl = `git@github.com:${orgName}/${repoName}`;
-        }
-      }
-      
-      // Add .git extension if not present
-      if (!cleanRepoUrl.endsWith('.git')) {
-        cleanRepoUrl += '.git';
-      }
-      
-      console.log(`Getting changelog for ${dep.name} from ${cleanRepoUrl} between ${dep.oldVersion} and ${dep.newVersion}`);
-      
-      let commits = []
-      try {
-        commits = await getCommitHistory(cleanRepoUrl, dep.oldVersion, dep.newVersion, reposDir);
-        if (commits.length > 0) {
-          changelogs[dep.name] = {
-            repoUrl: cleanRepoUrl,
-            oldVersion: dep.oldVersion,
-            newVersion: dep.newVersion,
-            commits
-          };
-        } else {
-          console.warn(`No commits found between ${dep.oldVersion} and ${dep.newVersion} for ${dep.name}`);
-          errors[dep.name] = {
-            repoUrl: cleanRepoUrl,
-            oldVersion: dep.oldVersion,
-            newVersion: dep.newVersion,
-            error: "No commits found between versions"
-          };
-        }
-      } catch (error) {
-        console.warn(`Error getting changelog for ${dep.name}: ${error.message}`);
-        errors[dep.name] = {
-          repoUrl: cleanRepoUrl,
-          oldVersion: dep.oldVersion,
-          newVersion: dep.newVersion,
-          error: error.message
-        };
-      }
-      
-      // Get GitHub Actions status for the new version
-      try {
-        const best = commits[0].hash
-        console.log(`Getting GitHub Actions status for ${dep.name} at version ${dep.newVersion} ${best} from ${cleanRepoUrl}`);
-        const actionsStatus = await getGitHubActionsStatus(cleanRepoUrl, dep.newVersion, best);
-        if (actionsStatus) {
-          console.log(`✓ Got CI status for ${dep.name}: ${actionsStatus.status}`);
-          ciStatus[dep.name] = actionsStatus;
-        } else {
-          console.log(`✗ No CI status returned for ${dep.name}`);
-        }
-      } catch (error) {
-        console.warn(`Error getting GitHub Actions status for ${dep.name}: ${error.message}`);
-      }
+  if (dependencies.length === 0) {
+    return { changelogs, errors, ciStatus };
+  }
+  
+  // Calculate the maximum name length for consistent padding
+  const maxNameLength = Math.min(
+    Math.max(...dependencies.map(dep => dep.name.length)),
+    40 // Reasonable maximum to prevent extremely long lines
+  );
+  
+  // Create multi progress bar
+  const multibar = new cliProgress.MultiBar({
+    clearOnComplete: false,
+    hideCursor: true,
+    format: '{name} |{bar}| {percentage}% | {status}'
+  }, {
+    barCompleteChar: '\u2588',
+    barIncompleteChar: '\u2591'
+  });
+  
+  // Register multibar for cleanup
+  globalCleanupState.multibar = multibar;
+  
+  console.log(`\nProcessing ${dependencies.length} dependencies with concurrency limit of ${concurrency}:\n`);
+  
+  // Create queue with concurrency limit
+  const queue = new PQueue({ concurrency });
+  
+  // Add all dependencies to the queue
+  const promises = dependencies.map(dep => 
+    queue.add(() => processSingleDependency(dep, newerVersionDir, reposDir, multibar, maxNameLength))
+  );
+  
+  // Wait for all tasks to complete
+  const results = await Promise.all(promises);
+  
+  // Collect results
+  for (const result of results) {
+    if (result.changelog) {
+      changelogs[result.name] = result.changelog;
+    }
+    if (result.error) {
+      errors[result.name] = result.error;
+    }
+    if (result.ciStatus) {
+      ciStatus[result.name] = result.ciStatus;
     }
   }
   
+  multibar.stop();
+  
+  // Unregister multibar from cleanup
+  globalCleanupState.multibar = null;
+  
+  // Ensure cursor is visible after progress bars
+  process.stdout.write('\x1b[?25h'); // Show cursor
+  
+  console.log(`\n✅ Completed processing ${dependencies.length} dependencies\n`);
+  
   return { changelogs, errors, ciStatus };
 };
 
+/**
+ * Get changelog and CI status for upgraded dependencies
+ * @param {Array} upgradedDeps - Array of upgraded dependencies
+ * @param {string} newerVersionDir - Directory of the newer version
+ * @param {string} reposDir - Repository directory
+ * @returns {Promise<Object>} - Object mapping package names to changelogs and CI status
+ */
+const getChangelogs = async (upgradedDeps, newerVersionDir, reposDir) => {
+  return await processInParallel(upgradedDeps, newerVersionDir, reposDir, 5);
+};
+
 /**
  * Compare dependencies between two versions
  * @param {Object} oldDeps - Old dependencies
@@ -1100,7 +1192,7 @@ const compareDependencies = (oldDeps, newDeps) => {
           }
         }
       } catch (error) {
-        console.warn(`Warning: Could not determine semver change type for ${name}: ${error.message}`);
+        // Silently continue with unknown change type
       }
 
       upgraded.push({
@@ -1195,7 +1287,7 @@ const compareDependencies = (oldDeps, newDeps) => {
             }
           }
         } catch (error) {
-          console.warn(`Warning: Could not determine semver change type for nested dependency ${name}: ${error.message}`);
+          // Silently continue with unknown change type
         }
 
         nestedUpgraded.push({
@@ -1252,6 +1344,9 @@ const compareDependencies = (oldDeps, newDeps) => {
  * @returns {Promise<Object>} - Analysis report
  */
 const analyzeDependencyChanges = async (repoUrl, olderVersion, newerVersion, workingDir = process.cwd(), namespace = null) => {
+  // Setup signal handlers for graceful shutdown
+  setupSignalHandlers();
+  
   // Extract project name from repo URL
   const projectName = basename(repoUrl, '.git');
   const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
@@ -1264,6 +1359,9 @@ const analyzeDependencyChanges = async (repoUrl, olderVersion, newerVersion, wor
     // Create the repos directory
     await mkdir(reposDir, { recursive: true });
     
+    // Register temp directory for cleanup
+    registerTempDir(reposDir);
+    
     // Clone both versions
     await cloneRepo(repoUrl, olderVersion, olderVersionDir);
     await cloneRepo(repoUrl, newerVersion, newerVersionDir);
@@ -1310,7 +1408,7 @@ const analyzeDependencyChanges = async (repoUrl, olderVersion, newerVersion, wor
                 }
               }
             } catch (e) {
-              console.warn(`Could not read package.json for ${packageName}: ${e.message}`);
+              // Silently skip packages we can't read
             }
             
             if (repoUrl) {
@@ -1348,44 +1446,48 @@ const analyzeDependencyChanges = async (repoUrl, olderVersion, newerVersion, wor
               // Also add to the comparison.upgraded array so it appears in the report
               comparison.upgraded.push(lockFileDep);
               
-              console.log(`Added ${packageName} from package-lock.json analysis: ${versionInfo.oldVersion} → ${versionInfo.newVersion}`);
+              // Added package from lock file analysis
             }
           } catch (error) {
-            console.warn(`Could not get repository info for ${packageName}: ${error.message}`);
+            // Silently skip packages we can't get info for
           }
         }
       }
     }
     
     // Get changelogs for upgraded dependencies
-    console.log(`Generating changelogs for ${allChangedPackages.length} dependencies (${comparison.upgraded.length} from npm ls + ${allChangedPackages.length - comparison.upgraded.length} from package-lock.json)...`);
+    console.log(`\nGenerating changelogs for ${allChangedPackages.length} dependencies...`);
     const { changelogs, errors, ciStatus } = await getChangelogs(allChangedPackages, newerVersionDir, reposDir);
   
     // Get changelogs for modified dependencies (namespace changes)
-    console.log('Generating changelogs for modified dependencies...');
-    const modifiedDepsForChangelog = comparison.modified.map(dep => ({
-      name: dep.newName,
-      oldVersion: dep.oldVersion,
-      newVersion: dep.newVersion,
-      changeType: 'namespace'
-    }));
-    const { changelogs: modifiedChangelogs, errors: modifiedErrors, ciStatus: modifiedCiStatus } = 
-      await getChangelogs(modifiedDepsForChangelog, newerVersionDir, reposDir);
-  
-    // Merge changelogs, errors, and CI status
-    Object.assign(changelogs, modifiedChangelogs);
-    Object.assign(errors, modifiedErrors);
-    Object.assign(ciStatus, modifiedCiStatus);
+    if (comparison.modified.length > 0) {
+      console.log(`Generating changelogs for ${comparison.modified.length} modified dependencies...`);
+      const modifiedDepsForChangelog = comparison.modified.map(dep => ({
+        name: dep.newName,
+        oldVersion: dep.oldVersion,
+        newVersion: dep.newVersion,
+        changeType: 'namespace'
+      }));
+      const { changelogs: modifiedChangelogs, errors: modifiedErrors, ciStatus: modifiedCiStatus } = 
+        await getChangelogs(modifiedDepsForChangelog, newerVersionDir, reposDir);
+    
+      // Merge changelogs, errors, and CI status
+      Object.assign(changelogs, modifiedChangelogs);
+      Object.assign(errors, modifiedErrors);
+      Object.assign(ciStatus, modifiedCiStatus);
+    }
     
     // Get changelogs for nested upgraded dependencies
-    console.log('Generating changelogs for nested upgraded dependencies...');
-    const { changelogs: nestedChangelogs, errors: nestedErrors, ciStatus: nestedCiStatus } = 
-      await getChangelogs(comparison.nested.upgraded, newerVersionDir, reposDir);
-    
-    // Merge nested changelogs, errors, and CI status
-    Object.assign(changelogs, nestedChangelogs);
-    Object.assign(errors, nestedErrors);
-    Object.assign(ciStatus, nestedCiStatus);
+    if (comparison.nested.upgraded.length > 0) {
+      console.log(`Generating changelogs for ${comparison.nested.upgraded.length} nested upgraded dependencies...`);
+      const { changelogs: nestedChangelogs, errors: nestedErrors, ciStatus: nestedCiStatus } = 
+        await getChangelogs(comparison.nested.upgraded, newerVersionDir, reposDir);
+      
+      // Merge nested changelogs, errors, and CI status
+      Object.assign(changelogs, nestedChangelogs);
+      Object.assign(errors, nestedErrors);
+      Object.assign(ciStatus, nestedCiStatus);
+    }
     
     // Write report to file
     const reportPath = join(reposDir, 'report.json');
@@ -1408,10 +1510,25 @@ const analyzeDependencyChanges = async (repoUrl, olderVersion, newerVersion, wor
     // Add reportPath after writing the file
     report.reportPath = reportPath;
     
-    console.log(`Report generated at ${reportPath}`);
+    console.log(`\n📊 Report generated: ${reportPath}`);
+    
+    // Don't auto-cleanup on success - user might want to examine the files
+    // But unregister from emergency cleanup since we completed successfully
+    unregisterTempDir(reposDir);
+    
     return report;
   } catch (error) {
-    console.error(`Error analyzing dependency changes: ${error.message}`);
+    console.error(`\n❌ Error analyzing dependency changes: ${error.message}`);
+    
+    // Clean up on error
+    try {
+      await rm(reposDir, { recursive: true, force: true });
+      unregisterTempDir(reposDir);
+      console.log(`🗑️  Cleaned up temporary directory: ${reposDir}`);
+    } catch (cleanupError) {
+      console.warn(`⚠️  Failed to clean up ${reposDir}: ${cleanupError.message}`);
+    }
+    
     throw error;
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dependency-change-report",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "main": "index.mjs",
   "type": "module",
   "bin": {
@@ -14,6 +14,9 @@
   "keywords": [],
   "description": "Generate a dependency change report between different versions of a project",
   "dependencies": {
-    "semver": "^7.7.1"
+    "cli-progress": "^3.12.0",
+    "execa": "^9.6.0",
+    "semver": "^7.7.1",
+    "p-queue": "^8.0.1"
   }
 }