@sun-asterisk/sunlint 1.3.31 → 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

@@ -7,12 +7,14 @@
 
 const chalk = require('chalk');
 const fs = require('fs');
+const path = require('path');
 const ConfigManager = require('./config-manager');
 const RuleSelectionService = require('./rule-selection-service');
 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
@@ -79,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
@@ -121,9 +137,10 @@ class CliActionHandler {
         enabledEngines: this.determineEnabledEngines(config),
         aiConfig: config.ai || {},
         eslintConfig: config.eslint || {},
-        heuristicConfig: { 
+        heuristicConfig: {
           ...config.heuristic || {},
           targetFiles: this.options.targetFiles,  // Pass filtered files for semantic optimization
+          projectPath: this.getProjectPath(),  // Pass target project path for semantic engine
           maxSemanticFiles: this.options.maxSemanticFiles ? parseInt(this.options.maxSemanticFiles) : 1000,
           verbose: this.options.verbose  // Pass verbose for debugging
         }
@@ -422,13 +439,39 @@ class CliActionHandler {
    */
   async applyFileTargeting(config) {
     // Handle both string and array input patterns
-    const inputPaths = Array.isArray(this.options.input) 
-      ? this.options.input 
+    const inputPaths = Array.isArray(this.options.input)
+      ? this.options.input
       : [this.options.input];
-    
+
     return await this.fileTargetingService.getTargetFiles(inputPaths, config, this.options);
   }
 
+  /**
+   * Get project path from input for semantic engine
+   * Returns the directory path of the target for proper file resolution
+   */
+  getProjectPath() {
+    const input = Array.isArray(this.options.input)
+      ? this.options.input[0]
+      : this.options.input;
+
+    if (!input) {
+      return process.cwd();
+    }
+
+    const absolutePath = path.isAbsolute(input) ? input : path.resolve(process.cwd(), input);
+
+    // If input is a file, return its directory; if directory, return as-is
+    try {
+      if (fs.existsSync(absolutePath) && fs.statSync(absolutePath).isFile()) {
+        return path.dirname(absolutePath);
+      }
+      return absolutePath;
+    } catch {
+      return absolutePath;
+    }
+  }
+
   /**
    * Display analysis information
    * Following Rule C006: Verb-noun naming
@@ -466,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);
         }