@sun-asterisk/sunlint 1.3.46 → 1.3.48

package/core/adapters/sunlint-rule-adapter.js

@@ -203,6 +203,22 @@ class SunlintRuleAdapter {
     return Array.from(this.rulesCache.keys());
   }
 
+  /**
+   * Get rules registry for severity resolution
+   * Returns object with rules property compatible with ConfigValidator
+   */
+  getRulesRegistry() {
+    if (this.registryCache) {
+      return { rules: this.registryCache };
+    }
+    // Convert cache map to registry format
+    const rules = {};
+    this.rulesCache.forEach((rule, ruleId) => {
+      rules[ruleId] = rule;
+    });
+    return { rules };
+  }
+
   /**
    * Validate rule ID
    */

package/core/architecture-integration.js

@@ -9,8 +9,9 @@ const fs = require('fs');
 const chalk = require('chalk');
 
 class ArchitectureIntegration {
-  constructor(options = {}) {
+  constructor(options = {}, config = {}) {
     this.options = options;
+    this.config = config;  // Store merged config
     this.archModule = null;
   }
 
@@ -78,13 +79,25 @@ class ArchitectureIntegration {
   }
 
   /**
-   * Parse architecture patterns from CLI option
+   * Parse architecture patterns from CLI option or config
+   * Priority: CLI --arch-patterns > Config file patterns > Default (undefined)
    */
   parsePatterns() {
-    if (!this.options.archPatterns) {
-      return undefined; // Use default patterns
+    // Priority 1: CLI --arch-patterns flag
+    if (this.options.archPatterns) {
+      return this.parsePatternString(this.options.archPatterns);
     }
 
+    // Priority 2: Config file patterns array
+    if (this.config?.architecture?.patterns?.length > 0) {
+      return this.normalizePatterns(this.config.architecture.patterns);
+    }
+
+    // Priority 3: Default (undefined = all patterns)
+    return undefined;
+  }
+
+  normalizePatterns(patterns) {
     const patternMap = {
       'layered': 'LAYERED',
       'modular': 'MODULAR',
@@ -95,13 +108,46 @@ class ArchitectureIntegration {
       'tdd': 'TDD_CLEAN_ARCHITECTURE',
     };
 
-    const patterns = this.options.archPatterns
-      .split(',')
-      .map(p => p.trim().toLowerCase())
+    return patterns
+      .map(p => typeof p === 'string' ? p.trim().toLowerCase() : p)
       .map(p => patternMap[p] || p.toUpperCase())
       .filter(Boolean);
+  }
+
+  parsePatternString(patternString) {
+    const patterns = patternString.split(',').map(p => p.trim());
+    return this.normalizePatterns(patterns);
+  }
+
+  /**
+   * Determine if markdown report should be generated
+   * Priority: CLI flag > Config file > Default (false)
+   */
+  shouldGenerateReport() {
+    if (this.options.archReport !== undefined) {
+      return this.options.archReport;
+    }
 
-    return patterns.length > 0 ? patterns : undefined;
+    if (this.config?.architecture?.generateReport !== undefined) {
+      return this.config.architecture.generateReport;
+    }
+
+    return false;
+  }
+
+  /**
+   * Get report filename from config or auto-generate
+   */
+  getReportFilename(projectPath) {
+    // Use config reportOutput if provided
+    if (this.config?.architecture?.reportOutput) {
+      return this.config.architecture.reportOutput;
+    }
+
+    // Auto-generate filename
+    const projectName = path.basename(projectPath);
+    const date = new Date().toISOString().split('T')[0];
+    return `sun_arch_report_${projectName}_${date}.md`;
   }
 
   /**
@@ -259,7 +305,7 @@ class ArchitectureIntegration {
 
     // Generate markdown report if requested
     let markdownReport = null;
-    if (this.options.archReport) {
+    if (this.shouldGenerateReport()) {
       try {
         markdownReport = analyzer.formatAsMarkdown(result);
       } catch (error) {
@@ -313,12 +359,8 @@ class ArchitectureIntegration {
   /**
    * Save markdown report to file
    */
-  async saveReport(markdownContent, projectPath) {
-    const projectName = path.basename(projectPath);
-    const date = new Date().toISOString().split('T')[0].replace(/-/g, '_');
-    const fileName = `sun_arch_report_${projectName}_${date}.md`;
-    const outputPath = path.join(process.cwd(), fileName);
-
+  async saveReport(markdownContent, reportFilename) {
+    const outputPath = path.join(process.cwd(), reportFilename);
     fs.writeFileSync(outputPath, markdownContent, 'utf8');
     return outputPath;
   }

package/core/cli-action-handler.js

@@ -25,13 +25,13 @@ class CliActionHandler {
     this.options = options;
     this.configManager = null;
     this.ruleSelectionService = new RuleSelectionService();
-    
+
     // Use new orchestrator by default, fallback to legacy if needed
     this.orchestrator = new AnalysisOrchestrator();
-      
+
     this.outputService = new OutputService(options);
     this.fileTargetingService = new FileTargetingService();
-    
+
     this.isModernMode = !options.useLegacy;
   }
 
@@ -43,10 +43,11 @@ class CliActionHandler {
     try {
       this.displayModernBanner();
       this.handleShortcuts();
-      
+
       // Load configuration
       const config = await this.loadConfiguration();
-      
+      this.loadedConfig = config;  // Store for architecture integration
+
       // Validate input with priority system
       this.validateInput(config);
 
@@ -60,7 +61,7 @@ class CliActionHandler {
 
       // Select rules to run
       const rulesToRun = await this.ruleSelectionService.selectRules(config, this.options);
-      
+
       if (rulesToRun.length === 0) {
         console.log(chalk.yellow('⚠️  No rules to run'));
         return;
@@ -68,13 +69,20 @@ class CliActionHandler {
 
       // Apply enhanced file targeting
       const targetingResult = await this.applyFileTargeting(config);
-      if (targetingResult.files.length === 0) {
+
+      // Determine if we should proceed based on requested analyses
+      const hasSourceFiles = targetingResult.files.length > 0;
+      const willRunCodeQuality = rulesToRun.length > 0 && !this.isArchitectureOnly() && !this.isImpactOnly();
+      const willRunArchitecture = !!config.architecture?.enabled;
+      const willRunImpact = !!(this.options.impact || config.impact?.enabled);
+
+      if (!hasSourceFiles && !willRunArchitecture && !willRunImpact) {
         console.log(chalk.yellow('⚠️  No files to analyze after applying filters'));
         this.displayTargetingStats(targetingResult.stats);
         return;
       }
 
-      // Update options with filtered files
+      // Update options with filtered files (even if empty, for engines that handle it)
       this.options.targetFiles = targetingResult.files;
 
       // Display analysis info
@@ -91,8 +99,8 @@ class CliActionHandler {
         results = { results: [], summary: { total: 0, errors: 0, warnings: 0 } };
       }
 
-      // Run architecture analysis if requested
-      if (this.options.architecture) {
+      // Run architecture analysis if requested (via CLI or Config)
+      if (config.architecture?.enabled) {
         const architectureResults = await this.runArchitectureAnalysis();
         results.architecture = architectureResults;
       }
@@ -114,10 +122,10 @@ class CliActionHandler {
 
       // Exit with appropriate code
       this.handleExit(results);
-      
+
     } catch (error) {
       console.error(chalk.red('❌ Sun Lint Error:'), error.message);
-      
+
       // Following Rule C035: Log complete error context
       if (this.options.debug) {
         console.error('Full error context:', {
@@ -127,7 +135,7 @@ class CliActionHandler {
           mode: this.isModernMode ? 'modern' : 'legacy'
         });
       }
-      
+
       process.exit(1);
     }
   }
@@ -150,7 +158,7 @@ class CliActionHandler {
           verbose: this.options.verbose  // Pass verbose for debugging
         }
       });
-      
+
       if (this.options.verbose) {
         console.log(`🔧 Debug: maxSemanticFiles option = ${this.options.maxSemanticFiles}`);
         console.log(`🔧 Debug: parsed maxSemanticFiles = ${this.options.maxSemanticFiles !== undefined ? parseInt(this.options.maxSemanticFiles) : Infinity}`);
@@ -192,15 +200,15 @@ class CliActionHandler {
       if (this.options.engine === 'auto') {
         // Auto-select best engines: default to heuristic for compatibility
         const autoEngines = ['heuristic'];
-        
+
         // Add ESLint for JS/TS files if available
         if (this.hasJavaScriptTypeScriptFiles() || config.eslint?.enabled !== false) {
           autoEngines.push('eslint');
         }
-        
+
         return autoEngines;
       }
-      
+
       // Return specific engine as requested
       return [this.options.engine];
     }
@@ -234,7 +242,7 @@ class CliActionHandler {
    */
   validateAIConfiguration(config) {
     const aiConfig = config.ai || {};
-    
+
     // Check for API key
     if (!aiConfig.apiKey && !process.env.OPENAI_API_KEY) {
       console.warn(chalk.yellow('⚠️ No OpenAI API key found in config or environment'));
@@ -256,7 +264,7 @@ class CliActionHandler {
    */
   hasJavaScriptTypeScriptFiles() {
     if (!this.options.targetFiles) return false;
-    
+
     return this.options.targetFiles.some(file => {
       const ext = require('path').extname(file).toLowerCase();
       return ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs'].includes(ext);
@@ -272,7 +280,7 @@ class CliActionHandler {
     if (this.options.quiet || this.options.format === 'json') {
       return;
     }
-    
+
     const { version } = require('../package.json');
 
     console.log();
@@ -284,7 +292,7 @@ class CliActionHandler {
   }
 
   // Delegate methods to base functionality (same as original CliActionHandler)
-  
+
   /**
    * Load configuration using existing config manager
    * Following Rule C006: Verb-noun naming
@@ -325,7 +333,7 @@ class CliActionHandler {
           chalk.gray('Example: sunlint --all --output-summary=report.json --upload-report --input=src')
         );
       }
-      
+
       // Set default URL if no URL provided (when uploadReport is true)
       if (typeof this.options.uploadReport === 'boolean' || !this.options.uploadReport) {
         this.options.uploadReport = 'https://coding-standards-report.sun-asterisk.vn/api/reports';
@@ -333,7 +341,7 @@ class CliActionHandler {
           console.log(chalk.gray(`ℹ️  Using default upload URL: ${this.options.uploadReport}`));
         }
       }
-      
+
       // Basic URL validation
       try {
         new URL(this.options.uploadReport);
@@ -361,8 +369,8 @@ class CliActionHandler {
     if (config && config.include && Array.isArray(config.include) && config.include.length > 0) {
       // Config provides include patterns, use current directory as base
       // Let FileTargetingService handle the include patterns from config
-      this.options.input = '.'; 
-      
+      this.options.input = '.';
+
       if (this.options.verbose) {
         console.log(chalk.gray(`ℹ️  Using config include patterns: ${config.include.join(', ')}`));
       }
@@ -373,7 +381,7 @@ class CliActionHandler {
     if (!this.options.input && (!config || !config.include)) {
       // Set default input directory instead of glob patterns
       this.options.input = '.'; // Current directory, let FileTargetingService handle patterns
-      
+
       if (this.options.verbose) {
         console.log(chalk.gray('ℹ️  Using default input: current directory with JS/TS file patterns'));
       }
@@ -422,14 +430,14 @@ class CliActionHandler {
   async showDryRunPreview(config, rulesToRun = null) {
     console.log(chalk.blue('🔍 Dry Run Preview'));
     console.log(chalk.gray('This would analyze the following configuration:'));
-    
+
     let rulesInfo;
     if (rulesToRun) {
       rulesInfo = `${rulesToRun.length} rules (${this.getPresetName()})`;
     } else {
       rulesInfo = this.options.rules || 'config-based';
     }
-    
+
     console.log(JSON.stringify({
       rules: rulesInfo,
       files: this.options.targetFiles?.length || 'auto-detected',
@@ -492,7 +500,7 @@ class CliActionHandler {
    */
   displayTargetingStats(stats) {
     if (this.options.quiet) return;
-    
+
     console.log(chalk.gray('Targeting Stats:'));
     Object.entries(stats).forEach(([key, value]) => {
       console.log(`• ${key}: ${value}`);
@@ -523,8 +531,11 @@ class CliActionHandler {
    * Following Rule C006: Verb-noun naming
    */
   isArchitectureOnly() {
-    return this.options.architecture &&
-      !this.options.impact &&
+    const isArchEnabled = this.options.architecture || this.loadedConfig?.architecture?.enabled;
+    const isImpactEnabled = this.options.impact || this.loadedConfig?.impact?.enabled;
+
+    return isArchEnabled &&
+      !isImpactEnabled &&
       !this.options.all &&
       !this.options.specific &&
       !this.options.rule &&
@@ -539,8 +550,11 @@ class CliActionHandler {
    * Following Rule C006: Verb-noun naming
    */
   isImpactOnly() {
-    return this.options.impact &&
-      !this.options.architecture &&
+    const isArchEnabled = this.options.architecture || this.loadedConfig?.architecture?.enabled;
+    const isImpactEnabled = this.options.impact || this.loadedConfig?.impact?.enabled;
+
+    return isImpactEnabled &&
+      !isArchEnabled &&
       !this.options.all &&
       !this.options.specific &&
       !this.options.rule &&
@@ -560,13 +574,14 @@ class CliActionHandler {
     }
 
     try {
-      const integration = new ArchitectureIntegration(this.options);
+      const integration = new ArchitectureIntegration(this.options, this.loadedConfig);
       const projectPath = this.getProjectPath();
       const results = await integration.analyze(projectPath);
 
       // Save markdown report if requested
-      if (this.options.archReport && results.markdownReport) {
-        const reportPath = await integration.saveReport(results.markdownReport, projectPath);
+      if (integration.shouldGenerateReport() && results.markdownReport) {
+        const reportFilename = integration.getReportFilename(projectPath);
+        const reportPath = await integration.saveReport(results.markdownReport, reportFilename);
         if (!this.options.quiet) {
           console.log(chalk.green(`📄 Architecture report saved: ${reportPath}`));
         }

package/core/config-manager.js

@@ -147,6 +147,12 @@ class ConfigManager {
         sortBy: 'severity',
         showProgress: true,
         exitOnError: false
+      },
+      architecture: {
+        enabled: false,
+        patterns: [],
+        generateReport: false,
+        reportOutput: undefined
       }
     };
   }

package/core/config-merger.js

@@ -92,6 +92,12 @@ class ConfigMerger {
     // Performance overrides
     overrides.performance = this.applyPerformanceOverrides(overrides.performance, options);
 
+    // Architecture overrides
+    overrides.architecture = this.applyArchitectureOverrides(
+      overrides.architecture,
+      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
@@ -139,6 +145,33 @@ class ConfigMerger {
     return performance;
   }
 
+  /**
+   * Apply CLI architecture overrides to config
+   * Rule C006: verb-noun naming convention
+   * Priority: CLI flags > Config file > Defaults
+   */
+  applyArchitectureOverrides(architectureConfig, options) {
+    const architecture = { ...architectureConfig };
+
+    // CLI --architecture overrides config enabled
+    if (options.architecture !== undefined) {
+      architecture.enabled = options.architecture;
+    }
+
+    // CLI --arch-patterns overrides config patterns
+    if (options.archPatterns) {
+      const patterns = options.archPatterns.split(',').map(p => p.trim());
+      architecture.patterns = patterns;
+    }
+
+    // CLI --arch-report overrides config generateReport
+    if (options.archReport !== undefined) {
+      architecture.generateReport = options.archReport;
+    }
+
+    return architecture;
+  }
+
   /**
    * Rule C006: applyEnvironmentVariables - verb-noun naming
    */

package/core/config-validator.js

@@ -11,12 +11,13 @@ class ConfigValidator {
     this.validRuleValues = ['error', 'warning', 'info', 'warn', 'off', true, false, 0, 1, 2];
     this.ruleValueMapping = {
       0: 'off',
-      1: 'warning', 
+      1: 'warning',
       2: 'error',
       'warn': 'warning',
       true: 'warning',
       false: 'off'
     };
+    this.validArchitecturePatterns = ['layered', 'modular', 'mvvm', 'viper', 'presentation', 'clean', 'tdd'];
   }
 
   /**
@@ -29,6 +30,7 @@ class ConfigValidator {
     this.validateIncludeExcludePatterns(config.include, config.exclude);
     this.validateOutputFormat(config.output);
     this.validateRuleValues(config.rules);
+    this.validateArchitectureConfig(config);
   }
 
   /**
@@ -109,7 +111,7 @@ class ConfigValidator {
 
     // Check category configuration
     const rule = rulesRegistry.rules[ruleId];
-    
+
     if (rule && config.categories && config.categories[rule.category] !== undefined) {
       return this.normalizeRuleValue(config.categories[rule.category]);
     }
@@ -121,6 +123,39 @@ class ConfigValidator {
 
     return 'off';
   }
+
+  /**
+   * Rule C006: validateArchitectureConfig - verb-noun naming
+   * Rule C031: Specific validation logic for architecture configuration
+   */
+  validateArchitectureConfig(config) {
+    if (!config.architecture) return;
+
+    const chalk = require('chalk');
+    const arch = config.architecture;
+
+    if (arch.enabled !== undefined && typeof arch.enabled !== 'boolean') {
+      console.warn(chalk.yellow('⚠️  architecture.enabled must be boolean'));
+    }
+
+    if (arch.patterns !== undefined && !Array.isArray(arch.patterns)) {
+      console.warn(chalk.yellow('⚠️  architecture.patterns must be an array'));
+    }
+
+    if (arch.patterns && Array.isArray(arch.patterns)) {
+      const invalid = arch.patterns.filter(p =>
+        !this.validArchitecturePatterns.includes(String(p).toLowerCase())
+      );
+      if (invalid.length > 0) {
+        console.warn(chalk.yellow(`⚠️  Unknown patterns: ${invalid.join(', ')}`));
+        console.warn(chalk.gray(`   Valid: ${this.validArchitecturePatterns.join(', ')}`));
+      }
+    }
+
+    if (arch.generateReport !== undefined && typeof arch.generateReport !== 'boolean') {
+      console.warn(chalk.yellow('⚠️  architecture.generateReport must be boolean'));
+    }
+  }
 }
 
 module.exports = ConfigValidator;

package/core/output-service.js

@@ -195,8 +195,11 @@ class OutputService {
     const totalFiles = results.filesAnalyzed || results.summary?.totalFiles || results.totalFiles || results.fileCount || 0;
     
     // Calculate LOC
+    // In changed-files mode (PR), use only the analyzed files for accurate scoring
     let loc = 0;
-    if (options.input) {
+    if (options.changedFiles && options.targetFiles && options.targetFiles.length > 0) {
+      loc = this.scoringService.calculateLOC(options.targetFiles);
+    } else if (options.input) {
       const inputPaths = Array.isArray(options.input) ? options.input : [options.input];
       for (const inputPath of inputPaths) {
         if (fs.existsSync(inputPath)) {
@@ -210,9 +213,10 @@ class OutputService {
       }
     }
 
-    // Count violations
+    // Count violations by severity
     const errorCount = violations.filter(v => v.severity === 'error').length;
     const warningCount = violations.filter(v => v.severity === 'warning').length;
+    const infoCount = violations.filter(v => v.severity === 'info').length;
 
     // Get number of rules checked - use metadata first, then parse from options
     let rulesChecked = metadata.rulesChecked;
@@ -225,10 +229,14 @@ class OutputService {
     }
     rulesChecked = rulesChecked || 1;
 
+    // Determine scoring mode
+    const scoringMode = options.changedFiles ? 'pr' : 'project';
+
     // Calculate score
     const scoringSummary = this.scoringService.generateScoringSummary({
       errorCount,
       warningCount,
+      infoCount,
       rulesChecked,
       loc
     });
@@ -243,7 +251,8 @@ class OutputService {
         filesAnalyzed: totalFiles,
         duration: metadata.duration,
         version: metadata.version || this.version,
-        architecture: results.architecture || null
+        architecture: results.architecture || null,
+        scoringMode
       }
     );
 

package/core/rule-selection-service.js

@@ -10,11 +10,13 @@ const fs = require('fs');
 const path = require('path');
 const RuleMappingService = require('./rule-mapping-service');
 const SunlintRuleAdapter = require('./adapters/sunlint-rule-adapter');
+const ConfigValidator = require('./config-validator');
 
 class RuleSelectionService {
   constructor() {
     this.ruleAdapter = SunlintRuleAdapter.getInstance();
     this.ruleMappingService = new RuleMappingService();
+    this.configValidator = new ConfigValidator();
     this.initialized = false;
     // Path works both in dev (from pages/) and npm package (from config/)
     this.releasedRulesPath = path.join(__dirname, '../config/released-rules.json');
@@ -209,14 +211,33 @@ class RuleSelectionService {
       selectedRules = selectedRules.filter(ruleId => !disabledRules.has(ruleId));
     }
 
-    // Convert to rule objects
+    // Get rules registry for severity resolution
+    const rulesRegistry = this.ruleAdapter.getRulesRegistry();
+
+    // Convert to rule objects with proper severity from config
     return selectedRules.map(ruleId => {
       const adapterRule = this.ruleAdapter.getRuleById(ruleId);
+      
+      // Resolve severity from config (config.rules > config.categories > rule default)
+      const effectiveConfig = this.configValidator.getEffectiveRuleConfiguration(
+        ruleId,
+        config,
+        rulesRegistry
+      );
+      
+      // Map config values to severity (error/warn)
+      let severity = 'warning';
+      if (effectiveConfig === 'error' || effectiveConfig === 2) {
+        severity = 'error';
+      } else if (effectiveConfig === 'warn' || effectiveConfig === 'warning' || effectiveConfig === 1) {
+        severity = 'warning';
+      }
+      
       return {
+        ...(adapterRule || {}),
         id: ruleId,
         name: this.getRuleName(ruleId),
-        severity: 'warning',
-        ...(adapterRule || {})
+        severity // Must come AFTER spread to override adapter's severity
       };
     }).filter(rule => rule.id);
   }