@sun-asterisk/sunlint 1.3.18 → 1.3.19

package/rules/common/C014_dependency_injection/symbol-based-analyzer.js

@@ -5,7 +5,7 @@ class C014SymbolBasedAnalyzer {
   constructor(semanticEngine = null) {
     this.semanticEngine = semanticEngine;
     this.verbose = false;
-    
+
     // Configuration
     this.config = {
       // Built-in classes that are allowed
@@ -17,27 +17,34 @@ class C014SymbolBasedAnalyzer {
         'TextEncoder', 'TextDecoder', 'MessageChannel', 'MessagePort',
         'Worker', 'SharedWorker', 'EventSource', 'WebSocket'
       ],
-      
+
       // Value objects/DTOs that are typically safe to instantiate
       allowedValueObjects: [
         'Money', 'Price', 'Currency', 'Quantity', 'Amount',
         'Email', 'Phone', 'Address', 'Name', 'Id', 'UserId',
         'UUID', 'Timestamp', 'Duration', 'Range'
       ],
-      
+
+      // Query builder and utility classes that are safe to instantiate
+      allowedQueryBuilders: [
+        'Brackets', 'SelectQueryBuilder', 'QueryBuilder',
+        'WhereExpression', 'OrderByCondition', 'JoinAttribute',
+        'Subquery', 'CTE', 'Raw'
+      ],
+
       // Infrastructure patterns that suggest external dependencies
       infraPatterns: [
         'Client', 'Repository', 'Service', 'Gateway', 'Adapter',
         'Provider', 'Factory', 'Builder', 'Manager', 'Handler',
         'Controller', 'Processor', 'Validator', 'Logger'
       ],
-      
+
       // DI decorators that indicate proper injection
       diDecorators: [
         'Injectable', 'Inject', 'Autowired', 'Component',
         'Service', 'Repository', 'Controller', 'autoInjectable'
       ],
-      
+
       // Patterns to exclude from analysis
       excludePatterns: [
         '**/*.test.ts', '**/*.spec.ts', '**/*.test.js', '**/*.spec.js',
@@ -55,29 +62,37 @@ class C014SymbolBasedAnalyzer {
 
   async analyzeFileBasic(filePath, options = {}) {
     const violations = [];
-    
+
     try {
+      // Check if semantic engine is initialized
+      if (!this.semanticEngine || !this.semanticEngine.project) {
+        throw new Error('Semantic engine not initialized');
+      }
+
       // Try different approaches to get the source file
       let sourceFile = this.semanticEngine.project.getSourceFile(filePath);
-      
+
       // If not found by full path, try by filename
       if (!sourceFile) {
         const fileName = filePath.split('/').pop();
         const allFiles = this.semanticEngine.project.getSourceFiles();
         sourceFile = allFiles.find(f => f.getBaseName() === fileName);
       }
-      
+
       // If still not found, try to add the file
       if (!sourceFile) {
         try {
-          if (require('fs').existsSync(filePath)) {
+          const fs = require('fs');
+          if (fs.existsSync(filePath)) {
             sourceFile = this.semanticEngine.project.addSourceFileAtPath(filePath);
           }
         } catch (addError) {
-          // Fall through to error below
+          if (this.verbose) {
+            console.error(`[DEBUG] ❌ C014: Failed to add source file: ${addError.message}`);
+          }
         }
       }
-      
+
       if (!sourceFile) {
         throw new Error(`Source file not found: ${filePath}`);
       }
@@ -96,7 +111,7 @@ class C014SymbolBasedAnalyzer {
 
       // Find all new expressions that might violate DI principles
       const newExpressions = this.findProblematicNewExpressions(sourceFile);
-      
+
       for (const expr of newExpressions) {
         if (this.isDependencyInjectionViolation(expr, sourceFile)) {
           violations.push({
@@ -128,21 +143,21 @@ class C014SymbolBasedAnalyzer {
 
   findProblematicNewExpressions(sourceFile) {
     const expressions = [];
-    
-    function traverse(node) {
+
+    const traverse = (node) => {
       if (node.getKind() === SyntaxKind.NewExpression) {
         const newExpr = node;
         const expression = newExpr.getExpression();
-        
+
         // Get class name and context information
         const className = this.getClassName(expression);
         const position = sourceFile.getLineAndColumnAtPos(newExpr.getStart());
         const context = this.analyzeContext(newExpr);
-        
-      if (this.verbose) {
-        console.log(`[DEBUG] 🔍 C014: Found new expression: ${className} at line ${position.line}`);
-      }
-        
+
+        if (this.verbose) {
+          console.log(`[DEBUG] 🔍 C014: Found new expression: ${className} at line ${position.line}`);
+        }
+
         if (className) {
           expressions.push({
             node: newExpr,
@@ -156,28 +171,34 @@ class C014SymbolBasedAnalyzer {
       }
 
       // Traverse children
-      node.forEachChild(child => traverse.call(this, child));
-    }
+      node.forEachChild(child => traverse(child));
+    };
+
+    traverse(sourceFile);
 
-    traverse.call(this, sourceFile);
-    
     if (this.verbose) {
       console.log(`[DEBUG] 🔍 C014: Found ${expressions.length} new expressions total`);
     }
-    
+
     return expressions;
   }
 
   getClassName(expression) {
-    if (expression.getKind() === SyntaxKind.Identifier) {
-      return expression.getText();
-    }
-    
-    // Handle qualified names like MyNamespace.MyClass
-    if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
-      return expression.getName();
+    try {
+      if (expression.getKind() === SyntaxKind.Identifier) {
+        return expression.getText();
+      }
+
+      // Handle qualified names like MyNamespace.MyClass
+      if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+        return expression.getName();
+      }
+    } catch (error) {
+      if (this.verbose) {
+        console.error(`[DEBUG] ❌ C014: Error getting class name: ${error.message}`);
+      }
     }
-    
+
     return null;
   }
 
@@ -189,70 +210,86 @@ class C014SymbolBasedAnalyzer {
       isLocalVariable: false,
       isReturnValue: false,
       isImmediateUse: false,
+      isCallArgument: false,
       parentFunction: null,
       hasDecorators: false
     };
 
-    let current = newExpressionNode.getParent();
-    
-    while (current) {
-      switch (current.getKind()) {
-        case SyntaxKind.Constructor:
-          context.isInConstructor = true;
-          context.parentFunction = current;
-          break;
-          
-        case SyntaxKind.MethodDeclaration:
-          context.isInMethod = true;
-          context.parentFunction = current;
-          break;
-          
-        case SyntaxKind.BinaryExpression:
-          // Check if it's assignment to this.property
-          const binaryExpr = current;
-          if (binaryExpr.getOperatorToken().getKind() === SyntaxKind.EqualsToken) {
-            const left = binaryExpr.getLeft();
-            if (left.getKind() === SyntaxKind.PropertyAccessExpression) {
-              const propAccess = left;
-              if (propAccess.getExpression().getKind() === SyntaxKind.ThisKeyword) {
-                context.isAssignedToThis = true;
+    try {
+      let current = newExpressionNode.getParent();
+
+      while (current) {
+        switch (current.getKind()) {
+          case SyntaxKind.Constructor:
+            context.isInConstructor = true;
+            context.parentFunction = current;
+            break;
+
+          case SyntaxKind.MethodDeclaration:
+            context.isInMethod = true;
+            context.parentFunction = current;
+            break;
+
+          case SyntaxKind.BinaryExpression:
+            // Check if it's assignment to this.property
+            const binaryExpr = current;
+            if (binaryExpr.getOperatorToken().getKind() === SyntaxKind.EqualsToken) {
+              const left = binaryExpr.getLeft();
+              if (left.getKind() === SyntaxKind.PropertyAccessExpression) {
+                const propAccess = left;
+                if (propAccess.getExpression().getKind() === SyntaxKind.ThisKeyword) {
+                  context.isAssignedToThis = true;
+                }
               }
             }
-          }
-          break;
-          
-        case SyntaxKind.PropertyDeclaration:
-          // Check if this new expression is in a class property initializer
-          const propDecl = current;
-          const initializer = propDecl.getInitializer();
-          if (initializer && this.containsNewExpression(initializer, newExpressionNode)) {
-            context.isAssignedToThis = true; // Class property is effectively "this.property"
-          }
-          break;
-          
-        case SyntaxKind.VariableDeclaration:
-          context.isLocalVariable = true;
-          break;
-          
-        case SyntaxKind.ReturnStatement:
-          context.isReturnValue = true;
-          break;
-          
-        case SyntaxKind.CallExpression:
-          // Check for immediate method call like new Date().getTime()
-          const callExpr = current;
-          if (callExpr.getExpression() === newExpressionNode) {
-            context.isImmediateUse = true;
-          }
-          break;
-          
-        case SyntaxKind.ClassDeclaration:
-          // Check for DI decorators on the class
-          context.hasDecorators = this.hasDecorators(current, this.config.diDecorators);
-          break;
+            break;
+
+          case SyntaxKind.PropertyDeclaration:
+            // Check if this new expression is in a class property initializer
+            const propDecl = current;
+            const initializer = propDecl.getInitializer();
+            if (initializer && this.containsNewExpression(initializer, newExpressionNode)) {
+              context.isAssignedToThis = true; // Class property is effectively "this.property"
+            }
+            break;
+
+          case SyntaxKind.VariableDeclaration:
+            context.isLocalVariable = true;
+            break;
+
+          case SyntaxKind.ReturnStatement:
+            context.isReturnValue = true;
+            break;
+
+          case SyntaxKind.CallExpression:
+            const callExpr = current;
+            // Check for immediate method call like new Date().getTime()
+            if (callExpr.getExpression() === newExpressionNode) {
+              context.isImmediateUse = true;
+            } else {
+              // Check if new expression is passed as argument to a function call
+              const args = callExpr.getArguments();
+              for (const arg of args) {
+                if (this.containsNewExpression(arg, newExpressionNode)) {
+                  context.isCallArgument = true;
+                  break;
+                }
+              }
+            }
+            break;
+
+          case SyntaxKind.ClassDeclaration:
+            // Check for DI decorators on the class
+            context.hasDecorators = this.hasDecorators(current, this.config.diDecorators);
+            break;
+        }
+
+        current = current.getParent();
+      }
+    } catch (error) {
+      if (this.verbose) {
+        console.error(`[DEBUG] ❌ C014: Error analyzing context: ${error.message}`);
       }
-      
-      current = current.getParent();
     }
 
     return context;
@@ -262,15 +299,19 @@ class C014SymbolBasedAnalyzer {
     if (node === targetNewExpr) {
       return true;
     }
-    
+
     let found = false;
-    node.forEachChild(child => {
-      if (found) return;
-      if (this.containsNewExpression(child, targetNewExpr)) {
-        found = true;
-      }
-    });
-    
+    try {
+      node.forEachChild(child => {
+        if (found) return;
+        if (this.containsNewExpression(child, targetNewExpr)) {
+          found = true;
+        }
+      });
+    } catch (error) {
+      // Silently handle errors in tree traversal
+    }
+
     return found;
   }
 
@@ -285,6 +326,7 @@ class C014SymbolBasedAnalyzer {
         isLocalVariable: context.isLocalVariable,
         isImmediateUse: context.isImmediateUse,
         isReturnValue: context.isReturnValue,
+        isCallArgument: context.isCallArgument,
         hasDecorators: context.hasDecorators
       });
     }
@@ -297,7 +339,23 @@ class C014SymbolBasedAnalyzer {
       return false;
     }
 
-    // 2. Skip exception/error classes
+    // 2. Skip query builder classes (TypeORM Brackets, etc.)
+    if (this.config.allowedQueryBuilders.includes(className)) {
+      if (this.verbose) {
+        console.log(`[DEBUG] 🔍 C014: Skipping ${className} - query builder class`);
+      }
+      return false;
+    }
+
+    // 3. Skip if it's passed as an argument to a function (like query builder methods)
+    if (context.isCallArgument) {
+      if (this.verbose) {
+        console.log(`[DEBUG] 🔍 C014: Skipping ${className} - passed as function argument`);
+      }
+      return false;
+    }
+
+    // 4. Skip exception/error classes
     if (this.isExceptionClass(className, sourceFile)) {
       if (this.verbose) {
         console.log(`[DEBUG] 🔍 C014: Skipping ${className} - Exception/Error class`);
@@ -305,7 +363,23 @@ class C014SymbolBasedAnalyzer {
       return false;
     }
 
-    // 4. Skip entity/model classes (data structures)
+    // 5. Skip if it's immediate usage (not stored as dependency)
+    if (context.isImmediateUse || context.isReturnValue) {
+      if (this.verbose) {
+        console.log(`[DEBUG] 🔍 C014: Skipping ${className} - immediate use or return value`);
+      }
+      return false;
+    }
+
+    // 6. Skip Singleton pattern (self-instantiation in getInstance-like methods)
+    if (this.isSingletonPattern(className, context, sourceFile)) {
+      if (this.verbose) {
+        console.log(`[DEBUG] 🔍 C014: Skipping ${className} - Singleton pattern`);
+      }
+      return false;
+    }
+
+    // 7. Skip entity/model classes (data structures)
     if (this.isEntityClass(className)) {
       if (this.verbose) {
         console.log(`[DEBUG] 🔍 C014: Skipping ${className} - Entity/Model class`);
@@ -313,7 +387,7 @@ class C014SymbolBasedAnalyzer {
       return false;
     }
 
-    // 5. Skip command pattern classes (value objects for operations)
+    // 8. Skip command pattern classes (value objects for operations)
     if (this.isCommandPattern(className)) {
       if (this.verbose) {
         console.log(`[DEBUG] 🔍 C014: Skipping ${className} - Command pattern class`);
@@ -321,7 +395,7 @@ class C014SymbolBasedAnalyzer {
       return false;
     }
 
-    // 6. Skip value objects/DTOs (configurable)
+    // 9. Skip value objects/DTOs (configurable)
     if (this.config.allowedValueObjects.includes(className)) {
       if (this.verbose) {
         console.log(`[DEBUG] 🔍 C014: Skipping ${className} - allowed value object`);
@@ -329,23 +403,15 @@ class C014SymbolBasedAnalyzer {
       return false;
     }
 
-    // 3. Skip if it's immediate usage (not stored as dependency)
-    if (context.isImmediateUse || context.isReturnValue) {
-      if (this.verbose) {
-        console.log(`[DEBUG] 🔍 C014: Skipping ${className} - immediate use or return value`);
-      }
-      return false;
-    }
-
-    // 4. Skip Singleton pattern (self-instantiation in getInstance-like methods)
-    if (this.isSingletonPattern(className, context, sourceFile)) {
+    // 10. Skip service locator pattern (centralized API client configuration)
+    if (this.isServiceLocatorPattern(context, sourceFile)) {
       if (this.verbose) {
-        console.log(`[DEBUG] 🔍 C014: Skipping ${className} - Singleton pattern`);
+        console.log(`[DEBUG] 🔍 C014: Skipping ${className} - Service locator pattern`);
       }
       return false;
     }
 
-    // 5. Skip if it's a local variable in method (not dependency field) UNLESS it's infrastructure
+    // 11. Skip if it's a local variable in method (not dependency field) UNLESS it's infrastructure
     if (context.isInMethod && context.isLocalVariable && !context.isAssignedToThis) {
       // Exception: Still flag if it's infrastructure dependency even as local variable
       if (this.isLikelyExternalDependency(className, sourceFile)) {
@@ -354,14 +420,14 @@ class C014SymbolBasedAnalyzer {
         }
         return true;
       }
-      
+
       if (this.verbose) {
         console.log(`[DEBUG] 🔍 C014: Skipping ${className} - local variable in method`);
       }
       return false;
     }
 
-    // 6. Main heuristic: Flag if assigned to this.* (field or in constructor/method)
+    // 12. Main heuristic: Flag if assigned to this.* (field or in constructor/method)
     if (context.isAssignedToThis) {
       // Check if target class suggests external dependency
       if (this.isLikelyExternalDependency(className, sourceFile)) {
@@ -372,16 +438,8 @@ class C014SymbolBasedAnalyzer {
       }
     }
 
-    // 7. Skip if it's service locator pattern (centralized API client configuration)
-    if (this.isServiceLocatorPattern(context, sourceFile)) {
-      if (this.verbose) {
-        console.log(`[DEBUG] 🔍 C014: Skipping ${className} - Service locator pattern`);
-      }
-      return false;
-    }
-
-    // 8. Flag if class has infrastructure patterns and no DI decorators
-    if (this.hasInfraPattern(className) && !context.hasDecorators) {
+    // 13. Flag if class has infrastructure patterns and no DI decorators
+    if (this.hasInfraPattern(className) && !context.hasDecorators && context.isAssignedToThis) {
       if (this.verbose) {
         console.log(`[DEBUG] ✅ C014: ${className} is violation - has infra pattern`);
       }
@@ -399,9 +457,9 @@ class C014SymbolBasedAnalyzer {
     if (this.verbose) {
       console.log(`[DEBUG] 🔍 C014: Checking if ${className} is external dependency`);
     }
-    
+
     // Check if class name suggests infrastructure/external service
-    const hasInfraPattern = this.config.infraPatterns.some(pattern => 
+    const hasInfraPattern = this.config.infraPatterns.some(pattern =>
       className.includes(pattern)
     );
 
@@ -413,24 +471,30 @@ class C014SymbolBasedAnalyzer {
     }
 
     // Check import statements to see if it's from external module
-    const imports = sourceFile.getImportDeclarations();
-    for (const importDecl of imports) {
-      const namedImports = importDecl.getNamedImports();
-      for (const namedImport of namedImports) {
-        if (namedImport.getName() === className) {
-          const moduleSpecifier = importDecl.getModuleSpecifierValue();
-          if (this.verbose) {
-            console.log(`[DEBUG] 🔍 C014: ${className} imported from: ${moduleSpecifier}`);
-          }
-          // Check if imported from infrastructure/adapter paths
-          if (this.isInfrastructurePath(moduleSpecifier)) {
+    try {
+      const imports = sourceFile.getImportDeclarations();
+      for (const importDecl of imports) {
+        const namedImports = importDecl.getNamedImports();
+        for (const namedImport of namedImports) {
+          if (namedImport.getName() === className) {
+            const moduleSpecifier = importDecl.getModuleSpecifierValue();
             if (this.verbose) {
-              console.log(`[DEBUG] ✅ C014: ${className} from infrastructure path`);
+              console.log(`[DEBUG] 🔍 C014: ${className} imported from: ${moduleSpecifier}`);
+            }
+            // Check if imported from infrastructure/adapter paths
+            if (this.isInfrastructurePath(moduleSpecifier)) {
+              if (this.verbose) {
+                console.log(`[DEBUG] ✅ C014: ${className} from infrastructure path`);
+              }
+              return true;
             }
-            return true;
           }
         }
       }
+    } catch (error) {
+      if (this.verbose) {
+        console.error(`[DEBUG] ❌ C014: Error checking imports: ${error.message}`);
+      }
     }
 
     if (this.verbose) {
@@ -441,15 +505,15 @@ class C014SymbolBasedAnalyzer {
 
   isInfrastructurePath(modulePath) {
     const infraPaths = [
-      'infra', 'infrastructure', 'adapters', 'clients', 
+      'infra', 'infrastructure', 'adapters', 'clients',
       'repositories', 'services', 'gateways', 'providers'
     ];
-    
+
     // Check explicit infra path keywords
     if (infraPaths.some(path => modulePath.includes(path))) {
       return true;
     }
-    
+
     // Check common external infrastructure packages
     const infraPackages = [
       '@aws-sdk/', 'aws-sdk', 'redis', 'mysql', 'postgresql', 'prisma',
@@ -458,12 +522,12 @@ class C014SymbolBasedAnalyzer {
       'twilio', 'sendgrid', 'nodemailer', 'kafka', 'rabbitmq',
       'elasticsearch', 'mongodb', 'cassandra'
     ];
-    
+
     return infraPackages.some(pkg => modulePath.includes(pkg));
   }
 
   hasInfraPattern(className) {
-    return this.config.infraPatterns.some(pattern => 
+    return this.config.infraPatterns.some(pattern =>
       className.includes(pattern)
     );
   }
@@ -473,11 +537,11 @@ class C014SymbolBasedAnalyzer {
     const errorPatterns = [
       'Error', 'Exception', 'Fault', 'Failure'
     ];
-    
-    const hasErrorName = errorPatterns.some(pattern => 
+
+    const hasErrorName = errorPatterns.some(pattern =>
       className.endsWith(pattern) || className.includes(pattern)
     );
-    
+
     if (hasErrorName) {
       return true;
     }
@@ -494,74 +558,87 @@ class C014SymbolBasedAnalyzer {
         return false;
       }
     }
-    
+
     return false;
   }
 
   inheritsFromErrorClass(className, sourceFile) {
-    // Find class declaration in current file
-    const classDecl = sourceFile.getClasses().find(cls => cls.getName() === className);
-    
-    if (!classDecl) {
-      // Class might be imported, try to resolve it
-      return this.isImportedErrorClass(className, sourceFile);
-    }
+    try {
+      // Find class declaration in current file
+      const classDecl = sourceFile.getClasses().find(cls => cls.getName() === className);
 
-    // Check direct inheritance
-    const extendsClauses = classDecl.getExtends();
-    if (!extendsClauses) {
-      return false;
-    }
+      if (!classDecl) {
+        // Class might be imported, try to resolve it
+        return this.isImportedErrorClass(className, sourceFile);
+      }
 
-    const baseClassName = extendsClauses.getExpression().getText();
-    
-    // Check if directly extends Error-like class
-    const errorBaseClasses = [
-      'Error', 'TypeError', 'ReferenceError', 'SyntaxError', 
-      'RangeError', 'EvalError', 'URIError', 'AggregateError'
-    ];
-    
-    if (errorBaseClasses.includes(baseClassName)) {
+      // Check direct inheritance
+      const extendsClauses = classDecl.getExtends();
+      if (!extendsClauses) {
+        return false;
+      }
+
+      const baseClassName = extendsClauses.getExpression().getText();
+
+      // Check if directly extends Error-like class
+      const errorBaseClasses = [
+        'Error', 'TypeError', 'ReferenceError', 'SyntaxError',
+        'RangeError', 'EvalError', 'URIError', 'AggregateError'
+      ];
+
+      if (errorBaseClasses.includes(baseClassName)) {
+        if (this.verbose) {
+          console.log(`[DEBUG] 🔍 C014: ${className} extends ${baseClassName} (Error class)`);
+        }
+        return true;
+      }
+
+      // Recursively check inheritance chain
+      return this.inheritsFromErrorClass(baseClassName, sourceFile);
+    } catch (error) {
       if (this.verbose) {
-        console.log(`[DEBUG] 🔍 C014: ${className} extends ${baseClassName} (Error class)`);
+        console.error(`[DEBUG] ❌ C014: Error checking inheritance: ${error.message}`);
       }
-      return true;
+      return false;
     }
-
-    // Recursively check inheritance chain
-    return this.inheritsFromErrorClass(baseClassName, sourceFile);
   }
 
   isImportedErrorClass(className, sourceFile) {
-    // Check imports to see if className is imported from error/exception modules
-    const imports = sourceFile.getImportDeclarations();
-    
-    for (const importDecl of imports) {
-      const namedImports = importDecl.getNamedImports();
-      for (const namedImport of namedImports) {
-        if (namedImport.getName() === className) {
-          const moduleSpecifier = importDecl.getModuleSpecifierValue();
-          
-          // Check if imported from error/exception related modules
-          const errorModulePatterns = [
-            'error', 'exception', 'http-exception', 'custom-error',
-            '../exceptions', './exceptions', '/errors/', '/exceptions/'
-          ];
-          
-          const isFromErrorModule = errorModulePatterns.some(pattern => 
-            moduleSpecifier.toLowerCase().includes(pattern)
-          );
-          
-          if (isFromErrorModule) {
-            if (this.verbose) {
-              console.log(`[DEBUG] 🔍 C014: ${className} imported from error module: ${moduleSpecifier}`);
+    try {
+      // Check imports to see if className is imported from error/exception modules
+      const imports = sourceFile.getImportDeclarations();
+
+      for (const importDecl of imports) {
+        const namedImports = importDecl.getNamedImports();
+        for (const namedImport of namedImports) {
+          if (namedImport.getName() === className) {
+            const moduleSpecifier = importDecl.getModuleSpecifierValue();
+
+            // Check if imported from error/exception related modules
+            const errorModulePatterns = [
+              'error', 'exception', 'http-exception', 'custom-error',
+              '../exceptions', './exceptions', '/errors/', '/exceptions/'
+            ];
+
+            const isFromErrorModule = errorModulePatterns.some(pattern =>
+              moduleSpecifier.toLowerCase().includes(pattern)
+            );
+
+            if (isFromErrorModule) {
+              if (this.verbose) {
+                console.log(`[DEBUG] 🔍 C014: ${className} imported from error module: ${moduleSpecifier}`);
+              }
+              return true;
             }
-            return true;
           }
         }
       }
+    } catch (error) {
+      if (this.verbose) {
+        console.error(`[DEBUG] ❌ C014: Error checking imported error class: ${error.message}`);
+      }
     }
-    
+
     return false;
   }
 
@@ -570,8 +647,8 @@ class C014SymbolBasedAnalyzer {
     const entityPatterns = [
       'Entity', 'Model', 'Schema', 'Document', 'Dto', 'DTO'
     ];
-    
-    return entityPatterns.some(pattern => 
+
+    return entityPatterns.some(pattern =>
       className.endsWith(pattern)
     );
   }
@@ -579,57 +656,71 @@ class C014SymbolBasedAnalyzer {
   isCommandPattern(className) {
     // Command pattern classes (value objects for operations)
     const commandPatterns = [
-      'Command', 'Request', 'Query', 'Operation', 
+      'Command', 'Request', 'Query', 'Operation',
       'Action', 'Task', 'Job'
     ];
-    
-    return commandPatterns.some(pattern => 
+
+    return commandPatterns.some(pattern =>
       className.endsWith(pattern)
     );
   }
 
   isServiceLocatorPattern(context, sourceFile) {
-    // Check if we're in an object literal assignment that looks like service locator
-    if (!context.isLocalVariable) {
-      return false;
-    }
+    try {
+      // Check if we're in an object literal assignment that looks like service locator
+      if (!context.isLocalVariable) {
+        return false;
+      }
 
-    // Additional check: if file contains many similar API instantiations, 
-    // it's likely a service locator pattern
-    const fileText = sourceFile.getFullText();
-    const newExpressionCount = (fileText.match(/new \w+Api\(\)/g) || []).length;
-    if (newExpressionCount >= 5) {
-      // Many API instantiations suggest service locator pattern
-      if (this.verbose) {
-        console.log(`[DEBUG] 🔍 C014: Found ${newExpressionCount} API instantiations - likely service locator`);
+      // Additional check: if file contains many similar API instantiations,
+      // it's likely a service locator pattern
+      const fileText = sourceFile.getFullText();
+      const newExpressionCount = (fileText.match(/new \w+Api\(\)/g) || []).length;
+      if (newExpressionCount >= 5) {
+        // Many API instantiations suggest service locator pattern
+        if (this.verbose) {
+          console.log(`[DEBUG] 🔍 C014: Found ${newExpressionCount} API instantiations - likely service locator`);
+        }
+        return true;
       }
-      return true;
-    }
 
-    // Check for service locator variable names in file text
-    const serviceLocatorPatterns = [
-      'apiClient', 'serviceContainer', 'container', 'services',
-      'clients', 'providers', 'factories', 'registry'
-    ];
+      // Check for service locator variable names in file text
+      const serviceLocatorPatterns = [
+        'apiClient', 'serviceContainer', 'container', 'services',
+        'clients', 'providers', 'factories', 'registry'
+      ];
 
-    const isServiceLocator = serviceLocatorPatterns.some(pattern => 
-      fileText.includes(`export const ${pattern}`) || 
-      fileText.includes(`const ${pattern}`)
-    );
+      const isServiceLocator = serviceLocatorPatterns.some(pattern =>
+        fileText.includes(`export const ${pattern}`) ||
+        fileText.includes(`const ${pattern}`)
+      );
 
-    if (isServiceLocator && this.verbose) {
-      console.log(`[DEBUG] 🔍 C014: Detected service locator pattern from variable name`);
-    }
+      if (isServiceLocator && this.verbose) {
+        console.log(`[DEBUG] 🔍 C014: Detected service locator pattern from variable name`);
+      }
 
-    return isServiceLocator;
+      return isServiceLocator;
+    } catch (error) {
+      if (this.verbose) {
+        console.error(`[DEBUG] ❌ C014: Error checking service locator pattern: ${error.message}`);
+      }
+      return false;
+    }
   }
 
   hasDecorators(node, decoratorNames) {
-    const decorators = node.getDecorators?.() || [];
-    return decorators.some(decorator => {
-      const decoratorText = decorator.getText();
-      return decoratorNames.some(name => decoratorText.includes(name));
-    });
+    try {
+      const decorators = node.getDecorators?.() || [];
+      return decorators.some(decorator => {
+        const decoratorText = decorator.getText();
+        return decoratorNames.some(name => decoratorText.includes(name));
+      });
+    } catch (error) {
+      if (this.verbose) {
+        console.error(`[DEBUG] ❌ C014: Error checking decorators: ${error.message}`);
+      }
+      return false;
+    }
   }
 
   shouldSkipFile(filePath) {
@@ -643,57 +734,70 @@ class C014SymbolBasedAnalyzer {
    * Check if this is a Singleton pattern (self-instantiation)
    */
   isSingletonPattern(className, context, sourceFile) {
-    // Must be in a method (not constructor)
-    if (!context.isInMethod || context.isInConstructor) {
-      return false;
-    }
+    try {
+      // Must be in a method (not constructor)
+      if (!context.isInMethod || context.isInConstructor) {
+        return false;
+      }
 
-    // Must be instantiating the same class we're in
-    const classDeclaration = this.findContainingClass(context, sourceFile);
-    if (!classDeclaration) {
-      return false;
-    }
+      // Must be instantiating the same class we're in
+      const classDeclaration = this.findContainingClass(context, sourceFile);
+      if (!classDeclaration) {
+        return false;
+      }
 
-    const currentClassName = classDeclaration.getName();
-    if (currentClassName !== className) {
-      return false;
-    }
+      const currentClassName = classDeclaration.getName();
+      if (currentClassName !== className) {
+        return false;
+      }
 
-    // Method name should suggest singleton (getInstance, instance, create, etc.)
-    const methodName = context.parentFunction?.getName?.() || '';
-    const singletonMethods = [
-      'getInstance', 'instance', 'getinstance', 'create', 'createInstance',
-      'singleton', 'getSingleton', 'getSharedInstance', 'shared'
-    ];
-    
-    const isSingletonMethod = singletonMethods.some(pattern => 
-      methodName.toLowerCase().includes(pattern.toLowerCase())
-    );
+      // Method name should suggest singleton (getInstance, instance, create, etc.)
+      const methodName = context.parentFunction?.getName?.() || '';
+      const singletonMethods = [
+        'getInstance', 'instance', 'getinstance', 'create', 'createInstance',
+        'singleton', 'getSingleton', 'getSharedInstance', 'shared'
+      ];
 
-    // Must be a static method
-    const isStaticMethod = context.parentFunction?.getModifiers?.()
-      ?.some(modifier => modifier.getKind() === SyntaxKind.StaticKeyword) || false;
+      const isSingletonMethod = singletonMethods.some(pattern =>
+        methodName.toLowerCase().includes(pattern.toLowerCase())
+      );
 
-    if (this.verbose && isSingletonMethod && isStaticMethod) {
-      console.log(`[DEBUG] 🔍 C014: Detected Singleton pattern: ${currentClassName}.${methodName}()`);
-    }
+      // Must be a static method
+      const isStaticMethod = context.parentFunction?.getModifiers?.()
+        ?.some(modifier => modifier.getKind() === SyntaxKind.StaticKeyword) || false;
 
-    return isSingletonMethod && isStaticMethod;
+      if (this.verbose && isSingletonMethod && isStaticMethod) {
+        console.log(`[DEBUG] 🔍 C014: Detected Singleton pattern: ${currentClassName}.${methodName}()`);
+      }
+
+      return isSingletonMethod && isStaticMethod;
+    } catch (error) {
+      if (this.verbose) {
+        console.error(`[DEBUG] ❌ C014: Error checking singleton pattern: ${error.message}`);
+      }
+      return false;
+    }
   }
 
   /**
    * Find the containing class declaration
    */
   findContainingClass(context, sourceFile) {
-    let current = context.parentFunction?.getParent();
-    
-    while (current) {
-      if (current.getKind() === SyntaxKind.ClassDeclaration) {
-        return current;
+    try {
+      let current = context.parentFunction?.getParent();
+
+      while (current) {
+        if (current.getKind() === SyntaxKind.ClassDeclaration) {
+          return current;
+        }
+        current = current.getParent();
+      }
+    } catch (error) {
+      if (this.verbose) {
+        console.error(`[DEBUG] ❌ C014: Error finding containing class: ${error.message}`);
       }
-      current = current.getParent();
     }
-    
+
     return null;
   }
 
@@ -725,27 +829,35 @@ class C014SymbolBasedAnalyzer {
 
   buildViolationMessage(expr) {
     const { className, context } = expr;
-    
+
     if (context.isInConstructor && context.isAssignedToThis) {
       return `Direct instantiation of '${className}' in constructor. Consider injecting this dependency instead of creating it directly.`;
     }
-    
+
     if (context.isInMethod && context.isAssignedToThis) {
       return `Direct instantiation of '${className}' assigned to instance field. Consider injecting this dependency.`;
     }
-    
+
     return `Direct instantiation of '${className}'. Consider using dependency injection or factory pattern.`;
   }
 
   buildSuggestion(expr) {
     const { className, context } = expr;
-    
+
     if (context.isInConstructor) {
-      return `Inject ${className} via constructor parameter: constructor(private ${className.toLowerCase()}: ${className})`;
+      return `Inject ${className} via constructor parameter: constructor(private ${this.toLowerCamelCase(className)}: ${className})`;
     }
-    
+
     return `Consider injecting ${className} as a dependency or using a factory pattern`;
   }
+
+  /**
+   * Convert class name to lower camel case for parameter names
+   */
+  toLowerCamelCase(str) {
+    if (!str || str.length === 0) return str;
+    return str.charAt(0).toLowerCase() + str.slice(1);
+  }
 }
 
 module.exports = C014SymbolBasedAnalyzer;