@sun-asterisk/sunlint 1.2.2 → 1.3.1

package/core/config-merger.js

@@ -1,3 +1,6 @@
+const { minimatch } = require('minimatch');
+const chalk = require('chalk');
+
 /**
  * Handles configuration merging and CLI overrides
  * Rule C005: Single responsibility - chỉ merge và override config
@@ -89,6 +92,11 @@ class ConfigMerger {
     // Performance overrides
     overrides.performance = this.applyPerformanceOverrides(overrides.performance, options);
 
+    // Auto-expand include patterns if input doesn't match any existing patterns
+    const expandedOverrides = this.autoExpandIncludePatterns(overrides, options);
+    // Copy expanded properties back to overrides
+    Object.assign(overrides, expandedOverrides);
+
     return overrides;
   }
 
@@ -161,6 +169,86 @@ class ConfigMerger {
     return updatedConfig;
   }
 
+  /**
+   * Rule C006: autoExpandIncludePatterns - verb-noun naming
+   * Rule C005: Single responsibility - auto-expand include patterns for input paths
+   */
+  autoExpandIncludePatterns(config, options) {
+    if (!options.input) {
+      return config;
+    }
+
+    const result = { ...config };
+    const inputPaths = Array.isArray(options.input) ? options.input : [options.input];
+    const currentInclude = result.include || [];
+    
+    console.log(chalk.gray(`🔍 AUTO-EXPANSION: Checking input paths: ${inputPaths.join(', ')}`));
+    console.log(chalk.gray(`🔍 AUTO-EXPANSION: Current include patterns: ${currentInclude.join(', ')}`));
+    
+    let needsExpansion = false;
+    for (const inputPath of inputPaths) {
+      const matchesExisting = currentInclude.some(pattern => {
+        const match1 = minimatch(inputPath, pattern);
+        const match2 = minimatch(inputPath + '/**', pattern);
+        const match3 = minimatch('**/' + inputPath, pattern);
+        const match4 = minimatch('**/' + inputPath + '/**', pattern);
+        
+        console.log(chalk.gray(`  AUTO-EXPANSION: ${inputPath} vs ${pattern}: ${match1 || match2 || match3 || match4}`));
+        
+        return match1 || match2 || match3 || match4;
+      });
+      
+      if (!matchesExisting) {
+        needsExpansion = true;
+        console.log(chalk.gray(`  🔄 AUTO-EXPANSION: ${inputPath} needs expansion`));
+        break;
+      }
+    }
+    
+    if (needsExpansion) {
+      // Add flexible patterns for input paths
+      const expandedInclude = [...currentInclude];
+      for (const inputPath of inputPaths) {
+        // Check if inputPath is a file or directory
+        const fs = require('fs');
+        const path = require('path');
+        
+        try {
+          const resolvedPath = path.resolve(inputPath);
+          if (fs.existsSync(resolvedPath)) {
+            const stat = fs.statSync(resolvedPath);
+            if (stat.isFile()) {
+              // For files, add the exact path
+              expandedInclude.push(inputPath);
+              expandedInclude.push('**/' + inputPath);
+            } else if (stat.isDirectory()) {
+              // For directories, add recursive patterns
+              expandedInclude.push(inputPath + '/**');
+              expandedInclude.push('**/' + inputPath + '/**');
+            }
+          } else {
+            // If path doesn't exist, assume it's a pattern and add both file and directory variants
+            expandedInclude.push(inputPath);
+            expandedInclude.push(inputPath + '/**');
+            expandedInclude.push('**/' + inputPath);
+            expandedInclude.push('**/' + inputPath + '/**');
+          }
+        } catch (error) {
+          // Fallback to original logic if file system check fails
+          expandedInclude.push(inputPath + '/**');
+          expandedInclude.push('**/' + inputPath + '/**');
+        }
+      }
+      result.include = expandedInclude;
+      
+      console.log(chalk.gray(`📁 AUTO-EXPANSION: Auto-expanded include patterns: ${expandedInclude.join(', ')}`));
+    } else {
+      console.log(chalk.gray(`✅ AUTO-EXPANSION: No expansion needed`));
+    }
+
+    return result;
+  }
+
   /**
    * Rule C006: processIgnorePatterns - verb-noun naming
    * Convert deprecated ignorePatterns to exclude for backward compatibility

package/core/constants/categories.js

@@ -0,0 +1,168 @@
+/**
+ * SunLint Category Constants
+ * Single source of truth for all category-principle mappings
+ * Used by: sunlint-rule-adapter.js, plugin-manager.js, custom rules, etc.
+ */
+
+/**
+ * Official SunLint Principles (constant values)
+ * These should match exactly with principles used in origin-rules
+ */
+const SUNLINT_PRINCIPLES = {
+  CODE_QUALITY: 'CODE_QUALITY',
+  DESIGN_PATTERNS: 'DESIGN_PATTERNS',
+  INTEGRATION: 'INTEGRATION', 
+  MAINTAINABILITY: 'MAINTAINABILITY',
+  PERFORMANCE: 'PERFORMANCE',
+  RELIABILITY: 'RELIABILITY',
+  SECURITY: 'SECURITY',
+  TESTABILITY: 'TESTABILITY',
+  USABILITY: 'USABILITY'
+};
+
+/**
+ * Category to Principle Mapping
+ * Single source of truth - used across all components
+ */
+const CATEGORY_PRINCIPLE_MAP = {
+  'security': [SUNLINT_PRINCIPLES.SECURITY],
+  'quality': [SUNLINT_PRINCIPLES.CODE_QUALITY], 
+  'performance': [SUNLINT_PRINCIPLES.PERFORMANCE],
+  'maintainability': [SUNLINT_PRINCIPLES.MAINTAINABILITY],
+  'testability': [SUNLINT_PRINCIPLES.TESTABILITY],
+  'reliability': [SUNLINT_PRINCIPLES.RELIABILITY],
+  'design': [SUNLINT_PRINCIPLES.DESIGN_PATTERNS],
+  'integration': [SUNLINT_PRINCIPLES.INTEGRATION],
+  'usability': [SUNLINT_PRINCIPLES.USABILITY]
+};
+
+/**
+ * Human-readable category descriptions
+ */
+const CATEGORY_DESCRIPTIONS = {
+  'quality': 'Code quality and best practices',
+  'design': 'Design patterns and architectural principles',
+  'integration': 'Integration and API design',
+  'maintainability': 'Code maintainability and readability', 
+  'performance': 'Performance optimization and efficiency',
+  'reliability': 'Error handling and code reliability',
+  'security': 'Security-related rules to prevent vulnerabilities',
+  'testability': 'Testing and test-driven development',
+  'usability': 'User experience and interface guidelines'
+};
+
+/**
+ * Get all valid categories
+ * @returns {Array<string>} Array of category names
+ */
+function getValidCategories() {
+  return Object.keys(CATEGORY_PRINCIPLE_MAP);
+}
+
+/**
+ * Get principles for a category
+ * @param {string} category - Category name
+ * @returns {Array<string>} Array of principles
+ */
+function getCategoryPrinciples(category) {
+  return CATEGORY_PRINCIPLE_MAP[category?.toLowerCase()] || [];
+}
+
+/**
+ * Validate if a category is valid
+ * @param {string} category - Category to validate
+ * @returns {boolean} True if valid
+ */
+function isValidCategory(category) {
+  return getValidCategories().includes(category?.toLowerCase());
+}
+
+/**
+ * Get category description
+ * @param {string} category - Category name
+ * @returns {string} Category description
+ */
+function getCategoryDescription(category) {
+  return CATEGORY_DESCRIPTIONS[category?.toLowerCase()] || 'Unknown category';
+}
+
+/**
+ * Get default category (fallback)
+ * @returns {string} Default category name
+ */
+function getDefaultCategory() {
+  return 'quality'; // CODE_QUALITY principle
+}
+
+/**
+ * Normalize category name (lowercase, validate)
+ * @param {string} category - Category to normalize
+ * @returns {string} Normalized category or default
+ */
+function normalizeCategory(category) {
+  if (!category) return getDefaultCategory();
+  
+  const normalized = category.toLowerCase();
+  return isValidCategory(normalized) ? normalized : getDefaultCategory();
+}
+
+/**
+ * Get category for a principle (reverse lookup)
+ * @param {string} principle - Principle name  
+ * @returns {string|null} Category name or null
+ */
+function getCategoryForPrinciple(principle) {
+  for (const [category, principles] of Object.entries(CATEGORY_PRINCIPLE_MAP)) {
+    if (principles.includes(principle)) {
+      return category;
+    }
+  }
+  return null;
+}
+
+/**
+ * Add new category-principle mapping (for future extensibility)
+ * @param {string} category - Category name
+ * @param {Array<string>} principles - Array of principles
+ * @param {string} description - Category description
+ */
+function addCategoryMapping(category, principles, description) {
+  const normalizedCategory = category.toLowerCase();
+  CATEGORY_PRINCIPLE_MAP[normalizedCategory] = principles;
+  CATEGORY_DESCRIPTIONS[normalizedCategory] = description;
+}
+
+/**
+ * Get category statistics
+ * @returns {Object} Category statistics
+ */
+function getCategoryStats() {
+  const categories = getValidCategories();
+  const principleCount = Object.values(CATEGORY_PRINCIPLE_MAP)
+    .flat().length;
+  
+  return {
+    totalCategories: categories.length,
+    totalPrinciples: principleCount,
+    categories: categories,
+    mapping: CATEGORY_PRINCIPLE_MAP
+  };
+}
+
+module.exports = {
+  // Constants
+  SUNLINT_PRINCIPLES,
+  CATEGORY_PRINCIPLE_MAP,
+  CATEGORY_DESCRIPTIONS,
+  
+  // Utility functions
+  getValidCategories,
+  getCategoryPrinciples,
+  isValidCategory,
+  getCategoryDescription,
+  getDefaultCategory,
+  normalizeCategory,
+  getCategoryForPrinciple,
+  addCategoryMapping,
+  getCategoryStats
+};

package/core/constants/defaults.js

@@ -0,0 +1,165 @@
+/**
+ * SunLint Default Values and Configuration Constants
+ * Centralized location for all default values used across the system
+ */
+
+/**
+ * Default rule sets for different scenarios
+ */
+const DEFAULT_RULE_SETS = {
+  // Minimal set for quick checks
+  MINIMAL: ['C006', 'C019'],
+  
+  // Essential rules for any project
+  ESSENTIAL: [
+    'C001', 'C002', 'C003', 'C004', 'C005', 'C006', 
+    'C007', 'C008', 'C009', 'C010', 'C019'
+  ],
+  
+  // Security-focused rules
+  SECURITY: [
+    'S001', 'S002', 'S003', 'S004', 'S005',
+    'S010', 'S015', 'S020', 'S025'
+  ],
+  
+  // Performance-focused rules
+  PERFORMANCE: [
+    'C015', 'C020', 'C025', 'C030',
+    'T010', 'T015', 'T020'
+  ]
+};
+
+/**
+ * Default severity levels
+ */
+const DEFAULT_SEVERITIES = {
+  ERROR: 'error',
+  WARNING: 'warning', 
+  INFO: 'info',
+  HINT: 'hint'
+};
+
+/**
+ * Default configuration values
+ */
+const DEFAULT_CONFIG = {
+  // Analysis options
+  verbose: false,
+  useRegistry: true,
+  skipTests: false,
+  includeTests: false,
+  
+  // File targeting
+  maxFileSize: 1024 * 1024, // 1MB
+  includePatterns: ['**/*.{js,ts,jsx,tsx,java,kt,dart,swift}'],
+  excludePatterns: [
+    '**/node_modules/**',
+    '**/dist/**', 
+    '**/build/**',
+    '**/.git/**',
+    '**/coverage/**'
+  ],
+  
+  // Rule selection
+  ruleSet: 'ESSENTIAL',
+  categories: [],
+  excludeRules: [],
+  
+  // Output options
+  outputFormat: 'console',
+  reportFile: null,
+  showStats: true
+};
+
+/**
+ * Default timeout values (in milliseconds)
+ */
+const DEFAULT_TIMEOUTS = {
+  RULE_EXECUTION: 30000,      // 30 seconds per rule
+  FILE_ANALYSIS: 5000,        // 5 seconds per file
+  ENGINE_INITIALIZATION: 10000, // 10 seconds for engine init
+  TOTAL_ANALYSIS: 300000      // 5 minutes total
+};
+
+/**
+ * Default file size limits
+ */
+const DEFAULT_LIMITS = {
+  MAX_FILE_SIZE: 1024 * 1024,    // 1MB
+  MAX_FILES_PER_BATCH: 100,      // Process 100 files at once
+  MAX_CONCURRENT_RULES: 5,       // Run 5 rules concurrently
+  MAX_OUTPUT_LINES: 1000         // Limit output to 1000 lines
+};
+
+/**
+ * Default language extensions mapping
+ */
+const DEFAULT_LANGUAGE_EXTENSIONS = {
+  javascript: ['.js', '.jsx', '.mjs'],
+  typescript: ['.ts', '.tsx'],
+  java: ['.java'],
+  kotlin: ['.kt', '.kts'],
+  dart: ['.dart'],
+  swift: ['.swift'],
+  python: ['.py'],
+  go: ['.go'],
+  rust: ['.rs'],
+  php: ['.php']
+};
+
+/**
+ * Get default rule set by name
+ * @param {string} setName - Name of the rule set
+ * @returns {Array<string>} Array of rule IDs
+ */
+function getDefaultRuleSet(setName = 'ESSENTIAL') {
+  return DEFAULT_RULE_SETS[setName.toUpperCase()] || DEFAULT_RULE_SETS.ESSENTIAL;
+}
+
+/**
+ * Get default configuration with overrides
+ * @param {Object} overrides - Configuration overrides
+ * @returns {Object} Merged configuration
+ */
+function getDefaultConfig(overrides = {}) {
+  return {
+    ...DEFAULT_CONFIG,
+    ...overrides
+  };
+}
+
+/**
+ * Get file extensions for a language
+ * @param {string} language - Programming language
+ * @returns {Array<string>} Array of file extensions
+ */
+function getLanguageExtensions(language) {
+  return DEFAULT_LANGUAGE_EXTENSIONS[language?.toLowerCase()] || [];
+}
+
+/**
+ * Check if file size is within limits
+ * @param {number} fileSize - File size in bytes
+ * @returns {boolean} True if within limits
+ */
+function isFileSizeValid(fileSize) {
+  return fileSize <= DEFAULT_LIMITS.MAX_FILE_SIZE;
+}
+
+module.exports = {
+  // Rule sets
+  DEFAULT_RULE_SETS,
+  
+  // Configuration
+  DEFAULT_CONFIG,
+  DEFAULT_SEVERITIES,
+  DEFAULT_TIMEOUTS,
+  DEFAULT_LIMITS,
+  DEFAULT_LANGUAGE_EXTENSIONS,
+  
+  // Utility functions
+  getDefaultRuleSet,
+  getDefaultConfig,
+  getLanguageExtensions,
+  isFileSizeValid
+};

package/core/constants/engines.js

@@ -0,0 +1,185 @@
+/**
+ * SunLint Engine Constants
+ * Constants related to analysis engines and their configurations
+ */
+
+/**
+ * Supported analysis engines
+ */
+const SUPPORTED_ENGINES = {
+  HEURISTIC: 'heuristic',
+  ESLINT: 'eslint',
+  OPENAI: 'openai',
+  TREE_SITTER: 'tree-sitter',
+  UNIVERSAL_AST: 'universal-ast'
+};
+
+/**
+ * Engine capabilities and supported languages
+ */
+const ENGINE_CAPABILITIES = {
+  [SUPPORTED_ENGINES.HEURISTIC]: {
+    languages: ['javascript', 'typescript', 'java', 'kotlin', 'dart', 'swift', 'python'],
+    features: ['pattern-matching', 'regex-analysis', 'text-based'],
+    priority: 1
+  },
+  
+  [SUPPORTED_ENGINES.ESLINT]: {
+    languages: ['javascript', 'typescript'],
+    features: ['ast-analysis', 'rule-plugins', 'fixable'],
+    priority: 2
+  },
+  
+  [SUPPORTED_ENGINES.OPENAI]: {
+    languages: ['javascript', 'typescript', 'java', 'kotlin', 'dart', 'swift', 'python'],
+    features: ['ai-analysis', 'context-aware', 'natural-language'],
+    priority: 3
+  },
+  
+  [SUPPORTED_ENGINES.TREE_SITTER]: {
+    languages: ['javascript', 'typescript', 'java', 'kotlin', 'python', 'go', 'rust'],
+    features: ['ast-parsing', 'syntax-tree', 'language-agnostic'],
+    priority: 2
+  },
+  
+  [SUPPORTED_ENGINES.UNIVERSAL_AST]: {
+    languages: ['javascript', 'typescript', 'java', 'kotlin', 'dart', 'swift'],
+    features: ['universal-ast', 'cross-language', 'normalized-tree'],
+    priority: 2
+  }
+};
+
+/**
+ * Engine execution modes
+ */
+const ENGINE_MODES = {
+  SEQUENTIAL: 'sequential',    // Run engines one by one
+  PARALLEL: 'parallel',        // Run engines in parallel
+  HYBRID: 'hybrid',           // Smart combination
+  FALLBACK: 'fallback'        // Use fallback engine on failure
+};
+
+/**
+ * Engine performance configurations
+ */
+const ENGINE_PERFORMANCE = {
+  [SUPPORTED_ENGINES.HEURISTIC]: {
+    maxConcurrentFiles: 50,
+    averageTimePerFile: 100,  // milliseconds
+    memoryUsage: 'low'
+  },
+  
+  [SUPPORTED_ENGINES.ESLINT]: {
+    maxConcurrentFiles: 20,
+    averageTimePerFile: 500,  // milliseconds
+    memoryUsage: 'medium'
+  },
+  
+  [SUPPORTED_ENGINES.OPENAI]: {
+    maxConcurrentFiles: 5,
+    averageTimePerFile: 2000, // milliseconds
+    memoryUsage: 'low',
+    rateLimited: true
+  },
+  
+  [SUPPORTED_ENGINES.TREE_SITTER]: {
+    maxConcurrentFiles: 30,
+    averageTimePerFile: 300,  // milliseconds
+    memoryUsage: 'medium'
+  },
+  
+  [SUPPORTED_ENGINES.UNIVERSAL_AST]: {
+    maxConcurrentFiles: 25,
+    averageTimePerFile: 400,  // milliseconds
+    memoryUsage: 'medium'
+  }
+};
+
+/**
+ * Default engine selection strategy
+ */
+const DEFAULT_ENGINE_STRATEGY = {
+  mode: ENGINE_MODES.HYBRID,
+  primaryEngine: SUPPORTED_ENGINES.HEURISTIC,
+  fallbackEngine: SUPPORTED_ENGINES.HEURISTIC,
+  enableParallel: false,
+  maxEngines: 2
+};
+
+/**
+ * Get supported languages for an engine
+ * @param {string} engineName - Name of the engine
+ * @returns {Array<string>} Supported languages
+ */
+function getEngineLanguages(engineName) {
+  const engine = ENGINE_CAPABILITIES[engineName];
+  return engine ? engine.languages : [];
+}
+
+/**
+ * Get engines that support a specific language
+ * @param {string} language - Programming language
+ * @returns {Array<string>} Engine names that support the language
+ */
+function getEnginesForLanguage(language) {
+  const supportedEngines = [];
+  
+  for (const [engineName, capabilities] of Object.entries(ENGINE_CAPABILITIES)) {
+    if (capabilities.languages.includes(language)) {
+      supportedEngines.push({
+        name: engineName,
+        priority: capabilities.priority,
+        features: capabilities.features
+      });
+    }
+  }
+  
+  // Sort by priority (lower number = higher priority)
+  return supportedEngines.sort((a, b) => a.priority - b.priority);
+}
+
+/**
+ * Get recommended engine for a language
+ * @param {string} language - Programming language
+ * @returns {string} Recommended engine name
+ */
+function getRecommendedEngine(language) {
+  const engines = getEnginesForLanguage(language);
+  return engines.length > 0 ? engines[0].name : SUPPORTED_ENGINES.HEURISTIC;
+}
+
+/**
+ * Check if engine supports a language
+ * @param {string} engineName - Engine name
+ * @param {string} language - Programming language
+ * @returns {boolean} True if supported
+ */
+function isLanguageSupported(engineName, language) {
+  const languages = getEngineLanguages(engineName);
+  return languages.includes(language);
+}
+
+/**
+ * Get engine performance configuration
+ * @param {string} engineName - Engine name
+ * @returns {Object} Performance configuration
+ */
+function getEnginePerformance(engineName) {
+  return ENGINE_PERFORMANCE[engineName] || ENGINE_PERFORMANCE[SUPPORTED_ENGINES.HEURISTIC];
+}
+
+module.exports = {
+  // Engine constants
+  SUPPORTED_ENGINES,
+  ENGINE_CAPABILITIES,
+  ENGINE_MODES,
+  ENGINE_PERFORMANCE,
+  DEFAULT_ENGINE_STRATEGY,
+  
+  // Utility functions
+  getEngineLanguages,
+  getEnginesForLanguage,
+  getRecommendedEngine,
+  isLanguageSupported,
+  getEnginePerformance
+};

package/core/constants/index.js

@@ -0,0 +1,30 @@
+/**
+ * SunLint Constants - Barrel Export
+ * Centralized access point for all constants
+ */
+
+// Re-export all constants from sub-modules
+const categories = require('./categories');
+const defaults = require('./defaults');
+const engines = require('./engines');
+const rules = require('./rules');
+
+module.exports = {
+  // Categories & Principles
+  ...categories,
+  
+  // Default values & configurations
+  ...defaults,
+  
+  // Engine-related constants
+  ...engines,
+  
+  // Rule-related constants
+  ...rules,
+  
+  // Grouped exports for specific use cases
+  categories,
+  defaults,
+  engines,
+  rules
+};