@sun-asterisk/sunlint 1.3.32 → 1.3.34

package/core/adapters/dart-analyzer.js

@@ -0,0 +1,658 @@
+/**
+ * Dart Analyzer
+ * Implements ILanguageAnalyzer for Dart files
+ * Communicates with embedded Dart binary via JSON-RPC over STDIO
+ *
+ * Following Rule C005: Single responsibility - Dart analysis only
+ * Following Rule C014: Dependency injection - implements ILanguageAnalyzer
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { spawn } = require('child_process');
+const { EventEmitter } = require('events');
+const { ILanguageAnalyzer } = require('../interfaces/language-analyzer.interface');
+
+/**
+ * JSON-RPC Client for Dart Analyzer subprocess
+ */
+class DartAnalyzerClient extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.process = null;
+    this.requestId = 0;
+    this.pendingRequests = new Map();
+    this.buffer = '';
+    this.timeout = options.timeout || 30000;
+    this.verbose = options.verbose || false;
+  }
+
+  /**
+   * Start the Dart analyzer subprocess
+   * @param {string} binaryPath - Path to the Dart analyzer binary
+   * @returns {Promise<boolean>}
+   */
+  async start(binaryPath) {
+    return new Promise((resolve, reject) => {
+      try {
+        if (this.verbose) {
+          console.log(`🎯 Starting Dart analyzer: ${binaryPath}`);
+        }
+
+        this.process = spawn(binaryPath, [], {
+          stdio: ['pipe', 'pipe', 'pipe'],
+          env: { ...process.env }
+        });
+
+        // Handle stdout (JSON-RPC responses)
+        this.process.stdout.on('data', (data) => {
+          this.handleData(data.toString());
+        });
+
+        // Handle stderr (debug output)
+        this.process.stderr.on('data', (data) => {
+          if (this.verbose) {
+            console.log(`[Dart Analyzer] ${data.toString().trim()}`);
+          }
+        });
+
+        // Handle process errors
+        this.process.on('error', (error) => {
+          console.error(`❌ Dart analyzer process error:`, error.message);
+          this.emit('error', error);
+          reject(error);
+        });
+
+        // Handle process exit
+        this.process.on('exit', (code, signal) => {
+          if (code !== 0 && this.verbose) {
+            console.warn(`⚠️ Dart analyzer exited with code ${code}, signal ${signal}`);
+          }
+          this.emit('exit', code, signal);
+        });
+
+        // Wait a bit for the process to start
+        setTimeout(() => resolve(true), 100);
+
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Handle incoming data from the subprocess
+   * @param {string} data - Raw data from stdout
+   */
+  handleData(data) {
+    this.buffer += data;
+
+    // Process complete lines (newline-delimited JSON)
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || ''; // Keep incomplete line in buffer
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+
+      try {
+        const response = JSON.parse(line);
+        this.handleResponse(response);
+      } catch (error) {
+        if (this.verbose) {
+          console.warn(`⚠️ Invalid JSON from Dart analyzer:`, line.substring(0, 100));
+        }
+      }
+    }
+  }
+
+  /**
+   * Handle a JSON-RPC response
+   * @param {Object} response - Parsed JSON-RPC response
+   */
+  handleResponse(response) {
+    if (response.id !== undefined) {
+      const pending = this.pendingRequests.get(response.id);
+      if (pending) {
+        this.pendingRequests.delete(response.id);
+        clearTimeout(pending.timeout);
+
+        if (response.error) {
+          pending.reject(new Error(response.error.message || 'Unknown error'));
+        } else {
+          pending.resolve(response.result);
+        }
+      }
+    } else if (response.method) {
+      // Notification from server
+      this.emit('notification', response.method, response.params);
+    }
+  }
+
+  /**
+   * Send a JSON-RPC request
+   * @param {string} method - RPC method name
+   * @param {Object} params - Method parameters
+   * @returns {Promise<Object>} - Response result
+   */
+  async sendRequest(method, params = {}) {
+    return new Promise((resolve, reject) => {
+      if (!this.process) {
+        reject(new Error('Dart analyzer not started'));
+        return;
+      }
+
+      const id = ++this.requestId;
+      const request = {
+        jsonrpc: '2.0',
+        id,
+        method,
+        params
+      };
+
+      // Set up timeout
+      const timeoutId = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Request ${method} timed out after ${this.timeout}ms`));
+      }, this.timeout);
+
+      // Store pending request
+      this.pendingRequests.set(id, { resolve, reject, timeout: timeoutId });
+
+      // Send request
+      try {
+        this.process.stdin.write(JSON.stringify(request) + '\n');
+      } catch (error) {
+        this.pendingRequests.delete(id);
+        clearTimeout(timeoutId);
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Stop the subprocess
+   */
+  async stop() {
+    if (this.process) {
+      // Cancel all pending requests
+      for (const [id, pending] of this.pendingRequests) {
+        clearTimeout(pending.timeout);
+        pending.reject(new Error('Analyzer stopped'));
+      }
+      this.pendingRequests.clear();
+
+      // Kill the process
+      this.process.kill('SIGTERM');
+      this.process = null;
+    }
+  }
+
+  /**
+   * Check if the client is connected
+   * @returns {boolean}
+   */
+  isConnected() {
+    return this.process !== null && !this.process.killed;
+  }
+}
+
+/**
+ * Dart Language Analyzer
+ */
+class DartAnalyzer extends ILanguageAnalyzer {
+  constructor() {
+    super('dart', ['.dart']);
+
+    this.client = null;
+    this.binaryPath = null;
+    this.projectPath = null;
+    this.useFallback = false; // Use regex fallback if binary not available
+
+    // Symbol table cache
+    this.symbolTableCache = new Map();
+  }
+
+  /**
+   * Initialize the Dart analyzer
+   * @param {Object} config - Configuration
+   * @returns {Promise<boolean>}
+   */
+  async initialize(config) {
+    const {
+      projectPath = process.cwd(),
+      targetFiles = null,
+      verbose = false
+    } = config;
+
+    this.projectPath = projectPath;
+    this.verbose = verbose;
+
+    // Filter only Dart files from targetFiles
+    const dartFiles = targetFiles
+      ? targetFiles.filter(f => this.supportsFile(f))
+      : [];
+
+    if (dartFiles.length === 0 && targetFiles) {
+      if (verbose) {
+        console.log(`🔷 DartAnalyzer: No Dart files to analyze, skipping initialization`);
+      }
+      this.initialized = true;
+      return true;
+    }
+
+    try {
+      // Resolve the Dart analyzer binary
+      this.binaryPath = await this.resolveBinary();
+
+      if (this.binaryPath) {
+        // Initialize the JSON-RPC client
+        this.client = new DartAnalyzerClient({ verbose, timeout: 30000 });
+        await this.client.start(this.binaryPath);
+
+        // Send initialization request
+        await this.client.sendRequest('initialize', {
+          projectPath,
+          targetFiles: dartFiles
+        });
+
+        this.initialized = true;
+        if (verbose) {
+          console.log(`✅ DartAnalyzer initialized with binary: ${this.binaryPath}`);
+          console.log(`   📄 Target files: ${dartFiles.length} Dart files`);
+        }
+
+        return true;
+      } else {
+        // Fall back to regex-based analysis
+        if (verbose) {
+          console.log(`ℹ️ DartAnalyzer: Binary not found, using regex fallback mode`);
+        }
+        this.useFallback = true;
+        this.initialized = true;
+        return true;
+      }
+    } catch (error) {
+      // Silent fallback - Dart analyzer not available
+      // Fall back to regex mode
+      this.useFallback = true;
+      this.initialized = true;
+      return false;
+    }
+  }
+
+  /**
+   * Resolve the path to the Dart analyzer binary
+   * Priority: bundled > downloaded > pub global
+   * @returns {Promise<string|null>}
+   */
+  async resolveBinary() {
+    const platform = process.platform;
+    const binaryName = platform === 'win32'
+      ? 'sunlint-dart-windows.exe'
+      : `sunlint-dart-${platform === 'darwin' ? 'macos' : 'linux'}`;
+
+    // Priority 1: Bundled binary in dart_analyzer/bin
+    const bundledPath = path.join(__dirname, '../../dart_analyzer/bin', binaryName);
+    if (fs.existsSync(bundledPath)) {
+      // Ensure executable on Unix
+      if (platform !== 'win32') {
+        try {
+          fs.chmodSync(bundledPath, '755');
+        } catch (e) {
+          // Ignore chmod errors
+        }
+      }
+      return bundledPath;
+    }
+
+    // Priority 2: Cached binary (downloaded on first use)
+    const cachePath = path.join(
+      process.env.HOME || process.env.USERPROFILE || '/tmp',
+      '.sunlint',
+      'bin',
+      binaryName
+    );
+    if (fs.existsSync(cachePath)) {
+      return cachePath;
+    }
+
+    // Priority 3: Check if Dart is available (pub global)
+    if (await this.isDartAvailable()) {
+      if (this.verbose) {
+        console.log(`ℹ️ Dart SDK detected, can use pub global analyzer`);
+      }
+      // For now, return null and use fallback
+      // In future, could run 'dart pub global run sunlint_analyzer'
+      return null;
+    }
+
+    // No binary available
+    if (this.verbose) {
+      console.log(`ℹ️ Dart analyzer binary not found at:`);
+      console.log(`   - ${bundledPath}`);
+      console.log(`   - ${cachePath}`);
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if Dart SDK is available
+   * @returns {Promise<boolean>}
+   */
+  async isDartAvailable() {
+    return new Promise((resolve) => {
+      const dartProcess = spawn('dart', ['--version'], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        shell: true
+      });
+
+      dartProcess.on('error', () => resolve(false));
+      dartProcess.on('exit', (code) => resolve(code === 0));
+
+      // Timeout after 2 seconds
+      setTimeout(() => {
+        dartProcess.kill();
+        resolve(false);
+      }, 2000);
+    });
+  }
+
+  /**
+   * Analyze a single Dart file
+   * @param {string} filePath - Path to the file
+   * @param {Object[]} rules - Rules to apply
+   * @param {Object} [options] - Analysis options
+   * @returns {Promise<Object[]>} - Array of violations
+   */
+  async analyzeFile(filePath, rules, options = {}) {
+    if (!this.initialized || !this.supportsFile(filePath)) {
+      return [];
+    }
+
+    const startTime = Date.now();
+    let violations = [];
+
+    try {
+      if (this.useFallback) {
+        // Use regex-based fallback analysis
+        violations = await this.analyzeWithRegex(filePath, rules, options);
+      } else if (this.client && this.client.isConnected()) {
+        // Use the binary analyzer
+        const result = await this.client.sendRequest('analyze', {
+          filePath,
+          rules: rules.map(r => ({
+            id: r.id || r.ruleId,
+            config: r.config || {}
+          }))
+        });
+        violations = result.violations || [];
+      } else {
+        // Fallback if client disconnected
+        violations = await this.analyzeWithRegex(filePath, rules, options);
+      }
+
+      this.stats.filesAnalyzed++;
+      this.stats.totalAnalysisTime += Date.now() - startTime;
+
+    } catch (error) {
+      if (this.verbose) {
+        console.warn(`⚠️ Error analyzing ${path.basename(filePath)}:`, error.message);
+      }
+    }
+
+    return violations;
+  }
+
+  /**
+   * Fallback regex-based analysis for Dart files
+   * @param {string} filePath - Path to the file
+   * @param {Object[]} rules - Rules to apply
+   * @param {Object} [options] - Analysis options
+   * @returns {Promise<Object[]>}
+   */
+  async analyzeWithRegex(filePath, rules, options = {}) {
+    const violations = [];
+
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const lines = content.split('\n');
+
+      for (const rule of rules) {
+        const ruleId = rule.id || rule.ruleId;
+
+        // Basic pattern-based analysis
+        const ruleViolations = this.applyPatternRule(filePath, content, lines, rule);
+        violations.push(...ruleViolations);
+      }
+    } catch (error) {
+      if (this.verbose) {
+        console.warn(`⚠️ Regex analysis failed for ${path.basename(filePath)}:`, error.message);
+      }
+    }
+
+    return violations;
+  }
+
+  /**
+   * Apply a pattern-based rule to Dart content
+   * @param {string} filePath - File path
+   * @param {string} content - File content
+   * @param {string[]} lines - Lines of content
+   * @param {Object} rule - Rule definition
+   * @returns {Object[]}
+   */
+  applyPatternRule(filePath, content, lines, rule) {
+    const violations = [];
+    const ruleId = rule.id || rule.ruleId;
+
+    // Common Dart patterns for basic analysis
+    const patterns = this.getDartPatterns(ruleId);
+
+    for (const pattern of patterns) {
+      let match;
+      while ((match = pattern.regex.exec(content)) !== null) {
+        // Find line number
+        const upToMatch = content.substring(0, match.index);
+        const lineNumber = (upToMatch.match(/\n/g) || []).length + 1;
+        const column = match.index - upToMatch.lastIndexOf('\n');
+
+        violations.push({
+          ruleId,
+          filePath,
+          line: lineNumber,
+          column,
+          message: pattern.message,
+          severity: rule.severity || 'warning',
+          analysisMethod: 'regex'
+        });
+      }
+    }
+
+    return violations;
+  }
+
+  /**
+   * Get Dart-specific patterns for a rule
+   * @param {string} ruleId - Rule ID
+   * @returns {Array<{regex: RegExp, message: string}>}
+   */
+  getDartPatterns(ruleId) {
+    // Common Dart anti-patterns by rule category
+    const patterns = {
+      // Complexity rules
+      'C001': [], // High complexity - requires AST
+      'C008': [], // Deep nesting - requires AST
+
+      // Naming rules
+      'N001': [
+        {
+          regex: /\bclass\s+[a-z][a-zA-Z0-9_]*/g,
+          message: 'Class names should use UpperCamelCase'
+        },
+        {
+          regex: /\b(var|final|const)\s+[A-Z][a-zA-Z0-9_]*\s*=/g,
+          message: 'Variable names should use lowerCamelCase'
+        }
+      ],
+
+      // Error handling rules
+      'E001': [
+        {
+          regex: /catch\s*\(\s*e\s*\)\s*\{\s*\}/g,
+          message: 'Empty catch block - errors are silently ignored'
+        },
+        {
+          regex: /catch\s*\(\s*_\s*\)\s*\{/g,
+          message: 'Ignoring caught exception'
+        }
+      ],
+
+      // Security rules
+      'S003': [
+        {
+          regex: /print\s*\(\s*['"]?(password|secret|token|key|api[_-]?key)/gi,
+          message: 'Potential sensitive data in print statement'
+        }
+      ],
+      'S022': [
+        {
+          regex: /\$\{[^}]*\}/g,
+          message: 'String interpolation - check for XSS vulnerability if rendering HTML'
+        }
+      ]
+    };
+
+    return patterns[ruleId] || [];
+  }
+
+  /**
+   * Get the Symbol Table for a Dart file
+   * @param {string} filePath - Path to the file
+   * @returns {Promise<Object|null>}
+   */
+  async getSymbolTable(filePath) {
+    if (!this.initialized || !this.supportsFile(filePath)) {
+      return null;
+    }
+
+    // Check cache
+    const absolutePath = path.resolve(filePath);
+    if (this.symbolTableCache.has(absolutePath)) {
+      this.stats.cacheHits++;
+      return this.symbolTableCache.get(absolutePath);
+    }
+
+    this.stats.cacheMisses++;
+
+    try {
+      if (this.client && this.client.isConnected()) {
+        const result = await this.client.sendRequest('getSymbolTable', { filePath });
+        if (result) {
+          this.symbolTableCache.set(absolutePath, result);
+        }
+        return result;
+      } else {
+        // Basic symbol table from regex parsing
+        return await this.buildBasicSymbolTable(filePath);
+      }
+    } catch (error) {
+      if (this.verbose) {
+        console.warn(`⚠️ Failed to get symbol table for ${path.basename(filePath)}:`, error.message);
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Build a basic symbol table using regex parsing
+   * @param {string} filePath - Path to the file
+   * @returns {Promise<Object|null>}
+   */
+  async buildBasicSymbolTable(filePath) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+
+      const symbolTable = {
+        filePath,
+        fileName: path.basename(filePath),
+        imports: [],
+        exports: [],
+        classes: [],
+        functions: [],
+        variables: [],
+        lastModified: Date.now()
+      };
+
+      // Extract imports
+      const importRegex = /import\s+['"]([^'"]+)['"]/g;
+      let match;
+      while ((match = importRegex.exec(content)) !== null) {
+        const lineNumber = (content.substring(0, match.index).match(/\n/g) || []).length + 1;
+        symbolTable.imports.push({
+          module: match[1],
+          line: lineNumber
+        });
+      }
+
+      // Extract classes
+      const classRegex = /class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+with\s+([\w,\s]+))?(?:\s+implements\s+([\w,\s]+))?\s*\{/g;
+      while ((match = classRegex.exec(content)) !== null) {
+        const lineNumber = (content.substring(0, match.index).match(/\n/g) || []).length + 1;
+        symbolTable.classes.push({
+          name: match[1],
+          extends: match[2] || null,
+          with: match[3] ? match[3].split(',').map(s => s.trim()) : [],
+          implements: match[4] ? match[4].split(',').map(s => s.trim()) : [],
+          line: lineNumber
+        });
+      }
+
+      // Extract functions
+      const functionRegex = /(?:Future|void|int|double|bool|String|dynamic|\w+)\s+(\w+)\s*\([^)]*\)\s*(?:async\s*)?\{/g;
+      while ((match = functionRegex.exec(content)) !== null) {
+        const lineNumber = (content.substring(0, match.index).match(/\n/g) || []).length + 1;
+        symbolTable.functions.push({
+          name: match[1],
+          line: lineNumber
+        });
+      }
+
+      this.symbolTableCache.set(path.resolve(filePath), symbolTable);
+      return symbolTable;
+
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Clear the symbol table cache
+   */
+  clearCache() {
+    this.symbolTableCache.clear();
+  }
+
+  /**
+   * Cleanup resources
+   * @returns {Promise<void>}
+   */
+  async dispose() {
+    if (this.client) {
+      await this.client.stop();
+      this.client = null;
+    }
+
+    this.symbolTableCache.clear();
+    this.initialized = false;
+
+    if (this.verbose) {
+      console.log(`🧹 DartAnalyzer disposed`);
+      console.log(`   📊 Files analyzed: ${this.stats.filesAnalyzed}`);
+      console.log(`   🎯 Cache hits: ${this.stats.cacheHits}`);
+      console.log(`   📦 Fallback mode: ${this.useFallback}`);
+    }
+  }
+}
+
+module.exports = DartAnalyzer;