@reliverse/dler 2.2.5 → 2.2.10

package/dist/cmds/perf/benchmarks/memory.js

@@ -1,169 +0,0 @@
-export class MemoryProfiler {
-  snapshots = [];
-  startMemory = null;
-  peakMemory = null;
-  start(label) {
-    this.startMemory = process.memoryUsage();
-    this.peakMemory = { ...this.startMemory };
-    this.snapshots.push({
-      timestamp: Date.now(),
-      memory: this.startMemory,
-      label: label ?? "start"
-    });
-  }
-  snapshot(label) {
-    const current = process.memoryUsage();
-    this.snapshots.push({
-      timestamp: Date.now(),
-      memory: current,
-      label: label ?? `snapshot-${this.snapshots.length}`
-    });
-    if (!this.peakMemory) {
-      this.peakMemory = { ...current };
-    } else {
-      this.peakMemory = {
-        rss: Math.max(this.peakMemory.rss, current.rss),
-        heapTotal: Math.max(this.peakMemory.heapTotal, current.heapTotal),
-        heapUsed: Math.max(this.peakMemory.heapUsed, current.heapUsed),
-        external: Math.max(this.peakMemory.external, current.external),
-        arrayBuffers: Math.max(
-          this.peakMemory.arrayBuffers,
-          current.arrayBuffers
-        )
-      };
-    }
-  }
-  stop() {
-    if (!this.startMemory) {
-      return null;
-    }
-    const endMemory = process.memoryUsage();
-    const duration = this.snapshots.length > 0 ? this.snapshots[this.snapshots.length - 1].timestamp - this.snapshots[0].timestamp : 0;
-    const snapshot = {
-      before: this.startMemory,
-      after: endMemory,
-      peak: this.peakMemory ?? endMemory,
-      growth: endMemory.rss - this.startMemory.rss,
-      duration
-    };
-    this.startMemory = null;
-    this.peakMemory = null;
-    this.snapshots = [];
-    return snapshot;
-  }
-  getSnapshots() {
-    return [...this.snapshots];
-  }
-  getMemoryGrowth() {
-    if (this.snapshots.length < 2) return 0;
-    const first = this.snapshots[0].memory;
-    const last = this.snapshots[this.snapshots.length - 1].memory;
-    return last.rss - first.rss;
-  }
-  getPeakMemory() {
-    return this.peakMemory;
-  }
-  getAverageMemory() {
-    if (this.snapshots.length === 0) return null;
-    const sum = this.snapshots.reduce(
-      (acc, snapshot) => ({
-        rss: acc.rss + snapshot.memory.rss,
-        heapTotal: acc.heapTotal + snapshot.memory.heapTotal,
-        heapUsed: acc.heapUsed + snapshot.memory.heapUsed,
-        external: acc.external + snapshot.memory.external,
-        arrayBuffers: acc.arrayBuffers + snapshot.memory.arrayBuffers
-      }),
-      { rss: 0, heapTotal: 0, heapUsed: 0, external: 0, arrayBuffers: 0 }
-    );
-    const count = this.snapshots.length;
-    return {
-      rss: sum.rss / count,
-      heapTotal: sum.heapTotal / count,
-      heapUsed: sum.heapUsed / count,
-      external: sum.external / count,
-      arrayBuffers: sum.arrayBuffers / count
-    };
-  }
-}
-export const createMemoryProfiler = () => {
-  return new MemoryProfiler();
-};
-export const measureMemoryUsage = (fn) => {
-  return new Promise((resolve) => {
-    const profiler = createMemoryProfiler();
-    profiler.start("measurement");
-    const executeFn = async () => {
-      try {
-        await fn();
-      } finally {
-        const snapshot = profiler.stop();
-        resolve(snapshot);
-      }
-    };
-    executeFn();
-  });
-};
-export const getCurrentMemoryUsage = () => {
-  return process.memoryUsage();
-};
-export const getMemoryInfo = () => {
-  const usage = process.memoryUsage();
-  const total = usage.rss * 4;
-  const used = usage.rss;
-  const free = total - used;
-  const percentage = used / total * 100;
-  return {
-    total,
-    free,
-    used,
-    percentage: Math.min(percentage, 100)
-  };
-};
-export const formatMemoryUsage = (usage) => {
-  const format = (bytes) => {
-    if (bytes === 0) return "0 B";
-    const k = 1024;
-    const sizes = ["B", "KB", "MB", "GB"];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
-  };
-  return `RSS: ${format(usage.rss)}, Heap: ${format(usage.heapUsed)}/${format(usage.heapTotal)}, External: ${format(usage.external)}`;
-};
-export const detectMemoryLeaks = (snapshots) => {
-  if (snapshots.length < 3) {
-    return {
-      hasLeak: false,
-      severity: "low",
-      growthRate: 0,
-      suggestion: "Need more snapshots to detect leaks"
-    };
-  }
-  const rssValues = snapshots.map((s) => s.memory.rss);
-  const growthRate = (rssValues[rssValues.length - 1] - rssValues[0]) / snapshots.length;
-  const isConsistentGrowth = rssValues.every(
-    (val, i) => i === 0 || val >= rssValues[i - 1] * 0.95
-  );
-  const hasLeak = isConsistentGrowth && growthRate > 1024 * 1024;
-  let severity = "low";
-  let suggestion = "";
-  if (hasLeak) {
-    if (growthRate > 10 * 1024 * 1024) {
-      severity = "high";
-      suggestion = "Critical memory leak detected. Check for unclosed resources, event listeners, or circular references.";
-    } else if (growthRate > 5 * 1024 * 1024) {
-      severity = "medium";
-      suggestion = "Moderate memory leak detected. Monitor memory usage and consider garbage collection.";
-    } else {
-      severity = "low";
-      suggestion = "Minor memory growth detected. Monitor for patterns over time.";
-    }
-  } else {
-    suggestion = "No significant memory leaks detected.";
-  }
-  return {
-    hasLeak,
-    severity,
-    growthRate,
-    suggestion
-  };
-};

package/dist/cmds/perf/benchmarks/runner.d.ts

@@ -1,22 +0,0 @@
-import type { BenchmarkResult } from "../types.js";
-export interface BenchmarkRunnerOptions {
-    command: string;
-    runs: number;
-    warmup: number;
-    concurrency: number;
-    cwd?: string;
-    timeout?: number;
-    env?: Record<string, string>;
-    verbose?: boolean;
-}
-export declare class BenchmarkRunner {
-    readonly options: BenchmarkRunnerOptions;
-    constructor(options: BenchmarkRunnerOptions);
-    run(): Promise<BenchmarkResult>;
-    private runWarmup;
-    private runBenchmark;
-    private calculateStatistics;
-    private calculateMemoryStats;
-}
-export declare const runBenchmark: (options: BenchmarkRunnerOptions) => Promise<BenchmarkResult>;
-export declare const createBenchmarkRunner: (options: BenchmarkRunnerOptions) => BenchmarkRunner;

package/dist/cmds/perf/benchmarks/runner.js

@@ -1,157 +0,0 @@
-import { logger } from "@reliverse/dler-logger";
-import pMap from "@reliverse/dler-mapper";
-import { formatProgress } from "../utils/formatter.js";
-import {
-  calculateMemoryAverage,
-  calculateStatistics,
-  findPeakMemory
-} from "../utils/stats.js";
-import { executeCommandWithMemoryTracking } from "./command.js";
-export class BenchmarkRunner {
-  options;
-  constructor(options) {
-    this.options = options;
-  }
-  async run() {
-    const { command, runs, warmup, concurrency, verbose } = this.options;
-    const startTime = Date.now();
-    if (verbose) {
-      logger.info(`\u{1F680} Starting benchmark for: ${command}`);
-      logger.info(
-        `   Runs: ${runs}, Warmup: ${warmup}, Concurrency: ${concurrency}`
-      );
-    }
-    if (warmup > 0) {
-      if (verbose) {
-        logger.info(`\u{1F525} Running ${warmup} warmup iterations...`);
-      }
-      await this.runWarmup();
-    }
-    if (verbose) {
-      logger.info(`\u{1F4CA} Running ${runs} benchmark iterations...`);
-    }
-    const measurements = await this.runBenchmark();
-    const statistics = this.calculateStatistics(measurements);
-    const memory = this.calculateMemoryStats(measurements);
-    const executionTime = Date.now() - startTime;
-    const failures = measurements.filter((m) => !m.success);
-    const success = failures.length === 0;
-    if (verbose && failures.length > 0) {
-      logger.warn(`\u26A0\uFE0F  ${failures.length} out of ${runs} runs failed`);
-    }
-    return {
-      command,
-      runs,
-      warmup,
-      concurrency,
-      measurements,
-      statistics,
-      memory,
-      executionTime,
-      success,
-      error: failures.length > 0 ? `${failures.length} runs failed` : void 0
-    };
-  }
-  async runWarmup() {
-    const { command, warmup, cwd, timeout, env } = this.options;
-    for (let i = 0; i < warmup; i++) {
-      try {
-        await executeCommandWithMemoryTracking(command, {
-          cwd,
-          timeout,
-          env
-        });
-      } catch {
-      }
-    }
-  }
-  async runBenchmark() {
-    const { command, runs, concurrency, cwd, timeout, env, verbose } = this.options;
-    const runIndices = Array.from({ length: runs }, (_, i) => i);
-    const measurements = await pMap(
-      runIndices,
-      async (runIndex) => {
-        if (verbose) {
-          logger.info(formatProgress(runIndex + 1, runs));
-        }
-        const measurement = await executeCommandWithMemoryTracking(command, {
-          cwd,
-          timeout,
-          env
-        });
-        measurement.run = runIndex + 1;
-        return measurement;
-      },
-      {
-        concurrency,
-        stopOnError: false
-      }
-    );
-    return measurements;
-  }
-  calculateStatistics(measurements) {
-    const durations = measurements.filter((m) => m.success).map((m) => m.duration);
-    if (durations.length === 0) {
-      return calculateStatistics([]);
-    }
-    return calculateStatistics(durations);
-  }
-  calculateMemoryStats(measurements) {
-    const successfulMeasurements = measurements.filter((m) => m.success);
-    if (successfulMeasurements.length === 0) {
-      return {
-        peak: {
-          rss: 0,
-          heapTotal: 0,
-          heapUsed: 0,
-          external: 0,
-          arrayBuffers: 0
-        },
-        average: {
-          rss: 0,
-          heapTotal: 0,
-          heapUsed: 0,
-          external: 0,
-          arrayBuffers: 0
-        },
-        growth: 0
-      };
-    }
-    const rssValues = successfulMeasurements.map((m) => m.memory.rss);
-    const heapTotalValues = successfulMeasurements.map(
-      (m) => m.memory.heapTotal
-    );
-    const heapUsedValues = successfulMeasurements.map((m) => m.memory.heapUsed);
-    const externalValues = successfulMeasurements.map((m) => m.memory.external);
-    const arrayBuffersValues = successfulMeasurements.map(
-      (m) => m.memory.arrayBuffers
-    );
-    const peak = {
-      rss: findPeakMemory(rssValues),
-      heapTotal: findPeakMemory(heapTotalValues),
-      heapUsed: findPeakMemory(heapUsedValues),
-      external: findPeakMemory(externalValues),
-      arrayBuffers: findPeakMemory(arrayBuffersValues)
-    };
-    const average = {
-      rss: calculateMemoryAverage(rssValues),
-      heapTotal: calculateMemoryAverage(heapTotalValues),
-      heapUsed: calculateMemoryAverage(heapUsedValues),
-      external: calculateMemoryAverage(externalValues),
-      arrayBuffers: calculateMemoryAverage(arrayBuffersValues)
-    };
-    const growth = rssValues.length > 1 ? rssValues[rssValues.length - 1] - rssValues[0] : 0;
-    return {
-      peak,
-      average,
-      growth
-    };
-  }
-}
-export const runBenchmark = async (options) => {
-  const runner = new BenchmarkRunner(options);
-  return runner.run();
-};
-export const createBenchmarkRunner = (options) => {
-  return new BenchmarkRunner(options);
-};

package/dist/cmds/perf/cmd.js

@@ -1,240 +0,0 @@
-import { defineArgs, defineCommand } from "@reliverse/dler-launcher";
-import { logger } from "@reliverse/dler-logger";
-import { runPerfAnalysis } from "./impl.js";
-import { createConsoleReporter } from "./reporters/console.js";
-import { createHtmlReporter } from "./reporters/html.js";
-import { createJsonReporter } from "./reporters/json.js";
-export default defineCommand({
-  meta: {
-    name: "perf",
-    description: "Comprehensive performance measurement and analysis tool. Benchmarks commands, analyzes bundles, profiles files/directories, and identifies monorepo bottlenecks.",
-    examples: [
-      "# Command Benchmarking:",
-      "dler perf build",
-      'dler perf "bun dler tsc"',
-      'dler perf "node --version"',
-      "dler perf build --runs 20 --warmup 5",
-      "dler perf build --concurrency 4 --verbose",
-      "dler perf build --compare --save",
-      "",
-      "# Bundle Analysis:",
-      "dler perf ./dist --type bundle",
-      "dler perf ./build --type bundle",
-      "dler perf ./dist --type bundle --verbose",
-      "",
-      "# File System Profiling:",
-      "dler perf ./src --type file",
-      "dler perf ./packages --type file",
-      "dler perf ./src --type file --verbose",
-      "",
-      "# Monorepo Analysis:",
-      "dler perf --type monorepo",
-      "dler perf --type monorepo --ignore '@reliverse/*'",
-      "dler perf --type monorepo --verbose",
-      "",
-      "# Auto-detection:",
-      "dler perf build                    # Auto-detects as command",
-      "dler perf ./dist                   # Auto-detects as bundle",
-      "dler perf ./src                    # Auto-detects as file system",
-      "dler perf                          # Auto-detects as monorepo",
-      "",
-      "# Output Formats:",
-      "dler perf build --output json",
-      "dler perf build --output html",
-      "dler perf build --output all",
-      "",
-      "# Baseline Comparison:",
-      "dler perf build --save             # Save current as baseline",
-      "dler perf build --compare          # Compare with baseline",
-      "dler perf build --compare --save   # Compare and update baseline",
-      "",
-      "# Advanced Examples:",
-      "dler perf 'bun dler tsc' --runs 50 --warmup 10 --concurrency 2",
-      "dler perf ./dist --type bundle --output html --verbose",
-      "dler perf --type monorepo --ignore '@reliverse/*' --output json",
-      "dler perf build --runs 100 --compare --save --output all",
-      "",
-      "# Performance Monitoring:",
-      "dler perf build --runs 10 --save  # Establish baseline",
-      "dler perf build --compare         # Check for regressions",
-      "dler perf build --runs 20 --compare --save  # Update baseline",
-      "",
-      "# Analysis Types:",
-      "dler perf --type command <cmd>    # Benchmark command execution",
-      "dler perf --type bundle <path>    # Analyze bundle size and structure",
-      "dler perf --type file <path>      # Profile file system usage",
-      "dler perf --type monorepo         # Analyze monorepo dependencies",
-      "dler perf --type auto <target>    # Auto-detect analysis type",
-      "",
-      "# Command Examples:",
-      "dler perf 'dler build'",
-      "dler perf 'bun dler tsc --verbose'",
-      "dler perf 'node --version'",
-      "dler perf 'npm run build'",
-      "dler perf 'yarn test'",
-      "",
-      "# Bundle Analysis Examples:",
-      "dler perf ./dist --type bundle",
-      "dler perf ./build --type bundle",
-      "dler perf ./out --type bundle",
-      "dler perf ./lib --type bundle",
-      "",
-      "# File System Examples:",
-      "dler perf ./src --type file",
-      "dler perf ./packages --type file",
-      "dler perf ./apps --type file",
-      "dler perf ./examples --type file",
-      "",
-      "# Monorepo Examples:",
-      "dler perf --type monorepo",
-      "dler perf --type monorepo --cwd /path/to/monorepo",
-      "dler perf --type monorepo --ignore '@reliverse/*'",
-      "dler perf --type monorepo --ignore '@reliverse/* @company/*'",
-      "",
-      "# Output Examples:",
-      "dler perf build --output console  # Console output (default)",
-      "dler perf build --output json     # JSON output",
-      "dler perf build --output html     # HTML report",
-      "dler perf build --output all      # All formats",
-      "",
-      "# Baseline Management:",
-      "dler perf build --save            # Save current run as baseline",
-      "dler perf build --compare         # Compare with saved baseline",
-      "dler perf build --compare --save  # Compare and update baseline",
-      "",
-      "# Verbose Output:",
-      "dler perf build --verbose         # Show detailed progress",
-      "dler perf ./dist --type bundle --verbose",
-      "dler perf --type monorepo --verbose",
-      "",
-      "# Concurrency Control:",
-      "dler perf build --concurrency 1   # Sequential execution",
-      "dler perf build --concurrency 4   # Parallel execution",
-      "dler perf build --concurrency 8   # High parallelism",
-      "",
-      "# Iteration Control:",
-      "dler perf build --runs 5          # Few iterations (faster)",
-      "dler perf build --runs 50         # Many iterations (more accurate)",
-      "dler perf build --warmup 0        # No warmup",
-      "dler perf build --warmup 10       # More warmup runs",
-      "",
-      "# Working Directory:",
-      "dler perf build --cwd /path/to/project",
-      "dler perf ./dist --type bundle --cwd /path/to/project",
-      "dler perf --type monorepo --cwd /path/to/monorepo"
-    ]
-  },
-  args: defineArgs({
-    target: {
-      type: "string",
-      description: "What to measure (command name, file path, or directory)"
-    },
-    type: {
-      type: "string",
-      description: "Type of analysis: command, bundle, file, monorepo, or auto (default: auto)"
-    },
-    runs: {
-      type: "number",
-      description: "Number of benchmark iterations (default: 10)"
-    },
-    warmup: {
-      type: "number",
-      description: "Warmup runs before measurement (default: 2)"
-    },
-    concurrency: {
-      type: "number",
-      description: "For parallel benchmarks (default: 1)"
-    },
-    compare: {
-      type: "boolean",
-      description: "Compare with cached baseline (default: false)"
-    },
-    output: {
-      type: "string",
-      description: "Output format: console, json, html, or all (default: console)"
-    },
-    save: {
-      type: "boolean",
-      description: "Save results as baseline (default: false)"
-    },
-    verbose: {
-      type: "boolean",
-      description: "Detailed output (default: false)"
-    },
-    cwd: {
-      type: "string",
-      description: "Working directory (default: current directory)"
-    },
-    ignore: {
-      type: "string",
-      description: "Packages to ignore for monorepo analysis (supports wildcards like @reliverse/*)"
-    }
-  }),
-  run: async ({ args }) => {
-    try {
-      if (typeof process.versions.bun === "undefined") {
-        logger.error("\u274C This command requires Bun runtime. Sorry.");
-        process.exit(1);
-      }
-      const validTypes = [
-        "command",
-        "bundle",
-        "file",
-        "monorepo",
-        "auto"
-      ];
-      if (args.type && !validTypes.includes(args.type)) {
-        logger.error(
-          `\u274C Invalid type: ${args.type}. Must be one of: ${validTypes.join(", ")}`
-        );
-        process.exit(1);
-      }
-      const validOutputs = [
-        "console",
-        "json",
-        "html",
-        "all"
-      ];
-      if (args.output && !validOutputs.includes(args.output)) {
-        logger.error(
-          `\u274C Invalid output format: ${args.output}. Must be one of: ${validOutputs.join(", ")}`
-        );
-        process.exit(1);
-      }
-      const result = await runPerfAnalysis(args);
-      if (!result.success) {
-        logger.error(`\u274C Performance analysis failed: ${result.error}`);
-        process.exit(1);
-      }
-      const outputFormats = args.output === "all" ? ["console", "json", "html"] : [args.output ?? "console"];
-      for (const format of outputFormats) {
-        switch (format) {
-          case "console": {
-            const consoleReporter = createConsoleReporter(args.verbose);
-            consoleReporter.report(result.report);
-            break;
-          }
-          case "json": {
-            const jsonReporter = createJsonReporter();
-            jsonReporter.report(result.report);
-            break;
-          }
-          case "html": {
-            const htmlReporter = createHtmlReporter();
-            htmlReporter.report(result.report);
-            break;
-          }
-        }
-      }
-      logger.success("\n\u2705 Performance analysis completed successfully!");
-    } catch (error) {
-      logger.error("\n\u274C Performance analysis failed:");
-      if (error instanceof Error) {
-        logger.error(error.message);
-      } else {
-        logger.error(String(error));
-      }
-      process.exit(1);
-    }
-  }
-});

package/dist/cmds/perf/impl.d.ts

@@ -1,24 +0,0 @@
-import type { PerfOptions, PerfReport } from "./types.js";
-export interface PerfAnalysisResult {
-    report: PerfReport;
-    success: boolean;
-    error?: string;
-}
-export declare class PerfAnalyzer {
-    private options;
-    private cache;
-    constructor(options: PerfOptions);
-    analyze(): Promise<PerfAnalysisResult>;
-    private detectType;
-    private detectTargetType;
-    private isCommand;
-    private isBundleFile;
-    private containsBundleFiles;
-    private runCommandBenchmark;
-    private runBundleAnalysis;
-    private runFileSystemAnalysis;
-    private runMonorepoAnalysis;
-    private compareWithBaseline;
-}
-export declare const runPerfAnalysis: (options: PerfOptions) => Promise<PerfAnalysisResult>;
-export declare const createPerfAnalyzer: (options: PerfOptions) => PerfAnalyzer;