@sun-asterisk/sunlint 1.3.0 → 1.3.2

package/rules/common/C023_no_duplicate_variable/analyzer.js

@@ -0,0 +1,180 @@
+/**
+ * C023 Main Analyzer - Do not declare duplicate variable
+ * Primary: Do not declare duplicate variable names in the same scope.
+ * Fallback: Regex-based for all other cases
+ */
+
+const C023SymbolBasedAnalyzer = require('./symbol-based-analyzer');
+
+class C023Analyzer {
+  constructor(options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C023] Constructor called with options:`, !!options);
+      console.log(`🔧 [C023] Options type:`, typeof options, Object.keys(options || {}));
+    }
+
+    this.ruleId = 'C023';
+    this.ruleName = 'Do not declare duplicate variable';
+    this.description = 'Do not declare duplicate variable names in the same scope';
+    this.semanticEngine = options.semanticEngine || null;
+    this.verbose = options.verbose || false;
+
+    // Configuration
+    this.config = {
+      useSymbolBased: true,      // Primary approach
+      fallbackToRegex: false,     // Only when symbol fails completely
+      symbolBasedOnly: false     // Can be set to true for pure mode
+    };
+
+    // Initialize both analyzers
+    try {
+      this.symbolAnalyzer = new C023SymbolBasedAnalyzer(this.semanticEngine);
+      if (process.env.SUNLINT_DEBUG) {
+        console.log(`🔧 [C023] Symbol analyzer created successfully`);
+      }
+    } catch (error) {
+      console.error(`🔧 [C023] Error creating symbol analyzer:`, error);
+    }
+  }
+
+  /**
+   * 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);
+
+    // Ensure verbose flag is propagated
+    this.symbolAnalyzer.verbose = this.verbose;
+
+    if (this.verbose) {
+      console.log(`🔧 [C023 Hybrid] Analyzer initialized - verbose: ${this.verbose}`);
+    }
+  }
+
+  async analyze(files, language, options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C023] analyze() method called with ${files.length} files, language: ${language}`);
+    }
+
+    const violations = [];
+
+    for (const filePath of files) {
+      try {
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C023] Processing file: ${filePath}`);
+        }
+
+        const fileViolations = await this.analyzeFile(filePath, options);
+        violations.push(...fileViolations);
+
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C023] File ${filePath}: Found ${fileViolations.length} violations`);
+        }
+      } catch (error) {
+        console.warn(`❌ [C023] Analysis failed for ${filePath}:`, error.message);
+      }
+    }
+
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C023] Total violations found: ${violations.length}`);
+    }
+
+    return violations;
+  }
+
+  async analyzeFile(filePath, options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C023] 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(`🔧 [C023] Trying symbol-based analysis...`);
+        }
+        const sourceFile = this.semanticEngine.project.getSourceFile(filePath);
+        if (sourceFile) {
+          if (process.env.SUNLINT_DEBUG) {
+            console.log(`🔧 [C023] 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(`✅ [C023] 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(`⚠️ [C023] Source file not found in project`);
+          }
+        }
+      } catch (error) {
+        console.warn(`⚠️ [C023] Symbol analysis failed: ${error.message}`);
+        // Continue to fallback
+      }
+    } else {
+      if (process.env.SUNLINT_DEBUG) {
+        console.log(`🔄 [C023] 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(`🔄 [C023] Symbol analysis unavailable, using regex fallback`);
+      }
+    }
+
+    if (options?.verbose) {
+      console.log(`🔧 [C023] No analysis methods succeeded, returning empty`);
+    }
+    return [];
+  }
+
+  async analyzeFileBasic(filePath, options = {}) {
+    console.log(`🔧 [C023] analyzeFileBasic() called for: ${filePath}`);
+    console.log(`🔧 [C023] semanticEngine exists: ${!!this.semanticEngine}`);
+    console.log(`🔧 [C023] symbolAnalyzer exists: ${!!this.symbolAnalyzer}`);
+
+    try {
+      // Try symbol-based analysis first
+      if (this.semanticEngine?.isSymbolEngineReady?.() &&
+          this.semanticEngine.project) {
+
+        if (this.verbose) {
+          console.log(`🔍 [C023] Using symbol-based analysis for ${filePath}`);
+        }
+
+        const violations = await this.symbolAnalyzer.analyzeFileBasic(filePath, options);
+        return violations;
+      }
+    } catch (error) {
+      if (this.verbose) {
+        console.warn(`⚠️ [C023] Symbol analysis failed: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * 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 = C023Analyzer;

package/rules/common/C023_no_duplicate_variable/config.json

@@ -0,0 +1,50 @@
+{
+  "id": "C023",
+  "name": "C023_do_not_declare_duplicate_variable",
+  "category": "architecture",
+  "description": "C023 - Do not declare duplicate variable names in the same scope.",
+  "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
+    }
+  }
+}

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

@@ -0,0 +1,158 @@
+/**
+ * C023 Symbol-based Analyzer - Advanced Do not declare duplicate variable
+ * Purpose: Use AST + Symbol Resolution to analyze log content quality in catch blocks
+ */
+
+const { SyntaxKind } = require('ts-morph');
+
+class C023SymbolBasedAnalyzer {
+  constructor(semanticEngine = null) {
+    this.ruleId = 'C023';
+    this.ruleName = 'Error declare duplicate variable names in the same scope. (Symbol-Based)';
+    this.semanticEngine = semanticEngine;
+    this.verbose = false;
+  }
+
+  async initialize(semanticEngine = null) {
+    if (semanticEngine) {
+      this.semanticEngine = semanticEngine;
+    }
+    this.verbose = semanticEngine?.verbose || false;
+
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C023 Symbol-Based] Analyzer initialized, verbose: ${this.verbose}`);
+    }
+  }
+
+  async analyzeFileBasic(filePath, options = {}) {
+    // This is the main entry point called by the hybrid analyzer
+    return await this.analyzeFileWithSymbols(filePath, options);
+  }
+
+  async analyzeFileWithSymbols(filePath, options = {}) {
+    const violations = [];
+
+    // Enable verbose mode if requested
+    const verbose = options.verbose || this.verbose;
+
+    if (!this.semanticEngine?.project) {
+      if (verbose) {
+        console.warn('[C023 Symbol-Based] No semantic engine available, skipping analysis');
+      }
+      return violations;
+    }
+
+    if (verbose) {
+      console.log(`🔍 [C023 Symbol-Based] Starting analysis for ${filePath}`);
+    }
+
+    try {
+      const sourceFile = this.semanticEngine.project.getSourceFile(filePath);
+      if (!sourceFile) {
+        return violations;
+      }
+      this.checkScope(sourceFile, violations);
+      if (verbose) {
+        console.log(`🔍 [C023 Symbol-Based] Total violations found: ${violations.length}`);
+      }
+
+      return violations;
+    } catch (error) {
+      if (verbose) {
+        console.warn(`[C023 Symbol-Based] Analysis failed for ${filePath}:`, error.message);
+      }
+
+      return violations;
+    }
+  }
+
+  checkScope(node, violations) {
+    const seen = new Map();
+
+    node.forEachChild((child) => {
+      switch (child.getKind()) {
+        case SyntaxKind.VariableStatement: {
+          for (const decl of child.getDeclarations()) {
+            this.checkDuplicate(decl, seen, violations);
+          }
+          break;
+        }
+
+        case SyntaxKind.FunctionDeclaration:
+        case SyntaxKind.FunctionExpression:
+        case SyntaxKind.ArrowFunction:
+        case SyntaxKind.MethodDeclaration:
+        case SyntaxKind.Constructor: { // ✅ also cover constructors
+          const func = child;
+          // Params
+          func.getParameters().forEach((p) =>
+            this.checkDuplicate(p, seen, violations)
+          );
+          // Body as new scope
+          const body = func.getBody?.();
+          if (body) this.checkScope(body, violations);
+          break;
+        }
+
+        case SyntaxKind.Block: {
+          this.checkScope(child, violations);
+          break;
+        }
+
+        case SyntaxKind.CatchClause: {
+          const catchVar = child.getVariableDeclaration();
+          if (catchVar) {
+            // ✅ register catch param in scope
+            this.checkDuplicate(catchVar, seen, violations);
+          }
+          // Traverse catch block (same scope as catch param)
+          this.checkScope(child.getBlock(), violations);
+          break;
+        }
+
+        case SyntaxKind.ForStatement:
+        case SyntaxKind.ForOfStatement:
+        case SyntaxKind.ForInStatement: {
+          const initializer = child.getInitializer?.();
+          if (initializer) {
+            initializer.getDeclarations?.().forEach((decl) =>
+              this.checkDuplicate(decl, seen, violations)
+            );
+          }
+          const statement = child.getStatement?.();
+          if (statement) this.checkScope(statement, violations);
+          break;
+        }
+
+        default: {
+          this.checkScope(child, violations);
+        }
+      }
+    });
+  }
+
+  checkDuplicate(node, seen, violations) {
+    const name = node.getName?.();
+    if (!name) return;
+    const filePath = node.getSourceFile().getFilePath();
+
+    if (seen.has(name)) {
+      violations.push({
+        ruleId: this.ruleId,
+        severity: 'warning',
+        message: `Duplicate variable name found: "${name}"`,
+        source: this.ruleId,
+        file: filePath,
+        line: node.getStartLineNumber(),
+        column: node.getStart() - node.getStartLinePos(),
+        description: `[SYMBOL-BASED] Duplicate variable names can lead to confusion and bugs. Use unique names.`,
+        suggestion: 'Rename variables to ensure uniqueness',
+        category: 'naming'
+      });
+    } else {
+      seen.set(name, node);
+    }
+  }
+}
+
+module.exports = C023SymbolBasedAnalyzer;

package/rules/common/C024_no_scatter_hardcoded_constants/analyzer.js

@@ -0,0 +1,180 @@
+/**
+ * C024 Main Analyzer - Do not scatter hardcoded constants throughout the logic
+ * Primary: Do not scatter hardcoded constants throughout the logic.
+ * Fallback: Regex-based for all other cases
+ */
+
+const C024SymbolBasedAnalyzer = require('./symbol-based-analyzer');
+
+class C024Analyzer {
+  constructor(options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C024] Constructor called with options:`, !!options);
+      console.log(`🔧 [C024] Options type:`, typeof options, Object.keys(options || {}));
+    }
+
+    this.ruleId = 'C024';
+    this.ruleName = 'Do not scatter hardcoded constants throughout the logic';
+    this.description = 'The rule prevents scattering hardcoded constants throughout the logic. Instead, constants should be defined in a single place to improve maintainability and readability.';
+    this.semanticEngine = options.semanticEngine || null;
+    this.verbose = options.verbose || false;
+
+    // Configuration
+    this.config = {
+      useSymbolBased: true,      // Primary approach
+      fallbackToRegex: false,     // Only when symbol fails completely
+      symbolBasedOnly: false     // Can be set to true for pure mode
+    };
+
+    // Initialize both analyzers
+    try {
+      this.symbolAnalyzer = new C024SymbolBasedAnalyzer(this.semanticEngine);
+      if (process.env.SUNLINT_DEBUG) {
+        console.log(`🔧 [C024] Symbol analyzer created successfully`);
+      }
+    } catch (error) {
+      console.error(`🔧 [C024] Error creating symbol analyzer:`, error);
+    }
+  }
+
+  /**
+   * 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);
+
+    // Ensure verbose flag is propagated
+    this.symbolAnalyzer.verbose = this.verbose;
+
+    if (this.verbose) {
+      console.log(`🔧 [C024 Hybrid] Analyzer initialized - verbose: ${this.verbose}`);
+    }
+  }
+
+  async analyze(files, language, options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C024] analyze() method called with ${files.length} files, language: ${language}`);
+    }
+
+    const violations = [];
+
+    for (const filePath of files) {
+      try {
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C024] Processing file: ${filePath}`);
+        }
+
+        const fileViolations = await this.analyzeFile(filePath, options);
+        violations.push(...fileViolations);
+
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C024] File ${filePath}: Found ${fileViolations.length} violations`);
+        }
+      } catch (error) {
+        console.warn(`❌ [C024] Analysis failed for ${filePath}:`, error.message);
+      }
+    }
+
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C024] Total violations found: ${violations.length}`);
+    }
+
+    return violations;
+  }
+
+  async analyzeFile(filePath, options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C024] 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(`🔧 [C024] Trying symbol-based analysis...`);
+        }
+        const sourceFile = this.semanticEngine.project.getSourceFile(filePath);
+        if (sourceFile) {
+          if (process.env.SUNLINT_DEBUG) {
+            console.log(`🔧 [C024] 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(`✅ [C024] 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(`⚠️ [C024] Source file not found in project`);
+          }
+        }
+      } catch (error) {
+        console.warn(`⚠️ [C024] Symbol analysis failed: ${error.message}`);
+        // Continue to fallback
+      }
+    } else {
+      if (process.env.SUNLINT_DEBUG) {
+        console.log(`🔄 [C024] 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(`🔄 [C024] Symbol analysis unavailable, using regex fallback`);
+      }
+    }
+
+    if (options?.verbose) {
+      console.log(`🔧 [C024] No analysis methods succeeded, returning empty`);
+    }
+    return [];
+  }
+
+  async analyzeFileBasic(filePath, options = {}) {
+    console.log(`🔧 [C024] analyzeFileBasic() called for: ${filePath}`);
+    console.log(`🔧 [C024] semanticEngine exists: ${!!this.semanticEngine}`);
+    console.log(`🔧 [C024] symbolAnalyzer exists: ${!!this.symbolAnalyzer}`);
+
+    try {
+      // Try symbol-based analysis first
+      if (this.semanticEngine?.isSymbolEngineReady?.() &&
+          this.semanticEngine.project) {
+
+        if (this.verbose) {
+          console.log(`🔍 [C024] Using symbol-based analysis for ${filePath}`);
+        }
+
+        const violations = await this.symbolAnalyzer.analyzeFileBasic(filePath, options);
+        return violations;
+      }
+    } catch (error) {
+      if (this.verbose) {
+        console.warn(`⚠️ [C024] Symbol analysis failed: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * 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 = C024Analyzer;

package/rules/common/C024_no_scatter_hardcoded_constants/config.json

@@ -0,0 +1,50 @@
+{
+  "id": "C024",
+  "name": "C024_do_not_scatter_hardcoded_constants_throughout_the_logic",
+  "category": "architecture",
+  "description": "C024 - Do not scatter hardcoded constants throughout the logic.",
+  "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
+    }
+  }
+}