@reliverse/dler 2.0.0 → 2.0.1

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

@@ -0,0 +1,162 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { lookpath } from "lookpath";
+export const executeCommand = async (command, options = {}) => {
+  const startTime = process.hrtime.bigint();
+  try {
+    const [cmd, ...args] = parseCommand(command);
+    if (!cmd) {
+      throw new Error("Command is empty");
+    }
+    const commandPath = await findCommand(cmd);
+    if (!commandPath) {
+      throw new Error(`Command not found: ${cmd}`);
+    }
+    const proc = Bun.spawn([commandPath, ...args], {
+      cwd: options.cwd ?? process.cwd(),
+      env: { ...process.env, ...options.env },
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    let timeoutId;
+    if (options.timeout) {
+      timeoutId = setTimeout(() => {
+        proc.kill();
+      }, options.timeout);
+    }
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text()
+    ]);
+    const exitCode = await proc.exited;
+    const endTime = process.hrtime.bigint();
+    const endMemory = process.memoryUsage();
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    const duration = Number(endTime - startTime) / 1e6;
+    return {
+      success: exitCode === 0,
+      duration,
+      memory: {
+        rss: endMemory.rss,
+        heapTotal: endMemory.heapTotal,
+        heapUsed: endMemory.heapUsed,
+        external: endMemory.external,
+        arrayBuffers: endMemory.arrayBuffers
+      },
+      stdout,
+      stderr,
+      exitCode
+    };
+  } catch (error) {
+    const endTime = process.hrtime.bigint();
+    const endMemory = process.memoryUsage();
+    const duration = Number(endTime - startTime) / 1e6;
+    return {
+      success: false,
+      duration,
+      memory: {
+        rss: endMemory.rss,
+        heapTotal: endMemory.heapTotal,
+        heapUsed: endMemory.heapUsed,
+        external: endMemory.external,
+        arrayBuffers: endMemory.arrayBuffers
+      },
+      stdout: "",
+      stderr: "",
+      error: error instanceof Error ? error.message : String(error),
+      exitCode: 1
+    };
+  }
+};
+export const executeCommandWithMemoryTracking = async (command, options = {}) => {
+  const result = await executeCommand(command, options);
+  const endMemory = process.memoryUsage();
+  return {
+    run: 0,
+    // Will be set by the runner
+    duration: result.duration,
+    memory: {
+      rss: endMemory.rss,
+      heapTotal: endMemory.heapTotal,
+      heapUsed: endMemory.heapUsed,
+      external: endMemory.external,
+      arrayBuffers: endMemory.arrayBuffers
+    },
+    success: result.success,
+    error: result.error,
+    stdout: result.stdout,
+    stderr: result.stderr
+  };
+};
+const parseCommand = (command) => {
+  const parts = [];
+  let current = "";
+  let inQuotes = false;
+  let quoteChar = "";
+  for (let i = 0; i < command.length; i++) {
+    const char = command[i];
+    if (char === '"' || char === "'") {
+      if (!inQuotes) {
+        inQuotes = true;
+        quoteChar = char;
+      } else if (char === quoteChar) {
+        inQuotes = false;
+        quoteChar = "";
+      } else {
+        current += char;
+      }
+    } else if (char === " " && !inQuotes) {
+      if (current.trim()) {
+        parts.push(current.trim());
+        current = "";
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) {
+    parts.push(current.trim());
+  }
+  return parts;
+};
+const findCommand = async (cmd) => {
+  if (!cmd) {
+    return null;
+  }
+  if (cmd === "dler") {
+    return "bun";
+  }
+  if (cmd === "bun") {
+    return "bun";
+  }
+  if (cmd === "node") {
+    return "node";
+  }
+  if (cmd.includes("/") || cmd.includes("\\")) {
+    const fullPath = resolve(cmd);
+    return existsSync(fullPath) ? fullPath : null;
+  }
+  try {
+    const path = await lookpath(cmd);
+    return path ?? null;
+  } catch {
+    return null;
+  }
+};
+export const isDlerCommand = (command) => {
+  return command.startsWith("dler ") || command === "dler";
+};
+export const isBunCommand = (command) => {
+  return command.startsWith("bun ") || command === "bun";
+};
+export const isNodeCommand = (command) => {
+  return command.startsWith("node ") || command === "node";
+};
+export const getCommandType = (command) => {
+  if (isDlerCommand(command)) return "dler";
+  if (isBunCommand(command)) return "bun";
+  if (isNodeCommand(command)) return "node";
+  return "external";
+};

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

@@ -0,0 +1,41 @@
+import type { MemoryUsage } from "../types.js";
+export interface MemoryProfile {
+    timestamp: number;
+    memory: MemoryUsage;
+    label?: string;
+}
+export interface MemorySnapshot {
+    before: MemoryUsage;
+    after: MemoryUsage;
+    peak: MemoryUsage;
+    growth: number;
+    duration: number;
+}
+export declare class MemoryProfiler {
+    private snapshots;
+    private startMemory;
+    private peakMemory;
+    start(label?: string): void;
+    snapshot(label?: string): void;
+    stop(): MemorySnapshot | null;
+    getSnapshots(): MemoryProfile[];
+    getMemoryGrowth(): number;
+    getPeakMemory(): MemoryUsage | null;
+    getAverageMemory(): MemoryUsage | null;
+}
+export declare const createMemoryProfiler: () => MemoryProfiler;
+export declare const measureMemoryUsage: (fn: () => void | Promise<void>) => Promise<MemorySnapshot>;
+export declare const getCurrentMemoryUsage: () => MemoryUsage;
+export declare const getMemoryInfo: () => {
+    total: number;
+    free: number;
+    used: number;
+    percentage: number;
+};
+export declare const formatMemoryUsage: (usage: MemoryUsage) => string;
+export declare const detectMemoryLeaks: (snapshots: MemoryProfile[]) => {
+    hasLeak: boolean;
+    severity: "low" | "medium" | "high";
+    growthRate: number;
+    suggestion: string;
+};

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

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

@@ -0,0 +1,22 @@
+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 {
+    private options;
+    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

@@ -0,0 +1,157 @@
+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.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;