@sun-asterisk/sunlint 1.3.34 → 1.3.35

package/engines/impact/core/utils/method-call-graph.js

@@ -0,0 +1,1192 @@
+/**
+ * Method-Level Call Graph using ts-morph
+ * Tracks which methods call which other methods across files
+ */
+
+import { Project, SyntaxKind } from 'ts-morph';
+import path from 'path';
+
+export class MethodCallGraph {
+  constructor() {
+    this.project = null;
+    this.methodCallMap = new Map(); // method -> [callers] (reverse map)
+    this.methodCallsMap = new Map(); // method -> [methods it calls] (forward map)
+    this.methodToFile = new Map(); // method -> file path
+    this.methodToEndpoint = new Map(); // method -> endpoint info
+    this.interfaceToClass = new Map(); // interface name -> concrete class name
+    this.commandNameToClass = new Map(); // command name -> command handler class
+    this.endpointToCommandNames = new Map(); // endpoint method -> [command names]
+    this.queueNameToProcessor = new Map(); // queue name -> processor class name
+    this.methodToQueueProcessor = new Map(); // method -> queue processor info
+    this.endpointToQueueNames = new Map(); // endpoint method -> [queue names]
+  }
+
+  /**
+   * Initialize ts-morph project and build call graph
+   */
+  async initialize(sourceDir, excludePaths = [], verbose = false) {
+    this.verbose = verbose;
+    
+    this.project = new Project({
+      tsConfigFilePath: path.join(sourceDir, '../tsconfig.json'),
+      skipAddingFilesFromTsConfig: true,
+    });
+
+    // Add source files
+    this.project.addSourceFilesAtPaths(`${sourceDir}/**/*.ts`);
+
+    // Filter out excluded paths
+    const sourceFiles = this.project.getSourceFiles().filter(sf => {
+      const filePath = sf.getFilePath();
+      return !excludePaths.some(ex => filePath.includes(ex));
+    });
+
+    for (const sourceFile of sourceFiles) {
+      this.extractInterfaceMappings(sourceFile);
+      this.extractCommandMappings(sourceFile);
+      this.extractQueueProcessorMappings(sourceFile);
+    }
+
+    for (const sourceFile of sourceFiles) {
+      this.analyzeFile(sourceFile);
+    }
+
+    return this;
+  }
+
+  /**
+   * Analyze a single file to extract method definitions and calls
+   */
+  analyzeFile(sourceFile) {
+    const filePath = sourceFile.getFilePath();
+
+    // Get all classes
+    const classes = sourceFile.getClasses();
+
+    for (const classDecl of classes) {
+      const className = classDecl.getName();
+      if (!className) continue; // Skip anonymous classes
+
+      // Check if this class is a queue processor
+      const classDecorators = classDecl.getDecorators();
+      const processorDecorator = classDecorators.find(d => d.getName() === 'Processor');
+      let processorQueueName = null;
+
+      if (processorDecorator) {
+        const args = processorDecorator.getArguments();
+        processorQueueName = args[0]?.getText().replace(/['"]/g, '');
+      }
+
+      // Get all methods in this class
+      const methods = classDecl.getMethods();
+
+      for (const method of methods) {
+        const methodName = method.getName();
+        const fullMethodName = `${className}.${methodName}`;
+
+        // Store method location
+        this.methodToFile.set(fullMethodName, filePath);
+
+        // Check if this is an endpoint method (has HTTP decorator)
+        const decorators = method.getDecorators();
+        const httpDecorator = decorators.find(d => 
+          ['Get', 'Post', 'Put', 'Delete', 'Patch', 'Options', 'Head', 'All'].includes(d.getName())
+        );
+
+        if (httpDecorator) {
+          const decoratorName = httpDecorator.getName();
+          const args = httpDecorator.getArguments();
+          const route = args[0]?.getText().replace(/['"]/g, '') || '/';
+
+          this.methodToEndpoint.set(fullMethodName, {
+            method: decoratorName.toUpperCase(),
+            path: route,
+            controller: className,
+            file: filePath,
+          });
+        }
+
+        // Check if this is a queue processor method (has @Process decorator)
+        const processDecorator = decorators.find(d => d.getName() === 'Process');
+        if (processDecorator && processorQueueName) {
+          const args = processDecorator.getArguments();
+          const jobName = args[0]?.getText().replace(/['"]/g, '') || '';
+
+          this.methodToQueueProcessor.set(fullMethodName, {
+            queueName: processorQueueName,
+            jobName: jobName,
+            processor: className,
+            method: methodName,
+            file: filePath,
+          });
+
+          if (this.verbose) {
+            console.log(`   🔄 Found queue processor: ${processorQueueName}${jobName ? `/${jobName}` : ''} → ${fullMethodName}`);
+          }
+        }
+
+        // Find all method calls within this method
+        this.analyzeMethodCalls(method, className, fullMethodName);
+
+        // Detect command dispatches and queue jobs in ALL methods (not just endpoints)
+        // This allows us to track: Controller → Service → Queue → Processor
+        this.detectCommandDispatches(method, fullMethodName);
+        this.detectQueueDispatches(method, fullMethodName);
+      }
+    }
+  }
+
+  /**
+   * Detect command dispatches in endpoint methods
+   * Handles both patterns:
+   * 1. Direct string: publishMessage('commandName', ...)
+   * 2. Object with command property: publishMessage({ message: { command: 'commandName' } })
+   */
+  detectCommandDispatches(method, fullMethodName) {
+    const callExpressions = method.getDescendantsOfKind(SyntaxKind.CallExpression);
+    const commandNames = [];
+
+    for (const call of callExpressions) {
+      const expression = call.getExpression();
+
+      // Look for method calls that might dispatch commands
+      if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+        const methodName = expression.getName();
+
+        // Common command dispatch patterns (partial match)
+        const dispatchMethods = [
+          'sendCommand', 'send', 'execute', 'dispatch',
+          'publish', 'emit', 'trigger', 'enqueue'
+        ];
+
+        // Check if method name contains or matches any dispatch pattern
+        const isDispatchMethod = dispatchMethods.some(pattern => {
+          const lowerMethodName = methodName.toLowerCase();
+          const lowerPattern = pattern.toLowerCase();
+
+          // Exact match
+          if (lowerMethodName === lowerPattern) return true;
+
+          // Contains pattern (e.g., publishMessage contains 'publish')
+          if (lowerMethodName.includes(lowerPattern)) return true;
+
+          return false;
+        });
+
+        if (isDispatchMethod) {
+          const args = call.getArguments();
+
+          if (args.length > 0) {
+            const firstArg = args[0];
+
+            // Pattern 1: Direct string literal
+            // Example: publishMessage('commandName', ...)
+            if (firstArg.getKind() === SyntaxKind.StringLiteral) {
+              const commandName = firstArg.getText().replace(/['"]/g, '');
+              commandNames.push(commandName);
+
+              if (this.verbose) {
+                console.log(`   📨 Found command dispatch: ${fullMethodName} → '${commandName}' (via ${methodName})`);
+              }
+            }
+
+            // Pattern 2: Object literal with command property
+            // Example: publishMessage({ message: { command: 'commandName' } })
+            else if (firstArg.getKind() === SyntaxKind.ObjectLiteralExpression) {
+              const commandName = this.extractCommandFromObject(firstArg, method);
+
+              if (commandName) {
+                commandNames.push(commandName);
+
+                if (this.verbose) {
+                  console.log(`   📨 Found command dispatch: ${fullMethodName} → '${commandName}' (via ${methodName}, object pattern)`);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (commandNames.length > 0) {
+      this.endpointToCommandNames.set(fullMethodName, commandNames);
+    }
+  }
+
+  /**
+   * Extract command name from object literal
+   * Handles patterns like:
+   * - { command: 'xxx' }
+   * - { message: { command: 'xxx' } }
+   * - { command: variable } (resolves variable value if possible)
+   * - { command } (ES6 shorthand - resolves variable)
+   */
+  extractCommandFromObject(objectLiteral, method) {
+    const properties = objectLiteral.getProperties();
+
+    for (const prop of properties) {
+      const propKind = prop.getKind();
+
+      // Handle ES6 shorthand: { command } → same as { command: command }
+      if (propKind === SyntaxKind.ShorthandPropertyAssignment) {
+        const propName = prop.getName();
+
+        if (propName === 'command') {
+          // The property name IS the variable name in shorthand
+          const variableName = propName;
+
+          // Try to resolve the variable value
+          const resolvedValue = this.resolveVariableValue(variableName, method);
+
+          if (resolvedValue) {
+            return resolvedValue;
+          }
+
+          // Fallback: return variable name if can't resolve
+          return variableName;
+        }
+      }
+
+      // Handle regular property assignment: { command: 'xxx' } or { command: variable }
+      if (propKind === SyntaxKind.PropertyAssignment) {
+        const propName = prop.getName();
+        const initializer = prop.getInitializer();
+
+        // Direct: { command: 'xxx' }
+        if (propName === 'command') {
+          if (initializer && initializer.getKind() === SyntaxKind.StringLiteral) {
+            return initializer.getText().replace(/['"]/g, '');
+          }
+
+          // { command: variable } - resolve variable value
+          if (initializer && initializer.getKind() === SyntaxKind.Identifier) {
+            const variableName = initializer.getText();
+
+            // Try to resolve the variable value
+            const resolvedValue = this.resolveVariableValue(variableName, method);
+
+            if (resolvedValue) {
+              return resolvedValue;
+            }
+
+            // Fallback: return variable name if can't resolve
+            return variableName;
+          }
+        }
+
+        // Nested: { message: { command: 'xxx' } } or { message: { command } }
+        if (propName === 'message' && initializer &&
+            initializer.getKind() === SyntaxKind.ObjectLiteralExpression) {
+          const nestedCommand = this.extractCommandFromObject(initializer, method);
+          if (nestedCommand) return nestedCommand;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Resolve variable value from its declaration
+   * Example: const command = 'exportCsv'; → returns 'exportCsv'
+   */
+  resolveVariableValue(variableName, method) {
+    if (!method) return null;
+
+    // Get all variable declarations in this method
+    const variableDeclarations = method.getDescendantsOfKind(SyntaxKind.VariableDeclaration);
+
+    for (const varDecl of variableDeclarations) {
+      if (varDecl.getName() === variableName) {
+        const initializer = varDecl.getInitializer();
+
+        // If initialized with string literal
+        if (initializer && initializer.getKind() === SyntaxKind.StringLiteral) {
+          return initializer.getText().replace(/['"]/g, '');
+        }
+
+        // If initialized with another identifier, try to resolve that too (one level)
+        if (initializer && initializer.getKind() === SyntaxKind.Identifier) {
+          const nestedVarName = initializer.getText();
+          return this.resolveVariableValue(nestedVarName, method);
+        }
+      }
+    }
+
+    // Check method parameters
+    const parameters = method.getParameters();
+    for (const param of parameters) {
+      if (param.getName() === variableName) {
+        // Can't resolve parameter values statically
+        return variableName;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Extract command name -> class mappings from @Command decorators
+   */
+  extractCommandMappings(sourceFile) {
+    const classes = sourceFile.getClasses();
+
+    for (const classDecl of classes) {
+      const commandDecorator = classDecl.getDecorator('Command');
+      if (!commandDecorator) continue;
+
+      const className = classDecl.getName();
+      if (!className) continue;
+
+      const args = commandDecorator.getArguments();
+      if (args.length === 0) continue;
+
+      const configObj = args[0];
+      if (!configObj) continue;
+
+      const text = configObj.getText();
+
+      // Pattern: { name: 'commandName', ... }
+      const nameMatch = text.match(/name:\s*['"]([^'"]+)['"]/);
+
+      if (nameMatch) {
+        const commandName = nameMatch[1];
+        this.commandNameToClass.set(commandName, className);
+      }
+    }
+  }
+
+  /**
+   * Extract interface -> class mappings from NestJS modules
+   */
+  extractInterfaceMappings(sourceFile) {
+    // Look for @Module decorators
+    const classes = sourceFile.getClasses();
+    
+    for (const classDecl of classes) {
+      const moduleDecorator = classDecl.getDecorator('Module');
+      if (!moduleDecorator) continue;
+
+      const args = moduleDecorator.getArguments();
+      if (args.length === 0) continue;
+
+      const configObj = args[0];
+      if (!configObj) continue;
+
+      // Parse the configuration object
+      const text = configObj.getText();
+      
+      // Pattern: { provide: 'IXxx', useClass: Xxx }
+      // or: { provide: 'IXxx', useClass: Xxx, }
+      const providerPattern = /\{\s*provide:\s*['"](\w+)['"]\s*,\s*useClass:\s*(\w+)/g;
+      
+      let match;
+      while ((match = providerPattern.exec(text)) !== null) {
+        const interfaceName = match[1];
+        const className = match[2];
+        
+        this.interfaceToClass.set(interfaceName, className);
+      }
+    }
+  }
+
+  /**
+   * Analyze all method calls within a method
+   */
+  analyzeMethodCalls(method, className, fullMethodName) {
+    const callExpressions = method.getDescendantsOfKind(SyntaxKind.CallExpression);
+
+    for (const call of callExpressions) {
+      const expression = call.getExpression();
+      
+      // Handle method calls: this.method(), service.method(), this.repo.method()
+      if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+        const calledMethod = expression.getName();
+        const objExpression = expression.getExpression();
+        
+        let calledClassName = null;
+        
+        // Special handling for 'this' keyword
+        if (objExpression.getKind() === SyntaxKind.ThisKeyword) {
+          calledClassName = className;
+        } else {
+          // Use TypeScript's type checker to resolve the type
+          const type = objExpression.getType();
+          const symbol = type.getSymbol();
+          
+          if (symbol) {
+            calledClassName = symbol.getName();
+
+            // Check if this is an interface - map to concrete class
+            if (this.interfaceToClass.has(calledClassName)) {
+              const concreteClass = this.interfaceToClass.get(calledClassName);
+              calledClassName = concreteClass;
+            }
+
+            // Handle interface naming convention (IXxx -> Xxx)
+            if (calledClassName.startsWith('I') && calledClassName.length > 1) {
+              const possibleClassName = calledClassName.substring(1);
+              if (this.classExists(possibleClassName)) {
+                calledClassName = possibleClassName;
+              }
+            }
+          }
+        }
+
+        if (calledClassName) {
+          this.recordMethodCall(fullMethodName, calledClassName, calledMethod);
+        }
+      }
+    }
+  }
+
+  /**
+   * Check if a class exists in the project
+   */
+  classExists(className) {
+    for (const [methodName] of this.methodToFile) {
+      if (methodName.startsWith(`${className}.`)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Record a method call in both forward and reverse maps
+   */
+  recordMethodCall(callerFullName, calleeClassName, calleeMethodName) {
+    const calleeFullName = `${calleeClassName}.${calleeMethodName}`;
+
+    // Add to reverse map (who calls this method)
+    if (!this.methodCallMap.has(calleeFullName)) {
+      this.methodCallMap.set(calleeFullName, []);
+    }
+
+    const callers = this.methodCallMap.get(calleeFullName);
+    if (!callers.includes(callerFullName)) {
+      callers.push(callerFullName);
+    }
+
+    // Add to forward map (what this method calls)
+    if (!this.methodCallsMap.has(callerFullName)) {
+      this.methodCallsMap.set(callerFullName, []);
+    }
+
+    const calls = this.methodCallsMap.get(callerFullName);
+    if (!calls.includes(calleeFullName)) {
+      calls.push(calleeFullName);
+    }
+  }
+
+  /**
+   * Get changed methods from git diff
+   * Uses ts-morph AST to detect which specific methods contain changes
+   */
+  getChangedMethods(diff, filePath) {
+    if (!diff || !filePath) return [];
+
+    const sourceFile = this.project.getSourceFile(filePath);
+    if (!sourceFile) return [];
+
+    // Extract changed line numbers from diff
+    const changedLines = this.extractChangedLineNumbers(diff);
+    if (changedLines.length === 0) return [];
+
+    const changedMethods = [];
+    
+    // Get all classes in the file
+    const classes = sourceFile.getClasses();
+    
+    for (const classDecl of classes) {
+      const className = classDecl.getName();
+      if (!className) continue;
+      
+      const methods = classDecl.getMethods();
+      
+      for (const method of methods) {
+        const methodName = method.getName();
+        
+        // Check if this specific method contains changes
+        if (this.methodContainsChanges(method, changedLines)) {
+          changedMethods.push({
+            className: className,
+            methodName: methodName,
+            file: filePath,
+            fullName: `${className}.${methodName}`
+          });
+        }
+      }
+    }
+    
+    return changedMethods;
+  }
+
+  /**
+   * Check if a method contains actual code changes using ts-morph AST
+   */
+  methodContainsChanges(method, changedLines) {
+    const body = method.getBody();
+    if (!body) return false;
+
+    // Get the method body block (excluding signature and decorators)
+    const bodyStartLine = body.getStartLineNumber();
+    const bodyEndLine = body.getEndLineNumber();
+
+    // Check if any changed line is within the method body
+    const hasChangesInBody = changedLines.some(
+      line => line >= bodyStartLine && line <= bodyEndLine
+    );
+
+    return hasChangesInBody;
+  }
+
+  /**
+   * Extract line numbers that were changed from git diff
+   */
+  extractChangedLineNumbers(diff) {
+    const changedLines = [];
+    const lines = diff.split('\n');
+    let currentLine = 0;
+
+    for (const line of lines) {
+      // Parse diff hunk headers: @@ -old +new @@
+      const hunkMatch = line.match(/^@@\s+-\d+(?:,\d+)?\s+\+(\d+)(?:,\d+)?\s+@@/);
+      if (hunkMatch) {
+        currentLine = parseInt(hunkMatch[1], 10);
+        continue;
+      }
+
+      // Track line numbers for added/modified lines
+      if (line.startsWith('+') && !line.startsWith('+++')) {
+        changedLines.push(currentLine);
+        currentLine++;
+      } else if (line.startsWith('-') && !line.startsWith('---')) {
+        // Don't increment for deleted lines (they don't exist in new file)
+        continue;
+      } else if (!line.startsWith('\\')) {
+        // Context lines (no +/-)
+        currentLine++;
+      }
+    }
+
+    return changedLines;
+  }
+
+  /**
+   * Resolve object type from variable/property name
+   */
+  resolveObjectType(objectName, sourceFile, classes) {
+    // Handle 'this.property' pattern
+    if (objectName.startsWith('this.')) {
+      const propertyName = objectName.replace('this.', '');
+      if (classes.length > 0) {
+        return this.resolvePropertyType(classes[0], propertyName);
+      }
+      return null;
+    }
+
+    // Check if it's 'this' or 'super'
+    if (objectName === 'this' && classes.length > 0) {
+      return classes[0].getName();
+    }
+
+    // Try to find the type from the current class
+    for (const classDecl of classes) {
+      // Check constructor parameters (DI)
+      const constructor = classDecl.getConstructors()[0];
+      if (constructor) {
+        const params = constructor.getParameters();
+        for (const param of params) {
+          const paramName = param.getName();
+          if (paramName === objectName) {
+            const type = param.getType();
+            const symbol = type.getSymbol();
+            if (symbol) {
+              return symbol.getName();
+            }
+          }
+        }
+      }
+
+      // Check class properties
+      const properties = classDecl.getProperties();
+      for (const prop of properties) {
+        if (prop.getName() === objectName) {
+          const type = prop.getType();
+          const symbol = type.getSymbol();
+          if (symbol) {
+            return symbol.getName();
+          }
+        }
+      }
+
+      // Check local variables in methods (simplified)
+      const methods = classDecl.getMethods();
+      for (const method of methods) {
+        const variableDeclarations = method.getDescendantsOfKind(SyntaxKind.VariableDeclaration);
+        for (const varDecl of variableDeclarations) {
+          if (varDecl.getName() === objectName) {
+            const type = varDecl.getType();
+            const symbol = type.getSymbol();
+            if (symbol) {
+              return symbol.getName();
+            }
+          }
+        }
+      }
+    }
+
+    // If we can't resolve, try to guess from naming convention
+    return this.guessTypeFromVariableName(objectName);
+  }
+
+  /**
+   * Guess class name from variable name using naming conventions
+   */
+  guessTypeFromVariableName(variableName) {
+    // Convert camelCase to PascalCase
+    return variableName.charAt(0).toUpperCase() + variableName.slice(1);
+  }
+
+  /**
+   * Get direct callers of a method
+   */
+  getCallers(methodName) {
+    return this.methodCallMap.get(methodName) || [];
+  }
+
+  /**
+   * Find all callers of a method (recursive)
+   */
+  findAllCallers(methodName, visited = new Set(), depth = 0) {
+    if (visited.has(methodName)) return [];
+
+    visited.add(methodName);
+    const directCallers = this.methodCallMap.get(methodName) || [];
+    let allCallers = [...directCallers];
+
+    if (this.verbose && depth === 0) {
+      console.log(`      Tracing callers of: ${methodName}`);
+      console.log(`      Direct callers: ${directCallers.join(', ') || 'none'}`);
+    }
+
+    // Recursively find callers of callers
+    for (const caller of directCallers) {
+      if (this.verbose && depth === 0) {
+        console.log(`      Tracing up from: ${caller}`);
+      }
+      const indirectCallers = this.findAllCallers(caller, visited, depth + 1);
+      allCallers = allCallers.concat(indirectCallers);
+    }
+
+    return [...new Set(allCallers)]; // Remove duplicates
+  }
+
+  /**
+   * Find affected endpoints from changed methods
+   * Traverses up the call chain: Repository → Service → Controller → Endpoint
+   */
+  findAffectedEndpoints(changedMethods) {
+    const affectedEndpoints = [];
+    const processedMethods = new Set();
+
+    const methodNames = changedMethods.map(m =>
+      typeof m === 'string' ? m : m.fullName
+    );
+
+    if (this.verbose) {
+      console.log('\n   🔍 Finding affected endpoints...');
+      console.log(`   Changed methods: ${methodNames.join(', ')}`);
+    }
+
+    for (const changedMethod of methodNames) {
+      const startLayer = this.getMethodLayer(changedMethod);
+
+      if (this.verbose) {
+        console.log(`\n   📌 Processing: ${changedMethod} (${startLayer})`);
+      }
+
+      const callers = this.findAllCallers(changedMethod);
+
+      if (this.verbose) {
+        console.log(`      All callers (${callers.length}): ${callers.join(', ') || 'none'}`);
+      }
+
+      const endpointCallers = this.filterUpToEndpoints(changedMethod, callers);
+
+      if (this.verbose) {
+        console.log(`      Endpoint callers (${endpointCallers.length}): ${endpointCallers.join(', ') || 'none'}`);
+      }
+
+      for (const caller of endpointCallers) {
+        if (processedMethods.has(caller)) continue;
+        processedMethods.add(caller);
+
+        const endpoint = this.methodToEndpoint.get(caller);
+        if (endpoint) {
+          const callChain = this.getCallChain(changedMethod, caller);
+
+          if (this.verbose) {
+            console.log(`      ✅ Found endpoint: ${endpoint.method} ${endpoint.path}`);
+            console.log(`         Call chain: ${callChain.join(' → ')}`);
+          }
+
+          affectedEndpoints.push({
+            ...endpoint,
+            affectedBy: changedMethod,
+            callChain: callChain,
+            layers: this.getCallChainLayers(callChain),
+            impactLevel: this.calculateImpactLevel(callChain),
+          });
+        }
+      }
+
+      const endpoint = this.methodToEndpoint.get(changedMethod);
+      if (endpoint && !processedMethods.has(changedMethod)) {
+        processedMethods.add(changedMethod);
+
+        if (this.verbose) {
+          console.log(`      ✅ Changed method itself is an endpoint: ${endpoint.method} ${endpoint.path}`);
+        }
+
+        affectedEndpoints.push({
+          ...endpoint,
+          affectedBy: changedMethod,
+          callChain: [changedMethod],
+          layers: [startLayer],
+          impactLevel: 'high',  // Direct endpoint change is always high impact
+        });
+      }
+
+      // Check if changed method is in a Command handler
+      const commandEndpoints = this.findEndpointsByCommand(changedMethod);
+      for (const cmdEndpoint of commandEndpoints) {
+        if (processedMethods.has(cmdEndpoint.endpointMethod)) continue;
+        processedMethods.add(cmdEndpoint.endpointMethod);
+
+        affectedEndpoints.push(cmdEndpoint);
+      }
+
+      // NEW: Check if changed method is in a Queue Processor
+      const queueEndpoints = this.findEndpointsByQueue(changedMethod);
+      for (const queueEndpoint of queueEndpoints) {
+        const endpointKey = queueEndpoint.endpointMethod || queueEndpoint.path;
+        if (processedMethods.has(endpointKey)) continue;
+        processedMethods.add(endpointKey);
+
+        affectedEndpoints.push(queueEndpoint);
+      }
+
+      // NEW: Check if any CALLER is in a Command handler
+      // Flow: ServiceB (changed) → ServiceA → Command.run → find endpoint
+      for (const caller of callers) {
+        const callerCommandEndpoints = this.findEndpointsByCommand(caller);
+        for (const cmdEndpoint of callerCommandEndpoints) {
+          if (processedMethods.has(cmdEndpoint.endpointMethod)) continue;
+          processedMethods.add(cmdEndpoint.endpointMethod);
+
+          if (this.verbose) {
+            console.log(`      🔗 Caller '${caller}' is in a command handler`);
+          }
+
+          affectedEndpoints.push(cmdEndpoint);
+        }
+
+        // NEW: Check if any CALLER is in a Queue Processor
+        const callerQueueEndpoints = this.findEndpointsByQueue(caller);
+        for (const queueEndpoint of callerQueueEndpoints) {
+          const endpointKey = queueEndpoint.endpointMethod || queueEndpoint.path;
+          if (processedMethods.has(endpointKey)) continue;
+          processedMethods.add(endpointKey);
+
+          if (this.verbose) {
+            console.log(`      🔗 Caller '${caller}' is in a queue processor`);
+          }
+
+          affectedEndpoints.push(queueEndpoint);
+        }
+      }
+    }
+
+    return affectedEndpoints;
+  }
+
+  /**
+   * Find endpoints that dispatch commands handled by the changed method
+   */
+  findEndpointsByCommand(changedMethod) {
+    const affectedEndpoints = [];
+
+    // Get the class name from the changed method
+    const className = changedMethod.split('.')[0];
+
+    // Check if this class is a command handler
+    let commandName = null;
+    for (const [cmdName, cmdClass] of this.commandNameToClass) {
+      if (cmdClass === className) {
+        commandName = cmdName;
+        break;
+      }
+    }
+
+    if (!commandName) {
+      return affectedEndpoints;
+    }
+
+    // Find endpoints that dispatch this command
+    for (const [endpointMethod, commandNames] of this.endpointToCommandNames) {
+      if (commandNames.includes(commandName)) {
+        const endpoint = this.methodToEndpoint.get(endpointMethod);
+
+        if (endpoint) {
+          if (this.verbose) {
+            console.log(`      ✅ Found endpoint via command: ${endpoint.method} ${endpoint.path}`);
+            console.log(`         Command chain: ${changedMethod} ← '${commandName}' ← ${endpointMethod}`);
+          }
+
+          affectedEndpoints.push({
+            ...endpoint,
+            affectedBy: changedMethod,
+            callChain: [changedMethod, `Command: '${commandName}'`, endpointMethod],
+            layers: [this.getMethodLayer(changedMethod), 'Command', this.getMethodLayer(endpointMethod)],
+            viaCommand: commandName,
+            endpointMethod: endpointMethod,
+            impactLevel: this.calculateImpactLevel([changedMethod, `Command: '${commandName}'`, endpointMethod]),
+          });
+        }
+      }
+    }
+
+    return affectedEndpoints;
+  }
+
+  /**
+   * Find endpoints that dispatch queue jobs handled by the changed method
+   * Handles two patterns:
+   * 1. Controller → Queue.add() → Processor (direct)
+   * 2. Controller → Service → Queue.add() → Processor (indirect)
+   */
+  findEndpointsByQueue(changedMethod) {
+    const affectedEndpoints = [];
+
+    // Check if this method is a queue processor method
+    const queueProcessorInfo = this.methodToQueueProcessor.get(changedMethod);
+    
+    if (!queueProcessorInfo) {
+      return affectedEndpoints;
+    }
+
+    const { queueName, jobName } = queueProcessorInfo;
+    const queueLabel = jobName ? `${queueName}/${jobName}` : queueName;
+
+    // Find all methods (endpoints OR services) that dispatch to this queue
+    for (const [methodName, queueNames] of this.endpointToQueueNames) {
+      if (queueNames.includes(queueName)) {
+        const endpoint = this.methodToEndpoint.get(methodName);
+
+        if (endpoint) {
+          // Pattern 1: Direct endpoint → queue
+          if (this.verbose) {
+            console.log(`      ✅ Found endpoint via queue (direct): ${endpoint.method} ${endpoint.path}`);
+            console.log(`         Queue chain: ${changedMethod} ← Queue '${queueLabel}' ← ${methodName}`);
+          }
+
+          affectedEndpoints.push({
+            ...endpoint,
+            affectedBy: changedMethod,
+            callChain: [changedMethod, `Queue: '${queueLabel}'`, methodName],
+            layers: [this.getMethodLayer(changedMethod), 'Queue', this.getMethodLayer(methodName)],
+            viaQueue: queueLabel,
+            endpointMethod: methodName,
+            impactLevel: this.calculateImpactLevel([changedMethod, `Queue: '${queueLabel}'`, methodName]),
+          });
+        } else {
+          // Pattern 2: Service method triggers queue, find controllers that call this service
+          // Flow: Processor ← Queue ← Service ← Controller
+          const serviceCallers = this.findAllCallers(methodName);
+          const endpointCallers = this.filterUpToEndpoints(methodName, serviceCallers);
+
+          if (this.verbose && endpointCallers.length > 0) {
+            console.log(`      🔗 Service method '${methodName}' triggers queue '${queueLabel}'`);
+            console.log(`         Finding controllers that call this service...`);
+          }
+
+          for (const endpointCaller of endpointCallers) {
+            const endpointInfo = this.methodToEndpoint.get(endpointCaller);
+            
+            if (endpointInfo) {
+              const callChain = this.getCallChain(methodName, endpointCaller);
+              const fullChain = [changedMethod, `Queue: '${queueLabel}'`, ...callChain];
+
+              if (this.verbose) {
+                console.log(`      ✅ Found endpoint via queue (indirect): ${endpointInfo.method} ${endpointInfo.path}`);
+                console.log(`         Full chain: ${fullChain.join(' → ')}`);
+              }
+
+              affectedEndpoints.push({
+                ...endpointInfo,
+                affectedBy: changedMethod,
+                callChain: fullChain,
+                layers: [this.getMethodLayer(changedMethod), 'Queue', ...this.getCallChainLayers(callChain)],
+                viaQueue: queueLabel,
+                endpointMethod: endpointCaller,
+                impactLevel: this.calculateImpactLevel(fullChain),
+              });
+            }
+          }
+        }
+      }
+    }
+
+    return affectedEndpoints;
+  }
+
+  /**
+   * Get the layer/tier of a method based on file path and class name
+   */
+  getMethodLayer(methodName) {
+    const filePath = this.methodToFile.get(methodName);
+    if (!filePath) return 'Unknown';
+
+    const lowerPath = filePath.toLowerCase();
+    const fileName = filePath.split('/').pop().toLowerCase();
+    
+    // Check file path for layer indicators (order matters - most specific first)
+    if (lowerPath.includes('/controllers/') || fileName.includes('.controller.')) return 'Controller';
+    if (lowerPath.includes('/processors/') || fileName.includes('.processor.')) return 'QueueProcessor';
+    if (lowerPath.includes('/services/') || fileName.includes('.service.')) return 'Service';
+    if (lowerPath.includes('/repositories/') || fileName.includes('.repository.')) return 'Repository';
+    if (lowerPath.includes('/providers/') || fileName.includes('.provider.')) return 'Provider';
+    if (lowerPath.includes('/commands/') || fileName.includes('.command.')) return 'Command';
+    if (lowerPath.includes('/queries/') || fileName.includes('.query.')) return 'Query';
+    if (lowerPath.includes('/handlers/') || fileName.includes('.handler.')) return 'Handler';
+    
+    // Additional layers you mentioned
+    if (lowerPath.includes('/dto/') || fileName.includes('.dto.')) return 'DTO';
+    if (lowerPath.includes('/request/') || fileName.includes('.request.')) return 'Request';
+    if (lowerPath.includes('/response/') || fileName.includes('.response.')) return 'Response';
+    if (lowerPath.includes('/config/') || fileName.includes('.config.')) return 'Config';
+    if (lowerPath.includes('/modules/') || fileName.includes('.module.')) return 'Module';
+    if (lowerPath.includes('/entities/') || fileName.includes('.entity.')) return 'Entity';
+    if (lowerPath.includes('/models/') || fileName.includes('.model.')) return 'Model';
+    
+    // Common utility/helper patterns
+    if (lowerPath.includes('/helpers/') || fileName.includes('.helper.')) return 'Helper';
+    if (lowerPath.includes('/utils/') || fileName.includes('.util.')) return 'Utility';
+    if (lowerPath.includes('/middleware/') || fileName.includes('.middleware.')) return 'Middleware';
+    if (lowerPath.includes('/guards/') || fileName.includes('.guard.')) return 'Guard';
+    if (lowerPath.includes('/interceptors/') || fileName.includes('.interceptor.')) return 'Interceptor';
+    if (lowerPath.includes('/decorators/') || fileName.includes('.decorator.')) return 'Decorator';
+    if (lowerPath.includes('/pipes/') || fileName.includes('.pipe.')) return 'Pipe';
+    if (lowerPath.includes('/filters/') || fileName.includes('.filter.')) return 'Filter';
+    
+    // Check class name
+    const className = methodName.split('.')[0];
+    if (className.endsWith('Controller')) return 'Controller';
+    if (className.endsWith('Service')) return 'Service';
+    if (className.endsWith('Repository')) return 'Repository';
+    if (className.endsWith('Provider')) return 'Provider';
+    if (className.endsWith('Command')) return 'Command';
+    if (className.endsWith('Query')) return 'Query';
+    if (className.endsWith('Handler')) return 'Handler';
+    if (className.endsWith('Dto') || className.endsWith('DTO')) return 'DTO';
+    if (className.endsWith('Request')) return 'Request';
+    if (className.endsWith('Response')) return 'Response';
+    if (className.endsWith('Config')) return 'Config';
+    if (className.endsWith('Module')) return 'Module';
+    if (className.endsWith('Entity')) return 'Entity';
+    if (className.endsWith('Model')) return 'Model';
+    if (className.endsWith('Helper')) return 'Helper';
+    if (className.endsWith('Util') || className.endsWith('Utils')) return 'Utility';
+    if (className.endsWith('Middleware')) return 'Middleware';
+    if (className.endsWith('Guard')) return 'Guard';
+    if (className.endsWith('Interceptor')) return 'Interceptor';
+    if (className.endsWith('Decorator')) return 'Decorator';
+    if (className.endsWith('Pipe')) return 'Pipe';
+    if (className.endsWith('Filter')) return 'Filter';
+    
+    return 'Other';
+  }
+
+  /**
+   * Filter callers up through layers to find endpoints
+   * Repository → Service → Controller (endpoint)
+   */
+  filterUpToEndpoints(changedMethod, allCallers) {
+    return allCallers.filter(caller => this.methodToEndpoint.has(caller));
+  }
+
+  /**
+   * Get layers for each method in call chain
+   */
+  getCallChainLayers(callChain) {
+    return callChain.map(method => {
+      if (method === '...') return '...';
+      return this.getMethodLayer(method);
+    });
+  }
+
+  /**
+   * Get the call chain from changed method to endpoint
+   */
+  getCallChain(fromMethod, toMethod) {
+    // Simple BFS to find path
+    const queue = [[fromMethod]];
+    const visited = new Set();
+
+    while (queue.length > 0) {
+      const path = queue.shift();
+      const current = path[path.length - 1];
+
+      if (current === toMethod) {
+        return path;
+      }
+
+      if (visited.has(current)) continue;
+      visited.add(current);
+
+      const callers = this.methodCallMap.get(current) || [];
+      for (const caller of callers) {
+        queue.push([...path, caller]);
+      }
+    }
+
+    return [fromMethod, '...', toMethod];
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return {
+      totalMethods: this.methodToFile.size,
+      totalEndpoints: this.methodToEndpoint.size,
+      totalCallRelationships: Array.from(this.methodCallMap.values())
+        .reduce((sum, callers) => sum + callers.length, 0),
+    };
+  }
+
+  /**
+   * Calculate impact level based on call chain length
+   * Shorter chain = higher impact (closer to endpoint)
+   */
+  calculateImpactLevel(callChain) {
+    const chainLength = callChain.length;
+    
+    // Direct endpoint change or very short chain
+    if (chainLength <= 1) return 'high';
+    
+    // Short chain (2-3 hops)
+    if (chainLength <= 3) return 'medium';
+    
+    // Longer chain
+    return 'low';
+  }
+
+  /**
+   * Extract queue name -> processor class mappings from @Processor decorators
+   */
+  extractQueueProcessorMappings(sourceFile) {
+    const classes = sourceFile.getClasses();
+
+    for (const classDecl of classes) {
+      const className = classDecl.getName();
+      if (!className) continue;
+
+      const decorators = classDecl.getDecorators();
+      const processorDecorator = decorators.find(d => d.getName() === 'Processor');
+
+      if (processorDecorator) {
+        const args = processorDecorator.getArguments();
+        if (args.length > 0) {
+          const queueName = args[0].getText().replace(/['"]/g, '');
+          this.queueNameToProcessor.set(queueName, className);
+
+          if (this.verbose) {
+            console.log(`   🔄 Mapped queue processor: '${queueName}' → ${className}`);
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Detect queue job dispatches in endpoint methods
+   * Handles patterns like:
+   * - await this.queueName.add('job-name', data)
+   * - await queue.add(data)
+   */
+  detectQueueDispatches(method, fullMethodName) {
+    const callExpressions = method.getDescendantsOfKind(SyntaxKind.CallExpression);
+    const queueNames = [];
+
+    for (const call of callExpressions) {
+      const expression = call.getExpression();
+
+      // Look for .add() method calls
+      if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+        const methodName = expression.getName();
+
+        if (methodName === 'add') {
+          // Get the object being called (e.g., 'this.queueName' or 'queue')
+          const objectExpr = expression.getExpression();
+          
+          // Check if it's a property access like 'this.queueName'
+          if (objectExpr.getKind() === SyntaxKind.PropertyAccessExpression) {
+            const queuePropertyName = objectExpr.getName();
+            
+            // Try to find @InjectQueue decorator in constructor
+            const classDecl = method.getParent();
+            if (classDecl && classDecl.getKind() === SyntaxKind.ClassDeclaration) {
+              const constructor = classDecl.getConstructors()[0];
+              if (constructor) {
+                const queueName = this.findQueueNameFromConstructor(constructor, queuePropertyName);
+                if (queueName && !queueNames.includes(queueName)) {
+                  queueNames.push(queueName);
+
+                  if (this.verbose) {
+                    console.log(`   📤 Found queue dispatch: ${fullMethodName} → queue '${queueName}'`);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (queueNames.length > 0) {
+      this.endpointToQueueNames.set(fullMethodName, queueNames);
+    }
+  }
+
+  /**
+   * Find queue name from @InjectQueue decorator in constructor
+   */
+  findQueueNameFromConstructor(constructor, propertyName) {
+    const parameters = constructor.getParameters();
+
+    for (const param of parameters) {
+      // Check if parameter name matches (e.g., 'queueName' parameter)
+      const paramName = param.getName();
+      
+      // Match patterns like:
+      // - private readonly queueName: Queue
+      // - private queueName: Queue
+      if (paramName === propertyName || paramName.includes(propertyName)) {
+        const decorators = param.getDecorators();
+        const injectQueueDecorator = decorators.find(d => d.getName() === 'InjectQueue');
+
+        if (injectQueueDecorator) {
+          const args = injectQueueDecorator.getArguments();
+          if (args.length > 0) {
+            return args[0].getText().replace(/['"]/g, '');
+          }
+        }
+      }
+    }
+
+    return null;
+  }
+}