@sun-asterisk/sunlint 1.3.0 → 1.3.2

package/rules/common/C017_constructor_logic/semantic-analyzer.js

@@ -0,0 +1,340 @@
+/**
+ * C017 Constructor Logic - Semantic Analyzer (Phase 2)
+ * Uses ts-morph for precise symbol-based analysis
+ * Detects complex logic in constructors with high accuracy
+ */
+
+const SemanticRuleBase = require('../../../core/semantic-rule-base');
+const path = require('path');
+
+class C017SemanticAnalyzer extends SemanticRuleBase {
+  constructor(ruleId = 'C017') {
+    super(ruleId);
+    this.ruleName = 'C017 - No Complex Logic in Constructors (Semantic)';
+    this.description = 'Constructors should only handle dependency injection and simple initialization';
+  }
+
+  /**
+   * Analyze a single file using ts-morph semantic analysis
+   * @param {string} filePath - Path to the file to analyze
+   * @param {Object} options - Analysis options
+   */
+  async analyzeFile(filePath, options = {}) {
+    if (!this.semanticEngine) {
+      throw new Error('Semantic engine not initialized');
+    }
+
+    try {
+      // Get file's absolute path
+      const absolutePath = path.resolve(filePath);
+      
+      // Get source file from semantic engine's project
+      const sourceFile = this.semanticEngine.project.getSourceFile(absolutePath);
+      if (!sourceFile) {
+        if (options.verbose) {
+          console.log(`⚠️ [C017-Semantic] Could not load source file: ${filePath}`);
+        }
+        return;
+      }
+
+      // Find all class declarations
+      const classes = sourceFile.getClasses();
+      
+      for (const classDecl of classes) {
+        const constructors = classDecl.getConstructors();
+        
+        for (const constructor of constructors) {
+          await this.analyzeConstructor(constructor, filePath, options);
+        }
+      }
+
+    } catch (error) {
+      if (options.verbose) {
+        console.warn(`⚠️ [C017-Semantic] Error analyzing ${filePath}:`, error.message);
+      }
+    }
+  }
+
+  /**
+   * Analyze a constructor node for complex logic
+   * @param {ts.ConstructorDeclaration} constructor - Constructor node
+   * @param {string} filePath - File path
+   * @param {Object} options - Analysis options
+   */
+  async analyzeConstructor(constructor, filePath, options) {
+    const body = constructor.getBody();
+    if (!body) {
+      // Constructor without body (interface, abstract, etc.)
+      return;
+    }
+
+    const statements = body.getStatements();
+    
+    for (const statement of statements) {
+      const violation = this.analyzeStatement(statement, constructor, filePath);
+      if (violation) {
+        this.addViolation(violation);
+      }
+    }
+  }
+
+  /**
+   * Analyze a statement for complex logic patterns
+   * @param {ts.Statement} statement - Statement node
+   * @param {ts.ConstructorDeclaration} constructor - Parent constructor
+   * @param {string} filePath - File path
+   * @returns {Object|null} Violation object or null
+   */
+  analyzeStatement(statement, constructor, filePath) {
+    const statementKind = statement.getKind();
+    const line = statement.getStartLineNumber();
+    const column = statement.getStart() - statement.getStartLinePos() + 1;
+
+    // Check for complex logic patterns
+    switch (statementKind) {
+      case this.SyntaxKind.IfStatement:
+        return this.createViolation(
+          filePath, line, column,
+          'Conditional logic (if statement) found in constructor',
+          'conditional_logic',
+          statement.getText()
+        );
+
+      case this.SyntaxKind.ForStatement:
+      case this.SyntaxKind.ForInStatement:
+      case this.SyntaxKind.ForOfStatement:
+      case this.SyntaxKind.WhileStatement:
+      case this.SyntaxKind.DoStatement:
+        return this.createViolation(
+          filePath, line, column,
+          'Loop logic found in constructor',
+          'loop_logic',
+          statement.getText()
+        );
+
+      case this.SyntaxKind.SwitchStatement:
+        return this.createViolation(
+          filePath, line, column,
+          'Switch statement found in constructor',
+          'switch_logic',
+          statement.getText()
+        );
+
+      case this.SyntaxKind.TryStatement:
+        return this.createViolation(
+          filePath, line, column,
+          'Exception handling (try/catch) found in constructor',
+          'exception_handling',
+          statement.getText()
+        );
+
+      case this.SyntaxKind.ExpressionStatement:
+        return this.analyzeExpressionStatement(statement, filePath);
+
+      default:
+        return null;
+    }
+  }
+
+  /**
+   * Analyze expression statements for complex patterns
+   * @param {ts.ExpressionStatement} statement - Expression statement
+   * @param {string} filePath - File path
+   * @returns {Object|null} Violation object or null
+   */
+  analyzeExpressionStatement(statement, filePath) {
+    const expression = statement.getExpression();
+    const line = statement.getStartLineNumber();
+    const column = statement.getStart() - statement.getStartLinePos() + 1;
+
+    // Check for async operations
+    if (this.isAsyncOperation(expression)) {
+      return this.createViolation(
+        filePath, line, column,
+        'Asynchronous operation found in constructor',
+        'async_operation',
+        statement.getText()
+      );
+    }
+
+    // Check for complex method calls
+    if (this.isComplexMethodCall(expression)) {
+      return this.createViolation(
+        filePath, line, column,
+        'Complex method call found in constructor',
+        'complex_method_call',
+        statement.getText()
+      );
+    }
+
+    // Allow simple assignments and DI setup
+    if (this.isSimpleAssignment(expression) || this.isConfigurationSetup(expression)) {
+      return null;
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if expression is an async operation
+   * @param {ts.Expression} expression - Expression node
+   * @returns {boolean} True if async operation
+   */
+  isAsyncOperation(expression) {
+    const text = expression.getText();
+    
+    // Await expressions
+    if (expression.getKind() === this.SyntaxKind.AwaitExpression) {
+      return true;
+    }
+
+    // Promise chains
+    if (text.includes('.then(') || text.includes('.catch(') || text.includes('.finally(')) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Check if expression is a complex method call
+   * @param {ts.Expression} expression - Expression node
+   * @returns {boolean} True if complex method call
+   */
+  isComplexMethodCall(expression) {
+    if (expression.getKind() !== this.SyntaxKind.CallExpression) {
+      return false;
+    }
+
+    const callExpr = expression;
+    const methodName = this.getMethodName(callExpr);
+
+    // Allow certain initialization methods
+    const allowedMethods = [
+      'makeObservable', 'makeAutoObservable', // MobX
+      'bind', 'bindAll', // Method binding
+      'Object.assign', 'Object.create', // Object utilities
+      'Array.from', 'Array.of', // Array utilities
+    ];
+
+    if (allowedMethods.some(method => methodName.includes(method))) {
+      return false;
+    }
+
+    // Check for chained calls (more than 2 levels = complex)
+    const chainLength = this.getChainLength(callExpr);
+    return chainLength > 2;
+  }
+
+  /**
+   * Check if expression is a simple assignment
+   * @param {ts.Expression} expression - Expression node
+   * @returns {boolean} True if simple assignment
+   */
+  isSimpleAssignment(expression) {
+    if (expression.getKind() !== this.SyntaxKind.BinaryExpression) {
+      return false;
+    }
+
+    const binaryExpr = expression;
+    const operator = binaryExpr.getOperatorToken();
+    
+    return operator.getKind() === this.SyntaxKind.EqualsToken;
+  }
+
+  /**
+   * Check if expression is configuration setup
+   * @param {ts.Expression} expression - Expression node
+   * @returns {boolean} True if configuration setup
+   */
+  isConfigurationSetup(expression) {
+    const text = expression.getText();
+    
+    // Configuration patterns
+    const configPatterns = [
+      /new\s+\w+Client\s*\(/,  // AWS clients, HTTP clients
+      /new\s+\w+\s*\(\s*\{/,   // Configuration objects
+      /\.getInstance\s*\(/,     // Singleton patterns
+      /\.create\s*\(/,         // Factory patterns
+    ];
+
+    return configPatterns.some(pattern => pattern.test(text));
+  }
+
+  /**
+   * Get method name from call expression
+   * @param {ts.CallExpression} callExpr - Call expression
+   * @returns {string} Method name
+   */
+  getMethodName(callExpr) {
+    const expression = callExpr.getExpression();
+    
+    if (expression.getKind() === this.SyntaxKind.PropertyAccessExpression) {
+      return expression.getName();
+    }
+    
+    if (expression.getKind() === this.SyntaxKind.Identifier) {
+      return expression.getText();
+    }
+    
+    return expression.getText();
+  }
+
+  /**
+   * Get chain length of method calls
+   * @param {ts.CallExpression} callExpr - Call expression
+   * @returns {number} Chain length
+   */
+  getChainLength(callExpr) {
+    let current = callExpr.getExpression();
+    let length = 1;
+    
+    while (current.getKind() === this.SyntaxKind.PropertyAccessExpression) {
+      const propAccess = current;
+      current = propAccess.getExpression();
+      length++;
+    }
+    
+    return length;
+  }
+
+  /**
+   * Create a violation object
+   * @param {string} filePath - File path
+   * @param {number} line - Line number
+   * @param {number} column - Column number
+   * @param {string} message - Violation message
+   * @param {string} type - Violation type
+   * @param {string} code - Code snippet
+   * @returns {Object} Violation object
+   */
+  createViolation(filePath, line, column, message, type, code) {
+    return {
+      ruleId: this.ruleId,
+      file: filePath,
+      line: line,
+      column: column,
+      message: `Constructor contains complex logic: ${message}. Move to initialization methods`,
+      severity: 'warning',
+      code: code.trim(),
+      type: type,
+      confidence: 95, // High confidence with semantic analysis
+      analysisMethod: 'semantic',
+      suggestion: 'Move complex logic to separate initialization methods or lifecycle hooks'
+    };
+  }
+
+  /**
+   * Get SyntaxKind enum from ts-morph
+   * @returns {Object} SyntaxKind enum
+   */
+  get SyntaxKind() {
+    if (!this.semanticEngine) {
+      throw new Error('Semantic engine not initialized');
+    }
+    return this.semanticEngine.project.getTypeChecker().compilerObject.SyntaxKind || 
+           require('typescript').SyntaxKind;
+  }
+}
+
+module.exports = C017SemanticAnalyzer;

package/rules/common/C018_no_throw_generic_error/analyzer.js

@@ -0,0 +1,232 @@
+/**
+ * C018 Main Analyzer - Do not throw generic errors
+ * Primary: Always provide detailed messages and context.
+ * Fallback: Regex-based for all other cases
+ */
+
+const C018SymbolBasedAnalyzer = require('./symbol-based-analyzer');
+const C018RegexBasedAnalyzer = require('./regex-based-analyzer');
+
+class C018Analyzer {
+  constructor(options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C018] Constructor called with options:`, !!options);
+      console.log(`🔧 [C018] Options type:`, typeof options, Object.keys(options || {}));
+    }
+
+    this.ruleId = 'C018';
+    this.ruleName = 'Do not throw generic errors';
+    this.description = 'Do not throw generic errors; always provide detailed messages and context.';
+    this.semanticEngine = options.semanticEngine || null;
+    this.verbose = options.verbose || false;
+
+    // Configuration
+    this.config = {
+      useSymbolBased: true,      // Primary approach
+      fallbackToRegex: true,     // Only when symbol fails completely
+      symbolBasedOnly: false     // Can be set to true for pure mode
+    };
+
+    // Initialize both analyzers
+    try {
+      this.symbolAnalyzer = new C018SymbolBasedAnalyzer(this.semanticEngine);
+      if (process.env.SUNLINT_DEBUG) {
+        console.log(`🔧 [C018] Symbol analyzer created successfully`);
+      }
+    } catch (error) {
+      console.error(`🔧 [C018] Error creating symbol analyzer:`, error);
+    }
+
+    try {
+      this.regexAnalyzer = new C018RegexBasedAnalyzer(this.semanticEngine);
+      if (process.env.SUNLINT_DEBUG) {
+        console.log(`🔧 [C018] Regex analyzer created successfully`);
+      }
+    } catch (error) {
+      console.error(`🔧 [C018] Error creating regex analyzer:`, error);
+    }
+
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C018] Constructor completed`);
+    }
+  }
+
+  /**
+   * Initialize with semantic engine
+   */
+  async initialize(semanticEngine = null) {
+    if (semanticEngine) {
+      this.semanticEngine = semanticEngine;
+    }
+    this.verbose = semanticEngine?.verbose || false;
+
+    // Initialize both analyzers
+    await this.symbolAnalyzer.initialize(semanticEngine);
+    await this.regexAnalyzer.initialize(semanticEngine);
+
+    // Ensure verbose flag is propagated
+    this.regexAnalyzer.verbose = this.verbose;
+    this.symbolAnalyzer.verbose = this.verbose;
+
+    if (this.verbose) {
+      console.log(`🔧 [C018 Hybrid] Analyzer initialized - verbose: ${this.verbose}`);
+    }
+  }
+
+  async analyze(files, language, options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C018] analyze() method called with ${files.length} files, language: ${language}`);
+    }
+
+    const violations = [];
+
+    for (const filePath of files) {
+      try {
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C018] Processing file: ${filePath}`);
+        }
+
+        const fileViolations = await this.analyzeFile(filePath, options);
+        violations.push(...fileViolations);
+
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C018] File ${filePath}: Found ${fileViolations.length} violations`);
+        }
+      } catch (error) {
+        console.warn(`❌ [C018] Analysis failed for ${filePath}:`, error.message);
+      }
+    }
+
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C018] Total violations found: ${violations.length}`);
+    }
+
+    return violations;
+  }
+
+  async analyzeFile(filePath, options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C018] analyzeFile() called for: ${filePath}`);
+    }
+
+    // 1. Try Symbol-based analysis first (primary)
+    if (this.config.useSymbolBased &&
+        this.semanticEngine?.project &&
+        this.semanticEngine?.initialized) {
+      try {
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C018] Trying symbol-based analysis...`);
+        }
+        const sourceFile = this.semanticEngine.project.getSourceFile(filePath);
+        if (sourceFile) {
+          if (process.env.SUNLINT_DEBUG) {
+            console.log(`🔧 [C018] Source file found, analyzing with symbol-based...`);
+          }
+          const violations = await this.symbolAnalyzer.analyzeFileWithSymbols(filePath, { ...options, verbose: options.verbose });
+
+          // Mark violations with analysis strategy
+          violations.forEach(v => v.analysisStrategy = 'symbol-based');
+
+          if (process.env.SUNLINT_DEBUG) {
+            console.log(`✅ [C018] Symbol-based analysis: ${violations.length} violations`);
+          }
+          return violations; // Return even if 0 violations - symbol analysis completed successfully
+        } else {
+          if (process.env.SUNLINT_DEBUG) {
+            console.log(`⚠️ [C018] Source file not found in project`);
+          }
+        }
+      } catch (error) {
+        console.warn(`⚠️ [C018] Symbol analysis failed: ${error.message}`);
+        // Continue to fallback
+      }
+    } else {
+      if (process.env.SUNLINT_DEBUG) {
+        console.log(`🔄 [C018] Symbol analysis conditions check:`);
+        console.log(`  - useSymbolBased: ${this.config.useSymbolBased}`);
+        console.log(`  - semanticEngine: ${!!this.semanticEngine}`);
+        console.log(`  - semanticEngine.project: ${!!this.semanticEngine?.project}`);
+        console.log(`  - semanticEngine.initialized: ${this.semanticEngine?.initialized}`);
+        console.log(`🔄 [C018] Symbol analysis unavailable, using regex fallback`);
+      }
+    }
+
+    // 2. Fallback to regex-based analysis
+    if (this.config.fallbackToRegex) {
+      try {
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C018] Trying regex-based analysis...`);
+        }
+        const violations = await this.regexAnalyzer.analyzeFileBasic(filePath, options);
+
+        // Mark violations with analysis strategy
+        violations.forEach(v => v.analysisStrategy = 'regex-fallback');
+
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔄 [C018] Regex-based analysis: ${violations.length} violations`);
+        }
+        return violations;
+      } catch (error) {
+        console.error(`❌ [C018] Regex analysis failed: ${error.message}`);
+      }
+    }
+
+    if (options?.verbose) {
+      console.log(`🔧 [C018] No analysis methods succeeded, returning empty`);
+    }
+    return [];
+  }
+
+  async analyzeFileBasic(filePath, options = {}) {
+    console.log(`🔧 [C018] analyzeFileBasic() called for: ${filePath}`);
+    console.log(`🔧 [C018] semanticEngine exists: ${!!this.semanticEngine}`);
+    console.log(`🔧 [C018] symbolAnalyzer exists: ${!!this.symbolAnalyzer}`);
+    console.log(`🔧 [C018] regexAnalyzer exists: ${!!this.regexAnalyzer}`);
+
+    try {
+      // Try symbol-based analysis first
+      if (this.semanticEngine?.isSymbolEngineReady?.() &&
+          this.semanticEngine.project) {
+
+        if (this.verbose) {
+          console.log(`🔍 [C018] Using symbol-based analysis for ${filePath}`);
+        }
+
+        const violations = await this.symbolAnalyzer.analyzeFileBasic(filePath, options);
+        return violations;
+      }
+    } catch (error) {
+      if (this.verbose) {
+        console.warn(`⚠️ [C018] Symbol analysis failed: ${error.message}`);
+      }
+    }
+
+    // Fallback to regex-based analysis
+    if (this.verbose) {
+      console.log(`🔄 [C018] Using regex-based analysis (fallback) for ${filePath}`);
+    }
+
+    console.log(`🔧 [C018] About to call regexAnalyzer.analyzeFileBasic()`);
+    try {
+      const result = await this.regexAnalyzer.analyzeFileBasic(filePath, options);
+      console.log(`🔧 [C018] Regex analyzer returned: ${result.length} violations`);
+      return result;
+    } catch (error) {
+      console.error(`🔧 [C018] Error in regex analyzer:`, error);
+      return [];
+    }
+  }
+
+  /**
+   * Methods for compatibility with different engine invocation patterns
+   */
+  async analyzeFileWithSymbols(filePath, options = {}) {
+    return this.analyzeFile(filePath, options);
+  }
+
+  async analyzeWithSemantics(filePath, options = {}) {
+    return this.analyzeFile(filePath, options);
+  }
+}
+
+module.exports = C018Analyzer;

package/rules/common/C018_no_throw_generic_error/config.json

@@ -0,0 +1,50 @@
+{
+  "id": "C018",
+  "name": "C018_do_not_throw_generic_errors",
+  "category": "architecture",
+  "description": "C018 - Always provide detailed messages and context.",
+  "severity": "warning",
+  "enabled": true,
+  "semantic": {
+    "enabled": true,
+    "priority": "high",
+    "fallback": "heuristic"
+  },
+  "patterns": {
+    "include": [
+      "**/*.js",
+      "**/*.ts",
+      "**/*.jsx",
+      "**/*.tsx"
+    ],
+    "exclude": [
+      "**/*.test.*",
+      "**/*.spec.*",
+      "**/*.mock.*",
+      "**/test/**",
+      "**/tests/**",
+      "**/spec/**"
+    ]
+  },
+  "options": {
+    "strictMode": false,
+    "allowedDbMethods": [],
+    "repositoryPatterns": [
+      "*Repository*",
+      "*Repo*",
+      "*DAO*",
+      "*Store*"
+    ],
+    "servicePatterns": [
+      "*Service*",
+      "*UseCase*",
+      "*Handler*",
+      "*Manager*"
+    ],
+    "complexityThreshold": {
+      "methodLength": 200,
+      "cyclomaticComplexity": 5,
+      "nestedDepth": 3
+    }
+  }
+}