@sun-asterisk/sunlint 1.3.46 → 1.3.48

package/core/scoring-service.js

@@ -22,9 +22,10 @@ class ScoringService {
     //
     this.weights = {
       // Penalty per violation type (per KLOC)
-      // Errors are 3x more severe than warnings
+      // Severity ratio: error(6) : warning(2) : info(0.5) = 12:4:1
       errorPenaltyPerKLOC: 6,      // Each error per KLOC reduces score by 6 points
       warningPenaltyPerKLOC: 2,    // Each warning per KLOC reduces score by 2 points
+      infoPenaltyPerKLOC: 0.5,     // Each info per KLOC reduces score by 0.5 points
 
       // Absolute penalty thresholds (regardless of LOC)
       // Large projects should still be penalized for raw violation counts
@@ -57,11 +58,12 @@ class ScoringService {
    * @param {Object} params
    * @param {number} params.errorCount - Number of errors found
    * @param {number} params.warningCount - Number of warnings found
+   * @param {number} params.infoCount - Number of info violations found
    * @param {number} params.rulesChecked - Number of rules checked
    * @param {number} params.loc - Total lines of code
    * @returns {number} Score between 0-100
    */
-  calculateScore({ errorCount = 0, warningCount = 0, rulesChecked = 0, loc = 0 }) {
+  calculateScore({ errorCount = 0, warningCount = 0, infoCount = 0, rulesChecked = 0, loc = 0 }) {
     // Base score starts at 100
     let score = 100;
 
@@ -72,12 +74,13 @@ class ScoringService {
     // Calculate violations per KLOC
     const errorsPerKLOC = errorCount / kloc;
     const warningsPerKLOC = warningCount / kloc;
-    const totalViolationsPerKLOC = errorsPerKLOC + warningsPerKLOC;
+    const infosPerKLOC = infoCount / kloc;
 
     // 1. Density-based penalty (main scoring factor)
     // This penalizes based on how "dense" the violations are
     const densityPenalty = (errorsPerKLOC * this.weights.errorPenaltyPerKLOC) +
-                          (warningsPerKLOC * this.weights.warningPenaltyPerKLOC);
+                          (warningsPerKLOC * this.weights.warningPenaltyPerKLOC) +
+                          (infosPerKLOC * this.weights.infoPenaltyPerKLOC);
     score -= densityPenalty;
 
     // 2. Absolute penalty for projects with too many errors
@@ -195,6 +198,8 @@ class ScoringService {
   generateScoringSummary(params) {
     const score = this.calculateScore(params);
     const grade = this.getGrade(score);
+    const infoCount = params.infoCount || 0;
+    const totalViolations = params.errorCount + params.warningCount + infoCount;
 
     return {
       score,
@@ -202,10 +207,11 @@ class ScoringService {
       metrics: {
         errors: params.errorCount,
         warnings: params.warningCount,
+        infos: infoCount,
         rulesChecked: params.rulesChecked,
         linesOfCode: params.loc,
-        violationsPerKLOC: params.loc > 0 
-          ? Math.round(((params.errorCount + params.warningCount) / params.loc * 1000) * 10) / 10
+        violationsPerKLOC: params.loc > 0
+          ? Math.round((totalViolations / params.loc * 1000) * 10) / 10
           : 0
       }
     };

package/core/summary-report-service.js

@@ -247,11 +247,12 @@ class SummaryReportService {
       total_violations: violations.length,
       error_count: scoringSummary.metrics.errors,
       warning_count: scoringSummary.metrics.warnings,
-      info_count: 0, // Reserved for future use
+      info_count: scoringSummary.metrics.infos || 0,
       lines_of_code: scoringSummary.metrics.linesOfCode,
       files_analyzed: options.filesAnalyzed || 0,
       sunlint_version: options.version || this.version,
       analysis_duration_ms: options.duration || 0,
+      scoring_mode: options.scoringMode || 'project',
       violations: violationsSummary,
 
       // Additional metadata for backwards compatibility
@@ -259,7 +260,8 @@ class SummaryReportService {
         generated_at: new Date().toISOString(),
         tool: 'SunLint',
         version: options.version || this.version,
-        analysis_duration_ms: options.duration || 0
+        analysis_duration_ms: options.duration || 0,
+        scoring_mode: options.scoringMode || 'project'
       },
       quality: {
         score: scoringSummary.score,
@@ -384,15 +386,18 @@ class SummaryReportService {
     const totalViolations = summaryReport.total_violations || 0;
     const errorCount = summaryReport.error_count || 0;
     const warningCount = summaryReport.warning_count || 0;
+    const infoCount = summaryReport.info_count || 0;
     const violationsByRule = summaryReport.violations || [];
     const violationsPerKLOC = summaryReport.quality?.metrics?.violationsPerKLOC || 0;
+    const scoringMode = summaryReport.scoring_mode || 'project';
 
     let output = '\n📊 Quality Summary Report\n';
     output += '━'.repeat(50) + '\n';
-    output += `📈 Quality Score: ${score} (Grade: ${grade})\n`;
+    output += `📈 Quality Score: ${score} (Grade: ${grade})`;
+    output += scoringMode === 'pr' ? ' [PR mode]\n' : '\n';
     output += `📁 Files Analyzed: ${filesAnalyzed}\n`;
     output += `📏 Lines of Code: ${linesOfCode.toLocaleString()}\n`;
-    output += `⚠️  Total Violations: ${totalViolations} (${errorCount} errors, ${warningCount} warnings)\n`;
+    output += `⚠️  Total Violations: ${totalViolations} (${errorCount} errors, ${warningCount} warnings, ${infoCount} info)\n`;
     output += `📊 Violations per KLOC: ${violationsPerKLOC}\n`;
 
     if (violationsByRule.length > 0) {

package/engines/heuristic-engine.js

@@ -1002,7 +1002,12 @@ class HeuristicEngine extends AnalysisEngineInterface {
               fileResult = { file: filePath, violations: [] };
               results.results.push(fileResult);
             }
-            fileResult.violations.push(...violations);
+            // Apply rule severity to each violation (from config)
+            const violationsWithSeverity = violations.map(v => ({
+              ...v,
+              severity: rule.severity || v.severity || 'warning'
+            }));
+            fileResult.violations.push(...violationsWithSeverity);
           }
         }
 

package/engines/impact/cli.js

@@ -50,57 +50,72 @@ DESCRIPTION:
   components in TypeScript/JavaScript projects.
 
 OPTIONS:
-  --input=<path>          Source directory to analyze
-                          Default: src
 
-  --base=<ref>            Base git reference for comparison
-                          Default: HEAD~1 (previous commit)
-                          Examples: origin/main, HEAD~5, abc123
+  Input & Source:
+    --input=<path>          Source directory to analyze (default: src)
+    
+  Git References:
+    --base=<ref>            Base git reference (default: HEAD~1)
+    --head=<ref>            Head git reference (default: current working dir)
+    
+  Exclusions:
+    --exclude=<paths>       Comma-separated paths to exclude
+                            Example: --exclude=test,examples,mocks
+    --use-gitignore         Use .gitignore patterns for exclusions (recommended)
+                            This automatically excludes files ignored by git
+    
+  Analysis Options:
+    --max-depth=<n>         Maximum call chain depth (default: 3)
+    --include-tests         Include test files in analysis
+    --verbose               Show detailed analysis output
+    
+  Output:
+    --format=<type>         Output format: markdown, json, csv (default: markdown)
+    --output=<file>         Output file path (default: impact-report.md)
+    
+  Other:
+    --help                  Show this help message
 
-  --head=<ref>            Head git reference (optional)
-                          Default: (working directory)
-
-  --exclude=<paths>       Comma-separated paths to exclude
-                          Default: node_modules,dist,build,specs,coverage
-
-  --output=<file>         Output markdown report file
-                          Default: impact-report.md
-
-  --json=<file>           Output JSON report file (optional)
-                          Example: --json=impact-report.json
-
-  --max-depth=<n>         Maximum call graph depth
-                          Default: 3
-
-  --include-tests         Include test files in analysis
+EXAMPLES:
 
-  --verbose               Show verbose output and stack traces
+  Basic usage (analyze changes from last commit):
+    $ impact-analyzer --input=src --verbose
 
-  --no-fail               Don't exit with error on critical impact
+  Use .gitignore patterns (recommended for large projects):
+    $ impact-analyzer --input=src --use-gitignore --verbose
 
-  --help, -h              Show this help message
+  Analyze specific git range:
+    $ impact-analyzer --base=main --head=feature-branch
 
-EXAMPLES:
-  # Analyze changes in last commit (default)
-  impact-analyzer
+  Custom exclusions:
+    $ impact-analyzer --exclude=test,examples,fixtures
 
-  # Analyze changes between main branch and current
-  impact-analyzer --base=origin/main
+  Include tests in analysis:
+    $ impact-analyzer --include-tests
 
-  # Analyze specific directory with JSON output
-  impact-analyzer --input=backend/src --json=report.json
+  Generate JSON report:
+    $ impact-analyzer --format=json --output=impact.json
 
-  # Analyze last 3 commits with verbose output
-  impact-analyzer --base=HEAD~3 --verbose
+PERFORMANCE TIPS:
 
-  # Compare two specific commits
-  impact-analyzer --base=abc123 --head=def456
+  ⚡ Use --use-gitignore for automatic exclusion of unnecessary files
+     This can reduce analysis time by 60-90% on large projects!
+  
+  ⚡ Exclude test/example directories if not needed:
+     --exclude=test,tests,examples,samples,mocks
+  
+  ⚡ For large codebases, limit max-depth:
+     --max-depth=2
 
-REFERENCE:
-  Architecture: .specify/plans/architecture.md
-  Coding Rules: .github/copilot-instructions.md
+DEFAULT EXCLUSIONS (when not using --use-gitignore):
 
-For more information, visit: https://github.com/sun-asterisk/impact-analyzer
+  • node_modules, dist, build, out
+  • test files: *.test.ts, *.spec.ts
+  • examples, samples, fixtures, mocks
+  • coverage, reports
+  • .cache, .temp, .history
+  • IDE: .idea, .vscode
+  • Type definitions: *.d.ts
 `);
   }
 }

package/engines/impact/config/default-config.js

@@ -3,15 +3,49 @@
  * Loads and validates configuration from CLI args and defaults
  */
 
+import { GitignoreParser, gitignoreToExcludePaths } from '../core/utils/gitignore-parser.js';
+import path from 'path';
+
 export function loadConfig(cli) {
+  const sourceDir = cli.getArg('input', 'src');
+  const rootDir = path.resolve(sourceDir, '..');
+  
+  // Load patterns from .gitignore
+  const gitignorePatterns = cli.hasArg('use-gitignore') 
+    ? gitignoreToExcludePaths(rootDir)
+    : [];
+
+  // Custom exclude paths from CLI
+  const customExcludes = cli.getArg('exclude', '')
+    .split(',')
+    .map(p => p.trim())
+    .filter(p => p);
+
+  // Merge: gitignore + custom + defaults
+  const allExcludes = [
+    ...new Set([
+      ...gitignorePatterns,
+      ...customExcludes,
+      ...DEFAULT_EXCLUDE_PATHS,
+    ])
+  ];
+
   const config = {
     // Source directory to analyze
-    sourceDir: cli.getArg('input', 'src'),
+    sourceDir: sourceDir,
+    rootDir: rootDir,
 
     // Paths to exclude from analysis
-    excludePaths: cli.getArg('exclude', 'node_modules,dist,build,specs,coverage')
-      .split(',')
-      .map(p => p.trim()),
+    excludePaths: allExcludes,
+    
+    // Gitignore parser for advanced pattern matching
+    gitignoreParser: cli.hasArg('use-gitignore') 
+      ? (() => {
+          const parser = new GitignoreParser(rootDir);
+          parser.loadGitignore();
+          return parser;
+        })()
+      : null,
 
     // Git references - defaults to HEAD~1 (previous commit)
     baseRef: cli.getArg('base', 'HEAD~1'),
@@ -41,9 +75,75 @@ function validateConfig(config) {
   // baseRef and headRef are optional, have sensible defaults
 }
 
+// Default exclude paths - comprehensive list
+const DEFAULT_EXCLUDE_PATHS = [
+  // Build & Dependencies
+  'node_modules',
+  'dist',
+  'build',
+  'out',
+  '.turbo',
+  '.next',
+  
+  // Tests (unless --include-tests)
+  '__tests__',
+  'test',
+  'tests',
+  '.test.ts',
+  '.spec.ts',
+  '.test.js',
+  '.spec.js',
+  '.test.tsx',
+  '.spec.tsx',
+  
+  // Examples & Samples
+  'examples',
+  'samples',
+  'fixtures',
+  'mocks',
+  '__mocks__',
+  'project-samples',
+  
+  // Coverage & Reports
+  'coverage',
+  'reports',
+  '.nyc_output',
+  
+  // Cache & Temp
+  '.cache',
+  '.temp',
+  '.tmp',
+  '.history',
+  
+  // Documentation Sites
+  'pages/_site',
+  '_site',
+  '.jekyll-cache',
+  '.jekyll-metadata',
+  'vendor',
+  '.bundle',
+  
+  // IDE & Tools
+  '.idea',
+  '.vscode',
+  '.github',
+  '.agent',
+  '.claude',
+  '.serena',
+  
+  // Config-specific
+  'specs',
+  '.sunlint-cache',
+  'origin-rules',
+  'arch-detect',
+  
+  // Type definitions (no runtime code to analyze)
+  '.d.ts',
+];
+
 export const DEFAULT_CONFIG = {
   sourceDir: 'src',
-  excludePaths: ['node_modules', 'dist', 'build', 'specs', 'coverage'],
+  excludePaths: DEFAULT_EXCLUDE_PATHS,
   baseRef: 'HEAD~1',  // Previous commit
   headRef: 'HEAD',     // Current commit
   maxDepth: 3,

package/engines/impact/core/impact-analyzer.js

@@ -20,7 +20,8 @@ export class ImpactAnalyzer {
     await this.methodCallGraph.initialize(
       this.absoluteSourceDir,
       this.config.excludePaths,
-      this.config.verbose
+      this.config.verbose,
+      this.config.gitignoreParser || null
     );
 
     this.endpointDetector = new EndpointDetector(this.methodCallGraph, this.config);
@@ -69,28 +70,24 @@ export class ImpactAnalyzer {
 
   detectLogicImpact(changedSymbols) {
     const directCallers = new Set();
-    const indirectCallers = new Set();
+    const allCallers = new Set();
 
     for (const symbol of changedSymbols) {
       const methodName = `${symbol.className || 'global'}.${symbol.name}`;
-      const callers = this.methodCallGraph.findAllCallers(methodName);
       
-      callers.forEach(caller => {
-        directCallers.add(caller);
-        
-        const indirectCallersOfCaller = this.methodCallGraph.findAllCallers(caller);
-        indirectCallersOfCaller.forEach(ic => {
-          if (!callers.includes(ic)) {
-            indirectCallers.add(ic);
-          }
-        });
-      });
+      const immediateCallers = this.methodCallGraph.getCallers(methodName);
+      immediateCallers.forEach(caller => directCallers.add(caller));
+      
+      const recursiveCallers = this.methodCallGraph.findAllCallers(methodName);
+      recursiveCallers.forEach(caller => allCallers.add(caller));
     }
 
+    const indirectCallers = Array.from(allCallers).filter(caller => !directCallers.has(caller));
+
     return {
       directCallers: Array.from(directCallers),
-      indirectCallers: Array.from(indirectCallers),
-      riskLevel: this.calculateRiskLevel(directCallers.size, indirectCallers.size),
+      indirectCallers: indirectCallers,
+      riskLevel: this.calculateRiskLevel(directCallers.size, indirectCallers.length),
     };
   }
 

package/engines/impact/core/utils/gitignore-parser.js

@@ -0,0 +1,123 @@
+/**
+ * Gitignore Parser
+ * Reads .gitignore files and converts patterns to exclude paths
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { minimatch } from 'minimatch';
+
+export class GitignoreParser {
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+    this.patterns = [];
+    this.negationPatterns = [];
+  }
+
+  /**
+   * Load patterns from .gitignore file
+   */
+  loadGitignore(gitignorePath = null) {
+    const ignoreFile = gitignorePath || path.join(this.rootDir, '.gitignore');
+    
+    if (!fs.existsSync(ignoreFile)) {
+      return [];
+    }
+
+    const content = fs.readFileSync(ignoreFile, 'utf8');
+    const lines = content.split('\n');
+
+    const patterns = [];
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      
+      // Skip empty lines and comments
+      if (!trimmed || trimmed.startsWith('#')) continue;
+
+      // Handle negation patterns (!)
+      if (trimmed.startsWith('!')) {
+        this.negationPatterns.push(trimmed.substring(1));
+        continue;
+      }
+
+      patterns.push(trimmed);
+    }
+
+    this.patterns = patterns;
+    return patterns;
+  }
+
+  /**
+   * Check if a file path should be excluded based on gitignore patterns
+   */
+  shouldExclude(filePath) {
+    // Normalize path separators
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    
+    // Check if path matches any pattern
+    for (const pattern of this.patterns) {
+      if (this.matchesPattern(normalizedPath, pattern)) {
+        // Check if there's a negation pattern that overrides
+        const isNegated = this.negationPatterns.some(negPattern => 
+          this.matchesPattern(normalizedPath, negPattern)
+        );
+        
+        if (!isNegated) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Match a file path against a gitignore pattern
+   */
+  matchesPattern(filePath, pattern) {
+    // Handle directory-only patterns (ending with /)
+    if (pattern.endsWith('/')) {
+      const dirPattern = pattern.slice(0, -1);
+      return filePath.includes(`/${dirPattern}/`) || filePath.includes(`${dirPattern}/`);
+    }
+
+    // Handle patterns starting with /
+    if (pattern.startsWith('/')) {
+      return minimatch(filePath, pattern.substring(1), { matchBase: true });
+    }
+
+    // Handle wildcards and glob patterns
+    if (pattern.includes('*') || pattern.includes('?') || pattern.includes('[')) {
+      return minimatch(filePath, pattern, { matchBase: true, dot: true });
+    }
+
+    // Simple substring match for paths
+    return filePath.includes(pattern) || 
+           filePath.includes(`/${pattern}/`) ||
+           filePath.endsWith(`/${pattern}`);
+  }
+
+  /**
+   * Get all patterns
+   */
+  getPatterns() {
+    return this.patterns;
+  }
+}
+
+/**
+ * Convert gitignore patterns to simple exclude path list
+ * for backward compatibility
+ */
+export function gitignoreToExcludePaths(rootDir) {
+  const parser = new GitignoreParser(rootDir);
+  parser.loadGitignore();
+  
+  // Extract simple path patterns (non-glob)
+  const simplePaths = parser.getPatterns().filter(p => 
+    !p.includes('*') && !p.includes('?') && !p.includes('[')
+  );
+  
+  return simplePaths.map(p => p.replace(/^\//, '').replace(/\/$/, ''));
+}