docs(changeset): add debug

Author: Dan Clayton

.changeset/nine-carrots-turn.md

@@ -0,0 +1,5 @@
+---
+"@azwebmaster/dependency-optimizer": patch
+---
+
+add debug

bun.lock

@@ -33,11 +33,13 @@
   },
   "dependencies": {
     "commander": "^12.1.0",
+    "debug": "^4.4.3",
     "depcheck": "^1.4.7",
     "globby": "^14.0.1"
   },
   "devDependencies": {
     "@changesets/cli": "^2.29.7",
+    "@types/debug": "^4.1.12",
     "@types/node": "latest",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",

package.json

@@ -1,14 +1,19 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import type { AnalyzeOptions, AnalyzeResult, PackageAnalysis } from './types.js';
+import createDebug from 'debug';
+
+const debug = createDebug('depoptimize:analyzer');
 
 export class NodeModulesAnalyzer {
   constructor(private options: AnalyzeOptions = {}) {}
 
   async analyze(projectPath: string = process.cwd()): Promise<AnalyzeResult> {
+    debug('Starting analysis for project: %s', projectPath);
     const nodeModulesPath = path.join(projectPath, 'node_modules');
     const sizeThreshold = (this.options.sizeThreshold || 10) * 1024 * 1024; // Convert MB to bytes
     const depthThreshold = this.options.depthThreshold || 5;
+    debug('Configuration - sizeThreshold: %d bytes, depthThreshold: %d', sizeThreshold, depthThreshold);
 
     const result: AnalyzeResult = {
       totalPackages: 0,
@@ -22,43 +27,53 @@ export class NodeModulesAnalyzer {
       // Check if node_modules exists
       const nodeModulesExists = await this.directoryExists(nodeModulesPath);
       if (!nodeModulesExists) {
+        debug('node_modules not found at: %s', nodeModulesPath);
         return result;
       }
+      debug('Found node_modules at: %s', nodeModulesPath);
 
       // Get all packages in node_modules
       const packages = await this.getAllPackages(nodeModulesPath);
       result.totalPackages = packages.length;
+      debug('Found %d packages in node_modules', packages.length);
 
       // Analyze each package
       for (const pkg of packages) {
+        debug('Analyzing package: %s', pkg.name);
         const analysis = await this.analyzePackage(pkg.path, pkg.name);
 
         result.totalSize += analysis.size;
 
         // Check if package exceeds size threshold
         if (analysis.size > sizeThreshold) {
+          debug('Large package detected: %s (%d bytes)', pkg.name, analysis.size);
           result.largePackages.push(analysis);
         }
 
         // Check if package exceeds depth threshold
         if (analysis.depth > depthThreshold) {
+          debug('Deep package detected: %s (depth: %d)', pkg.name, analysis.depth);
           result.deepPackages.push(analysis);
         }
       }
 
       // Sort results by size/depth descending
       result.largePackages.sort((a, b) => b.size - a.size);
       result.deepPackages.sort((a, b) => b.depth - a.depth);
+      debug('Analysis complete - total size: %d bytes, large packages: %d, deep packages: %d',
+            result.totalSize, result.largePackages.length, result.deepPackages.length);
 
     } catch (error) {
       // Handle errors gracefully
+      debug('Error during analysis: %O', error);
       console.warn(`Warning: Failed to analyze node_modules: ${error}`);
     }
 
     return result;
   }
 
   private async getAllPackages(nodeModulesPath: string): Promise<{ name: string; path: string }[]> {
+    debug('Scanning for packages in: %s', nodeModulesPath);
     const packages: { name: string; path: string }[] = [];
 
     try {
@@ -70,6 +85,7 @@ export class NodeModulesAnalyzer {
 
           if (entry.name.startsWith('@')) {
             // Scoped packages
+            debug('Processing scoped package directory: %s', entry.name);
             try {
               const scopedEntries = await fs.readdir(entryPath, { withFileTypes: true });
               for (const scopedEntry of scopedEntries) {
@@ -79,25 +95,30 @@ export class NodeModulesAnalyzer {
 
                   // Verify it's a valid package
                   if (await this.isValidPackage(scopedPath)) {
+                    debug('Found scoped package: %s', packageName);
                     packages.push({ name: packageName, path: scopedPath });
                   }
                 }
               }
-            } catch {
+            } catch (error) {
               // Skip if can't read scoped directory
+              debug('Failed to read scoped directory %s: %O', entry.name, error);
             }
           } else {
             // Regular packages
             if (await this.isValidPackage(entryPath)) {
+              debug('Found package: %s', entry.name);
               packages.push({ name: entry.name, path: entryPath });
             }
           }
         }
       }
-    } catch {
+    } catch (error) {
       // Return empty array if can't read node_modules
+      debug('Failed to read node_modules directory: %O', error);
     }
 
+    debug('Total packages found: %d', packages.length);
     return packages;
   }
 
@@ -112,6 +133,7 @@ export class NodeModulesAnalyzer {
   }
 
   private async analyzePackage(packagePath: string, packageName: string): Promise<PackageAnalysis> {
+    debug('Analyzing package details for: %s', packageName);
     const analysis: PackageAnalysis = {
       name: packageName,
       size: 0,
@@ -122,18 +144,22 @@ export class NodeModulesAnalyzer {
     try {
       // Calculate package size
       analysis.size = await this.getDirectorySize(packagePath);
+      debug('Package %s size: %d bytes', packageName, analysis.size);
 
       // Calculate dependency depth
       analysis.depth = await this.getDependencyDepth(packagePath);
+      debug('Package %s depth: %d', packageName, analysis.depth);
 
-    } catch {
+    } catch (error) {
       // If we can't analyze, just return default values
+      debug('Failed to analyze package %s: %O', packageName, error);
     }
 
     return analysis;
   }
 
   private async getDirectorySize(dirPath: string): Promise<number> {
+    debug('Calculating size for directory: %s', dirPath);
     let size = 0;
 
     try {
@@ -145,31 +171,37 @@ export class NodeModulesAnalyzer {
         if (entry.isDirectory()) {
           // Skip nested node_modules to avoid double counting
           if (entry.name === 'node_modules') {
+            debug('Skipping nested node_modules in: %s', dirPath);
             continue;
           }
           size += await this.getDirectorySize(entryPath);
         } else if (entry.isFile()) {
           try {
             const stats = await fs.stat(entryPath);
             size += stats.size;
-          } catch {
+          } catch (error) {
             // Skip files we can't read
+            debug('Failed to read file %s: %O', entryPath, error);
           }
         }
       }
-    } catch {
+    } catch (error) {
       // Return 0 if we can't read the directory
+      debug('Failed to read directory %s: %O', dirPath, error);
     }
 
+    debug('Total size for %s: %d bytes', dirPath, size);
     return size;
   }
 
   private async getDependencyDepth(packagePath: string, visited = new Set<string>()): Promise<number> {
     // Prevent infinite recursion
     if (visited.has(packagePath)) {
+      debug('Circular dependency detected, skipping: %s', packagePath);
       return 0;
     }
     visited.add(packagePath);
+    debug('Calculating depth for: %s', packagePath);
 
     try {
       const packageJsonPath = path.join(packagePath, 'package.json');
@@ -182,14 +214,17 @@ export class NodeModulesAnalyzer {
       };
 
       if (!dependencies || Object.keys(dependencies).length === 0) {
+        debug('No dependencies found for: %s', packagePath);
         return 0;
       }
+      debug('Found %d dependencies for: %s', Object.keys(dependencies).length, packagePath);
 
       let maxDepth = 0;
       const nodeModulesPath = path.join(packagePath, 'node_modules');
 
       // Check if this package has its own node_modules
       if (await this.directoryExists(nodeModulesPath)) {
+        debug('Checking nested node_modules: %s', nodeModulesPath);
         for (const depName of Object.keys(dependencies)) {
           const depPath = await this.findDependencyPath(nodeModulesPath, depName);
           if (depPath) {
@@ -199,27 +234,33 @@ export class NodeModulesAnalyzer {
         }
       }
 
+      debug('Max depth for %s: %d', packagePath, maxDepth);
       return maxDepth;
 
-    } catch {
+    } catch (error) {
+      debug('Failed to calculate depth for %s: %O', packagePath, error);
       return 0;
     }
   }
 
   private async findDependencyPath(nodeModulesPath: string, depName: string): Promise<string | null> {
+    debug('Looking for dependency %s in %s', depName, nodeModulesPath);
     // Check for scoped package
     if (depName.includes('/')) {
       const depPath = path.join(nodeModulesPath, depName);
       if (await this.directoryExists(depPath)) {
+        debug('Found scoped dependency at: %s', depPath);
         return depPath;
       }
     } else {
       const depPath = path.join(nodeModulesPath, depName);
       if (await this.directoryExists(depPath)) {
+        debug('Found dependency at: %s', depPath);
         return depPath;
       }
     }
 
+    debug('Dependency %s not found in %s', depName, nodeModulesPath);
     return null;
   }