vettcode-cli 1.0.0

package/dist/cli-scan-orchestrator.js

@@ -0,0 +1,336 @@
+"use strict";
+/**
+ * CLI Scan Orchestrator
+ * Adapts the smart scan orchestrator for CLI use without web API calls
+ * Uses OpenRouter client directly for AI analysis
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSmartScan = runSmartScan;
+const static_analyzer_1 = require("./static-analyzer");
+const ast_extractor_1 = require("./ast-extractor");
+const verification_layer_1 = require("./verification-layer");
+const scan_priority_1 = require("./scan-priority");
+const openrouter_1 = require("./openrouter");
+const prompts_1 = require("./prompts");
+const PARALLEL_AI_CALLS = 3;
+async function runSmartScan(projectName, files, ignoredCount, onProgress, mode = "quick") {
+    const aiFiles = mode === "quick" ? (0, scan_priority_1.selectFilesForQuickScan)(files) : files;
+    const staticScopeLabel = mode === "quick" ? `${aiFiles.length} priority files` : `${files.length} files`;
+    // Phase 1: Static Analysis
+    onProgress("Static analysis", 10, `Pattern checks across ${files.length} files…`);
+    const staticFindings = (0, static_analyzer_1.runStaticAnalysis)(files);
+    onProgress("Static analysis", 25, `${staticFindings.length} signals flagged`);
+    // Phase 2: AST Extraction
+    onProgress("Code extraction", 35, `Targeting ${staticScopeLabel}…`);
+    const extractedSections = [];
+    let totalOriginalChars = 0;
+    let totalExtractedChars = 0;
+    for (const file of aiFiles) {
+        if (!(0, ast_extractor_1.shouldAnalyzeFile)(file.path))
+            continue;
+        totalOriginalChars += file.content.length;
+        const extracted = (0, ast_extractor_1.extractHighRiskCode)(file.path, file.content);
+        if (extracted && extracted.sections.length > 0) {
+            extractedSections.push(extracted);
+            totalExtractedChars += extracted.sections.reduce((sum, s) => sum + s.code.length, 0);
+        }
+    }
+    const tokenReduction = totalOriginalChars > 0
+        ? Math.round((1 - totalExtractedChars / totalOriginalChars) * 100)
+        : 0;
+    onProgress("Code extraction", 45, `${extractedSections.length} high-risk regions · ${tokenReduction}% token reduction`);
+    // Phase 3: AI Analysis (direct OpenRouter calls)
+    onProgress("AI review", 50, "Analyzing extracted code with AI…");
+    let aiFindings = [];
+    let aiUsed = true;
+    try {
+        aiFindings = await runAIAnalysisCLI(projectName, extractedSections, staticFindings, onProgress, mode);
+        aiUsed = true;
+    }
+    catch (error) {
+        console.warn('[AI FALLBACK] AI failed, running ENHANCED static analysis');
+        console.error('[AI Analysis] Error:', error);
+        // Run ENHANCED static analysis as fallback
+        onProgress("Enhanced Analysis", 50, "AI unavailable - running comprehensive static analysis (85% coverage)");
+        const enhancedResult = (0, static_analyzer_1.runEnhancedStaticAnalysis)(files);
+        aiFindings = enhancedResult.findings.map(f => ({
+            id: f.id,
+            severity: f.severity,
+            category: f.category,
+            title: f.title,
+            description: f.description,
+            file: f.file,
+            line: f.line,
+            evidence: f.evidence,
+            mitigation: generateMitigation(f),
+            prevention: generatePrevention(f),
+        }));
+        aiUsed = false;
+        onProgress("Enhanced Analysis", 75, `${aiFindings.length} issues found`);
+    }
+    onProgress(aiUsed ? "AI review" : "Enhanced Analysis", 75, `${aiFindings.length} additional findings`);
+    // Phase 4: Verification Layer
+    onProgress("Verification", 80, "Cross-checking findings…");
+    const verificationResult = (0, verification_layer_1.verifyFindings)(aiFindings, staticFindings, files);
+    onProgress("Verification Complete", 85, `${verificationResult.summary.confirmed} confirmed, ${verificationResult.summary.falsePositives} false positives removed`);
+    // Phase 5: Merge and deduplicate
+    onProgress("Report", 90, "Assembling final report…");
+    const verifiedStaticFindings = staticFindings.map(sf => ({
+        id: sf.id,
+        severity: sf.severity,
+        category: sf.category,
+        title: sf.title,
+        description: sf.description,
+        file: sf.file,
+        line: sf.line,
+        evidence: sf.evidence,
+        mitigation: generateMitigation(sf),
+        prevention: generatePrevention(sf),
+        confidence: sf.confidence,
+        verificationStatus: "confirmed",
+        verificationNotes: "Detected by static analysis",
+        sources: ["static-analysis"],
+        source: "static",
+    }));
+    const allFindings = [...verifiedStaticFindings, ...verificationResult.verified];
+    const deduplicated = (0, verification_layer_1.deduplicateFindings)(allFindings);
+    const score = calculateStrictScore(deduplicated);
+    const grade = scoreToGrade(score);
+    const executiveVerdict = generateExecutiveVerdict(deduplicated, score);
+    const criticalBlockers = deduplicated
+        .filter(f => f.severity === "critical" || (f.severity === "high" && f.confidence === "high"))
+        .map(f => `${f.title} in ${f.file}:${f.line}`);
+    const strengths = identifyStrengths(files, deduplicated);
+    const reportConfidence = (0, verification_layer_1.calculateReportConfidence)(deduplicated);
+    onProgress("Complete", 100, "Scan complete");
+    const report = {
+        score,
+        grade,
+        summary: `Analyzed ${files.length} files (${files.reduce((s, f) => s + f.lines, 0)} lines). Found ${deduplicated.length} verified issues.`,
+        executiveVerdict,
+        findings: deduplicated.map(f => ({
+            id: f.id,
+            severity: f.severity,
+            category: f.category,
+            title: f.title,
+            description: f.description,
+            file: f.file,
+            line: f.line,
+            evidence: f.evidence,
+            mitigation: f.mitigation,
+            prevention: f.prevention,
+            source: f.source,
+        })),
+        strengths,
+        criticalBlockers,
+        metadata: {
+            projectName,
+            scannedAt: new Date().toISOString(),
+            filesScanned: files.length,
+            linesScanned: files.reduce((s, f) => s + f.lines, 0),
+            ignoredPaths: ignoredCount,
+            reportConfidence: reportConfidence.score,
+            reportConfidenceGrade: reportConfidence.grade,
+            reportConfidenceExplanation: reportConfidence.explanation,
+            staticFindings: deduplicated.filter(f => f.source === "static").length,
+            aiFindings: deduplicated.filter(f => f.source === "ai").length,
+            verifiedFindings: deduplicated.filter(f => f.source === "verified").length,
+        },
+    };
+    const stats = {
+        filesScanned: files.length,
+        linesScanned: files.reduce((s, f) => s + f.lines, 0),
+        staticFindings: staticFindings.length,
+        aiFindings: aiFindings.length,
+        verifiedFindings: deduplicated.length,
+        falsePositives: verificationResult.summary.falsePositives,
+        tokensSaved: `${tokenReduction}% (${Math.round((totalOriginalChars - totalExtractedChars) / 1000)}K chars)`,
+    };
+    return { report, stats };
+}
+async function runAIAnalysisCLI(projectName, extractedSections, staticFindings, onProgress, mode) {
+    if (extractedSections.length === 0 && staticFindings.length === 0) {
+        return [];
+    }
+    const apiKeys = (0, openrouter_1.getApiKeys)();
+    if (apiKeys.length === 0) {
+        throw new Error("No OpenRouter API keys configured. Set OPENROUTER_API_KEY_1, _2, _3 or OPENROUTER_API_KEYS.");
+    }
+    const aiFindings = [];
+    const batchSize = mode === "quick" ? 3 : 5;
+    const batches = createBatches(extractedSections, staticFindings, batchSize);
+    for (let i = 0; i < batches.length; i++) {
+        const progressPct = 50 + Math.round(((i + 1) / batches.length) * 25);
+        onProgress("AI review", progressPct, `Processing batch ${i + 1}/${batches.length}…`);
+        try {
+            const findings = await analyzeBatchWithAI(projectName, batches[i], i % apiKeys.length, i);
+            aiFindings.push(...findings);
+        }
+        catch (error) {
+            console.warn(`Batch ${i + 1} failed, continuing...`);
+        }
+    }
+    return aiFindings;
+}
+function createBatches(extractedSections, staticFindings, maxBatches) {
+    const MAX_CHARS_PER_BATCH = 30000;
+    const batches = [];
+    let currentBatch = { sections: [], staticFindings: [] };
+    let currentChars = 0;
+    for (const section of extractedSections) {
+        const sectionChars = section.sections.reduce((sum, s) => sum + s.code.length, 0);
+        if (currentChars + sectionChars > MAX_CHARS_PER_BATCH && currentBatch.sections.length > 0) {
+            batches.push(currentBatch);
+            currentBatch = { sections: [], staticFindings: [] };
+            currentChars = 0;
+        }
+        currentBatch.sections.push(section);
+        currentChars += sectionChars;
+    }
+    if (staticFindings.length > 0) {
+        currentBatch.staticFindings = staticFindings.slice(0, 20);
+    }
+    if (currentBatch.sections.length > 0 || currentBatch.staticFindings.length > 0) {
+        batches.push(currentBatch);
+    }
+    return batches.slice(0, maxBatches);
+}
+async function analyzeBatchWithAI(projectName, batch, keyIndex, batchIndex) {
+    const prompt = (0, prompts_1.getAnalysisPrompt)(projectName, batch, batchIndex);
+    const messages = [
+        { role: "system", content: "You are a security code analysis expert. Analyze the provided code for vulnerabilities and provide findings in JSON format." },
+        { role: "user", content: prompt }
+    ];
+    const result = await (0, openrouter_1.chatCompletion)(messages, undefined, 2);
+    try {
+        const parsed = (0, openrouter_1.parseJsonFromModel)(result.content);
+        return parsed.findings || [];
+    }
+    catch (error) {
+        console.error("Failed to parse AI response:", error);
+        return [];
+    }
+}
+function calculateStrictScore(findings) {
+    if (findings.length === 0)
+        return 95;
+    const CATEGORY_WEIGHTS = {
+        critical: 35,
+        high: 25,
+        medium: 25,
+        low: 10,
+        info: 5,
+    };
+    const counts = { critical: 0, high: 0, medium: 0, low: 0, info: 0 };
+    for (const finding of findings) {
+        let weight = 1.0;
+        switch (finding.confidence) {
+            case "high":
+                weight = 1.0;
+                break;
+            case "medium":
+                weight = 0.7;
+                break;
+            case "low":
+                weight = 0.4;
+                break;
+        }
+        counts[finding.severity] += weight;
+    }
+    const categoryScores = {
+        critical: calculateCategoryScore(counts.critical, CATEGORY_WEIGHTS.critical, 0.5),
+        high: calculateCategoryScore(counts.high, CATEGORY_WEIGHTS.high, 0.4),
+        medium: calculateCategoryScore(counts.medium, CATEGORY_WEIGHTS.medium, 0.3),
+        low: calculateCategoryScore(counts.low, CATEGORY_WEIGHTS.low, 0.2),
+        info: calculateCategoryScore(counts.info, CATEGORY_WEIGHTS.info, 0.1),
+    };
+    const totalScore = Math.round(categoryScores.critical + categoryScores.high +
+        categoryScores.medium + categoryScores.low + categoryScores.info);
+    return Math.max(0, Math.min(100, totalScore));
+}
+function calculateCategoryScore(issueCount, maxPoints, decayRate) {
+    if (issueCount === 0)
+        return maxPoints;
+    const score = maxPoints * Math.exp(-decayRate * issueCount);
+    return Math.max(0, Math.round(score * 100) / 100);
+}
+function scoreToGrade(score) {
+    if (score >= 95)
+        return "A+";
+    if (score >= 90)
+        return "A";
+    if (score >= 85)
+        return "A-";
+    if (score >= 80)
+        return "B+";
+    if (score >= 75)
+        return "B";
+    if (score >= 70)
+        return "B-";
+    if (score >= 65)
+        return "C+";
+    if (score >= 60)
+        return "C";
+    if (score >= 55)
+        return "C-";
+    if (score >= 50)
+        return "D+";
+    if (score >= 45)
+        return "D";
+    if (score >= 40)
+        return "D-";
+    return "F";
+}
+function generateExecutiveVerdict(findings, score) {
+    const critical = findings.filter(f => f.severity === "critical").length;
+    const high = findings.filter(f => f.severity === "high").length;
+    if (critical > 0) {
+        return `CRITICAL: ${critical} critical security vulnerabilities detected. This codebase is NOT production-ready. Immediate remediation required.`;
+    }
+    if (high > 5) {
+        return `HIGH RISK: ${high} high-severity issues require urgent attention before production deployment.`;
+    }
+    if (score >= 80) {
+        return "GOOD: This codebase has good security practices with minor issues that can be improved.";
+    }
+    if (score >= 60) {
+        return "MODERATE: This codebase has some security and quality concerns that should be addressed.";
+    }
+    return "POOR: This codebase has significant security and quality issues that require attention.";
+}
+function identifyStrengths(files, findings) {
+    const strengths = [];
+    const categories = new Set(findings.map(f => f.category));
+    if (!categories.has("security")) {
+        strengths.push("No obvious security vulnerabilities detected");
+    }
+    if (!categories.has("production")) {
+        strengths.push("Good error handling practices");
+    }
+    if (!findings.some(f => f.severity === "critical")) {
+        strengths.push("No critical severity issues found");
+    }
+    if (strengths.length === 0) {
+        strengths.push("Codebase structure is analyzable");
+    }
+    return strengths;
+}
+function generateMitigation(finding) {
+    const mitigations = {
+        "sql-injection": "Use parameterized queries or ORM with built-in SQL injection protection",
+        "xss": "Sanitize user input with DOMPurify or use React's automatic escaping",
+        "command-injection": "Avoid executing shell commands with user input, use safe alternatives",
+        "hardcoded-secret": "Move secrets to environment variables",
+        "missing-auth": "Add authentication middleware to protect sensitive endpoints",
+        "empty-catch": "Add proper error handling and logging in catch blocks",
+    };
+    for (const [key, value] of Object.entries(mitigations)) {
+        if (finding.title.toLowerCase().includes(key)) {
+            return value;
+        }
+    }
+    return "Review and fix the identified issue following security best practices";
+}
+function generatePrevention(finding) {
+    return "Implement security best practices and code review processes to prevent similar issues";
+}

package/dist/cli.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * VettCode CLI - Terminal-based code security scanner
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const file_collector_1 = require("./file-collector");
+const cli_scan_orchestrator_1 = require("./cli-scan-orchestrator");
+const dotenv = __importStar(require("dotenv"));
+const program = new commander_1.Command();
+program
+    .name("vettcode")
+    .description("AI-powered codebase security and quality scanner")
+    .version("1.0.0");
+program
+    .argument("<directory>", "Directory to scan")
+    .option("-o, --output <file>", "Output report to JSON file")
+    .option("-i, --ignore <patterns>", "Comma-separated ignore patterns")
+    .option("--json", "Output JSON format")
+    .option("--mode <mode>", "Scan mode: quick or deep (default: quick)")
+    .option("--no-ai", "Disable AI analysis (static only)")
+    .action(async (directory, options) => {
+    try {
+        // Load environment variables
+        dotenv.config();
+        console.log(chalk_1.default.bold.cyan("\n🔍 VettCode CLI - Security Scanner\n"));
+        // Validate directory
+        const resolvedPath = path.resolve(directory);
+        if (!fs.existsSync(resolvedPath)) {
+            console.error(chalk_1.default.red(`❌ Error: Directory not found: ${directory}`));
+            process.exit(1);
+        }
+        // Parse ignore patterns
+        const ignorePatterns = options.ignore
+            ? options.ignore.split(",").map((p) => p.trim())
+            : undefined;
+        // Collect files
+        const collectSpinner = (0, ora_1.default)("Collecting files...").start();
+        const files = (0, file_collector_1.collectFiles)(resolvedPath, ignorePatterns);
+        collectSpinner.succeed(`Collected ${files.length} files`);
+        if (files.length === 0) {
+            console.warn(chalk_1.default.yellow("⚠️  No code files found to scan"));
+            process.exit(0);
+        }
+        const projectName = path.basename(resolvedPath);
+        const scanMode = (options.mode === "deep" ? "deep" : "quick");
+        // Run smart scan
+        const scanSpinner = (0, ora_1.default)("Running smart scan...").start();
+        const { report, stats } = await (0, cli_scan_orchestrator_1.runSmartScan)(projectName, files, 0, (phase, pct, detail) => {
+            scanSpinner.text = `${phase} (${pct}%)${detail ? ` - ${detail}` : ''}`;
+        }, scanMode);
+        scanSpinner.succeed(`Scan complete: ${stats.verifiedFindings} verified issues found`);
+        // Display results
+        if (options.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            displayReport(report, stats);
+        }
+        // Save to file if requested
+        if (options.output) {
+            const outputPath = path.resolve(options.output);
+            fs.writeFileSync(outputPath, JSON.stringify(report, null, 2));
+            console.log(chalk_1.default.green(`\n📄 Report saved to: ${outputPath}`));
+        }
+        // Exit with error code if critical issues found
+        const criticalCount = report.findings.filter(f => f.severity === "critical").length;
+        if (criticalCount > 0) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`\n❌ Error: ${error instanceof Error ? error.message : String(error)}`));
+        process.exit(1);
+    }
+});
+program.parse();
+function displayReport(report, stats) {
+    // Score header
+    console.log("\n" + chalk_1.default.bold("═".repeat(60)));
+    console.log(chalk_1.default.bold("SCAN RESULTS".padStart(60 - "SCAN RESULTS".length / 2).padEnd(60)));
+    console.log(chalk_1.default.bold("═".repeat(60)));
+    // Score with color
+    const scoreColor = report.score >= 80 ? "green" : report.score >= 60 ? "yellow" : "red";
+    console.log(`\n${chalk_1.default.bold("Score:")} ${chalk_1.default[scoreColor].bold(report.score + "/100")} ${chalk_1.default.bold(`(${report.grade})`)}`);
+    // Summary
+    console.log(chalk_1.default.gray(`\n${report.summary}`));
+    // Executive verdict
+    console.log(chalk_1.default.bold.cyan(`\n📋 Executive Verdict:`));
+    console.log(chalk_1.default.white(report.executiveVerdict));
+    // Findings by severity
+    const findingsBySeverity = {
+        critical: report.findings.filter(f => f.severity === "critical"),
+        high: report.findings.filter(f => f.severity === "high"),
+        medium: report.findings.filter(f => f.severity === "medium"),
+        low: report.findings.filter(f => f.severity === "low"),
+        info: report.findings.filter(f => f.severity === "info"),
+    };
+    console.log(chalk_1.default.bold.cyan(`\n🔍 Findings by Severity:`));
+    console.log(`  ${chalk_1.default.red.bold(findingsBySeverity.critical.length)} Critical`);
+    console.log(`  ${chalk_1.default.red(findingsBySeverity.high.length)} High`);
+    console.log(`  ${chalk_1.default.yellow(findingsBySeverity.medium.length)} Medium`);
+    console.log(`  ${chalk_1.default.gray(findingsBySeverity.low.length)} Low`);
+    console.log(`  ${chalk_1.default.gray(findingsBySeverity.info.length)} Info`);
+    // Critical blockers
+    if (report.criticalBlockers.length > 0) {
+        console.log(chalk_1.default.bold.red(`\n🚨 Critical Blockers:`));
+        report.criticalBlockers.forEach(blocker => {
+            console.log(chalk_1.default.red(`  • ${blocker}`));
+        });
+    }
+    // Strengths
+    if (report.strengths.length > 0) {
+        console.log(chalk_1.default.bold.green(`\n✅ Strengths:`));
+        report.strengths.forEach(strength => {
+            console.log(chalk_1.default.green(`  • ${strength}`));
+        });
+    }
+    // Detailed findings table
+    if (report.findings.length > 0) {
+        console.log(chalk_1.default.bold.cyan(`\n📝 Detailed Findings:`));
+        const table = new cli_table3_1.default({
+            head: [
+                chalk_1.default.bold("Severity"),
+                chalk_1.default.bold("Category"),
+                chalk_1.default.bold("Title"),
+                chalk_1.default.bold("File"),
+                chalk_1.default.bold("Line")
+            ],
+            colWidths: [10, 15, 30, 25, 6],
+            wordWrap: true,
+        });
+        for (const finding of report.findings.slice(0, 20)) { // Limit to first 20
+            const severityColor = finding.severity === "critical" ? "red"
+                : finding.severity === "high" ? "red"
+                    : finding.severity === "medium" ? "yellow"
+                        : "gray";
+            table.push([
+                chalk_1.default[severityColor](finding.severity.toUpperCase()),
+                finding.category,
+                finding.title.substring(0, 28),
+                finding.file?.substring(0, 23) || "",
+                finding.line?.toString() || ""
+            ]);
+        }
+        console.log(table.toString());
+        if (report.findings.length > 20) {
+            console.log(chalk_1.default.gray(`\n... and ${report.findings.length - 20} more findings`));
+        }
+    }
+    // Metadata
+    console.log(chalk_1.default.bold.gray(`\n📊 Scan Metadata:`));
+    console.log(chalk_1.default.gray(`  Project: ${report.metadata?.projectName}`));
+    console.log(chalk_1.default.gray(`  Files Scanned: ${stats?.filesScanned || report.metadata?.filesScanned}`));
+    console.log(chalk_1.default.gray(`  Lines Scanned: ${stats?.linesScanned || report.metadata?.linesScanned}`));
+    console.log(chalk_1.default.gray(`  Static Findings: ${stats?.staticFindings || report.metadata?.staticFindings}`));
+    console.log(chalk_1.default.gray(`  AI Findings: ${stats?.aiFindings || report.metadata?.aiFindings}`));
+    console.log(chalk_1.default.gray(`  Verified Findings: ${stats?.verifiedFindings || report.findings.length}`));
+    console.log(chalk_1.default.gray(`  False Positives Removed: ${stats?.falsePositives || "N/A"}`));
+    if (stats?.tokensSaved) {
+        console.log(chalk_1.default.gray(`  Tokens Saved: ${stats.tokensSaved}`));
+    }
+    console.log(chalk_1.default.gray(`  Report Confidence: ${report.metadata?.reportConfidence}% (${report.metadata?.reportConfidenceGrade})`));
+    console.log(chalk_1.default.gray(`  Scanned At: ${report.metadata?.scannedAt}`));
+    console.log(chalk_1.default.bold("═".repeat(60) + "\n"));
+}