@reliverse/dler 1.7.153 → 2.0.1

package/dist/cmds/perf/cmd.js

@@ -0,0 +1,238 @@
+import {
+  defineCmd,
+  defineCmdArgs,
+  defineCmdCfg
+} 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";
+const perfCmd = 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);
+  }
+};
+const perfCmdArgs = defineCmdArgs({
+  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/*)"
+  }
+});
+const perfCmdCfg = defineCmdCfg({
+  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"
+  ]
+});
+export default defineCmd(perfCmd, perfCmdArgs, perfCmdCfg);

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

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

package/dist/cmds/perf/impl.js

@@ -0,0 +1,304 @@
+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",
+        ".nuxt",
+        "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

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