Performance

// From parseImports.go:1505
func ParseImportsFromFiles(filePaths []string, ...) {
    // Create worker pool with 2x CPU cores
    maxConcurrency := runtime.GOMAXPROCS(0) * 2
    sem := make(chan struct{}, maxConcurrency)
    
    for _, filePath := range filePaths {
        wg.Add(1)
        sem <- struct{}{} // Acquire semaphore
        
        go func(path string) {
            defer func() { <-sem }() // Release
            
            // Parse this file in parallel
            fileContent, _ := os.ReadFile(path)
            imports := ParseImportsByte(fileContent, ...)
            
            // Safe concurrent append
            mu.Lock()
            results = append(results, imports)
            mu.Unlock()
        }(filePath)
    }
    
    wg.Wait()
}

// From main.go:274
for _, entryPoint := range entryPoints {
    wg.Add(1)
    sem <- struct{}{}
    
    go func(ep string) {
        defer func() { <-sem }()
        
        // Build dependency graph for this entry point
        depsGraph := buildDepsGraphForMultiple(minimalTree, []string{ep}, ...)
        
        mu.Lock()
        allGraphs = append(allGraphs, depsGraph)
        mu.Unlock()
    }(entryPoint)
}

// Pseudo-code for config execution
// 1. Build dependency tree ONCE
minimalTree := GetMinimalDepsTreeForCwd(...)

// 2. Process all rules in parallel
for _, rule := range config.Rules {
    go func(rule) {
        // 3. Run all checks for this rule in parallel
        var wg sync.WaitGroup
        
        wg.Add(1)
        go checkCircularDeps(minimalTree)
        
        wg.Add(1) 
        go checkOrphanFiles(minimalTree)
        
        wg.Add(1)
        go checkUnusedExports(minimalTree)
        
        wg.Wait()
    }(rule)
}

// From parseImports.go:1370
for i < n {
    switch code[i] {
    case 'i':
        // Check for 'import' keyword
        if isImportKeywordStart(i) {
            module, next := parseImportStatement(i)
            imports = append(imports, module)
            i = next
            continue
        }
    case 'e':
        // Check for 'export' keyword
        if isExportKeywordStart(i) {
            module, next := parseExportStatement(i)
            imports = append(imports, module)
            i = next
            continue
        }
    }
    i++
}

// From parseImports.go:299
func skipToStringEnd(code []byte, start int, quote byte) int {
    i := start + 1
    for i < len(code) {
        if code[i] == quote {
            return i
        }
        if code[i] == '\\' && i+1 < len(code) {
            i += 2  // Skip escape sequence
        } else {
            i++
        }
    }
    return i
}

// From parseImports.go:1374
if depth > 0 {
    // Fast path: only look for dynamic import() and require()
    switch code[i] {
    case '{':
        depth++
    case '}':
        depth--
    case 'i':
        if isImportKeywordStart(i) && code[i+6] == '(' {
            // Dynamic import
        }
    }
} else {
    // Full keyword scanning at top level
}

// Pre-allocate with capacity
imports := make([]Import, 0, 32)
path := make([]string, 0, 64)

// Reuse the same path slice during DFS
path = append(path, node)
// ...
path = path[:len(path)-1]  // Shrink instead of allocating new

func ParseImportsByte(code []byte, ...) []Import {
    // Work directly with bytes
    if code[i] == 'i' && code[i+1] == 'm' && code[i+2] == 'p' ...
}

visited := make(map[string]bool)
if visited[filePath] {
    return  // Reuse existing string
}

// From main.go:1442
func GetMinimalDepsTreeForCwd(cwd string, ...) MinimalDependencyTree {
    // 1. Discover all files (parallel walk)
    files := GetFiles(cwd, []string{}, excludePatterns)
    
    // 2. Parse imports (parallel parsing)
    fileImportsArr, _ := ParseImportsFromFiles(files, ...)
    
    // 3. Resolve imports (single pass)
    fileImportsArr, _, _ := ResolveImports(...)
    
    // 4. Build minimal tree (single pass)
    minimalTree := TransformToMinimalDependencyTreeCustomParser(fileImportsArr)
    
    return minimalTree  // Reused for all checks
}

# Slow: builds tree 3 times
rev-dep circular       # Build tree → detect cycles
rev-dep node-modules unused  # Build tree → check modules
rev-dep entry-points   # Build tree → find entry points

# Fast: builds tree once
rev-dep config run     # Build tree → run all checks in parallel

# View CPU usage during analysis
rev-dep config run &
PID=$!
top -p $PID

# You'll see 800%+ CPU usage on 8-core machines

# ❌ Slow: builds tree multiple times
rev-dep circular
rev-dep node-modules unused
rev-dep entry-points

# ✅ Fast: builds tree once
rev-dep config run

# .gitignore
node_modules/
dist/
build/
.next/
*.generated.ts

{
  "prodEntryPoints": [
    "src/main.tsx",
    "src/pages/**/*.tsx"
  ],
  "devEntryPoints": [
    "scripts/**/*.ts",
    "**/*.test.ts"
  ]
}

{
  "unusedNodeModulesDetection": {
    "enabled": true,
    "excludeModules": ["@types/**"],  // Skip type packages
    "includeModules": ["@myorg/**"]   // Only check our packages
  }
}

# .github/workflows/checks.yml
- name: Check dependencies
  run: rev-dep config run
  
- name: Cache rev-dep results
  uses: actions/cache@v3
  with:
    path: .rev-dep-cache
    key: ${{ hashFiles('**/*.ts', '**/*.tsx') }}