@sun-asterisk/sunlint 1.2.2 → 1.3.0

package/core/constants/rules.js

@@ -0,0 +1,215 @@
+/**
+ * SunLint Rule Constants
+ * Constants related to rules, their metadata, and analysis
+ */
+
+/**
+ * Rule severity levels (ordered by importance)
+ */
+const RULE_SEVERITIES = {
+  ERROR: 'error',
+  WARNING: 'warning',
+  INFO: 'info',
+  HINT: 'hint'
+};
+
+/**
+ * Rule execution status
+ */
+const RULE_STATUS = {
+  PENDING: 'pending',
+  RUNNING: 'running',
+  COMPLETED: 'completed',
+  FAILED: 'failed',
+  SKIPPED: 'skipped',
+  TIMEOUT: 'timeout'
+};
+
+/**
+ * Rule types based on analysis approach
+ */
+const RULE_TYPES = {
+  HEURISTIC: 'heuristic',      // Pattern-based analysis
+  AST: 'ast',                  // Abstract Syntax Tree analysis
+  SEMANTIC: 'semantic',        // Semantic analysis
+  AI: 'ai',                    // AI-powered analysis
+  HYBRID: 'hybrid'             // Combination of approaches
+};
+
+/**
+ * Rule scopes - what level the rule operates on
+ */
+const RULE_SCOPES = {
+  FILE: 'file',                // Single file analysis
+  PROJECT: 'project',          // Project-wide analysis
+  MODULE: 'module',            // Module/package analysis
+  FUNCTION: 'function',        // Function-level analysis
+  CLASS: 'class',              // Class-level analysis
+  EXPRESSION: 'expression'     // Expression-level analysis
+};
+
+/**
+ * Rule language patterns for quick identification
+ */
+const RULE_LANGUAGE_PATTERNS = {
+  COMMON: /^C\d{3}$/,          // C001, C002, etc.
+  JAVASCRIPT: /^J\d{3}$/,      // J001, J002, etc.
+  TYPESCRIPT: /^T\d{3}$/,      // T001, T002, etc.
+  JAVA: /^JV\d{3}$/,           // JV001, JV002, etc.
+  KOTLIN: /^K\d{3}$/,          // K001, K002, etc.
+  DART: /^D\d{3}$/,            // D001, D002, etc.
+  SWIFT: /^SW\d{3}$/,          // SW001, SW002, etc.
+  PYTHON: /^PY\d{3}$/,         // PY001, PY002, etc.
+  SECURITY: /^S\d{3}$/,        // S001, S002, etc.
+  REACT: /^R\d{3}$/,           // R001, R002, etc.
+  CUSTOM: /^CUSTOM_\w+$/       // Custom rules
+};
+
+/**
+ * Rule execution timeouts by type (in milliseconds)
+ */
+const RULE_TIMEOUTS = {
+  [RULE_TYPES.HEURISTIC]: 5000,    // 5 seconds
+  [RULE_TYPES.AST]: 10000,          // 10 seconds
+  [RULE_TYPES.SEMANTIC]: 15000,     // 15 seconds
+  [RULE_TYPES.AI]: 30000,           // 30 seconds
+  [RULE_TYPES.HYBRID]: 20000        // 20 seconds
+};
+
+/**
+ * Rule confidence levels for AI/heuristic analysis
+ */
+const CONFIDENCE_LEVELS = {
+  VERY_HIGH: 0.9,
+  HIGH: 0.8,
+  MEDIUM: 0.6,
+  LOW: 0.4,
+  VERY_LOW: 0.2
+};
+
+/**
+ * Default rule metadata template
+ */
+const DEFAULT_RULE_METADATA = {
+  severity: RULE_SEVERITIES.WARNING,
+  type: RULE_TYPES.HEURISTIC,
+  scope: RULE_SCOPES.FILE,
+  category: 'quality',
+  languages: [],
+  description: '',
+  examples: {
+    good: [],
+    bad: []
+  },
+  tags: [],
+  fixable: false,
+  confidence: CONFIDENCE_LEVELS.HIGH
+};
+
+/**
+ * Rule performance metrics template
+ */
+const RULE_PERFORMANCE_TEMPLATE = {
+  executionTime: 0,
+  filesAnalyzed: 0,
+  violationsFound: 0,
+  falsePositives: 0,
+  memoryUsage: 0,
+  cacheHits: 0
+};
+
+/**
+ * Get language from rule ID
+ * @param {string} ruleId - Rule identifier (e.g., "C001", "J005")
+ * @returns {string|null} Language name or null if not found
+ */
+function getLanguageFromRuleId(ruleId) {
+  const patterns = {
+    javascript: RULE_LANGUAGE_PATTERNS.JAVASCRIPT,
+    typescript: RULE_LANGUAGE_PATTERNS.TYPESCRIPT,
+    java: RULE_LANGUAGE_PATTERNS.JAVA,
+    kotlin: RULE_LANGUAGE_PATTERNS.KOTLIN,
+    dart: RULE_LANGUAGE_PATTERNS.DART,
+    swift: RULE_LANGUAGE_PATTERNS.SWIFT,
+    python: RULE_LANGUAGE_PATTERNS.PYTHON,
+    react: RULE_LANGUAGE_PATTERNS.REACT
+  };
+  
+  for (const [language, pattern] of Object.entries(patterns)) {
+    if (pattern.test(ruleId)) {
+      return language;
+    }
+  }
+  
+  // Check for common rules
+  if (RULE_LANGUAGE_PATTERNS.COMMON.test(ruleId)) {
+    return 'common';
+  }
+  
+  // Check for security rules
+  if (RULE_LANGUAGE_PATTERNS.SECURITY.test(ruleId)) {
+    return 'security';
+  }
+  
+  return null;
+}
+
+/**
+ * Check if rule ID is valid format
+ * @param {string} ruleId - Rule identifier
+ * @returns {boolean} True if valid format
+ */
+function isValidRuleId(ruleId) {
+  const allPatterns = Object.values(RULE_LANGUAGE_PATTERNS);
+  return allPatterns.some(pattern => pattern.test(ruleId));
+}
+
+/**
+ * Get rule timeout by type
+ * @param {string} ruleType - Rule type
+ * @returns {number} Timeout in milliseconds
+ */
+function getRuleTimeout(ruleType) {
+  return RULE_TIMEOUTS[ruleType] || RULE_TIMEOUTS[RULE_TYPES.HEURISTIC];
+}
+
+/**
+ * Get default rule metadata with overrides
+ * @param {Object} overrides - Metadata overrides
+ * @returns {Object} Merged metadata
+ */
+function getDefaultRuleMetadata(overrides = {}) {
+  return {
+    ...DEFAULT_RULE_METADATA,
+    ...overrides
+  };
+}
+
+/**
+ * Check if severity level is valid
+ * @param {string} severity - Severity level
+ * @returns {boolean} True if valid
+ */
+function isValidSeverity(severity) {
+  return Object.values(RULE_SEVERITIES).includes(severity);
+}
+
+module.exports = {
+  // Rule constants
+  RULE_SEVERITIES,
+  RULE_STATUS,
+  RULE_TYPES,
+  RULE_SCOPES,
+  RULE_LANGUAGE_PATTERNS,
+  RULE_TIMEOUTS,
+  CONFIDENCE_LEVELS,
+  DEFAULT_RULE_METADATA,
+  RULE_PERFORMANCE_TEMPLATE,
+  
+  // Utility functions
+  getLanguageFromRuleId,
+  isValidRuleId,
+  getRuleTimeout,
+  getDefaultRuleMetadata,
+  isValidSeverity
+};

package/core/file-targeting-service.js

@@ -1,5 +1,6 @@
 const path = require('path');
 const fs = require('fs');
+const chalk = require('chalk');
 const { minimatch } = require('minimatch');
 
 /**
@@ -15,24 +16,42 @@ class FileTargetingService {
 
   /**
    * Get target files based on enhanced configuration
-   * Rule C012: Command method - performs file selection
+   * ENHANCED: Uses metadata for intelligent file targeting
    */
   async getTargetFiles(inputPaths, config, cliOptions = {}) {
     try {
-      const allFiles = [];
+      const startTime = Date.now();
+      const metadata = config._metadata;
       
-      // Collect all files from input paths
-      for (const inputPath of inputPaths) {
-        const files = await this.collectFiles(inputPath);
-        allFiles.push(...files);
+      if (cliOptions.verbose) {
+        console.log(chalk.cyan(`📁 File Targeting: ${this.getTargetingMode(metadata)}`));
+        if (metadata?.shouldBypassProjectDiscovery) {
+          console.log(chalk.blue(`🎯 Optimized targeting for ${metadata.analysisScope}`));
+        }
+      }
+      
+      let allFiles = [];
+      
+      // Use enhanced targeting based on metadata
+      if (metadata?.shouldBypassProjectDiscovery) {
+        allFiles = await this.collectTargetedFiles(inputPaths, config, cliOptions);
+      } else {
+        allFiles = await this.collectProjectFiles(inputPaths, config, cliOptions);
       }
 
       // Apply filtering logic
       const targetFiles = this.applyFiltering(allFiles, config, cliOptions);
       
+      const duration = Date.now() - startTime;
+      
+      if (cliOptions.verbose) {
+        console.log(chalk.green(`✅ File targeting completed in ${duration}ms (${targetFiles.length} files)`));
+      }
+      
       return {
         files: targetFiles,
-        stats: this.generateStats(targetFiles, config)
+        stats: this.generateStats(targetFiles, config),
+        timing: { duration, filesPerMs: targetFiles.length / Math.max(duration, 1) }
       };
     } catch (error) {
       console.error('❌ FileTargetingService error:', error);
@@ -40,6 +59,108 @@ class FileTargetingService {
     }
   }
 
+  /**
+   * Get targeting mode description
+   */
+  getTargetingMode(metadata) {
+    if (!metadata) return 'legacy';
+    
+    if (metadata.shouldBypassProjectDiscovery) {
+      return metadata.analysisScope === 'file' ? 'single_file' : 'folder_targeted';
+    } else {
+      return 'project_wide';
+    }
+  }
+
+  /**
+   * Collect files with targeted approach (bypassing project discovery)
+   */
+  async collectTargetedFiles(inputPaths, config, cliOptions) {
+    const files = [];
+    
+    for (const inputPath of inputPaths) {
+      const resolvedPath = path.resolve(inputPath);
+      
+      if (!fs.existsSync(resolvedPath)) {
+        if (cliOptions.verbose) {
+          console.log(chalk.yellow(`⚠️  Path not found: ${inputPath}`));
+        }
+        continue;
+      }
+      
+      const stat = fs.statSync(resolvedPath);
+      
+      if (stat.isFile()) {
+        // Single file targeting
+        files.push(resolvedPath);
+      } else if (stat.isDirectory()) {
+        // Folder-only targeting (no recursive project scan)
+        const folderFiles = await this.collectFolderFiles(resolvedPath);
+        files.push(...folderFiles);
+      }
+    }
+    
+    return files;
+  }
+
+  /**
+   * Collect files from specific folder (no project-wide scanning)
+   */
+  async collectFolderFiles(folderPath) {
+    const files = [];
+    const targetExtensions = ['.ts', '.tsx', '.js', '.jsx', '.dart', '.kt', '.kts'];
+    
+    try {
+      const entries = fs.readdirSync(folderPath);
+      
+      for (const entry of entries) {
+        const fullPath = path.join(folderPath, entry);
+        const stat = fs.statSync(fullPath);
+        
+        if (stat.isFile()) {
+          const ext = path.extname(fullPath);
+          if (targetExtensions.includes(ext)) {
+            files.push(path.resolve(fullPath));
+          }
+        } else if (stat.isDirectory() && !this.shouldSkipDirectory(entry)) {
+          // Recursive collection within target folder only
+          const subFiles = await this.collectFolderFiles(fullPath);
+          files.push(...subFiles);
+        }
+      }
+    } catch (error) {
+      console.warn(`⚠️ Error reading folder ${folderPath}: ${error.message}`);
+    }
+    
+    return files;
+  }
+
+  /**
+   * Collect files with project-wide approach (original logic)
+   */
+  async collectProjectFiles(inputPaths, config, cliOptions) {
+    const allFiles = [];
+    
+    // Use original collection logic for project-wide analysis
+    for (const inputPath of inputPaths) {
+      const files = await this.collectFiles(inputPath);
+      allFiles.push(...files);
+    }
+    
+    return allFiles;
+  }
+
+  /**
+   * Check if directory should be skipped
+   */
+  shouldSkipDirectory(dirName) {
+    const skipDirs = [
+      'node_modules', '.git', 'dist', 'build', 'coverage', 
+      '.next', '.nuxt', 'vendor', 'target', 'generated'
+    ];
+    return skipDirs.includes(dirName);
+  }
+
   /**
    * Apply comprehensive filtering logic
    * Priority: CLI > Config > Default

package/core/interfaces/rule-plugin.interface.js

@@ -0,0 +1,207 @@
+/**
+ * Rule Plugin Interface
+ * Defines the contract for all rule plugins in SunLint
+ * Following Rule C014: Dependency injection - Plugin interface
+ */
+
+class RulePluginInterface {
+  constructor(ruleId, metadata = {}) {
+    if (this.constructor === RulePluginInterface) {
+      throw new Error('RulePluginInterface is abstract and cannot be instantiated');
+    }
+    
+    this.ruleId = ruleId;
+    this.metadata = {
+      name: metadata.name || ruleId,
+      description: metadata.description || '',
+      category: metadata.category || 'custom',
+      severity: metadata.severity || 'warning',
+      languages: metadata.languages || ['javascript', 'typescript'],
+      version: metadata.version || '1.0.0',
+      author: metadata.author || '',
+      tags: metadata.tags || [],
+      ...metadata
+    };
+  }
+
+  /**
+   * Initialize the rule plugin
+   * @param {Object} config - Rule configuration
+   * @returns {Promise<void>}
+   */
+  async initialize(config = {}) {
+    throw new Error('initialize() must be implemented by rule plugin');
+  }
+
+  /**
+   * Analyze files for violations
+   * @param {string[]} files - Files to analyze
+   * @param {string} language - Programming language
+   * @param {Object} options - Analysis options
+   * @returns {Promise<Object[]>} Array of violations
+   */
+  async analyze(files, language, options = {}) {
+    throw new Error('analyze() must be implemented by rule plugin');
+  }
+
+  /**
+   * Get rule metadata
+   * @returns {Object} Rule metadata
+   */
+  getMetadata() {
+    return this.metadata;
+  }
+
+  /**
+   * Check if rule supports a language
+   * @param {string} language - Language to check
+   * @returns {boolean} True if supported
+   */
+  supportsLanguage(language) {
+    return this.metadata.languages.includes(language) ||
+           this.metadata.languages.includes('all');
+  }
+
+  /**
+   * Validate rule configuration
+   * @param {Object} config - Configuration to validate
+   * @returns {Object} Validation result
+   */
+  validateConfig(config) {
+    return {
+      isValid: true,
+      errors: [],
+      warnings: []
+    };
+  }
+
+  /**
+   * Get rule documentation
+   * @returns {Object} Documentation object
+   */
+  getDocumentation() {
+    return {
+      name: this.metadata.name,
+      description: this.metadata.description,
+      examples: [],
+      configuration: {},
+      links: []
+    };
+  }
+
+  /**
+   * Cleanup rule resources
+   * @returns {Promise<void>}
+   */
+  async cleanup() {
+    // Default implementation - can be overridden
+  }
+}
+
+/**
+ * Semantic Rule Interface
+ * For rules that use symbol table and semantic analysis
+ */
+class SemanticRuleInterface extends RulePluginInterface {
+  constructor(ruleId, metadata = {}) {
+    super(ruleId, { ...metadata, type: 'semantic' });
+    this.semanticEngine = null;
+    this.violations = [];
+  }
+
+  /**
+   * Initialize with semantic engine
+   * @param {Object} semanticEngine - Semantic analysis engine
+   */
+  initializeSemanticEngine(semanticEngine) {
+    this.semanticEngine = semanticEngine;
+  }
+
+  /**
+   * Analyze a single file using semantic analysis
+   * @param {string} filePath - File to analyze
+   * @param {Object} options - Analysis options
+   * @returns {Promise<void>}
+   */
+  async analyzeFile(filePath, options = {}) {
+    throw new Error('analyzeFile() must be implemented by semantic rule');
+  }
+
+  /**
+   * Get violations found during analysis
+   * @returns {Object[]} Array of violations
+   */
+  getViolations() {
+    return this.violations;
+  }
+
+  /**
+   * Clear violations for next analysis
+   */
+  clearViolations() {
+    this.violations = [];
+  }
+
+  /**
+   * Add a violation
+   * @param {Object} violation - Violation object
+   */
+  addViolation(violation) {
+    this.violations.push({
+      ruleId: this.ruleId,
+      severity: this.metadata.severity,
+      ...violation
+    });
+  }
+}
+
+/**
+ * Custom Rule Interface
+ * For user-defined custom rules
+ */
+class CustomRuleInterface extends RulePluginInterface {
+  constructor(ruleId, metadata = {}) {
+    super(ruleId, { ...metadata, type: 'custom', source: 'user' });
+    this.configSchema = null;
+  }
+
+  /**
+   * Set configuration schema for validation
+   * @param {Object} schema - JSON schema for configuration
+   */
+  setConfigSchema(schema) {
+    this.configSchema = schema;
+  }
+
+  /**
+   * Validate configuration against schema
+   * @param {Object} config - Configuration to validate
+   * @returns {Object} Validation result
+   */
+  validateConfig(config) {
+    if (!this.configSchema) {
+      return super.validateConfig(config);
+    }
+
+    // TODO: Implement JSON schema validation
+    return {
+      isValid: true,
+      errors: [],
+      warnings: []
+    };
+  }
+
+  /**
+   * Register custom helper methods
+   * @param {Object} helpers - Helper methods
+   */
+  registerHelpers(helpers) {
+    this.helpers = helpers;
+  }
+}
+
+module.exports = {
+  RulePluginInterface,
+  SemanticRuleInterface,
+  CustomRuleInterface
+};