@sun-asterisk/sunlint 1.3.47 → 1.3.48

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(/\/$/, ''));
+}