@reliverse/dler 2.2.5 → 2.2.10

package/dist/cmds/perf/impl.js

@@ -1,297 +0,0 @@
-import { existsSync, statSync } from "node:fs";
-import { resolve } from "node:path";
-import { logger } from "@reliverse/dler-logger";
-import { analyzeBundle } from "./analysis/bundle.js";
-import { analyzeFileSystem } from "./analysis/filesystem.js";
-import { analyzeMonorepo } from "./analysis/monorepo.js";
-import { runBenchmark } from "./benchmarks/runner.js";
-import { createPerfCache } from "./utils/cache.js";
-import { calculateImprovement, calculateRegression } from "./utils/stats.js";
-export class PerfAnalyzer {
-  options;
-  cache = createPerfCache();
-  constructor(options) {
-    this.options = options;
-  }
-  async analyze() {
-    try {
-      const startTime = Date.now();
-      const analysisType = this.options.type ?? await this.detectType();
-      if (this.options.verbose) {
-        logger.info(`\u{1F50D} Starting performance analysis (type: ${analysisType})`);
-      }
-      let benchmark;
-      let bundleAnalysis;
-      let fileSystemAnalysis;
-      let monorepoAnalysis;
-      switch (analysisType) {
-        case "command":
-          benchmark = await this.runCommandBenchmark();
-          break;
-        case "bundle":
-          bundleAnalysis = await this.runBundleAnalysis();
-          break;
-        case "file":
-          fileSystemAnalysis = await this.runFileSystemAnalysis();
-          break;
-        case "monorepo":
-          monorepoAnalysis = await this.runMonorepoAnalysis();
-          break;
-        case "auto":
-          if (this.options.target) {
-            const targetType = await this.detectTargetType(this.options.target);
-            switch (targetType) {
-              case "command":
-                benchmark = await this.runCommandBenchmark();
-                break;
-              case "bundle":
-                bundleAnalysis = await this.runBundleAnalysis();
-                break;
-              case "file":
-                fileSystemAnalysis = await this.runFileSystemAnalysis();
-                break;
-            }
-          } else {
-            monorepoAnalysis = await this.runMonorepoAnalysis();
-          }
-          break;
-      }
-      const report = {
-        timestamp: Date.now(),
-        options: this.options,
-        benchmark,
-        bundleAnalysis,
-        fileSystemAnalysis,
-        monorepoAnalysis
-      };
-      if (this.options.compare) {
-        const baseline = await this.cache.findBaseline(
-          this.options.target ?? "unknown",
-          this.options.type
-        );
-        if (baseline) {
-          report.baseline = this.compareWithBaseline(report, baseline);
-        }
-      }
-      if (this.options.save) {
-        await this.cache.save(report);
-        if (this.options.verbose) {
-          logger.info("\u{1F4BE} Baseline saved");
-        }
-      }
-      const executionTime = Date.now() - startTime;
-      if (this.options.verbose) {
-        logger.info(`\u2705 Analysis completed in ${executionTime}ms`);
-      }
-      return {
-        report,
-        success: true
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      if (this.options.verbose) {
-        logger.error(`\u274C Analysis failed: ${errorMessage}`);
-      }
-      return {
-        report: {
-          timestamp: Date.now(),
-          options: this.options
-        },
-        success: false,
-        error: errorMessage
-      };
-    }
-  }
-  async detectType() {
-    if (this.options.target) {
-      return await this.detectTargetType(this.options.target);
-    }
-    return "monorepo";
-  }
-  async detectTargetType(target) {
-    if (this.isCommand(target)) {
-      return "command";
-    }
-    const targetPath = resolve(target);
-    if (!existsSync(targetPath)) {
-      throw new Error(`Target not found: ${target}`);
-    }
-    const stat = statSync(targetPath);
-    if (stat.isFile()) {
-      if (this.isBundleFile(target)) {
-        return "bundle";
-      }
-      return "file";
-    }
-    if (stat.isDirectory()) {
-      if (await this.containsBundleFiles(targetPath)) {
-        return "bundle";
-      }
-      return "file";
-    }
-    return "file";
-  }
-  isCommand(target) {
-    return target.includes(" ") || target.startsWith("dler ") || target.startsWith("bun ") || target.startsWith("node ") || target.startsWith("npm ") || target.startsWith("yarn ") || target.startsWith("pnpm ");
-  }
-  isBundleFile(target) {
-    const bundleExtensions = [".js", ".mjs", ".cjs", ".ts", ".jsx", ".tsx"];
-    const ext = target.split(".").pop()?.toLowerCase();
-    return ext ? bundleExtensions.includes(`.${ext}`) : false;
-  }
-  async containsBundleFiles(dirPath) {
-    try {
-      const glob = new Bun.Glob("**/*.{js,mjs,cjs,ts,jsx,tsx}");
-      const matches = glob.scanSync({ cwd: dirPath, onlyFiles: true });
-      for (const _ of matches) {
-        return true;
-      }
-      return false;
-    } catch {
-      return false;
-    }
-  }
-  async runCommandBenchmark() {
-    if (!this.options.target) {
-      throw new Error("Target is required for command benchmarking");
-    }
-    const {
-      target,
-      runs = 10,
-      warmup = 2,
-      concurrency = 1,
-      cwd,
-      verbose
-    } = this.options;
-    if (verbose) {
-      logger.info(`\u{1F680} Benchmarking command: ${target}`);
-    }
-    return runBenchmark({
-      command: target,
-      runs,
-      warmup,
-      concurrency,
-      cwd,
-      verbose
-    });
-  }
-  async runBundleAnalysis() {
-    if (!this.options.target) {
-      throw new Error("Target is required for bundle analysis");
-    }
-    const { target, verbose } = this.options;
-    if (verbose) {
-      logger.info(`\u{1F4E6} Analyzing bundle: ${target}`);
-    }
-    return analyzeBundle({
-      target,
-      verbose,
-      includeSourceMaps: true,
-      analyzeDependencies: true
-    });
-  }
-  async runFileSystemAnalysis() {
-    if (!this.options.target) {
-      throw new Error("Target is required for file system analysis");
-    }
-    const { target, verbose } = this.options;
-    if (verbose) {
-      logger.info(`\u{1F4C1} Analyzing file system: ${target}`);
-    }
-    return analyzeFileSystem({
-      target,
-      verbose,
-      maxDepth: 10,
-      includeHidden: false,
-      excludePatterns: ["node_modules", ".git", ".next", "dist", "build"]
-    });
-  }
-  async runMonorepoAnalysis() {
-    const { cwd, ignore, verbose } = this.options;
-    if (verbose) {
-      logger.info("\u{1F3D7}\uFE0F Analyzing monorepo structure");
-    }
-    return analyzeMonorepo({
-      cwd,
-      ignore,
-      verbose,
-      includeDevDependencies: true,
-      analyzeBuildOrder: true
-    });
-  }
-  compareWithBaseline(current, baseline) {
-    const changes = {};
-    if (current.benchmark && baseline.benchmark) {
-      const currentDuration = current.benchmark.statistics.mean;
-      const baselineDuration = baseline.benchmark.statistics.mean;
-      if (currentDuration < baselineDuration) {
-        changes.duration = calculateImprovement(
-          baselineDuration,
-          currentDuration
-        );
-      } else {
-        changes.duration = calculateRegression(
-          baselineDuration,
-          currentDuration
-        );
-      }
-      const currentMemory = current.benchmark.memory.average.rss;
-      const baselineMemory = baseline.benchmark.memory.average.rss;
-      if (currentMemory < baselineMemory) {
-        changes.memory = calculateImprovement(baselineMemory, currentMemory);
-      } else {
-        changes.memory = calculateRegression(baselineMemory, currentMemory);
-      }
-    }
-    if (current.bundleAnalysis && baseline.bundleAnalysis) {
-      const currentSize = current.bundleAnalysis.totalSize;
-      const baselineSize = baseline.bundleAnalysis.totalSize;
-      if (currentSize < baselineSize) {
-        changes.size = calculateImprovement(baselineSize, currentSize);
-      } else {
-        changes.size = calculateRegression(baselineSize, currentSize);
-      }
-      const currentFiles = current.bundleAnalysis.fileCount;
-      const baselineFiles = baseline.bundleAnalysis.fileCount;
-      if (currentFiles !== baselineFiles) {
-        changes.files = calculateRegression(baselineFiles, currentFiles);
-      }
-    }
-    if (current.fileSystemAnalysis && baseline.fileSystemAnalysis) {
-      const currentSize = current.fileSystemAnalysis.totalSize;
-      const baselineSize = baseline.fileSystemAnalysis.totalSize;
-      if (currentSize < baselineSize) {
-        changes.size = calculateImprovement(baselineSize, currentSize);
-      } else {
-        changes.size = calculateRegression(baselineSize, currentSize);
-      }
-      const currentFiles = current.fileSystemAnalysis.totalFiles;
-      const baselineFiles = baseline.fileSystemAnalysis.totalFiles;
-      if (currentFiles !== baselineFiles) {
-        changes.files = calculateRegression(baselineFiles, currentFiles);
-      }
-    }
-    let improvement;
-    let regression;
-    if (changes.duration !== void 0) {
-      if (changes.duration > 0) {
-        improvement = changes.duration;
-      } else {
-        regression = Math.abs(changes.duration);
-      }
-    }
-    return {
-      exists: true,
-      improvement,
-      regression,
-      changes
-    };
-  }
-}
-export const runPerfAnalysis = async (options) => {
-  const analyzer = new PerfAnalyzer(options);
-  return analyzer.analyze();
-};
-export const createPerfAnalyzer = (options) => {
-  return new PerfAnalyzer(options);
-};

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

@@ -1,12 +0,0 @@
-import type { PerfReport } from "../types.js";
-export declare class ConsoleReporter {
-    private verbose;
-    constructor(verbose?: boolean);
-    report(report: PerfReport): void;
-    private reportBenchmark;
-    private reportBundleAnalysis;
-    private reportFileSystemAnalysis;
-    private reportMonorepoAnalysis;
-    private reportBaselineComparison;
-}
-export declare const createConsoleReporter: (verbose?: boolean) => ConsoleReporter;

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

@@ -1,257 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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;