@sun-asterisk/sunlint 1.3.23 → 1.3.25

package/rules/common/C021_import_organization/ts-morph-analyzer.js

@@ -0,0 +1,373 @@
+/**
+ * C021 ts-morph Analyzer - Import Organization
+ *
+ * Enforces organized imports with proper grouping and sorting:
+ * 1. Built-in modules (fs, path, etc.)
+ * 2. External dependencies (express, axios, etc.)
+ * 3. Internal modules (./utils, ../services, etc.)
+ *
+ * Within each group, imports should be sorted alphabetically.
+ * Blank lines should separate groups.
+ *
+ * Following Rule C005: Single responsibility - import organization only
+ * Following Rule C006: Verb-noun naming
+ */
+
+const { Project, SyntaxKind, Node } = require('ts-morph');
+const fs = require('fs');
+const path = require('path');
+
+class C021TsMorphAnalyzer {
+  constructor(semanticEngine = null, options = {}) {
+    this.ruleId = 'C021';
+    this.ruleName = 'Import Organization';
+    this.description = 'Enforce organized imports with grouping and sorting';
+    this.semanticEngine = semanticEngine;
+    this.project = null;
+    this.verbose = false;
+
+    // Load config
+    this.config = this.loadConfig();
+  }
+
+  loadConfig() {
+    try {
+      const configPath = path.join(__dirname, 'config.json');
+      const configData = fs.readFileSync(configPath, 'utf8');
+      return JSON.parse(configData).config;
+    } catch (error) {
+      console.warn('[C021] Could not load config, using defaults');
+      return {
+        groups: [
+          {
+            name: 'builtin',
+            patterns: ['^(fs|path|http|https|crypto)$']
+          },
+          {
+            name: 'external',
+            patterns: ['^[^.]']
+          },
+          {
+            name: 'internal',
+            patterns: ['^\\\\.|^@/|^~/']
+          }
+        ],
+        sortOrder: {
+          groupOrder: ['builtin', 'external', 'internal'],
+          withinGroup: 'alphabetical'
+        },
+        spacing: {
+          requireBlankLineBetweenGroups: true
+        }
+      };
+    }
+  }
+
+  async initialize(semanticEngine = null) {
+    if (semanticEngine) {
+      this.semanticEngine = semanticEngine;
+    }
+    this.verbose = semanticEngine?.verbose || false;
+
+    // Use semantic engine's project if available
+    if (this.semanticEngine?.project) {
+      this.project = this.semanticEngine.project;
+      if (this.verbose) {
+        console.log('[DEBUG] 🎯 C021: Using semantic engine project');
+      }
+    } else {
+      this.project = new Project({
+        compilerOptions: {
+          target: 99,
+          module: 99,
+          allowJs: true,
+          checkJs: false,
+          jsx: 2,
+        },
+      });
+      if (this.verbose) {
+        console.log('[DEBUG] 🎯 C021: Created standalone ts-morph project');
+      }
+    }
+  }
+
+  async analyze(files, language, options = {}) {
+    this.verbose = options.verbose || this.verbose;
+
+    if (!this.project) {
+      await this.initialize();
+    }
+
+    const violations = [];
+
+    for (const filePath of files) {
+      try {
+        const fileViolations = await this.analyzeFile(filePath, options);
+        violations.push(...fileViolations);
+      } catch (error) {
+        if (this.verbose) {
+          console.warn(`[C021] Error analyzing ${filePath}:`, error.message);
+        }
+      }
+    }
+
+    return violations;
+  }
+
+  async analyzeFile(filePath, options = {}) {
+    // Get or add source file
+    let sourceFile = this.project.getSourceFile(filePath);
+
+    if (!sourceFile && fs.existsSync(filePath)) {
+      sourceFile = this.project.addSourceFileAtPath(filePath);
+    }
+
+    if (!sourceFile) {
+      return [];
+    }
+
+    const violations = [];
+
+    // Get all import declarations
+    const imports = sourceFile.getImportDeclarations();
+
+    if (imports.length === 0) {
+      return [];
+    }
+
+    // Organize imports into groups
+    const importGroups = this.organizeImports(imports);
+
+    // Check group order
+    const orderViolations = this.checkGroupOrder(importGroups, imports);
+    violations.push(...orderViolations);
+
+    // Check sorting within groups
+    const sortViolations = this.checkGroupSorting(importGroups);
+    violations.push(...sortViolations);
+
+    // Check spacing between groups
+    const spacingViolations = this.checkGroupSpacing(importGroups, sourceFile);
+    violations.push(...spacingViolations);
+
+    return violations.map(v => ({
+      ...v,
+      filePath: sourceFile.getFilePath()
+    }));
+  }
+
+  /**
+   * Organize imports into groups based on config
+   */
+  organizeImports(imports) {
+    const groups = {};
+
+    // Initialize groups
+    for (const groupConfig of this.config.groups) {
+      groups[groupConfig.name] = [];
+    }
+
+    // Categorize each import
+    for (const importDecl of imports) {
+      const moduleSpecifier = importDecl.getModuleSpecifierValue();
+      const groupName = this.categorizeImport(moduleSpecifier);
+
+      if (groupName && groups[groupName]) {
+        groups[groupName].push({
+          node: importDecl,
+          moduleSpecifier,
+          line: importDecl.getStartLineNumber()
+        });
+      }
+    }
+
+    return groups;
+  }
+
+  /**
+   * Categorize an import into a group
+   */
+  categorizeImport(moduleSpecifier) {
+    for (const groupConfig of this.config.groups) {
+      for (const pattern of groupConfig.patterns) {
+        const regex = new RegExp(pattern);
+        if (regex.test(moduleSpecifier)) {
+          return groupConfig.name;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Check if groups appear in correct order
+   */
+  checkGroupOrder(importGroups, allImports) {
+    const violations = [];
+    const expectedOrder = this.config.sortOrder.groupOrder;
+
+    // Get actual order of groups
+    const actualOrder = [];
+    const groupFirstLines = new Map();
+
+    for (const importInfo of allImports.map(imp => ({
+      node: imp,
+      moduleSpecifier: imp.getModuleSpecifierValue(),
+      line: imp.getStartLineNumber()
+    }))) {
+      const groupName = this.categorizeImport(importInfo.moduleSpecifier);
+      if (groupName && !groupFirstLines.has(groupName)) {
+        groupFirstLines.set(groupName, importInfo.line);
+        actualOrder.push(groupName);
+      }
+    }
+
+    // Check if actual order matches expected order
+    const expectedFiltered = expectedOrder.filter(g => actualOrder.includes(g));
+
+    for (let i = 0; i < actualOrder.length; i++) {
+      if (actualOrder[i] !== expectedFiltered[i]) {
+        // Find the misplaced import
+        const misplacedGroup = actualOrder[i];
+        const imports = importGroups[misplacedGroup];
+
+        if (imports && imports.length > 0) {
+          violations.push({
+            ruleId: this.ruleId,
+            message: `Import group "${misplacedGroup}" should come ${this.getOrderMessage(misplacedGroup, expectedFiltered, i)}`,
+            severity: 'info',
+            location: {
+              start: {
+                line: imports[0].line,
+                column: 1
+              },
+              end: {
+                line: imports[0].line,
+                column: 1
+              }
+            },
+            context: {
+              violationType: 'group-order',
+              currentGroup: misplacedGroup,
+              expectedOrder: expectedFiltered
+            }
+          });
+        }
+        break;
+      }
+    }
+
+    return violations;
+  }
+
+  /**
+   * Get descriptive message for group order violation
+   */
+  getOrderMessage(groupName, expectedOrder, currentIndex) {
+    const expectedIndex = expectedOrder.indexOf(groupName);
+    if (expectedIndex < currentIndex) {
+      return `before "${expectedOrder[currentIndex]}" imports`;
+    } else {
+      return `after "${expectedOrder[currentIndex - 1]}" imports`;
+    }
+  }
+
+  /**
+   * Check sorting within each group
+   */
+  checkGroupSorting(importGroups) {
+    const violations = [];
+
+    for (const [groupName, imports] of Object.entries(importGroups)) {
+      if (imports.length <= 1) continue;
+
+      // Check if sorted alphabetically
+      for (let i = 0; i < imports.length - 1; i++) {
+        const current = imports[i].moduleSpecifier;
+        const next = imports[i + 1].moduleSpecifier;
+
+        if (current.toLowerCase() > next.toLowerCase()) {
+          violations.push({
+            ruleId: this.ruleId,
+            message: `Import "${current}" should come after "${next}" (alphabetical order within ${groupName} group)`,
+            severity: 'info',
+            location: {
+              start: {
+                line: imports[i].line,
+                column: 1
+              },
+              end: {
+                line: imports[i].line,
+                column: 1
+              }
+            },
+            context: {
+              violationType: 'sorting',
+              group: groupName,
+              currentImport: current,
+              nextImport: next
+            }
+          });
+        }
+      }
+    }
+
+    return violations;
+  }
+
+  /**
+   * Check spacing between groups
+   */
+  checkGroupSpacing(importGroups, sourceFile) {
+    const violations = [];
+
+    if (!this.config.spacing.requireBlankLineBetweenGroups) {
+      return violations;
+    }
+
+    const expectedOrder = this.config.sortOrder.groupOrder;
+    const nonEmptyGroups = expectedOrder.filter(groupName =>
+      importGroups[groupName] && importGroups[groupName].length > 0
+    );
+
+    // Check spacing between consecutive groups
+    for (let i = 0; i < nonEmptyGroups.length - 1; i++) {
+      const currentGroup = importGroups[nonEmptyGroups[i]];
+      const nextGroup = importGroups[nonEmptyGroups[i + 1]];
+
+      const lastImportOfCurrentGroup = currentGroup[currentGroup.length - 1];
+      const firstImportOfNextGroup = nextGroup[0];
+
+      const lastLine = lastImportOfCurrentGroup.line;
+      const nextLine = firstImportOfNextGroup.line;
+
+      // Should have at least 1 blank line between groups
+      if (nextLine - lastLine < 2) {
+        violations.push({
+          ruleId: this.ruleId,
+          message: `Missing blank line between "${nonEmptyGroups[i]}" and "${nonEmptyGroups[i + 1]}" import groups`,
+          severity: 'info',
+          location: {
+            start: {
+              line: lastLine,
+              column: 1
+            },
+            end: {
+              line: nextLine,
+              column: 1
+            }
+          },
+          context: {
+            violationType: 'spacing',
+            currentGroup: nonEmptyGroups[i],
+            nextGroup: nonEmptyGroups[i + 1]
+          }
+        });
+      }
+    }
+
+    return violations;
+  }
+}
+
+module.exports = C021TsMorphAnalyzer;

package/rules/common/C029_catch_block_logging/analyzer.js

@@ -49,7 +49,7 @@ class C029Analyzer {
       ],
 
       // Test file patterns (more lenient checking)
-      testPatterns: ['__tests__', '.test.', '.spec.', '/test/', '/tests/', '.stories.']
+      testPatterns: ['__tests__', '.test.', '.spec.', '/test/', '/tests/', '.stories.', '-test.', '-spec.', 'test-fixtures']
     };
   }
 
@@ -154,6 +154,35 @@ class C029Analyzer {
 
     // STAGE 1: Check if catch block is empty
     if (this.isEmptyCatchBlock(block)) {
+      // Allow empty catch in test files if there's any comment explaining it
+      const hasComment = this.hasAnyComment(catchClause);
+      if (this.isTestFile(filePath) && hasComment) {
+        // Test files with explanatory comments are OK
+        return violations;
+      }
+
+      // Allow empty catch if there's a finally block with cleanup
+      // Common pattern: try { } catch { } finally { setLoading(false); }
+      const tryStatement = catchClause.getParent();
+      if (tryStatement && tryStatement.getFinallyBlock()) {
+        const finallyBlock = tryStatement.getFinallyBlock();
+        const finallyText = finallyBlock.getText();
+
+        // Check if finally block does cleanup (setState, setLoading, cleanup, etc.)
+        const cleanupPatterns = [
+          /set[A-Z]\w*\s*\(/,        // setLoading, setState, setError, etc.
+          /cleanup/i,                 // cleanup function
+          /reset/i,                   // reset function
+          /\.close\s*\(/,            // close connections
+          /\.disconnect\s*\(/,       // disconnect
+          /finally/i                  // any finally-related code
+        ];
+
+        if (cleanupPatterns.some(pattern => pattern.test(finallyText))) {
+          return violations; // Acceptable: empty catch with finally cleanup
+        }
+      }
+
       violations.push(this.createViolation(
         filePath,
         startLine,
@@ -338,7 +367,7 @@ class C029Analyzer {
     const issues = [];
 
     // Issue 1: Using inappropriate log level (log/info/debug instead of error/warn)
-    const hasInappropriateLevel = loggingInfo.logLevels.some(level => 
+    const hasInappropriateLevel = loggingInfo.logLevels.some(level =>
       this.config.inappropriateLevels.includes(level)
     );
 
@@ -361,26 +390,9 @@ class C029Analyzer {
       });
     }
 
-    // Issue 3: No stack trace (optional but recommended)
-    if (exceptionVar && loggingInfo.usesExceptionVar && !loggingInfo.hasStackTrace) {
-      // This is a warning, not critical
-      issues.push({
-        type: 'missing_stack_trace',
-        message: `Logging does not include stack trace (${exceptionVar}.stack)`,
-        suggestion: `Consider logging ${exceptionVar}.stack for better debugging`,
-        confidence: 0.60
-      });
-    }
-
-    // Issue 4: No context data (optional but recommended)
-    if (!loggingInfo.hasContextData && !this.isTestFile(filePath)) {
-      issues.push({
-        type: 'missing_context_data',
-        message: 'Error logging lacks context information (user ID, request ID, parameters)',
-        suggestion: 'Add context object with relevant data: { userId, requestId, ...params, error }',
-        confidence: 0.55
-      });
-    }
+    // REMOVED: Issue 3 & 4 (missing stack trace and context data)
+    // These are optional best practices, not violations. They created too much noise.
+    // Teams can enable them separately if desired through configuration.
 
     return issues;
   }
@@ -414,7 +426,20 @@ class C029Analyzer {
       }
     }
 
-    // Pattern 3: Common error handler functions
+    // Pattern 2b: Return default value (defensive programming)
+    // Common in frontend: catch { return []; } or catch { return null; }
+    // This is acceptable - returning safe default instead of crashing
+    if (/\breturn\b/.test(text)) {
+      const returnStatements = block.getDescendantsOfKind(SyntaxKind.ReturnStatement);
+      const statements = block.getStatements();
+
+      // If catch block ONLY contains a return statement, it's defensive programming
+      if (returnStatements.length === 1 && statements.length === 1) {
+        return true; // Acceptable pattern: return default value
+      }
+    }
+
+    // Pattern 3: Common error handler functions and external error trackers
     const errorHandlerPatterns = [
       /handleError\s*\(/,
       /processError\s*\(/,
@@ -425,35 +450,72 @@ class C029Analyzer {
       /externalErrorHandler\s*\(/,
       /logError\s*\(/,
       /captureError\s*\(/,
-      /recordError\s*\(/
+      /recordError\s*\(/,
+      // External error tracking services
+      /Sentry\.captureException\s*\(/,
+      /Bugsnag\.notify\s*\(/,
+      /Rollbar\.error\s*\(/,
+      /Airbrake\.notify\s*\(/,
+      /Raygun\.send\s*\(/,
+      // Common utility patterns
+      /sendToSentry\s*\(/,
+      /utils?\.log/i,
+      /helpers?\.log/i,
+      /ErrorUtils/,
+      /ErrorService/
     ];
 
     if (errorHandlerPatterns.some(pattern => pattern.test(text))) {
       return true;
     }
 
-    // Pattern 4: Delegation - calling ANY function/helper with exception variable
+    // Pattern 4: React/Vue state management (error stored in state)
+    // Examples: setError(error), dispatch(setError(error)), setState({error})
+    if (exceptionVar) {
+      const stateManagementPatterns = [
+        /set[A-Z]\w*\s*\(/,           // setState, setError, setLoading
+        /dispatch\s*\(/,               // Redux dispatch
+        /commit\s*\(/,                 // Vuex commit
+        /this\.setState\s*\(/,         // Class component setState
+        /useState/,                    // React hooks
+        /useReducer/                   // React reducer hook
+      ];
+
+      if (stateManagementPatterns.some(pattern => pattern.test(text))) {
+        // Check if error is passed to state function
+        const callExpressions = block.getDescendantsOfKind(SyntaxKind.CallExpression);
+        for (const call of callExpressions) {
+          const args = call.getArguments();
+          const argsText = args.map(arg => arg.getText()).join(' ');
+          if (new RegExp(`\\b${exceptionVar}\\b`).test(argsText)) {
+            return true; // Error stored in state
+          }
+        }
+      }
+    }
+
+    // Pattern 5: Delegation - calling ANY function/helper with exception variable
     // Examples: handleApiError(error), utils.logException(err), sendToSentry(e)
     if (exceptionVar) {
       const callExpressions = block.getDescendantsOfKind(SyntaxKind.CallExpression);
-      
+
       for (const call of callExpressions) {
         const args = call.getArguments();
-        
+
         // Check if exception variable is passed to any function
         for (const arg of args) {
           const argText = arg.getText().trim();
-          
+
           // Direct usage: someFunction(error)
           if (argText === exceptionVar) {
             return true;
           }
-          
+
           // Property access: someFunction(error.message)
           if (argText.startsWith(exceptionVar + '.')) {
             return true;
           }
-          
+
           // In object/array: someFunction({error: error})
           if (new RegExp(`\\b${exceptionVar}\\b`).test(argText)) {
             return true;
@@ -482,12 +544,25 @@ class C029Analyzer {
     return (matches.length - declarationMatches.length) > 0;
   }
 
+  /**
+   * Check if catch clause has any comment (for test files)
+   */
+  hasAnyComment(catchClause) {
+    const text = catchClause.getText();
+
+    // Check for any line or block comments
+    const hasLineComment = /\/\/.*\S/.test(text);
+    const hasBlockComment = /\/\*[\s\S]*?\*\//.test(text);
+
+    return hasLineComment || hasBlockComment;
+  }
+
   /**
    * Check if catch clause has explicit ignore comment
    */
   hasExplicitIgnoreComment(catchClause) {
     const text = catchClause.getText();
-    
+
     const ignorePatterns = [
       /\/\/\s*ignore/i,
       /\/\/\s*TODO/i,