@reliverse/dler 2.0.6 → 2.0.7

package/src/cmds/perf/cmd.ts

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

@@ -1,411 +0,0 @@
-// 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);
-};