@reliverse/dler 2.0.0 → 2.0.1

package/src/cmds/perf/cmd.ts

@@ -0,0 +1,285 @@
+// apps/dler/src/cmds/perf/cmd.ts
+
+// Examples:
+// # Command benchmarking
+//   dler perf --target "node --version" --runs 10 --warmup 2
+//   bun dler perf --runs 10 --warmup 2 --target "node --version"
+// # Monorepo analysis
+//   dler perf --type monorepo --verbose
+// # File system profiling
+//   dler perf --target ./src --type file --verbose
+// # JSON output
+//   dler perf --target "node --version" --output json
+// # Baseline comparison
+//   dler perf build --save
+//   dler perf build --compare
+
+import {
+  defineCmd,
+  defineCmdArgs,
+  defineCmdCfg,
+} from "@reliverse/dler-launcher";
+import { logger } from "@reliverse/dler-logger";
+import { runPerfAnalysis } from "./impl";
+import { createConsoleReporter } from "./reporters/console";
+import { createHtmlReporter } from "./reporters/html";
+import { createJsonReporter } from "./reporters/json";
+import type { PerfAnalysisType, PerfOptions, PerfOutputFormat } from "./types";
+
+const perfCmd = async (args: PerfOptions): Promise<void> => {
+  try {
+    // Check if running in Bun
+    if (typeof process.versions.bun === "undefined") {
+      logger.error("❌ This command requires Bun runtime. Sorry.");
+      process.exit(1);
+    }
+
+    // Validate type parameter
+    const validTypes: PerfAnalysisType[] = [
+      "command",
+      "bundle",
+      "file",
+      "monorepo",
+      "auto",
+    ];
+    if (args.type && !validTypes.includes(args.type as PerfAnalysisType)) {
+      logger.error(
+        `❌ Invalid type: ${args.type}. Must be one of: ${validTypes.join(", ")}`,
+      );
+      process.exit(1);
+    }
+
+    // Validate output parameter
+    const validOutputs: PerfOutputFormat[] = ["console", "json", "html", "all"];
+    if (
+      args.output &&
+      !validOutputs.includes(args.output as PerfOutputFormat)
+    ) {
+      logger.error(
+        `❌ Invalid output format: ${args.output}. Must be one of: ${validOutputs.join(", ")}`,
+      );
+      process.exit(1);
+    }
+
+    // Run performance analysis
+    const result = await runPerfAnalysis(args);
+
+    if (!result.success) {
+      logger.error(`❌ Performance analysis failed: ${result.error}`);
+      process.exit(1);
+    }
+
+    // Generate reports based on output format
+    const outputFormats: PerfOutputFormat[] =
+      args.output === "all"
+        ? ["console", "json", "html"]
+        : [(args.output as PerfOutputFormat) ?? "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✅ Performance analysis completed successfully!");
+  } catch (error) {
+    logger.error("\n❌ 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/src/cmds/perf/impl.ts

@@ -0,0 +1,411 @@
+// apps/dler/src/cmds/perf/impl.ts
+
+import { existsSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { logger } from "@reliverse/dler-logger";
+import { analyzeBundle } from "./analysis/bundle";
+import { analyzeFileSystem } from "./analysis/filesystem";
+import { analyzeMonorepo } from "./analysis/monorepo";
+import { runBenchmark } from "./benchmarks/runner";
+import type {
+  BenchmarkResult,
+  BundleAnalysisResult,
+  FileSystemAnalysisResult,
+  MonorepoAnalysisResult,
+  PerfOptions,
+  PerfReport,
+} from "./types";
+import { createPerfCache } from "./utils/cache";
+import { calculateImprovement, calculateRegression } from "./utils/stats";
+
+export interface PerfAnalysisResult {
+  report: PerfReport;
+  success: boolean;
+  error?: string;
+}
+
+export class PerfAnalyzer {
+  private options: PerfOptions;
+  private cache = createPerfCache();
+
+  constructor(options: PerfOptions) {
+    this.options = options;
+  }
+
+  async analyze(): Promise<PerfAnalysisResult> {
+    try {
+      const startTime = Date.now();
+
+      // Auto-detect type if not specified
+      const analysisType = this.options.type ?? (await this.detectType());
+
+      if (this.options.verbose) {
+        logger.info(`🔍 Starting performance analysis (type: ${analysisType})`);
+      }
+
+      // Run analysis based on type
+      let benchmark: BenchmarkResult | undefined;
+      let bundleAnalysis: BundleAnalysisResult | undefined;
+      let fileSystemAnalysis: FileSystemAnalysisResult | undefined;
+      let monorepoAnalysis: MonorepoAnalysisResult | undefined;
+
+      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":
+          // Run all analyses
+          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;
+      }
+
+      // Create report
+      const report: PerfReport = {
+        timestamp: Date.now(),
+        options: this.options,
+        benchmark,
+        bundleAnalysis,
+        fileSystemAnalysis,
+        monorepoAnalysis,
+      };
+
+      // Compare with baseline if requested
+      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);
+        }
+      }
+
+      // Save baseline if requested
+      if (this.options.save) {
+        await this.cache.save(report);
+        if (this.options.verbose) {
+          logger.info("💾 Baseline saved");
+        }
+      }
+
+      const executionTime = Date.now() - startTime;
+
+      if (this.options.verbose) {
+        logger.info(`✅ 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(`❌ Analysis failed: ${errorMessage}`);
+      }
+
+      return {
+        report: {
+          timestamp: Date.now(),
+          options: this.options,
+        },
+        success: false,
+        error: errorMessage,
+      };
+    }
+  }
+
+  private async detectType(): Promise<PerfOptions["type"]> {
+    if (this.options.target) {
+      return await this.detectTargetType(this.options.target);
+    }
+
+    // Default to monorepo analysis if no target specified
+    return "monorepo";
+  }
+
+  private async detectTargetType(target: string): Promise<PerfOptions["type"]> {
+    // Check if it's a command
+    if (this.isCommand(target)) {
+      return "command";
+    }
+
+    // Check if target exists as file/directory
+    const targetPath = resolve(target);
+    if (!existsSync(targetPath)) {
+      throw new Error(`Target not found: ${target}`);
+    }
+
+    const stat = statSync(targetPath);
+
+    if (stat.isFile()) {
+      // Check if it's a bundle file
+      if (this.isBundleFile(target)) {
+        return "bundle";
+      }
+      return "file";
+    }
+
+    if (stat.isDirectory()) {
+      // Check if it contains bundle files
+      if (await this.containsBundleFiles(targetPath)) {
+        return "bundle";
+      }
+      return "file";
+    }
+
+    return "file";
+  }
+
+  private isCommand(target: string): boolean {
+    // Simple heuristic: if it contains spaces or starts with common command prefixes
+    return (
+      target.includes(" ") ||
+      target.startsWith("dler ") ||
+      target.startsWith("bun ") ||
+      target.startsWith("node ") ||
+      target.startsWith("npm ") ||
+      target.startsWith("yarn ") ||
+      target.startsWith("pnpm ")
+    );
+  }
+
+  private isBundleFile(target: string): boolean {
+    const bundleExtensions = [".js", ".mjs", ".cjs", ".ts", ".jsx", ".tsx"];
+    const ext = target.split(".").pop()?.toLowerCase();
+    return ext ? bundleExtensions.includes(`.${ext}`) : false;
+  }
+
+  private async containsBundleFiles(dirPath: string): Promise<boolean> {
+    try {
+      const glob = new Bun.Glob("**/*.{js,mjs,cjs,ts,jsx,tsx}");
+      const matches = glob.scanSync({ cwd: dirPath, onlyFiles: true });
+      // Check if there's at least one match
+      for (const _ of matches) {
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  private async runCommandBenchmark(): Promise<BenchmarkResult> {
+    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(`🚀 Benchmarking command: ${target}`);
+    }
+
+    return runBenchmark({
+      command: target,
+      runs,
+      warmup,
+      concurrency,
+      cwd,
+      verbose,
+    });
+  }
+
+  private async runBundleAnalysis(): Promise<BundleAnalysisResult> {
+    if (!this.options.target) {
+      throw new Error("Target is required for bundle analysis");
+    }
+
+    const { target, verbose } = this.options;
+
+    if (verbose) {
+      logger.info(`📦 Analyzing bundle: ${target}`);
+    }
+
+    return analyzeBundle({
+      target,
+      verbose,
+      includeSourceMaps: true,
+      analyzeDependencies: true,
+    });
+  }
+
+  private async runFileSystemAnalysis(): Promise<FileSystemAnalysisResult> {
+    if (!this.options.target) {
+      throw new Error("Target is required for file system analysis");
+    }
+
+    const { target, verbose } = this.options;
+
+    if (verbose) {
+      logger.info(`📁 Analyzing file system: ${target}`);
+    }
+
+    return analyzeFileSystem({
+      target,
+      verbose,
+      maxDepth: 10,
+      includeHidden: false,
+      excludePatterns: [
+        "node_modules",
+        ".git",
+        ".next",
+        ".nuxt",
+        "dist",
+        "build",
+      ],
+    });
+  }
+
+  private async runMonorepoAnalysis(): Promise<MonorepoAnalysisResult> {
+    const { cwd, ignore, verbose } = this.options;
+
+    if (verbose) {
+      logger.info("🏗️ Analyzing monorepo structure");
+    }
+
+    return analyzeMonorepo({
+      cwd,
+      ignore,
+      verbose,
+      includeDevDependencies: true,
+      analyzeBuildOrder: true,
+    });
+  }
+
+  private compareWithBaseline(
+    current: PerfReport,
+    baseline: PerfReport,
+  ): PerfReport["baseline"] {
+    const changes: NonNullable<PerfReport["baseline"]>["changes"] = {};
+
+    // Compare benchmark results
+    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);
+      }
+    }
+
+    // Compare bundle analysis
+    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);
+      }
+    }
+
+    // Compare file system analysis
+    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);
+      }
+    }
+
+    // Calculate overall improvement/regression
+    let improvement: number | undefined;
+    let regression: number | undefined;
+
+    if (changes.duration !== undefined) {
+      if (changes.duration > 0) {
+        improvement = changes.duration;
+      } else {
+        regression = Math.abs(changes.duration);
+      }
+    }
+
+    return {
+      exists: true,
+      improvement,
+      regression,
+      changes,
+    };
+  }
+}
+
+export const runPerfAnalysis = async (
+  options: PerfOptions,
+): Promise<PerfAnalysisResult> => {
+  const analyzer = new PerfAnalyzer(options);
+  return analyzer.analyze();
+};
+
+export const createPerfAnalyzer = (options: PerfOptions): PerfAnalyzer => {
+  return new PerfAnalyzer(options);
+};