@sun-asterisk/sunlint 1.3.32 → 1.3.33

package/README.md

@@ -19,6 +19,7 @@ Sun Lint is a universal coding standards checker providing comprehensive code qu
 - ✅ **Advanced File Targeting**: Include/exclude patterns, language filtering
 - ✅ **Quality Scoring System**: Automated quality score (0-100) with grade (A+ to F)
 - ✅ **Summary Reports**: JSON format for CI/CD dashboards and management reports
+- ✅ **Architecture Detection**: Detect architecture patterns (Layered, Modular, MVVM, VIPER) with health scoring
 
 ### **🏗️ Architecture**
 
@@ -128,6 +129,52 @@ sunlint --all --input=src --output-summary=quality.json
 - Quality gate setup
 - Trending analysis
 
+## 🏛️ **Architecture Detection** 🆕
+
+Detect and analyze architecture patterns in your codebase with health scoring and violation detection.
+
+### **Features**
+- **Pattern Detection**: Layered, Modular, MVVM, VIPER, Clean Architecture
+- **Health Score (0-100)**: Architecture compliance scoring
+- **Violation Detection**: Identify architecture anti-patterns
+- **Markdown Reports**: Detailed analysis reports for documentation
+
+### **Quick Usage**
+```bash
+# Architecture analysis only
+sunlint --architecture --input=src
+
+# Combined: Code quality + Architecture
+sunlint --all --architecture --input=src
+
+# Generate markdown report
+sunlint --architecture --arch-report --input=src
+
+# Target specific patterns
+sunlint --architecture --arch-patterns=mvvm,layered --input=src
+```
+
+### **Example Output**
+```
+🏛️ Architecture Analysis:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+• Pattern: LAYERED (69% confidence)
+• Health Score: 85/100
+• Violations: 3
+
+Top Architecture Violations:
+  ⚠ Interface/Contract Definitions - score 20% (threshold: 50%)
+  ⚠ Middleware/Interceptor Layer - score 0% (threshold: 50%)
+  ... and 1 more
+```
+
+### **Options**
+| Option | Description |
+|--------|-------------|
+| `--architecture` | Enable architecture pattern detection |
+| `--arch-patterns <patterns>` | Target specific patterns (comma-separated: layered, modular, mvvm, viper) |
+| `--arch-report` | Generate separate markdown report |
+
 ## 📦 **Installation**
 
 ### **Global Installation (Recommended)**

package/core/architecture-integration.js

@@ -0,0 +1,220 @@
+/**
+ * Architecture Integration for SunLint
+ * Wraps architecture-detection module for seamless integration
+ * Following Rule C005: Single responsibility - handle architecture analysis integration
+ */
+
+const path = require('path');
+const fs = require('fs');
+const chalk = require('chalk');
+
+class ArchitectureIntegration {
+  constructor(options = {}) {
+    this.options = options;
+    this.archModule = null;
+  }
+
+  /**
+   * Load architecture detection module
+   * Tries bundled version first, then falls back to local development path
+   */
+  async loadArchitectureModule() {
+    if (this.archModule) {
+      return this.archModule;
+    }
+
+    // Try bundled version first (engines/arch-detect)
+    const bundledPath = path.join(__dirname, '..', 'engines', 'arch-detect', 'index.js');
+
+    if (fs.existsSync(bundledPath)) {
+      try {
+        this.archModule = require(bundledPath);
+        if (this.options.verbose) {
+          console.log(chalk.gray('📦 Loaded bundled architecture-detection'));
+        }
+        return this.archModule;
+      } catch (error) {
+        if (this.options.verbose) {
+          console.log(chalk.yellow(`⚠️ Failed to load bundled module: ${error.message}`));
+        }
+      }
+    }
+
+    // Fallback: Try local development path
+    const devPaths = [
+      path.join(__dirname, '..', '..', '..', '..', 'architecture-detection', 'dist', 'index.js'),
+      path.join(__dirname, '..', '..', '..', 'architecture-detection', 'dist', 'index.js'),
+    ];
+
+    for (const devPath of devPaths) {
+      if (fs.existsSync(devPath)) {
+        try {
+          this.archModule = require(devPath);
+          if (this.options.verbose) {
+            console.log(chalk.gray(`📦 Loaded architecture-detection from: ${devPath}`));
+          }
+          return this.archModule;
+        } catch (error) {
+          if (this.options.verbose) {
+            console.log(chalk.yellow(`⚠️ Failed to load from ${devPath}: ${error.message}`));
+          }
+        }
+      }
+    }
+
+    throw new Error(
+      'Architecture detection module not found. Run "npm run build" to bundle it, ' +
+      'or ensure architecture-detection is built in the parent directory.'
+    );
+  }
+
+  /**
+   * Parse architecture patterns from CLI option
+   */
+  parsePatterns() {
+    if (!this.options.archPatterns) {
+      return undefined; // Use default patterns
+    }
+
+    const patternMap = {
+      'layered': 'LAYERED',
+      'modular': 'MODULAR',
+      'mvvm': 'MVVM',
+      'viper': 'VIPER',
+      'presentation': 'PRESENTATION',
+      'clean': 'CLEAN_ARCHITECTURE',
+      'tdd': 'TDD_CLEAN_ARCHITECTURE',
+    };
+
+    const patterns = this.options.archPatterns
+      .split(',')
+      .map(p => p.trim().toLowerCase())
+      .map(p => patternMap[p] || p.toUpperCase())
+      .filter(Boolean);
+
+    return patterns.length > 0 ? patterns : undefined;
+  }
+
+  /**
+   * Run architecture analysis on project
+   * @param {string} projectPath - Path to analyze
+   * @returns {Object} Architecture analysis results
+   */
+  async analyze(projectPath) {
+    const archModule = await this.loadArchitectureModule();
+    const { ArchitectureAnalyzer } = archModule;
+
+    if (!ArchitectureAnalyzer) {
+      throw new Error('ArchitectureAnalyzer not found in architecture-detection module');
+    }
+
+    const analyzer = new ArchitectureAnalyzer({
+      patterns: this.parsePatterns(),
+      respectGitignore: true,
+      verbose: this.options.verbose,
+    });
+
+    if (this.options.verbose) {
+      console.log(chalk.blue(`🏛️ Analyzing architecture: ${projectPath}`));
+    }
+
+    const result = await analyzer.analyze(projectPath);
+
+    // Convert to SunLint-compatible format
+    return this.convertToSunLintFormat(result, analyzer, projectPath);
+  }
+
+  /**
+   * Convert architecture results to SunLint format
+   */
+  convertToSunLintFormat(result, analyzer, projectPath) {
+    const violations = [];
+
+    // Convert architecture violations to SunLint violation format
+    // Check violationAssessment.violations from the new format
+    const violationAssessment = result.violationAssessment;
+    if (violationAssessment && violationAssessment.violations && violationAssessment.violations.length > 0) {
+      for (const violation of violationAssessment.violations) {
+        violations.push({
+          ruleId: `ARCH-${violation.type || 'VIOLATION'}`,
+          severity: this.mapSeverity(violation.impact),
+          message: violation.description || violation.ruleName,
+          file: violation.affectedFiles?.[0] || projectPath,
+          line: 1,
+          column: 1,
+          category: 'architecture',
+          source: 'architecture-detection',
+          details: {
+            ruleName: violation.ruleName,
+            impactReason: violation.impactReason,
+            suggestedFix: violation.suggestedFix,
+            affectedFiles: violation.affectedFiles,
+          },
+        });
+      }
+    }
+
+    // Generate markdown report if requested
+    let markdownReport = null;
+    if (this.options.archReport) {
+      try {
+        markdownReport = analyzer.formatAsMarkdown(result);
+      } catch (error) {
+        if (this.options.verbose) {
+          console.log(chalk.yellow(`⚠️ Could not generate markdown report: ${error.message}`));
+        }
+      }
+    }
+
+    // Map from hybridAnalysis structure
+    const hybridAnalysis = result.hybridAnalysis || {};
+    const healthScore = violationAssessment?.healthScore || 100;
+
+    return {
+      summary: {
+        primaryPattern: hybridAnalysis.primaryPattern || result.primaryPattern || 'UNKNOWN',
+        primaryConfidence: hybridAnalysis.confidence || 0,
+        secondaryPatterns: (hybridAnalysis.secondaryPatterns || []).map(p => ({
+          pattern: p,
+          confidence: 0.5, // Default confidence for secondary patterns
+        })),
+        healthScore: healthScore,
+        violationCount: violations.length,
+        analysisTime: result.metadata?.analysisTimeMs || 0,
+        isHybrid: hybridAnalysis.isHybrid || false,
+        combination: hybridAnalysis.combination || null,
+      },
+      violations,
+      markdownReport,
+      raw: result,
+    };
+  }
+
+  /**
+   * Map architecture severity to SunLint severity
+   */
+  mapSeverity(severity) {
+    const severityMap = {
+      'critical': 'error',
+      'high': 'error',
+      'medium': 'warning',
+      'low': 'info',
+    };
+    return severityMap[severity?.toLowerCase()] || 'warning';
+  }
+
+  /**
+   * 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);
+
+    fs.writeFileSync(outputPath, markdownContent, 'utf8');
+    return outputPath;
+  }
+}
+
+module.exports = { ArchitectureIntegration };

package/core/cli-action-handler.js

@@ -14,6 +14,7 @@ const AnalysisOrchestrator = require('./analysis-orchestrator');
 const OutputService = require('./output-service');
 const GitUtils = require('./git-utils');
 const FileTargetingService = require('./file-targeting-service');
+const { ArchitectureIntegration } = require('./architecture-integration');
 
 // Legacy orchestrator for fallback
 // const LegacyOrchestrator = require('./legacy-analysis-orchestrator'); // Removed
@@ -80,11 +81,25 @@ class CliActionHandler {
 
       // Run analysis with appropriate orchestrator
       const startTime = Date.now();
-      const results = await this.runModernAnalysis(rulesToRun, targetingResult.files, config);
+      let results = null;
+
+      // Run code quality analysis (unless --architecture is used alone)
+      if (rulesToRun.length > 0 && !this.isArchitectureOnly()) {
+        results = await this.runModernAnalysis(rulesToRun, targetingResult.files, config);
+      } else {
+        results = { results: [], summary: { total: 0, errors: 0, warnings: 0 } };
+      }
+
+      // Run architecture analysis if requested
+      if (this.options.architecture) {
+        const architectureResults = await this.runArchitectureAnalysis();
+        results.architecture = architectureResults;
+      }
+
       const duration = Date.now() - startTime;
 
       // Output results
-      await this.outputService.outputResults(results, this.options, { 
+      await this.outputService.outputResults(results, this.options, {
         duration,
         rulesRun: rulesToRun.length,
         rulesChecked: rulesToRun.length
@@ -494,18 +509,64 @@ class CliActionHandler {
    */
   handleExit(results) {
     if (this.options.noExit) return;
-    
+
     // Check if any violations were found
-    const hasViolations = results.results?.some(result => 
+    const hasViolations = results.results?.some(result =>
       result.violations && result.violations.length > 0
     );
-    
+
     if (hasViolations && this.options.failOnViolations !== false) {
       process.exit(1);
     } else {
       process.exit(0);
     }
   }
+
+  /**
+   * Check if only architecture analysis was requested (no code quality rules)
+   * Following Rule C006: Verb-noun naming
+   */
+  isArchitectureOnly() {
+    return this.options.architecture &&
+      !this.options.all &&
+      !this.options.rule &&
+      !this.options.rules &&
+      !this.options.quality &&
+      !this.options.security &&
+      !this.options.category;
+  }
+
+  /**
+   * Run architecture analysis using architecture-detection module
+   * Following Rule C006: Verb-noun naming
+   */
+  async runArchitectureAnalysis() {
+    if (!this.options.quiet) {
+      console.log(chalk.blue('🏛️ Running architecture analysis...'));
+    }
+
+    try {
+      const integration = new ArchitectureIntegration(this.options);
+      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 (!this.options.quiet) {
+          console.log(chalk.green(`📄 Architecture report saved: ${reportPath}`));
+        }
+      }
+
+      return results;
+    } catch (error) {
+      console.error(chalk.yellow(`⚠️ Architecture analysis failed: ${error.message}`));
+      if (this.options.debug) {
+        console.error(error.stack);
+      }
+      return null;
+    }
+  }
 }
 
 module.exports = CliActionHandler;

package/core/cli-program.js

@@ -23,6 +23,12 @@ function createCliProgram() {
     .option('--quality', 'Run all code quality rules')
     .option('--security', 'Run all secure coding rules');
 
+  // Architecture Analysis options
+  program
+    .option('--architecture', 'Enable architecture pattern detection (layered, modular, mvvm, viper)')
+    .option('--arch-patterns <patterns>', 'Target specific architecture patterns (comma-separated)')
+    .option('--arch-report', 'Generate separate architecture MD report');
+
   // TypeScript specific options (Phase 1 focus)
   program
     .option('--typescript', 'Enable TypeScript-specific analysis')
@@ -156,11 +162,17 @@ Advanced File Targeting:
 
 Large Project Optimization:
   $ sunlint --all --input=. --max-semantic-files=500    # Conservative analysis
-  $ sunlint --all --input=. --max-semantic-files=2000   # Comprehensive analysis  
+  $ sunlint --all --input=. --max-semantic-files=2000   # Comprehensive analysis
   $ sunlint --all --input=. --max-semantic-files=-1     # Unlimited (all files)
   $ sunlint --all --input=. --max-semantic-files=0      # Disable semantic analysis
   $ sunlint --all --changed-files --max-semantic-files=300  # Fast CI analysis
 
+Architecture Analysis:
+  $ sunlint --all --architecture --input=src            # Code quality + architecture
+  $ sunlint --architecture --input=src                  # Architecture only
+  $ sunlint --architecture --arch-report --input=src    # Generate MD report
+  $ sunlint --architecture --arch-patterns=mvvm,layered --input=src
+
 Sun* Engineering - Coding Standards Made Simple ☀️
 `);
 

package/core/output-service.js

@@ -115,6 +115,74 @@ class OutputService {
     if (!options.quiet && options.format !== 'json') {
       console.log(report.summary);
     }
+
+    // Output architecture results if available
+    if (results.architecture && !options.quiet) {
+      this.outputArchitectureResults(results.architecture, options);
+    }
+  }
+
+  /**
+   * Output architecture analysis results
+   * @param {Object} archResults - Architecture analysis results
+   * @param {Object} options - Output options
+   */
+  outputArchitectureResults(archResults, options) {
+    if (!archResults || !archResults.summary) {
+      return;
+    }
+
+    const summary = archResults.summary;
+
+    console.log(chalk.blue('\n🏛️ Architecture Analysis:'));
+    console.log('━'.repeat(50));
+
+    // Primary pattern
+    const confidence = Math.round(summary.primaryConfidence * 100);
+    console.log(`• Pattern: ${chalk.cyan(summary.primaryPattern)} (${confidence}% confidence)`);
+
+    // Secondary patterns
+    if (summary.secondaryPatterns && summary.secondaryPatterns.length > 0) {
+      const secondary = summary.secondaryPatterns
+        .map(p => `${p.pattern} (${Math.round(p.confidence * 100)}%)`)
+        .join(', ');
+      console.log(`• Secondary: ${chalk.gray(secondary)}`);
+    }
+
+    // Health score
+    const healthScore = Math.round(summary.healthScore);
+    const healthColor = healthScore >= 80 ? chalk.green :
+                        healthScore >= 60 ? chalk.yellow : chalk.red;
+    console.log(`• Health Score: ${healthColor(healthScore + '/100')}`);
+
+    // Violations
+    if (summary.violationCount > 0) {
+      console.log(`• Violations: ${chalk.red(summary.violationCount)}`);
+
+      // Show first 5 violations
+      if (archResults.violations && archResults.violations.length > 0) {
+        console.log(chalk.gray('\nTop Architecture Violations:'));
+        archResults.violations.slice(0, 5).forEach((v, i) => {
+          const severity = v.severity === 'error' ? chalk.red('✗') : chalk.yellow('⚠');
+          console.log(`  ${severity} ${v.message}`);
+          if (v.file) {
+            console.log(chalk.gray(`    → ${v.file}:${v.line || 1}`));
+          }
+        });
+        if (archResults.violations.length > 5) {
+          console.log(chalk.gray(`  ... and ${archResults.violations.length - 5} more`));
+        }
+      }
+    } else {
+      console.log(`• Violations: ${chalk.green('None')}`);
+    }
+
+    // Report file info
+    if (archResults.markdownReport && options.archReport) {
+      console.log(chalk.gray('\n📄 Full architecture report saved'));
+    }
+
+    console.log();
   }
 
   generateAndSaveSummaryReport(violations, results, options, metadata) {
@@ -463,35 +531,30 @@ class OutputService {
       });
 
       if (uploadResult.success) {
-        if (!options.quiet) {
-          console.log(chalk.green(`✅ Report successfully uploaded to: ${apiUrl}`));
-          if (uploadResult.statusCode) {
-            console.log(chalk.green(`📡 HTTP Status: ${uploadResult.statusCode}`));
-          }
-          if (uploadResult.response) {
-            try {
-              const responseData = JSON.parse(uploadResult.response);
-              if (responseData.message) {
-                console.log(chalk.blue(`💬 Server response: ${responseData.message}`));
-              }
-              if (responseData.report_id) {
-                console.log(chalk.blue(`📝 Report ID: ${responseData.report_id}`));
-              }
-              if (responseData.repository) {
-                console.log(chalk.blue(`🏠 Repository: ${responseData.repository}`));
-              }
-              if (responseData.actor) {
-                console.log(chalk.blue(`👤 Submitted by: ${responseData.actor}`));
-              }
-            } catch (parseError) {
-              // If response is not JSON, show raw response
+        if (!options.quiet && uploadResult.response) {
+          try {
+            const responseData = JSON.parse(uploadResult.response);
+            if (responseData.message) {
+              console.log(chalk.blue(`💬 Server response: ${responseData.message}`));
+            }
+            if (responseData.report_id) {
+              console.log(chalk.blue(`📝 Report ID: ${responseData.report_id}`));
+            }
+            if (responseData.repository) {
+              console.log(chalk.blue(`🏠 Repository: ${responseData.repository}`));
+            }
+            if (responseData.actor) {
+              console.log(chalk.blue(`👤 Submitted by: ${responseData.actor}`));
+            }
+          } catch (parseError) {
+            // If response is not JSON, show raw response if verbose
+            if (options.verbose) {
               console.log(chalk.gray(`📄 Response: ${uploadResult.response.substring(0, 200)}...`));
             }
           }
         }
       } else {
-        console.warn(chalk.yellow(`⚠️  Failed to upload report: ${uploadResult.error}`));
-        
+        // Error already logged in upload-service.js
         if (options.verbose && uploadResult.errorContext) {
           console.warn('Upload error details:', uploadResult.errorContext);
         }

package/core/scoring-service.js

@@ -10,19 +10,50 @@ const path = require('path');
 
 class ScoringService {
   constructor() {
-    // Scoring weights
+    // Scoring weights based on violations per KLOC (1000 lines)
+    //
+    // Calibration targets:
+    //   - 0 violations/KLOC = 100 (A+)
+    //   - 1-2 violations/KLOC = 90-95 (A/A+)
+    //   - 3-4 violations/KLOC = 80-89 (B/B+)
+    //   - 5-7 violations/KLOC = 70-79 (C/C+)
+    //   - 8-10 violations/KLOC = 60-69 (D)
+    //   - >10 violations/KLOC = <60 (F)
+    //
     this.weights = {
-      errorPenalty: 5,      // Each error reduces score by 5 points
-      warningPenalty: 1,    // Each warning reduces score by 1 point
-      ruleBonus: 0.5,       // Bonus for each rule checked
-      locFactor: 0.001      // Factor for normalizing by LOC
+      // Penalty per violation type (per KLOC)
+      // Errors are 3x more severe than warnings
+      errorPenaltyPerKLOC: 6,      // Each error per KLOC reduces score by 6 points
+      warningPenaltyPerKLOC: 2,    // Each warning per KLOC reduces score by 2 points
+
+      // Absolute penalty thresholds (regardless of LOC)
+      // Large projects should still be penalized for raw violation counts
+      absoluteErrorThreshold: 20,   // Start penalizing if errors > 20
+      absoluteErrorPenalty: 0.05,   // Each error above threshold reduces score by 0.05 (max 15 pts)
+
+      absoluteWarningThreshold: 100, // Start penalizing if warnings > 100
+      absoluteWarningPenalty: 0.01,  // Each warning above threshold reduces score by 0.01 (max 10 pts)
+    };
+
+    // Thresholds for violations per KLOC (used for grading reference)
+    this.thresholds = {
+      excellent: 1,    // < 1 violation per KLOC = excellent (A+/A)
+      good: 3,         // < 3 violations per KLOC = good (B+/B)
+      acceptable: 5,   // < 5 violations per KLOC = acceptable (C+/C)
+      poor: 10,        // < 10 violations per KLOC = poor (D)
+      // >= 10 = very poor (F)
     };
   }
 
   /**
    * Calculate quality score
-   * Score formula: 100 - (errorCount * 5 + warningCount * 1) * (1000 / LOC) + (rulesChecked * 0.5)
-   * 
+   *
+   * New formula (v2):
+   * 1. Calculate violations per KLOC (errorsPerKLOC, warningsPerKLOC)
+   * 2. Apply penalty based on density: errorsPerKLOC * 2 + warningsPerKLOC * 0.5
+   * 3. Apply absolute penalty for projects with too many errors
+   * 4. Add small bonus for rules checked
+   *
    * @param {Object} params
    * @param {number} params.errorCount - Number of errors found
    * @param {number} params.warningCount - Number of warnings found
@@ -34,20 +65,34 @@ class ScoringService {
     // Base score starts at 100
     let score = 100;
 
-    // Calculate violations penalty
-    const totalPenalty = (errorCount * this.weights.errorPenalty) + 
-                        (warningCount * this.weights.warningPenalty);
-
-    // Normalize penalty by LOC (per 1000 lines)
-    const locNormalization = loc > 0 ? 1000 / loc : 1;
-    const normalizedPenalty = totalPenalty * locNormalization;
-
-    // Apply penalty
-    score -= normalizedPenalty;
+    // Calculate KLOC (thousands of lines of code)
+    const kloc = Math.max(loc / 1000, 1); // Minimum 1 KLOC to avoid division issues
+
+    // Calculate violations per KLOC
+    const errorsPerKLOC = errorCount / kloc;
+    const warningsPerKLOC = warningCount / kloc;
+    const totalViolationsPerKLOC = errorsPerKLOC + warningsPerKLOC;
+
+    // 1. Density-based penalty (main scoring factor)
+    // This penalizes based on how "dense" the violations are
+    const densityPenalty = (errorsPerKLOC * this.weights.errorPenaltyPerKLOC) +
+                          (warningsPerKLOC * this.weights.warningPenaltyPerKLOC);
+    score -= densityPenalty;
+
+    // 2. Absolute penalty for projects with too many errors
+    // Even large codebases should not have hundreds of errors
+    if (errorCount > this.weights.absoluteErrorThreshold) {
+      const excessErrors = errorCount - this.weights.absoluteErrorThreshold;
+      const absoluteErrorPenalty = excessErrors * this.weights.absoluteErrorPenalty;
+      score -= Math.min(absoluteErrorPenalty, 15); // Cap at 15 points
+    }
 
-    // Add bonus for rules checked (more rules = more thorough check)
-    const ruleBonus = Math.min(rulesChecked * this.weights.ruleBonus, 10); // Max 10 points bonus
-    score += ruleBonus;
+    // 3. Absolute penalty for projects with too many warnings
+    if (warningCount > this.weights.absoluteWarningThreshold) {
+      const excessWarnings = warningCount - this.weights.absoluteWarningThreshold;
+      const absoluteWarningPenalty = excessWarnings * this.weights.absoluteWarningPenalty;
+      score -= Math.min(absoluteWarningPenalty, 10); // Cap at 10 points
+    }
 
     // Ensure score is between 0-100
     score = Math.max(0, Math.min(100, score));

package/core/upload-service.js

@@ -24,15 +24,49 @@ class UploadService {
       }
 
       const uploadResult = await this.executeUploadCommand(filePath, apiUrl, options);
-      
-      console.log(chalk.green(`✅ Report uploaded successfully!`));
-      return {
-        success: true,
-        url: apiUrl,
-        filePath: filePath,
-        response: uploadResult.response,
-        statusCode: uploadResult.statusCode
-      };
+
+      // Check if upload was actually successful based on HTTP status code
+      const statusCode = uploadResult.statusCode;
+      const isSuccess = statusCode >= 200 && statusCode < 300;
+
+      if (isSuccess) {
+        console.log(chalk.green(`✅ Report uploaded successfully!`));
+        console.log(chalk.green(`📡 HTTP Status: ${statusCode}`));
+        return {
+          success: true,
+          url: apiUrl,
+          filePath: filePath,
+          response: uploadResult.response,
+          statusCode: statusCode
+        };
+      } else {
+        // Handle non-success HTTP status codes
+        const errorMessages = {
+          401: 'Unauthorized - Authentication required. Make sure OIDC token is configured correctly.',
+          403: 'Forbidden - Access denied. Check your permissions.',
+          404: 'Not Found - API endpoint does not exist.',
+          500: 'Internal Server Error - Server-side issue.',
+          502: 'Bad Gateway - Server is temporarily unavailable.',
+          503: 'Service Unavailable - Server is overloaded or under maintenance.'
+        };
+
+        const errorMessage = errorMessages[statusCode] || `HTTP Error ${statusCode}`;
+        console.error(chalk.red(`❌ Upload failed: ${errorMessage}`));
+        console.error(chalk.red(`📡 HTTP Status: ${statusCode}`));
+
+        if (uploadResult.response) {
+          console.error(chalk.yellow(`📄 Response: ${uploadResult.response}`));
+        }
+
+        return {
+          success: false,
+          url: apiUrl,
+          filePath: filePath,
+          response: uploadResult.response,
+          statusCode: statusCode,
+          error: errorMessage
+        };
+      }
       
     } catch (error) {
       const errorContext = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sun-asterisk/sunlint",
-  "version": "1.3.32",
+  "version": "1.3.33",
   "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/C024_no_scatter_hardcoded_constants/symbol-based-analyzer.js

@@ -114,6 +114,25 @@ class C024SymbolBasedAnalyzer {
       'commit',
       'useState',
       'useReducer',
+      // Logging functions
+      'console.log',
+      'console.error',
+      'console.warn',
+      'console.info',
+      'console.debug',
+      'console.trace',
+      'logger.log',
+      'logger.error',
+      'logger.warn',
+      'logger.info',
+      'logger.debug',
+      'this.logger',
+      'log',
+      'error',
+      'warn',
+      'info',
+      'debug',
+      'trace',
     ];
 
     // === String patterns that are acceptable (not magic strings) ===

package/scripts/copy-arch-detect.js

@@ -0,0 +1,78 @@
+/**
+ * Copy architecture-detection dist to engines/arch-detect
+ * This script is run during build to bundle architecture detection
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const SOURCE = path.resolve(__dirname, '../../../../architecture-detection/dist');
+const DEST = path.resolve(__dirname, '../engines/arch-detect');
+
+function copyDir(src, dest) {
+  if (!fs.existsSync(src)) {
+    console.log('⚠️  architecture-detection/dist not found. Run "npm run build" in architecture-detection first.');
+    return false;
+  }
+
+  // Clean destination
+  if (fs.existsSync(dest)) {
+    fs.rmSync(dest, { recursive: true });
+  }
+  fs.mkdirSync(dest, { recursive: true });
+
+  // Copy files recursively
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    // Skip source maps and declaration files
+    if (entry.name.endsWith('.map') || entry.name.endsWith('.d.ts')) {
+      continue;
+    }
+
+    // Skip CLI and LLM folders
+    if (entry.name === 'cli.js' || entry.name === 'llm' || entry.name === 'llm-primary') {
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+
+  return true;
+}
+
+console.log('📦 Copying architecture-detection...');
+
+if (copyDir(SOURCE, DEST)) {
+  const size = getTotalSize(DEST);
+  console.log(`✅ Copied to engines/arch-detect (${formatSize(size)})`);
+} else {
+  console.log('⚠️  Skipped architecture-detection copy');
+}
+
+function getTotalSize(dir) {
+  let size = 0;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      size += getTotalSize(fullPath);
+    } else {
+      size += fs.statSync(fullPath).size;
+    }
+  }
+  return size;
+}
+
+function formatSize(bytes) {
+  if (bytes < 1024) return bytes + ' B';
+  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
+  return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+}