@reliverse/dler 2.0.0 → 2.0.1

package/dist/cmds/perf/reporters/console.js

@@ -0,0 +1,257 @@
+import { logger } from "@reliverse/dler-logger";
+import {
+  formatBottleneckType,
+  formatBytes,
+  formatDuration,
+  formatNumber,
+  formatPercentage,
+  formatRelativeChange,
+  formatSeverity,
+  formatTable,
+  truncatePath
+} from "../utils/formatter.js";
+export class ConsoleReporter {
+  verbose;
+  constructor(verbose = false) {
+    this.verbose = verbose;
+  }
+  report(report) {
+    logger.log("\u2501".repeat(80));
+    logger.log("\u{1F4CA} Performance Analysis Report");
+    logger.log("\u2501".repeat(80));
+    if (report.benchmark) {
+      this.reportBenchmark(report.benchmark);
+    }
+    if (report.bundleAnalysis) {
+      this.reportBundleAnalysis(report.bundleAnalysis);
+    }
+    if (report.fileSystemAnalysis) {
+      this.reportFileSystemAnalysis(report.fileSystemAnalysis);
+    }
+    if (report.monorepoAnalysis) {
+      this.reportMonorepoAnalysis(report.monorepoAnalysis);
+    }
+    if (report.baseline) {
+      this.reportBaselineComparison(report.baseline);
+    }
+    logger.log("\u2501".repeat(80));
+  }
+  reportBenchmark(result) {
+    logger.log("\n\u{1F680} Command Benchmark Results");
+    logger.log("\u2500".repeat(40));
+    logger.log(`Command: ${result.command}`);
+    logger.log(`Runs: ${result.runs} (${result.warmup} warmup)`);
+    logger.log(`Concurrency: ${result.concurrency}`);
+    logger.log(`Success: ${result.success ? "\u2705" : "\u274C"}`);
+    if (!result.success && result.error) {
+      logger.error(`Error: ${result.error}`);
+    }
+    logger.log("\n\u23F1\uFE0F  Timing Statistics:");
+    logger.log(`   Mean: ${formatDuration(result.statistics.mean)}`);
+    logger.log(`   Median: ${formatDuration(result.statistics.median)}`);
+    logger.log(`   Min: ${formatDuration(result.statistics.min)}`);
+    logger.log(`   Max: ${formatDuration(result.statistics.max)}`);
+    logger.log(`   P95: ${formatDuration(result.statistics.p95)}`);
+    logger.log(`   P99: ${formatDuration(result.statistics.p99)}`);
+    logger.log(
+      `   Std Dev: ${formatDuration(result.statistics.standardDeviation)}`
+    );
+    logger.log(
+      `   CV: ${(result.statistics.coefficientOfVariation * 100).toFixed(2)}%`
+    );
+    logger.log("\n\u{1F4BE} Memory Statistics:");
+    logger.log(`   Peak RSS: ${formatBytes(result.memory.peak.rss)}`);
+    logger.log(`   Avg RSS: ${formatBytes(result.memory.average.rss)}`);
+    logger.log(`   Peak Heap: ${formatBytes(result.memory.peak.heapUsed)}`);
+    logger.log(`   Avg Heap: ${formatBytes(result.memory.average.heapUsed)}`);
+    logger.log(`   Growth: ${formatBytes(result.memory.growth)}`);
+    if (this.verbose && result.measurements.length > 0) {
+      logger.log("\n\u{1F4CB} Individual Runs:");
+      const headers = ["Run", "Duration", "RSS", "Heap", "Status"];
+      const rows = result.measurements.map((m, i) => [
+        (i + 1).toString(),
+        formatDuration(m.duration),
+        formatBytes(m.memory.rss),
+        formatBytes(m.memory.heapUsed),
+        m.success ? "\u2705" : "\u274C"
+      ]);
+      logger.log(formatTable(headers, rows));
+    }
+  }
+  reportBundleAnalysis(result) {
+    logger.log("\n\u{1F4E6} Bundle Analysis Results");
+    logger.log("\u2500".repeat(40));
+    logger.log(`Target: ${result.target}`);
+    logger.log(`Total Size: ${formatBytes(result.totalSize)}`);
+    logger.log(`File Count: ${formatNumber(result.fileCount)}`);
+    logger.log(
+      `Compression Potential: ${result.compressionPotential.toFixed(1)}%`
+    );
+    if (result.largestFiles.length > 0) {
+      logger.log("\n\u{1F4C1} Largest Files:");
+      const headers = ["File", "Size", "Percentage", "Type"];
+      const rows = result.largestFiles.map((file) => [
+        truncatePath(file.path, 50),
+        formatBytes(file.size),
+        formatPercentage(file.percentage, 100),
+        file.type
+      ]);
+      logger.log(formatTable(headers, rows));
+    }
+    if (result.modules.length > 0) {
+      logger.log("\n\u{1F517} Top Modules:");
+      const headers = ["Module", "Size", "Percentage", "Type"];
+      const rows = result.modules.map((module) => [
+        truncatePath(module.name, 50),
+        formatBytes(module.size),
+        formatPercentage(module.percentage, 100),
+        module.isExternal ? "External" : "Internal"
+      ]);
+      logger.log(formatTable(headers, rows));
+    }
+    if (result.duplicates.length > 0) {
+      logger.log("\n\u{1F504} Duplicate Dependencies:");
+      const headers = ["Module", "Count", "Total Size", "Locations"];
+      const rows = result.duplicates.map((dup) => [
+        truncatePath(dup.name, 30),
+        dup.count.toString(),
+        formatBytes(dup.totalSize),
+        dup.locations.length.toString()
+      ]);
+      logger.log(formatTable(headers, rows));
+    }
+  }
+  reportFileSystemAnalysis(result) {
+    logger.log("\n\u{1F4C1} File System Analysis Results");
+    logger.log("\u2500".repeat(40));
+    logger.log(`Target: ${result.target}`);
+    logger.log(`Total Files: ${formatNumber(result.totalFiles)}`);
+    logger.log(`Total Size: ${formatBytes(result.totalSize)}`);
+    logger.log(`Directories: ${formatNumber(result.directoryCount)}`);
+    logger.log(`Max Depth: ${result.maxDepth}`);
+    logger.log(
+      `Compression Potential: ${result.compressionPotential.toFixed(1)}%`
+    );
+    if (result.largestFiles.length > 0) {
+      logger.log("\n\u{1F4C4} Largest Files:");
+      const headers = ["File", "Size", "Percentage", "Type"];
+      const rows = result.largestFiles.map((file) => [
+        truncatePath(file.path, 50),
+        formatBytes(file.size),
+        formatPercentage(file.percentage, 100),
+        file.type
+      ]);
+      logger.log(formatTable(headers, rows));
+    }
+    if (result.largestDirectories.length > 0) {
+      logger.log("\n\u{1F4C2} Largest Directories:");
+      const headers = ["Directory", "Size", "Files", "Depth"];
+      const rows = result.largestDirectories.map((dir) => [
+        truncatePath(dir.path, 50),
+        formatBytes(dir.size),
+        formatNumber(dir.fileCount),
+        dir.depth.toString()
+      ]);
+      logger.log(formatTable(headers, rows));
+    }
+    if (result.fileTypes.length > 0) {
+      logger.log("\n\u{1F4CA} File Type Distribution:");
+      const headers = ["Type", "Count", "Size", "Percentage"];
+      const rows = result.fileTypes.map((type) => [
+        type.extension || "no-extension",
+        formatNumber(type.count),
+        formatBytes(type.totalSize),
+        formatPercentage(type.percentage, 100)
+      ]);
+      logger.log(formatTable(headers, rows));
+    }
+  }
+  reportMonorepoAnalysis(result) {
+    logger.log("\n\u{1F3D7}\uFE0F  Monorepo Analysis Results");
+    logger.log("\u2500".repeat(40));
+    logger.log(`Packages: ${formatNumber(result.packages.length)}`);
+    logger.log(
+      `Dependencies: ${formatNumber(result.dependencies.edges.length)}`
+    );
+    logger.log(`Circular Dependencies: ${result.circularDependencies.length}`);
+    logger.log(`Suggested Concurrency: ${result.suggestedConcurrency}`);
+    if (result.buildOrder.length > 0) {
+      logger.log("\n\u{1F504} Build Order:");
+      const levels = result.dependencies.levels;
+      for (let i = 0; i < levels.length; i++) {
+        const level = levels[i];
+        logger.log(`   Level ${i + 1}: ${level.join(", ")}`);
+      }
+    }
+    if (result.criticalPath.length > 0) {
+      logger.log("\n\u{1F3AF} Critical Path:");
+      logger.log(`   ${result.criticalPath.slice(0, 10).join(" \u2192 ")}`);
+      if (result.criticalPath.length > 10) {
+        logger.log(`   ... and ${result.criticalPath.length - 10} more`);
+      }
+    }
+    if (result.circularDependencies.length > 0) {
+      logger.log("\n\u{1F504} Circular Dependencies:");
+      for (const circular of result.circularDependencies) {
+        logger.log(
+          `   ${formatSeverity(circular.severity)} ${circular.cycle.join(" \u2192 ")}`
+        );
+      }
+    }
+    if (result.bottlenecks.length > 0) {
+      logger.log("\n\u26A0\uFE0F  Bottlenecks:");
+      const headers = ["Package", "Type", "Impact", "Suggestion"];
+      const rows = result.bottlenecks.map((bottleneck) => [
+        bottleneck.package,
+        formatBottleneckType(bottleneck.type),
+        bottleneck.impact.toString(),
+        bottleneck.suggestion
+      ]);
+      logger.log(formatTable(headers, rows));
+    }
+    if (this.verbose) {
+      logger.log("\n\u{1F4E6} Package Details:");
+      const headers = ["Package", "Dependencies", "Dependents", "Type"];
+      const rows = result.packages.map((pkg) => [
+        pkg.name,
+        pkg.dependencies.length.toString(),
+        pkg.dependents.length.toString(),
+        pkg.dependencies.length > 10 ? "Heavy" : "Light"
+      ]);
+      logger.log(formatTable(headers, rows));
+    }
+  }
+  reportBaselineComparison(baseline) {
+    if (!baseline?.exists) return;
+    logger.log("\n\u{1F4C8} Baseline Comparison");
+    logger.log("\u2500".repeat(40));
+    if (baseline.improvement !== void 0) {
+      logger.log(
+        `Performance: ${formatRelativeChange(0, baseline.improvement)}`
+      );
+    }
+    if (baseline.regression !== void 0) {
+      logger.log(
+        `Performance: ${formatRelativeChange(0, -baseline.regression)}`
+      );
+    }
+    if (baseline.changes) {
+      const changes = baseline.changes;
+      if (changes.duration !== void 0) {
+        logger.log(`Duration: ${formatRelativeChange(0, changes.duration)}`);
+      }
+      if (changes.memory !== void 0) {
+        logger.log(`Memory: ${formatRelativeChange(0, changes.memory)}`);
+      }
+      if (changes.size !== void 0) {
+        logger.log(`Size: ${formatRelativeChange(0, changes.size)}`);
+      }
+      if (changes.files !== void 0) {
+        logger.log(`Files: ${formatRelativeChange(0, changes.files)}`);
+      }
+    }
+  }
+}
+export const createConsoleReporter = (verbose = false) => {
+  return new ConsoleReporter(verbose);
+};

package/dist/cmds/perf/reporters/html.d.ts

@@ -0,0 +1,27 @@
+import type { PerfReport } from "../types.js";
+export declare class HtmlReporter {
+    private outputPath?;
+    constructor(outputPath?: string);
+    report(report: PerfReport): void;
+    private generateHtml;
+    private generateBenchmarkSection;
+    private generateBundleAnalysisSection;
+    private generateFileSystemAnalysisSection;
+    private generateMonorepoAnalysisSection;
+    private generateBaselineComparisonSection;
+    private generateFileTable;
+    private generateModuleTable;
+    private generateDuplicateTable;
+    private generateDirectoryTable;
+    private generateFileTypeTable;
+    private generateBuildOrderSection;
+    private generateCircularDependenciesSection;
+    private generateBottlenecksSection;
+    private generateTimingChart;
+    private truncatePath;
+    private getStyles;
+    private getScripts;
+    static save(report: PerfReport, outputPath: string): void;
+    static print(report: PerfReport): void;
+}
+export declare const createHtmlReporter: (outputPath?: string) => HtmlReporter;