@sun-asterisk/sunlint 1.3.2 → 1.3.3

package/docs/SIMPLIFIED_USAGE_GUIDE.md

@@ -0,0 +1,208 @@
+# 🚀 SunLint Performance - Simplified Usage Guide
+
+## 🎯 **TÓM TẮT: 3 Commands Duy Nhất Bạn Cần Biết**
+
+### **1. 🏃‍♂️ Quick Start (90% use cases)**
+```bash
+sunlint --all --input=src
+```
+✅ **Auto-detects** project size và chọn settings tối ưu  
+✅ **Zero configuration** - chỉ cần chỉ định input folder  
+✅ **Works everywhere** - small projects đến enterprise  
+
+### **2. ⚡ Performance Modes (khi cần tùy chỉnh)**
+```bash
+# Fast scan (for testing/development)
+sunlint --all --input=src --performance=fast
+
+# Thorough analysis (for CI/CD)  
+sunlint --all --input=src --performance=careful
+```
+
+### **3. 🛠️ Custom Timeout (khi project rất lớn)**
+```bash
+sunlint --all --input=src --timeout=120000  # 2 minutes
+```
+
+---
+
+## 🤖 **Auto Performance Detection**
+
+SunLint **tự động phát hiện** project size và chọn settings tối ưu:
+
+| **Project Size** | **Files** | **Auto Settings** | **Timeout** |
+|------------------|-----------|-------------------|-------------|
+| **Small** | < 100 | Fast analysis | 30s |
+| **Medium** | 100-500 | Balanced | 60s |
+| **Large** | 500-1000 | Careful + progressive | 120s |
+| **Enterprise** | 1000+ | Conservative + streaming | 300s |
+
+### **Auto-Detection Logic**
+```bash
+# ✅ SunLint tự động:
+# - Đếm số files trong input folder
+# - Phát hiện TypeScript, Node.js project
+# - Chọn timeout và batch size phù hợp
+# - Bật progressive results cho large projects
+
+sunlint --all --input=src  # Làm tất cả tự động!
+```
+
+---
+
+## 📋 **Common Usage Patterns**
+
+### **Development (hàng ngày)**
+```bash
+# Quick feedback loop
+sunlint --rules=C019,C041,S027 --input=src
+
+# Check specific files
+sunlint --all --input=src/components --performance=fast
+```
+
+### **Code Review/PR**
+```bash
+# Check changed files only
+sunlint --all --changed-files
+
+# Quick but comprehensive
+sunlint --all --input=src --performance=fast --verbose
+```
+
+### **CI/CD Pipeline**
+```bash
+# Thorough analysis with auto-optimization
+sunlint --all --input=src --format=json --output=results.json
+
+# For large projects in CI
+sunlint --all --input=src --performance=careful --quiet
+```
+
+### **Weekly Code Quality Review**
+```bash
+# Full analysis with detailed reporting
+sunlint --all --input=src --verbose --format=table
+```
+
+---
+
+## 🚨 **Troubleshooting Simplified**
+
+### **❌ Getting Timeouts?**
+```bash
+# Try longer timeout
+sunlint --all --input=src --timeout=120000
+
+# Or limit files
+sunlint --all --input=src --max-files=500
+```
+
+### **❌ Taking Too Long?**
+```bash
+# Use fast mode
+sunlint --all --input=src --performance=fast
+
+# Or check specific rules
+sunlint --rules=C002,C019,S027 --input=src
+```
+
+### **❌ Memory Issues?**
+```bash
+# Automatic handling - just use auto mode
+sunlint --all --input=src --performance=auto
+```
+
+---
+
+## 🎛️ **Migration from Complex Commands**
+
+### **BEFORE (v3.x - Complex)**
+```bash
+# ❌ Too many options to remember
+sunlint --all --input=src \
+  --performance-profile=balanced \
+  --adaptive-timeout \
+  --max-memory=2GB \
+  --batch-size=10 \
+  --progressive-results \
+  --verbose
+```
+
+### **AFTER (v4.x - Simplified)**
+```bash
+# ✅ Simple and effective
+sunlint --all --input=src --verbose
+```
+
+### **Advanced Users Can Still Customize**
+```bash
+# For power users who need control
+sunlint --all --input=src --performance=careful --timeout=180000
+```
+
+---
+
+## 📊 **Performance Comparison**
+
+| **Command** | **Small Project** | **Large Project** | **Enterprise** |
+|-------------|-------------------|-------------------|----------------|
+| `--performance=auto` | ~10s | ~60s | ~120s |
+| `--performance=fast` | ~5s | ~30s | ~60s |
+| `--performance=careful` | ~15s | ~90s | ~180s |
+
+---
+
+## ✅ **Best Practices**
+
+### **🎯 DO (Recommended)**
+```bash
+✅ sunlint --all --input=src                    # Let auto-detection work
+✅ sunlint --all --input=src --verbose          # See what's happening  
+✅ sunlint --quality --input=src --performance=fast  # Quick quality check
+✅ sunlint --all --changed-files                # Only check changes
+```
+
+### **❌ DON'T (Avoid)**
+```bash
+❌ sunlint --all --input=src --performance-profile=conservative --batch-size=5 --streaming-analysis
+   # Too complex - just use --performance=careful
+
+❌ sunlint --all --input=src --timeout=5000     
+   # Too short - let auto-detection choose
+
+❌ sunlint --all --input=huge-project           
+   # Missing performance hint - add --performance=careful
+```
+
+---
+
+## 🏆 **Success Metrics**
+
+### **✅ Simplified CLI Achieved**
+- **3 main commands** cover 90% of use cases
+- **Auto-detection** eliminates guesswork  
+- **Zero configuration** for most projects
+- **Predictable performance** across project sizes
+
+### **✅ Backward Compatibility**
+- Old commands still work but show deprecation warnings
+- Gradual migration path for existing users
+- Advanced options available for power users
+
+---
+
+## 🚀 **Quick Start Checklist**
+
+- [ ] **Update to SunLint v4.x** with auto-performance
+- [ ] **Use basic command**: `sunlint --all --input=src`
+- [ ] **Add --verbose** if you want to see progress
+- [ ] **Use --performance=fast** for quick checks
+- [ ] **Use --performance=careful** for thorough analysis
+- [ ] **Test with your project** to validate performance
+
+---
+
+**🎯 Bottom Line: Chỉ cần nhớ `sunlint --all --input=src` - mọi thứ khác được tự động optimize!**
+
+*🚀 Simple • ⚡ Fast • 🎯 Effective*

package/engines/heuristic-engine.js

@@ -12,12 +12,13 @@ const SunlintRuleAdapter = require('../core/adapters/sunlint-rule-adapter');
 const SemanticEngine = require('../core/semantic-engine');
 const SemanticRuleBase = require('../core/semantic-rule-base');
 const { getInstance: getUnifiedRegistry } = require('../core/unified-rule-registry');
+const AutoPerformanceManager = require('../core/auto-performance-manager');
 const fs = require('fs');
 const path = require('path');
 
 class HeuristicEngine extends AnalysisEngineInterface {
   constructor() {
-    super('heuristic', '3.0', ['typescript', 'javascript', 'dart', 'swift', 'kotlin', 'java', 'python', 'go', 'rust', 'all']);
+    super('heuristic', '4.0', ['typescript', 'javascript', 'dart', 'swift', 'kotlin', 'java', 'python', 'go', 'rust', 'all']);
     
     this.ruleAnalyzers = new Map();
     this.supportedRulesList = [];
@@ -32,18 +33,38 @@ class HeuristicEngine extends AnalysisEngineInterface {
     
     // Unified rule registry
     this.unifiedRegistry = getUnifiedRegistry();
+    
+    // ✅ PERFORMANCE OPTIMIZATIONS (Integrated)
+    this.performanceManager = new AutoPerformanceManager();
+    this.performanceConfig = null;
+    this.metrics = {
+      startTime: null,
+      filesProcessed: 0,
+      rulesProcessed: 0,
+      violationsFound: 0,
+      memoryUsage: 0
+    };
   }
 
   /**
    * Initialize Heuristic engine with ts-morph core and configuration
+   * ✅ ENHANCED: Now includes performance optimization
    * Following Rule C006: Verb-noun naming
    * @param {Object} config - Engine configuration
    */
   async initialize(config) {
     try {
+      // ✅ PERFORMANCE: Get optimal settings based on project
+      this.performanceConfig = this.performanceManager.getOptimalSettings(config, config?.targetFiles || []);
+      
       // Store verbosity setting
       this.verbose = config?.verbose || false;
       
+      if (this.verbose && this.performanceConfig.autoDetected) {
+        console.log(`🤖 [HeuristicEngine] Auto-detected performance profile: ${this.performanceConfig.name}`);
+        console.log(`   ⚡ Settings: ${this.performanceConfig.timeout/1000}s timeout, ${this.performanceConfig.batchSize || 'auto'} batch size`);
+      }
+      
       // Initialize unified rule registry
       await this.unifiedRegistry.initialize({ verbose: this.verbose });
       
@@ -66,10 +87,11 @@ class HeuristicEngine extends AnalysisEngineInterface {
       
       this.initialized = true;
       if (this.verbose) {
-        console.log(`🔍 Heuristic engine v3.0 initialized:`);
+        console.log(`🔍 Heuristic engine v4.0 initialized:`);
         console.log(`   📊 Total rules: ${this.supportedRulesList.length}`);
         console.log(`   🧠 Symbol Table: ${this.symbolTableInitialized ? 'enabled' : 'disabled'}`);
         console.log(`   🔧 Semantic rules: ${this.semanticRules.size}`);
+        console.log(`   ⚡ Performance: ${this.performanceConfig.name || 'standard'}`);
       }
       
     } catch (error) {
@@ -607,6 +629,7 @@ class HeuristicEngine extends AnalysisEngineInterface {
 
   /**
    * Analyze files using heuristic patterns
+   * ✅ ENHANCED: Now includes performance optimizations and batch processing
    * Following Rule C006: Verb-noun naming
    * @param {string[]} files - Files to analyze
    * @param {Object[]} rules - Rules to apply
@@ -618,12 +641,166 @@ class HeuristicEngine extends AnalysisEngineInterface {
       throw new Error('Heuristic engine not initialized');
     }
 
+    // ✅ PERFORMANCE: Apply file limits and timeout protection
+    const startTime = Date.now();
+    this.metrics.startTime = startTime;
+    
+    // Apply analysis file limits (different from semantic file limits)
+    const maxFiles = this.getAnalysisFileLimit(options);
+    const limitedFiles = files.slice(0, maxFiles);
+    
+    if (files.length > maxFiles && this.verbose) {
+      console.warn(`⚠️  [HeuristicEngine] Analysis file limit: ${limitedFiles.length}/${files.length} files`);
+      console.log(`   💡 Note: Symbol table uses separate limit (--max-semantic-files)`);
+    }
+
+    // Set up timeout if configured
+    const timeout = this.performanceConfig?.timeout || parseInt(options.timeout) || 0;
+    let timeoutId = null;
+    
+    if (timeout > 0) {
+      timeoutId = setTimeout(() => {
+        throw new Error(`Analysis timeout after ${timeout}ms`);
+      }, timeout);
+    }
+
     if (options.verbose) {
-      console.log(`🔍 [HeuristicEngine] Analyzing ${files.length} files with ${rules.length} rules`);
-      console.log(`🔍 [HeuristicEngine] Files: ${files.map(f => path.basename(f)).join(', ')}`);
-      console.log(`🔍 [HeuristicEngine] Rules: ${rules.map(r => r.id).join(', ')}`);
+      console.log(`🔍 [HeuristicEngine] Analyzing ${limitedFiles.length} files with ${rules.length} rules`);
+      if (this.performanceConfig?.name) {
+        console.log(`⚡ [Performance] Using ${this.performanceConfig.name} profile`);
+      }
+      if (timeout > 0) {
+        console.log(`⏰ [Timeout] Analysis will timeout after ${timeout/1000}s`);
+      }
     }
 
+    try {
+      // Check if we should use batch processing
+      if (this.shouldUseBatchProcessing(limitedFiles, rules)) {
+        return await this.analyzeBatched(limitedFiles, rules, options);
+      } else {
+        return await this.analyzeStandard(limitedFiles, rules, options);
+      }
+    } finally {
+      // Clear timeout
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      
+      // Log performance metrics
+      const duration = Date.now() - startTime;
+      this.metrics.filesProcessed = limitedFiles.length;
+      this.metrics.rulesProcessed = rules.length;
+      
+      if (options.verbose) {
+        console.log(`✅ [HeuristicEngine] Analysis completed in ${duration}ms`);
+      }
+    }
+  }
+
+  /**
+   * ✅ NEW: Get analysis file limit (separate from semantic file limit)
+   */
+  getAnalysisFileLimit(options) {
+    // User-specified limit
+    if (options.maxFiles && parseInt(options.maxFiles) > 0) {
+      return parseInt(options.maxFiles);
+    }
+    
+    // Performance config limit
+    if (this.performanceConfig?.maxFiles) {
+      return this.performanceConfig.maxFiles;
+    }
+    
+    // Default based on performance mode
+    const mode = options.performance || 'auto';
+    const defaults = {
+      fast: 500,
+      auto: 1000,
+      careful: 1500
+    };
+    
+    return defaults[mode] || 1000;
+  }
+
+  /**
+   * ✅ NEW: Determine if batch processing should be used
+   */
+  shouldUseBatchProcessing(files, rules) {
+    const batchThreshold = this.performanceConfig?.batchThreshold || 100;
+    const totalWorkload = files.length * rules.length;
+    
+    return totalWorkload > batchThreshold || 
+           files.length > 200 || 
+           rules.length > 30;
+  }
+
+  /**
+   * ✅ NEW: Batch processing for large workloads
+   */
+  async analyzeBatched(files, rules, options) {
+    if (options.verbose) {
+      console.log(`� [HeuristicEngine] Using batch processing for large workload`);
+    }
+
+    const results = {
+      results: [],
+      filesAnalyzed: files.length,
+      engine: 'heuristic',
+      metadata: {
+        rulesAnalyzed: rules.map(r => r.id),
+        analyzersUsed: [],
+        batchProcessing: true
+      }
+    };
+
+    // Create rule batches
+    const batchSize = this.performanceConfig?.batchSize || 10;
+    const ruleBatches = [];
+    
+    for (let i = 0; i < rules.length; i += batchSize) {
+      ruleBatches.push(rules.slice(i, i + batchSize));
+    }
+
+    if (options.verbose) {
+      console.log(`📦 [Batch] Processing ${ruleBatches.length} rule batches (${batchSize} rules each)`);
+    }
+
+    // Process each batch
+    for (let batchIndex = 0; batchIndex < ruleBatches.length; batchIndex++) {
+      const ruleBatch = ruleBatches[batchIndex];
+      
+      if (options.verbose) {
+        console.log(`⚡ [Batch ${batchIndex + 1}/${ruleBatches.length}] Processing ${ruleBatch.length} rules...`);
+      }
+
+      const batchResults = await this.analyzeStandard(files, ruleBatch, options);
+      
+      // Merge batch results
+      for (const fileResult of batchResults.results) {
+        let existingFile = results.results.find(r => r.file === fileResult.file);
+        if (!existingFile) {
+          existingFile = { file: fileResult.file, violations: [] };
+          results.results.push(existingFile);
+        }
+        existingFile.violations.push(...fileResult.violations);
+      }
+      
+      results.metadata.analyzersUsed.push(...batchResults.metadata.analyzersUsed);
+      
+      // Memory management
+      if (batchIndex % 3 === 0 && global.gc) {
+        global.gc(); // Trigger garbage collection every 3 batches
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * ✅ REFACTORED: Standard analysis method (extracted from original analyze)
+   */
+  async analyzeStandard(files, rules, options) {
     const results = {
       results: [],
       filesAnalyzed: files.length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sun-asterisk/sunlint",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "☀️ SunLint - Multi-language static analysis tool for code quality and security | Sun* Engineering Standards",
   "main": "cli.js",
   "bin": {
@@ -22,6 +22,7 @@
     "test:integration": "echo 'Temporarily disabled - config extension issue'",
     "test:realworld": "node examples/integration-tests/realworld-integration-test.js",
     "test:cli": "node examples/integration-tests/direct-cli-test.js",
+    "test:performance": "node test/performance-test.js",
     "test:c019": "node cli.js --rule=C019 --input=examples/test-fixtures --format=eslint",
     "test:c006": "node cli.js --rule=C006 --input=examples/test-fixtures --format=eslint",
     "test:c029": "node cli.js --rule=C029 --input=examples/test-fixtures --format=eslint",

package/rules/common/C048_no_bypass_architectural_layers/analyzer.js

@@ -0,0 +1,180 @@
+/**
+ * C048 Main Analyzer - Do not bypass architectural layers (controller/service/repository)
+ * Primary: Maintain a clear layered architecture, ensuring logic and data flow are well-structured and maintainable.
+ * Fallback: Regex-based for all other cases
+ */
+
+const C048SymbolBasedAnalyzer = require('./symbol-based-analyzer');
+
+class C048Analyzer {
+  constructor(options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C048] Constructor called with options:`, !!options);
+      console.log(`🔧 [C048] Options type:`, typeof options, Object.keys(options || {}));
+    }
+
+    this.ruleId = 'C048';
+    this.ruleName = 'Do not bypass architectural layers (controller/service/repository)';
+    this.description = 'Maintain a clear layered architecture, ensuring logic and data flow are well-structured and maintainable.';
+    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 C048SymbolBasedAnalyzer(this.semanticEngine);
+      if (process.env.SUNLINT_DEBUG) {
+        console.log(`🔧 [C048] Symbol analyzer created successfully`);
+      }
+    } catch (error) {
+      console.error(`🔧 [C048] 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(`🔧 [C048 Hybrid] Analyzer initialized - verbose: ${this.verbose}`);
+    }
+  }
+
+  async analyze(files, language, options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C048] analyze() method called with ${files.length} files, language: ${language}`);
+    }
+
+    const violations = [];
+
+    for (const filePath of files) {
+      try {
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C048] Processing file: ${filePath}`);
+        }
+
+        const fileViolations = await this.analyzeFile(filePath, options);
+        violations.push(...fileViolations);
+
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C048] File ${filePath}: Found ${fileViolations.length} violations`);
+        }
+      } catch (error) {
+        console.warn(`❌ [C048] Analysis failed for ${filePath}:`, error.message);
+      }
+    }
+
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C048] Total violations found: ${violations.length}`);
+    }
+
+    return violations;
+  }
+
+  async analyzeFile(filePath, options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C048] 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(`🔧 [C048] Trying symbol-based analysis...`);
+        }
+        const sourceFile = this.semanticEngine.project.getSourceFile(filePath);
+        if (sourceFile) {
+          if (process.env.SUNLINT_DEBUG) {
+            console.log(`🔧 [C048] 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(`✅ [C048] 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(`⚠️ [C048] Source file not found in project`);
+          }
+        }
+      } catch (error) {
+        console.warn(`⚠️ [C048] Symbol analysis failed: ${error.message}`);
+        // Continue to fallback
+      }
+    } else {
+      if (process.env.SUNLINT_DEBUG) {
+        console.log(`🔄 [C048] 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(`🔄 [C048] Symbol analysis unavailable, using regex fallback`);
+      }
+    }
+
+    if (options?.verbose) {
+      console.log(`🔧 [C048] No analysis methods succeeded, returning empty`);
+    }
+    return [];
+  }
+
+  async analyzeFileBasic(filePath, options = {}) {
+    console.log(`🔧 [C048] analyzeFileBasic() called for: ${filePath}`);
+    console.log(`🔧 [C048] semanticEngine exists: ${!!this.semanticEngine}`);
+    console.log(`🔧 [C048] symbolAnalyzer exists: ${!!this.symbolAnalyzer}`);
+
+    try {
+      // Try symbol-based analysis first
+      if (this.semanticEngine?.isSymbolEngineReady?.() &&
+          this.semanticEngine.project) {
+
+        if (this.verbose) {
+          console.log(`🔍 [C048] Using symbol-based analysis for ${filePath}`);
+        }
+
+        const violations = await this.symbolAnalyzer.analyzeFileBasic(filePath, options);
+        return violations;
+      }
+    } catch (error) {
+      if (this.verbose) {
+        console.warn(`⚠️ [C048] 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 = C048Analyzer;

package/rules/common/C048_no_bypass_architectural_layers/config.json

@@ -0,0 +1,50 @@
+{
+  "id": "C048",
+  "name": "C048_do_not_bypass_architectural_layers",
+  "category": "architecture",
+  "description": "C048 - Do not bypass architectural layers (controller/service/repository)",
+  "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
+    }
+  }
+}