@sun-asterisk/sunlint 1.3.47 → 1.3.49

package/core/project-detector.js

@@ -0,0 +1,517 @@
+/**
+ * SunLint Project Detector
+ * Analyzes project directory structure to recommend a language/framework preset.
+ * Rule C005: Single responsibility - detect project type only
+ * Rule C015: Uses domain language (preset, framework, confidence)
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * @typedef {Object} DetectionResult
+ * @property {string} language         - Matched language key (e.g. 'php', 'typescript')
+ * @property {string} framework        - Detected framework name (e.g. 'Laravel', 'Next.js')
+ * @property {string|null} frameworkKey - Rules sub-folder key (e.g. 'php-laravel', 'ruby-rails', 'go-gin') or null
+ * @property {string} confidence       - 'high' | 'medium' | 'low'
+ * @property {string} reason           - Human-readable explanation
+ * @property {string[]} signals        - File/dir signals that triggered the match
+ */
+
+/**
+ * Ordered detection rules. First match wins.
+ * Each rule: { check(dir) → string[] | null, language, framework, confidence }
+ */
+const DETECTION_RULES = [
+    // ── PHP ──────────────────────────────────────────────────────────────────
+    {
+        name: 'PHP/Laravel',
+        language: 'php',
+        framework: 'Laravel',
+        frameworkKey: 'php-laravel',
+        confidence: 'high',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'artisan')) signals.push('artisan');
+            if (fileExists(dir, 'composer.json')) {
+                signals.push('composer.json');
+                const composerJson = readJsonSafe(path.join(dir, 'composer.json'));
+                if (composerJson && composerJson.require && composerJson.require['laravel/framework']) {
+                    signals.push('require.laravel/framework');
+                }
+            }
+            if (dirExists(dir, 'vendor', 'laravel')) signals.push('vendor/laravel/');
+
+            const isLaravel = signals.includes('artisan') ||
+                signals.includes('require.laravel/framework') ||
+                signals.includes('vendor/laravel/');
+            return isLaravel && signals.length >= 2 ? signals : null;
+        }
+    },
+    {
+        name: 'PHP/Symfony',
+        language: 'php',
+        framework: 'Symfony',
+        confidence: 'high',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'composer.json')) signals.push('composer.json');
+            if (fileExists(dir, 'symfony.lock')) signals.push('symfony.lock');
+            if (dirExists(dir, 'config', 'packages')) signals.push('config/packages/');
+            const composerJson = readJsonSafe(path.join(dir, 'composer.json'));
+            if (composerJson && composerJson.require && composerJson.require['symfony/framework-bundle']) {
+                signals.push('require.symfony/framework-bundle');
+            }
+            return signals.length >= 2 ? signals : null;
+        }
+    },
+    {
+        name: 'PHP',
+        language: 'php',
+        framework: 'PHP',
+        confidence: 'medium',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'composer.json')) signals.push('composer.json');
+            if (fileExists(dir, 'composer.lock')) signals.push('composer.lock');
+            if (hasFilesWithExtension(dir, '.php', 2)) signals.push('*.php files');
+            return signals.length >= 1 ? signals : null;
+        }
+    },
+
+    // ── Dart / Flutter ───────────────────────────────────────────────────────
+    {
+        name: 'Dart/Flutter',
+        language: 'dart',
+        framework: 'Flutter',
+        confidence: 'high',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'pubspec.yaml')) signals.push('pubspec.yaml');
+            const pubspec = readYamlLineSafe(path.join(dir, 'pubspec.yaml'), 'flutter');
+            if (pubspec) signals.push('pubspec.yaml → flutter dependency');
+            if (dirExists(dir, 'lib')) signals.push('lib/');
+            if (dirExists(dir, 'android') || dirExists(dir, 'ios')) signals.push('android/ or ios/');
+            return fileExists(dir, 'pubspec.yaml') ? signals : null;
+        }
+    },
+
+    // ── Kotlin ───────────────────────────────────────────────────────────────
+    {
+        name: 'Kotlin/Android',
+        language: 'kotlin',
+        framework: 'Android',
+        confidence: 'high',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'build.gradle') || fileExists(dir, 'build.gradle.kts')) {
+                signals.push('build.gradle');
+            }
+            if (fileExists(dir, 'gradlew')) signals.push('gradlew');
+            if (dirExists(dir, 'app', 'src', 'main')) signals.push('app/src/main/');
+            if (hasFilesWithExtension(dir, '.kt', 2)) signals.push('*.kt files');
+            const hasAndroidManifest = fileExists(dir, 'app', 'src', 'main', 'AndroidManifest.xml');
+            if (hasAndroidManifest) signals.push('AndroidManifest.xml');
+            return (signals.includes('*.kt files') || hasAndroidManifest) ? signals : null;
+        }
+    },
+    {
+        name: 'Kotlin',
+        language: 'kotlin',
+        framework: 'Kotlin',
+        confidence: 'medium',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'build.gradle.kts')) signals.push('build.gradle.kts');
+            if (hasFilesWithExtension(dir, '.kt', 1)) signals.push('*.kt files');
+            return signals.length >= 1 ? signals : null;
+        }
+    },
+
+    // ── Java ─────────────────────────────────────────────────────────────────
+    {
+        name: 'Java/Spring Boot',
+        language: 'java',
+        framework: 'Spring Boot',
+        confidence: 'high',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'pom.xml')) signals.push('pom.xml');
+            if (fileExists(dir, 'build.gradle') || fileExists(dir, 'gradlew')) signals.push('build.gradle');
+            const pom = readFileSafeu(path.join(dir, 'pom.xml'));
+            if (pom && pom.includes('spring-boot')) signals.push('pom.xml → spring-boot');
+            if (dirExists(dir, 'src', 'main', 'java')) signals.push('src/main/java/');
+            return (signals.includes('pom.xml → spring-boot') || signals.includes('src/main/java/')) ? signals : null;
+        }
+    },
+    {
+        name: 'Java',
+        language: 'java',
+        framework: 'Java',
+        confidence: 'medium',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'pom.xml')) signals.push('pom.xml');
+            if (fileExists(dir, 'build.gradle')) signals.push('build.gradle');
+            if (hasFilesWithExtension(dir, '.java', 2)) signals.push('*.java files');
+            return signals.length >= 1 ? signals : null;
+        }
+    },
+
+    // ── C# / .NET ────────────────────────────────────────────────────────────
+    {
+        name: 'C#/.NET',
+        language: 'csharp',
+        framework: '.NET',
+        confidence: 'high',
+        check(dir) {
+            const signals = [];
+            if (hasFilesWithExtension(dir, '.csproj', 1)) signals.push('*.csproj');
+            if (hasFilesWithExtension(dir, '.sln', 1)) signals.push('*.sln');
+            if (fileExists(dir, 'global.json')) signals.push('global.json');
+            if (hasFilesWithExtension(dir, '.cs', 2)) signals.push('*.cs files');
+            return signals.length >= 1 ? signals : null;
+        }
+    },
+
+    // ── Swift / iOS ──────────────────────────────────────────────────────────
+    {
+        name: 'Swift/iOS',
+        language: 'swift',
+        framework: 'iOS/macOS',
+        confidence: 'high',
+        check(dir) {
+            const signals = [];
+            if (hasFilesWithExtension(dir, '.xcodeproj', 1)) signals.push('*.xcodeproj');
+            if (hasFilesWithExtension(dir, '.xcworkspace', 1)) signals.push('*.xcworkspace');
+            if (fileExists(dir, 'Podfile')) signals.push('Podfile');
+            if (fileExists(dir, 'Package.swift')) signals.push('Package.swift');
+            if (hasFilesWithExtension(dir, '.swift', 2)) signals.push('*.swift files');
+            return signals.length >= 1 ? signals : null;
+        }
+    },
+
+    // ── Go ───────────────────────────────────────────────────────────────────
+    {
+        name: 'Go/Gin',
+        language: 'go',
+        framework: 'Gin',
+        frameworkKey: 'go-gin',
+        confidence: 'high',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'go.mod')) {
+                signals.push('go.mod');
+                const goMod = readFileSafe(path.join(dir, 'go.mod'));
+                if (goMod && goMod.includes('github.com/gin-gonic/gin')) {
+                    signals.push('go.mod → gin-gonic/gin');
+                }
+            }
+            if (fileExists(dir, 'go.sum')) signals.push('go.sum');
+            return signals.includes('go.mod → gin-gonic/gin') ? signals : null;
+        }
+    },
+    {
+        name: 'Go',
+        language: 'go',
+        framework: 'Go',
+        frameworkKey: null,
+        confidence: 'high',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'go.mod')) signals.push('go.mod');
+            if (fileExists(dir, 'go.sum')) signals.push('go.sum');
+            if (hasFilesWithExtension(dir, '.go', 2)) signals.push('*.go files');
+            return signals.length >= 1 ? signals : null;
+        }
+    },
+
+    // ── Ruby ─────────────────────────────────────────────────────────────────
+    {
+        name: 'Ruby/Rails',
+        language: 'ruby',
+        framework: 'Rails',
+        frameworkKey: 'ruby-rails',
+        confidence: 'high',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'Gemfile')) signals.push('Gemfile');
+            if (fileExists(dir, 'config', 'application.rb')) signals.push('config/application.rb');
+            if (fileExists(dir, 'config', 'routes.rb')) signals.push('config/routes.rb');
+            if (fileExists(dir, 'Rakefile')) signals.push('Rakefile');
+            const gemfile = readFileSafe(path.join(dir, 'Gemfile'));
+            if (gemfile && gemfile.includes("gem 'rails'")) signals.push('Gemfile → rails gem');
+            return (signals.includes('config/routes.rb') || signals.includes('Gemfile → rails gem')) ? signals : null;
+        }
+    },
+    {
+        name: 'Ruby',
+        language: 'ruby',
+        framework: 'Ruby',
+        confidence: 'medium',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'Gemfile')) signals.push('Gemfile');
+            if (fileExists(dir, 'Gemfile.lock')) signals.push('Gemfile.lock');
+            if (hasFilesWithExtension(dir, '.rb', 2)) signals.push('*.rb files');
+            return signals.length >= 1 ? signals : null;
+        }
+    },
+
+    // ── Python ───────────────────────────────────────────────────────────────
+    {
+        name: 'Python/Django',
+        language: 'python',
+        framework: 'Django',
+        confidence: 'high',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'manage.py')) signals.push('manage.py');
+            if (fileExists(dir, 'requirements.txt')) signals.push('requirements.txt');
+            const req = readFileSafe(path.join(dir, 'requirements.txt'));
+            if (req && req.toLowerCase().includes('django')) signals.push('requirements.txt → django');
+            return signals.includes('manage.py') ? signals : null;
+        }
+    },
+    {
+        name: 'Python/FastAPI',
+        language: 'python',
+        framework: 'FastAPI',
+        confidence: 'high',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'requirements.txt')) {
+                signals.push('requirements.txt');
+                const req = readFileSafe(path.join(dir, 'requirements.txt'));
+                if (req && req.toLowerCase().includes('fastapi')) signals.push('requirements.txt → fastapi');
+            }
+            if (fileExists(dir, 'pyproject.toml')) {
+                signals.push('pyproject.toml');
+                const pyp = readFileSafe(path.join(dir, 'pyproject.toml'));
+                if (pyp && pyp.toLowerCase().includes('fastapi')) signals.push('pyproject.toml → fastapi');
+            }
+            return signals.some(s => s.includes('fastapi')) ? signals : null;
+        }
+    },
+    {
+        name: 'Python',
+        language: 'python',
+        framework: 'Python',
+        confidence: 'medium',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'requirements.txt')) signals.push('requirements.txt');
+            if (fileExists(dir, 'pyproject.toml')) signals.push('pyproject.toml');
+            if (fileExists(dir, 'setup.py')) signals.push('setup.py');
+            if (fileExists(dir, 'Pipfile')) signals.push('Pipfile');
+            if (hasFilesWithExtension(dir, '.py', 2)) signals.push('*.py files');
+            return signals.length >= 1 ? signals : null;
+        }
+    },
+
+    // ── TypeScript / JavaScript (Next.js, Nuxt, Angular, Vue, React, etc.) ──
+    {
+        name: 'TypeScript/Next.js',
+        language: 'typescript',
+        framework: 'Next.js',
+        confidence: 'high',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'package.json')) signals.push('package.json');
+            if (fileExists(dir, 'next.config.js') || fileExists(dir, 'next.config.ts') || fileExists(dir, 'next.config.mjs')) {
+                signals.push('next.config.*');
+            }
+            const pkg = readJsonSafe(path.join(dir, 'package.json'));
+            if (pkg && pkg.dependencies && pkg.dependencies['next']) signals.push('package.json → next');
+            return signals.includes('next.config.*') || signals.includes('package.json → next') ? signals : null;
+        }
+    },
+    {
+        name: 'TypeScript/Nuxt',
+        language: 'typescript',
+        framework: 'Nuxt',
+        confidence: 'high',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'package.json')) signals.push('package.json');
+            if (fileExists(dir, 'nuxt.config.js') || fileExists(dir, 'nuxt.config.ts')) signals.push('nuxt.config.*');
+            const pkg = readJsonSafe(path.join(dir, 'package.json'));
+            if (pkg && pkg.dependencies && (pkg.dependencies['nuxt'] || pkg.dependencies['nuxt3'])) signals.push('package.json → nuxt');
+            return signals.includes('nuxt.config.*') || signals.includes('package.json → nuxt') ? signals : null;
+        }
+    },
+    {
+        name: 'TypeScript/Angular',
+        language: 'typescript',
+        framework: 'Angular',
+        confidence: 'high',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'angular.json')) signals.push('angular.json');
+            if (fileExists(dir, 'package.json')) {
+                const pkg = readJsonSafe(path.join(dir, 'package.json'));
+                if (pkg && pkg.dependencies && pkg.dependencies['@angular/core']) signals.push('package.json → @angular/core');
+            }
+            return signals.length >= 1 ? signals : null;
+        }
+    },
+    {
+        name: 'TypeScript/NestJS',
+        language: 'typescript',
+        framework: 'NestJS',
+        confidence: 'high',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'nest-cli.json')) signals.push('nest-cli.json');
+            if (fileExists(dir, 'package.json')) {
+                const pkg = readJsonSafe(path.join(dir, 'package.json'));
+                if (pkg && pkg.dependencies && pkg.dependencies['@nestjs/core']) signals.push('package.json → @nestjs/core');
+            }
+            return signals.length >= 1 ? signals : null;
+        }
+    },
+    {
+        name: 'TypeScript/React',
+        language: 'typescript',
+        framework: 'React',
+        confidence: 'medium',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'package.json')) {
+                signals.push('package.json');
+                const pkg = readJsonSafe(path.join(dir, 'package.json'));
+                if (pkg && pkg.dependencies && pkg.dependencies['react']) signals.push('package.json → react');
+                if (pkg && pkg.dependencies && pkg.dependencies['typescript']) signals.push('package.json → typescript');
+            }
+            if (fileExists(dir, 'tsconfig.json')) signals.push('tsconfig.json');
+            return signals.includes('package.json → react') ? signals : null;
+        }
+    },
+    {
+        name: 'TypeScript',
+        language: 'typescript',
+        framework: 'TypeScript',
+        confidence: 'medium',
+        check(dir) {
+            const signals = [];
+            if (fileExists(dir, 'tsconfig.json')) signals.push('tsconfig.json');
+            if (fileExists(dir, 'package.json')) signals.push('package.json');
+            if (hasFilesWithExtension(dir, '.ts', 2)) signals.push('*.ts files');
+            return signals.length >= 1 ? signals : null;
+        }
+    },
+];
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function fileExists(dir, ...parts) {
+    try {
+        return fs.existsSync(path.join(dir, ...parts));
+    } catch {
+        return false;
+    }
+}
+
+function dirExists(dir, ...parts) {
+    try {
+        const p = path.join(dir, ...parts);
+        return fs.existsSync(p) && fs.statSync(p).isDirectory();
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Check if at least `minCount` files with the given extension exist (shallow scan + 1-level deep)
+ */
+function hasFilesWithExtension(dir, ext, minCount = 1) {
+    try {
+        let count = 0;
+        const topItems = fs.readdirSync(dir);
+        for (const item of topItems) {
+            if (item.endsWith(ext)) count++;
+            if (count >= minCount) return true;
+        }
+        // One level deeper
+        for (const item of topItems) {
+            const subDir = path.join(dir, item);
+            try {
+                if (fs.statSync(subDir).isDirectory() && !item.startsWith('.') && item !== 'node_modules' && item !== 'vendor') {
+                    const subItems = fs.readdirSync(subDir);
+                    for (const sub of subItems) {
+                        if (sub.endsWith(ext)) count++;
+                        if (count >= minCount) return true;
+                    }
+                }
+            } catch { /* skip */ }
+        }
+        return false;
+    } catch {
+        return false;
+    }
+}
+
+function readFileSafe(filePath) {
+    try {
+        return fs.readFileSync(filePath, 'utf8');
+    } catch {
+        return null;
+    }
+}
+
+function readJsonSafe(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    } catch {
+        return null;
+    }
+}
+
+/** Check if a YAML file contains a top-level key (simple line-based check) */
+function readYamlLineSafe(filePath, key) {
+    const content = readFileSafe(filePath);
+    if (!content) return null;
+    return content.split('\n').some(line => line.startsWith(key + ':')) ? key : null;
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+/**
+ * Analyze a project directory and return the best-matched language preset.
+ * Returns null if no match found (caller should fall back to 'typescript').
+ *
+ * @param {string} projectDir - Absolute path to project root
+ * @returns {DetectionResult | null}
+ */
+function detectProjectLanguage(projectDir) {
+    if (!fs.existsSync(projectDir)) return null;
+
+    for (const rule of DETECTION_RULES) {
+        try {
+            const signals = rule.check(projectDir);
+            if (signals && signals.length > 0) {
+                return {
+                    language: rule.language,
+                    framework: rule.framework,
+                    frameworkKey: rule.frameworkKey || null,
+                    confidence: rule.confidence,
+                    reason: buildReason(rule, signals),
+                    signals,
+                };
+            }
+        } catch {
+            // Skip broken checks silently
+        }
+    }
+
+    return null;
+}
+
+function buildReason(rule, signals) {
+    const sigStr = signals.slice(0, 3).join(', ');
+    return `${rule.framework} detected (${sigStr})`;
+}
+
+module.exports = { detectProjectLanguage };

package/core/scoring-service.js

@@ -22,9 +22,10 @@ class ScoringService {
     //
     this.weights = {
       // Penalty per violation type (per KLOC)
-      // Errors are 3x more severe than warnings
+      // Severity ratio: error(6) : warning(2) : info(0.5) = 12:4:1
       errorPenaltyPerKLOC: 6,      // Each error per KLOC reduces score by 6 points
       warningPenaltyPerKLOC: 2,    // Each warning per KLOC reduces score by 2 points
+      infoPenaltyPerKLOC: 0.5,     // Each info per KLOC reduces score by 0.5 points
 
       // Absolute penalty thresholds (regardless of LOC)
       // Large projects should still be penalized for raw violation counts
@@ -57,11 +58,12 @@ class ScoringService {
    * @param {Object} params
    * @param {number} params.errorCount - Number of errors found
    * @param {number} params.warningCount - Number of warnings found
+   * @param {number} params.infoCount - Number of info violations found
    * @param {number} params.rulesChecked - Number of rules checked
    * @param {number} params.loc - Total lines of code
    * @returns {number} Score between 0-100
    */
-  calculateScore({ errorCount = 0, warningCount = 0, rulesChecked = 0, loc = 0 }) {
+  calculateScore({ errorCount = 0, warningCount = 0, infoCount = 0, rulesChecked = 0, loc = 0 }) {
     // Base score starts at 100
     let score = 100;
 
@@ -72,12 +74,13 @@ class ScoringService {
     // Calculate violations per KLOC
     const errorsPerKLOC = errorCount / kloc;
     const warningsPerKLOC = warningCount / kloc;
-    const totalViolationsPerKLOC = errorsPerKLOC + warningsPerKLOC;
+    const infosPerKLOC = infoCount / kloc;
 
     // 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);
+                          (warningsPerKLOC * this.weights.warningPenaltyPerKLOC) +
+                          (infosPerKLOC * this.weights.infoPenaltyPerKLOC);
     score -= densityPenalty;
 
     // 2. Absolute penalty for projects with too many errors
@@ -195,6 +198,8 @@ class ScoringService {
   generateScoringSummary(params) {
     const score = this.calculateScore(params);
     const grade = this.getGrade(score);
+    const infoCount = params.infoCount || 0;
+    const totalViolations = params.errorCount + params.warningCount + infoCount;
 
     return {
       score,
@@ -202,10 +207,11 @@ class ScoringService {
       metrics: {
         errors: params.errorCount,
         warnings: params.warningCount,
+        infos: infoCount,
         rulesChecked: params.rulesChecked,
         linesOfCode: params.loc,
-        violationsPerKLOC: params.loc > 0 
-          ? Math.round(((params.errorCount + params.warningCount) / params.loc * 1000) * 10) / 10
+        violationsPerKLOC: params.loc > 0
+          ? Math.round((totalViolations / params.loc * 1000) * 10) / 10
           : 0
       }
     };

package/core/summary-report-service.js

@@ -247,11 +247,12 @@ class SummaryReportService {
       total_violations: violations.length,
       error_count: scoringSummary.metrics.errors,
       warning_count: scoringSummary.metrics.warnings,
-      info_count: 0, // Reserved for future use
+      info_count: scoringSummary.metrics.infos || 0,
       lines_of_code: scoringSummary.metrics.linesOfCode,
       files_analyzed: options.filesAnalyzed || 0,
       sunlint_version: options.version || this.version,
       analysis_duration_ms: options.duration || 0,
+      scoring_mode: options.scoringMode || 'project',
       violations: violationsSummary,
 
       // Additional metadata for backwards compatibility
@@ -259,7 +260,8 @@ class SummaryReportService {
         generated_at: new Date().toISOString(),
         tool: 'SunLint',
         version: options.version || this.version,
-        analysis_duration_ms: options.duration || 0
+        analysis_duration_ms: options.duration || 0,
+        scoring_mode: options.scoringMode || 'project'
       },
       quality: {
         score: scoringSummary.score,
@@ -384,15 +386,18 @@ class SummaryReportService {
     const totalViolations = summaryReport.total_violations || 0;
     const errorCount = summaryReport.error_count || 0;
     const warningCount = summaryReport.warning_count || 0;
+    const infoCount = summaryReport.info_count || 0;
     const violationsByRule = summaryReport.violations || [];
     const violationsPerKLOC = summaryReport.quality?.metrics?.violationsPerKLOC || 0;
+    const scoringMode = summaryReport.scoring_mode || 'project';
 
     let output = '\n📊 Quality Summary Report\n';
     output += '━'.repeat(50) + '\n';
-    output += `📈 Quality Score: ${score} (Grade: ${grade})\n`;
+    output += `📈 Quality Score: ${score} (Grade: ${grade})`;
+    output += scoringMode === 'pr' ? ' [PR mode]\n' : '\n';
     output += `📁 Files Analyzed: ${filesAnalyzed}\n`;
     output += `📏 Lines of Code: ${linesOfCode.toLocaleString()}\n`;
-    output += `⚠️  Total Violations: ${totalViolations} (${errorCount} errors, ${warningCount} warnings)\n`;
+    output += `⚠️  Total Violations: ${totalViolations} (${errorCount} errors, ${warningCount} warnings, ${infoCount} info)\n`;
     output += `📊 Violations per KLOC: ${violationsPerKLOC}\n`;
 
     if (violationsByRule.length > 0) {