@sun-asterisk/sunlint 1.3.32 → 1.3.34

package/engines/eslint-engine.js

@@ -438,7 +438,6 @@ export default [
 `;
       
       fs.writeFileSync(tempConfigPath, configContent);
-      console.log(`🔧 [ESLintEngine] Created temporary flat config: ${tempConfigPath}`);
       
       // Schedule cleanup
       this.tempConfigPaths = this.tempConfigPaths || [];
@@ -545,7 +544,6 @@ export default [
         }
       }
       
-      console.log(`🔄 [ESLintEngine] Converted legacy config to flat config`);
       return flatConfig;
       
     } catch (error) {
@@ -1081,7 +1079,7 @@ export default [
         }
       }
 
-      console.log(`✅ [ESLintEngine] Loaded ${Object.keys(plugin.rules).length} custom rules`);
+      // Custom rules loaded silently
       return plugin;
     } catch (error) {
       console.warn('⚠️ Failed to load custom plugin:', error.message);
@@ -1148,7 +1146,7 @@ export default [
         projectPath = process.cwd();
       }
       
-      console.log(`🔍 [ESLintEngine] Using project path: ${projectPath}`);
+      // Project path detected silently
       
       // Get config detection for reuse
       const configDetection = this.detectESLintConfig(projectPath);
@@ -1189,7 +1187,6 @@ export default [
           overrideConfigFile: tempFlatConfigPath,
           cwd: projectPath
         };
-        console.log(`✅ [ESLintEngine] Created temporary flat config for plugin compatibility`);
       } else if (configDetection.hasLegacyConfig || configDetection.hasPackageConfig) {
         // For legacy config, create a temporary flat config file
         const tempFlatConfigPath = await this.createTemporaryFlatConfig(projectPath, configDetection, eslintConfig);
@@ -1197,20 +1194,17 @@ export default [
           overrideConfigFile: tempFlatConfigPath,
           cwd: projectPath
         };
-        console.log(`✅ [ESLintEngine] Created temporary flat config for legacy compatibility`);
       } else {
         // No config found - use analysis config only
         finalESLintOptions = {
           overrideConfig: eslintConfig,
           cwd: projectPath
         };
-        console.log(`⚠️ [ESLintEngine] Using analysis config only`);
       }
       
       const finalESLintInstance = new ESLint(finalESLintOptions);
 
       // Run ESLint analysis - let ESLint handle parsing errors gracefully
-      console.log(`🔍 [ESLintEngine] Analyzing ${jstsFiles.length} JavaScript/TypeScript files...`);
       let eslintResults;
       
       try {

package/engines/heuristic-engine.js

@@ -13,9 +13,43 @@ 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');
+// Multi-language support
+const { getManager: getSemanticEngineManager } = require('../core/semantic-engine-manager');
+const { registerBuiltInAnalyzers } = require('../core/adapters/index');
 const fs = require('fs');
 const path = require('path');
 
+/**
+ * Check if a rule supports Dart by detecting dart/ folder in rule structure
+ * @param {string} ruleId - Rule ID (e.g., 'C002', 'S003')
+ * @returns {boolean} True if rule has dart/ subfolder
+ */
+function detectDartSupport(ruleId) {
+  const rulesBasePath = path.join(__dirname, '../rules');
+  const categories = ['common', 'security', 'typescript'];
+
+  for (const category of categories) {
+    const categoryPath = path.join(rulesBasePath, category);
+    if (!fs.existsSync(categoryPath)) continue;
+
+    try {
+      const ruleFolders = fs.readdirSync(categoryPath);
+      for (const folder of ruleFolders) {
+        // Match rule folder by ID prefix (e.g., C002_no_duplicate_code matches C002)
+        if (folder.startsWith(ruleId + '_') || folder === ruleId) {
+          const dartPath = path.join(categoryPath, folder, 'dart');
+          if (fs.existsSync(dartPath) && fs.statSync(dartPath).isDirectory()) {
+            return true;
+          }
+        }
+      }
+    } catch (error) {
+      // Ignore errors when scanning directories
+    }
+  }
+  return false;
+}
+
 class HeuristicEngine extends AnalysisEngineInterface {
   constructor() {
     super('heuristic', '4.0', ['typescript', 'javascript', 'dart', 'swift', 'kotlin', 'java', 'python', 'go', 'rust', 'all']);
@@ -30,6 +64,9 @@ class HeuristicEngine extends AnalysisEngineInterface {
     this.semanticEngine = null;
     this.semanticRules = new Map();
     this.symbolTableEnabled = false;
+
+    // Multi-language support via SemanticEngineManager
+    this.semanticEngineManager = null;
     
     // Unified rule registry
     this.unifiedRegistry = getUnifiedRegistry();
@@ -101,12 +138,13 @@ class HeuristicEngine extends AnalysisEngineInterface {
   }
 
   /**
-   * Initialize ts-morph Symbol Table as core requirement
+   * Initialize Symbol Table with multi-language support
+   * ENHANCED: Uses SemanticEngineManager to support TypeScript, Dart, and other languages
    * OPTIMIZED: Use targeted files instead of entire project for better performance
    */
   async initializeSymbolTable(config) {
     const projectPath = config?.projectPath || process.cwd();
-    
+
     try {
       // Initialize semantic engine with config options including maxSemanticFiles
       const semanticOptions = {
@@ -114,14 +152,49 @@ class HeuristicEngine extends AnalysisEngineInterface {
         verbose: this.verbose,
         ...config?.semanticOptions
       };
-      
+
+      // =========================================
+      // Multi-language support via SemanticEngineManager
+      // =========================================
+
+      // Register built-in language analyzers (TypeScript, Dart, etc.)
+      registerBuiltInAnalyzers({ verbose: this.verbose });
+
+      // Get the SemanticEngineManager singleton
+      this.semanticEngineManager = getSemanticEngineManager({
+        verbose: this.verbose,
+        maxSemanticFiles: config?.maxSemanticFiles
+      });
+
+      // Initialize all registered analyzers with the project
+      const managerSuccess = await this.semanticEngineManager.initialize(
+        projectPath,
+        config?.targetFiles
+      );
+
+      if (managerSuccess && this.verbose) {
+        console.log(`🌍 Multi-language support enabled:`);
+        const names = this.semanticEngineManager.getAnalyzerNames();
+        for (const name of names) {
+          const analyzer = this.semanticEngineManager.getAnalyzer(name);
+          if (analyzer?.isReady()) {
+            console.log(`   ✅ ${name}: ${analyzer.extensions.join(', ')}`);
+          }
+        }
+      }
+
+      // =========================================
+      // Legacy SemanticEngine for backward compatibility
+      // =========================================
+
+      // Also initialize the legacy SemanticEngine directly for TypeScript
+      // This ensures backward compatibility with existing semantic rules
       this.semanticEngine = new SemanticEngine(semanticOptions);
-      // Pass verbose option to semantic engine
       this.semanticEngine.verbose = this.verbose;
-      
+
       // ts-morph is now a core dependency - but optimized for targeted files
       const success = await this.semanticEngine.initialize(projectPath, config?.targetFiles);
-      
+
       if (success) {
         this.semanticEnabled = true;
         this.symbolTableInitialized = true;
@@ -133,7 +206,7 @@ class HeuristicEngine extends AnalysisEngineInterface {
           console.warn('⚠️  Symbol Table initialization failed, using fallback mode');
         }
       }
-      
+
     } catch (error) {
       if (this.verbose) {
         console.warn('⚠️  ts-morph Symbol Table unavailable:', error.message);
@@ -602,14 +675,25 @@ class HeuristicEngine extends AnalysisEngineInterface {
     if (ruleId === 'C047') {
       return true;
     }
-    
+
+    // Check if rule supports Dart by detecting dart/ folder in rule structure
+    if (detectDartSupport(ruleId)) {
+      // Check if DartAnalyzer is available
+      if (this.semanticEngineManager) {
+        const dartAnalyzer = this.semanticEngineManager.getAnalyzer('dart');
+        if (dartAnalyzer && dartAnalyzer.isReady()) {
+          return true;
+        }
+      }
+    }
+
     // Use unified registry for primary lookup
     if (this.unifiedRegistry && this.unifiedRegistry.initialized) {
       return this.unifiedRegistry.isRuleSupported(ruleId, 'heuristic');
     }
-    
+
     // Fallback to original logic for backward compatibility
-    return this.supportedRulesList.includes(ruleId) || 
+    return this.supportedRulesList.includes(ruleId) ||
            this.semanticRules.has(ruleId) ||
            this.ruleAnalyzers.has(ruleId) ||
            this.checkShortRuleIdMatch(ruleId);
@@ -827,6 +911,11 @@ class HeuristicEngine extends AnalysisEngineInterface {
       processedRules++;
       const ruleProgress = Math.floor((processedRules / totalRules) * 100);
 
+      // Notify progress callback
+      if (options.onRuleStart) {
+        options.onRuleStart(rule.id);
+      }
+
       // Special case: Load C047 semantic rule on-demand
       if (rule.id === 'C047' && !this.semanticRules.has('C047')) {
         if (options.verbose) {
@@ -835,15 +924,22 @@ class HeuristicEngine extends AnalysisEngineInterface {
         await this.manuallyLoadC047();
       }
 
-      // Lazy load rule if not already loaded
-      if (!this.isRuleSupported(rule.id)) {
+      // Check if this rule is handled by DartAnalyzer for Dart files
+      // Detect Dart support by checking for dart/ folder in rule structure
+      const isDartRule = detectDartSupport(rule.id);
+      const hasDartFiles = filesByLanguage['dart'] && filesByLanguage['dart'].length > 0;
+      const dartAnalyzer = this.semanticEngineManager?.getAnalyzer('dart');
+      const useDartAnalyzer = isDartRule && hasDartFiles && dartAnalyzer && dartAnalyzer.isReady();
+
+      // Lazy load rule if not already loaded (skip for Dart-only rules)
+      if (!useDartAnalyzer && !this.isRuleSupported(rule.id)) {
         if (options.verbose) {
           console.log(`🔄 [HeuristicEngine] Lazy loading rule ${rule.id}...`);
         }
         await this.lazyLoadRule(rule.id, options);
       }
 
-      if (!this.isRuleSupported(rule.id)) {
+      if (!useDartAnalyzer && !this.isRuleSupported(rule.id)) {
         if (options.verbose) {
           console.warn(`⚠️ Rule ${rule.id} not supported by Heuristic engine, skipping...`);
         }
@@ -853,24 +949,35 @@ class HeuristicEngine extends AnalysisEngineInterface {
       try {
         let ruleViolations = [];
 
+        // Handle Dart files with DartAnalyzer
+        if (useDartAnalyzer) {
+          const dartFiles = filesByLanguage['dart'];
+
+          // Use DartAnalyzer directly
+          const rules = [{ id: rule.id, config: rule.config || {} }];
+          for (const filePath of dartFiles) {
+            try {
+              const violations = await dartAnalyzer.analyzeFile(filePath, rules, options);
+              if (violations && violations.length > 0) {
+                ruleViolations.push(...violations.map(v => ({
+                  ...v,
+                  ruleId: v.ruleId || rule.id,
+                  analysisMethod: v.analysisMethod || 'ast'
+                })));
+              }
+            } catch (error) {
+              // Silent error handling
+            }
+          }
+        }
         // Check if this is a semantic rule first (higher priority)
-        if (this.semanticRules.has(rule.id)) {
-          const progressInfo = options.batchInfo?.overallProgress !== undefined
-            ? `[${options.batchInfo.overallProgress}% overall] `
-            : '';
-          console.log(`🧠 ${progressInfo}Rule ${processedRules}/${totalRules} (${ruleProgress}%): ${rule.id} - Analyzing ${files.length} files...`);
-
+        else if (this.semanticRules.has(rule.id)) {
           ruleViolations = await this.analyzeSemanticRule(rule, files, options);
         } else {
           // Fallback to traditional analysis
-          const progressInfo = options.batchInfo?.overallProgress !== undefined
-            ? `[${options.batchInfo.overallProgress}% overall] `
-            : '';
-          console.log(`🔧 ${progressInfo}Rule ${processedRules}/${totalRules} (${ruleProgress}%): ${rule.id} - Analyzing ${files.length} files...`);
-
           ruleViolations = await this.analyzeRule(rule, filesByLanguage, options);
         }
-        
+
         if (ruleViolations.length > 0) {
           // Group violations by file
           const violationsByFile = this.groupViolationsByFile(ruleViolations);
@@ -886,11 +993,10 @@ class HeuristicEngine extends AnalysisEngineInterface {
           }
         }
 
-        // Log completion
-        const progressInfo = options.batchInfo?.overallProgress !== undefined
-          ? `[${options.batchInfo.overallProgress}% overall] `
-          : '';
-        console.log(`✅ ${progressInfo}${rule.id}: Found ${ruleViolations.length} violations`);
+        // Only log in verbose mode
+        if (options.verbose) {
+          console.log(`   ${rule.id}: ${ruleViolations.length} violations`);
+        }
 
         results.metadata.analyzersUsed.push(rule.id);
 
@@ -1208,6 +1314,48 @@ class HeuristicEngine extends AnalysisEngineInterface {
     return this.supportedRulesList;
   }
 
+  /**
+   * Get the SemanticEngineManager for multi-language support
+   * @returns {SemanticEngineManager|null}
+   */
+  getSemanticEngineManager() {
+    return this.semanticEngineManager;
+  }
+
+  /**
+   * Get a language-specific analyzer
+   * @param {string} language - Language name (e.g., 'dart', 'typescript')
+   * @returns {ILanguageAnalyzer|null}
+   */
+  getLanguageAnalyzer(language) {
+    if (!this.semanticEngineManager) {
+      return null;
+    }
+    return this.semanticEngineManager.getAnalyzer(language);
+  }
+
+  /**
+   * Get Symbol Table for a file using the appropriate language analyzer
+   * @param {string} filePath - Path to the file
+   * @returns {Promise<Object|null>}
+   */
+  async getSymbolTableForFile(filePath) {
+    // Try multi-language manager first
+    if (this.semanticEngineManager && this.semanticEngineManager.isReady()) {
+      const symbolTable = await this.semanticEngineManager.getSymbolTable(filePath);
+      if (symbolTable) {
+        return symbolTable;
+      }
+    }
+
+    // Fallback to legacy TypeScript-only semantic engine
+    if (this.semanticEngine && this.semanticEngine.isSymbolEngineReady()) {
+      return await this.semanticEngine.getSymbolTable(filePath);
+    }
+
+    return null;
+  }
+
   /**
    * Run enhanced analysis with multiple strategies
    * Automatically selects optimal analysis method per rule
@@ -1349,22 +1497,58 @@ class HeuristicEngine extends AnalysisEngineInterface {
    */
   async runASTPrimaryAnalysis(analyzer, ruleId, files, language, options, strategy, debugConfig) {
     const violations = [];
-    
+
     if (debugConfig.enabled) {
       debugConfig.logger(this.constructor.name, `Starting AST-primary analysis for ${ruleId}, AST available: ${strategy.astAvailable}`);
     }
-    
+
+    // Check if Dart analyzer is available for Dart files
+    const dartAnalyzer = language === 'dart' && this.semanticEngineManager
+      ? this.semanticEngineManager.getAnalyzer('dart')
+      : null;
+
+    if (dartAnalyzer && dartAnalyzer.isReady()) {
+      if (debugConfig.enabled) {
+        debugConfig.logger(this.constructor.name, `Using DartAnalyzer for ${files.length} Dart files`);
+      }
+
+      // Use DartAnalyzer for all Dart files
+      try {
+        const rules = [{ id: ruleId, config: {} }];
+        for (const filePath of files) {
+          const dartViolations = await dartAnalyzer.analyzeFile(filePath, rules, options);
+          if (dartViolations && dartViolations.length > 0) {
+            violations.push(...dartViolations.map(v => ({
+              ...v,
+              analysisMethod: v.analysisMethod || 'ast',
+              confidence: 90
+            })));
+          }
+        }
+
+        if (debugConfig.enabled) {
+          debugConfig.logger(this.constructor.name, `DartAnalyzer found ${violations.length} violations`);
+        }
+
+        return violations;
+      } catch (error) {
+        if (debugConfig.enabled) {
+          debugConfig.logger(this.constructor.name, `DartAnalyzer failed: ${error.message}, falling back to regex`);
+        }
+      }
+    }
+
     for (const filePath of files) {
       try {
         const code = fs.readFileSync(filePath, 'utf8');
         let analysisResult = null;
-        
+
         // Try AST analysis first if available
         if (strategy.astAvailable) {
           if (debugConfig.enabled) {
             debugConfig.logger(this.constructor.name, `Attempting AST for file: ${filePath}`);
           }
-          
+
           try {
             const astResult = await this.astRegistry.analyzeRule(ruleId, code, language, filePath);
             if (astResult && astResult.length > 0) {
@@ -1374,7 +1558,7 @@ class HeuristicEngine extends AnalysisEngineInterface {
                 analysisMethod: 'ast',
                 confidence: strategy.config?.accuracy?.ast || 90
               }));
-              
+
               if (debugConfig.enabled) {
                 debugConfig.logger(this.constructor.name, `AST found ${astResult.length} violations in ${filePath}`);
               }
@@ -1383,7 +1567,7 @@ class HeuristicEngine extends AnalysisEngineInterface {
             if (debugConfig.enabled) {
               debugConfig.logger(this.constructor.name, `AST failed for ${filePath}: ${astError.message}`);
             }
-            
+
             if (options.verbose) {
               console.warn(`⚠️ AST analysis failed for ${filePath}, falling back to regex`);
             }
@@ -1412,7 +1596,7 @@ class HeuristicEngine extends AnalysisEngineInterface {
         if (analysisResult) {
           violations.push(...analysisResult);
         }
-        
+
       } catch (error) {
         if (options.verbose) {
           console.error(`❌ Analysis failed for ${filePath}:`, error.message);
@@ -1625,7 +1809,19 @@ class HeuristicEngine extends AnalysisEngineInterface {
     // Clear analyzer cache
     this.ruleAnalyzers.clear();
     this.supportedRulesList = [];
-    
+
+    // Cleanup SemanticEngineManager (multi-language support)
+    if (this.semanticEngineManager) {
+      await this.semanticEngineManager.cleanup();
+      this.semanticEngineManager = null;
+    }
+
+    // Cleanup legacy semantic engine
+    if (this.semanticEngine) {
+      await this.semanticEngine.cleanup();
+      this.semanticEngine = null;
+    }
+
     await super.cleanup();
     if (this.verbose) {
       console.log('🔍 Heuristic engine cleanup completed');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sun-asterisk/sunlint",
-  "version": "1.3.32",
+  "version": "1.3.34",
   "description": "☀️ SunLint - Multi-language static analysis tool for code quality and security | Sun* Engineering Standards",
   "main": "cli.js",
   "bin": {
@@ -41,18 +41,19 @@
     "demo:file-targeting": "./demo-file-targeting.sh",
     "lint": "node cli.js --config=.sunlint.json --input=.",
     "lint:eslint-integration": "node cli.js --all --eslint-integration --input=.",
-    "build": "npm run copy-rules && npm run generate-registry && echo 'Build completed with rules copy and registry generation'",
+    "build": "npm run copy-rules && npm run generate-registry && npm run copy-arch-detect && echo 'Build completed'",
     "copy-rules": "node scripts/copy-rules.js",
     "generate-registry": "node scripts/generate-rules-registry.js",
-    "clean": "rm -rf coverage/ *.log reports/ *.tgz",
+    "copy-arch-detect": "node scripts/copy-arch-detect.js",
+    "clean": "rm -rf coverage/ *.log reports/ *.tgz engines/arch-detect",
     "postpack": "echo '📦 Package created successfully! Size: ' && ls -lh *.tgz | awk '{print $5}'",
     "start": "node cli.js --help",
     "version": "node cli.js --version",
-    "pack": "npm run copy-rules && npm run generate-registry && npm pack",
+    "pack": "npm run build && npm pack",
     "publish:github": "npm publish --registry=https://npm.pkg.github.com",
     "publish:npmjs": "npm publish --registry=https://registry.npmjs.org",
     "publish:test": "npm publish --dry-run --registry=https://registry.npmjs.org",
-    "prepublishOnly": "npm run clean && npm run copy-rules && npm run generate-registry"
+    "prepublishOnly": "npm run clean && npm run build"
   },
   "keywords": [
     "linting",

package/rules/common/C002_no_duplicate_code/config.json

@@ -1,23 +1,15 @@
 {
-  "id": "C002_no_duplicate_code",
-  "name": "C002_no_duplicate_code",
-  "category": "coding",
-  "description": "C002_no_duplicate_code heuristic rule - migrated from ESLint",
-  "severity": "error",
-  "enabled": true,
-  "migration": {
-    "from_eslint": "c002-no-duplicate-code",
-    "compatibility": "partial",
-    "status": "pending"
+  "id": "C002",
+  "name": "No Duplicate Code",
+  "description": "Không để trùng lặp code > 10 dòng - Tránh code rối, khó refactor và áp dụng DRY principle",
+  "category": "complexity",
+  "severity": "warning",
+  "languages": ["typescript", "javascript", "dart"],
+  "config": {
+    "minLines": 10,
+    "similarityThreshold": 0.95
   },
-  "patterns": {
-    "include": [
-      "**/*.js",
-      "**/*.ts"
-    ],
-    "exclude": [
-      "**/*.test.*",
-      "**/*.spec.*"
-    ]
-  }
+  "references": [
+    "https://en.wikipedia.org/wiki/Don%27t_repeat_yourself"
+  ]
 }

package/rules/common/C002_no_duplicate_code/dart/analyzer.js

@@ -0,0 +1,53 @@
+/**
+ * C002 Dart Analyzer - No Duplicate Code (> 10 lines)
+ *
+ * This is a JS wrapper that delegates to DartAnalyzer binary.
+ * Actual implementation: dart_analyzer/lib/rules/duplicate_code_analyzer.dart
+ *
+ * Rule: Không để trùng lặp code > 10 dòng
+ */
+
+class DartC002Analyzer {
+  constructor() {
+    this.ruleId = 'C002';
+    this.language = 'dart';
+  }
+
+  /**
+   * Get rule metadata
+   */
+  getMetadata() {
+    return {
+      ruleId: 'C002',
+      name: 'No Duplicate Code',
+      language: 'dart',
+      delegateTo: 'dart_analyzer',
+      description: 'Detect duplicate code blocks > 10 lines'
+    };
+  }
+
+  /**
+   * Get default configuration
+   */
+  getConfig() {
+    return {
+      minLines: 10,
+      similarityThreshold: 0.95,
+      severity: 'warning'
+    };
+  }
+
+  /**
+   * Analysis is delegated to DartAnalyzer via heuristic-engine.js
+   */
+  async analyze(files, language, options) {
+    // Delegated to DartAnalyzer binary via heuristic-engine.js
+    return [];
+  }
+
+  supportsLanguage(language) {
+    return language === 'dart';
+  }
+}
+
+module.exports = DartC002Analyzer;