@reliverse/dler 1.7.153 → 2.0.1

package/src/cmds/perf/analysis/monorepo.ts

@@ -0,0 +1,439 @@
+// apps/dler/src/cmds/perf/analysis/monorepo.ts
+
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { logger } from "@reliverse/dler-logger";
+import { createIgnoreFilter } from "@reliverse/dler-matcher";
+import {
+  getWorkspacePatterns,
+  hasWorkspaces,
+  readPackageJSON,
+} from "@reliverse/dler-pkg-tsc";
+import type {
+  Bottleneck,
+  CircularDependency,
+  DependencyEdge,
+  DependencyGraph,
+  MonorepoAnalysisResult,
+  PackageInfo,
+} from "../types";
+
+export interface MonorepoAnalysisOptions {
+  cwd?: string;
+  ignore?: string | string[];
+  verbose?: boolean;
+  includeDevDependencies?: boolean;
+  analyzeBuildOrder?: boolean;
+}
+
+export class MonorepoAnalyzer {
+  private options: MonorepoAnalysisOptions;
+  private packages: PackageInfo[] = [];
+  private dependencyGraph: DependencyGraph = {
+    nodes: [],
+    edges: [],
+    levels: [],
+  };
+
+  constructor(options: MonorepoAnalysisOptions) {
+    this.options = options;
+  }
+
+  async analyze(): Promise<MonorepoAnalysisResult> {
+    const startTime = Date.now();
+    const { cwd, verbose } = this.options;
+
+    if (verbose) {
+      logger.info("🔍 Analyzing monorepo structure...");
+    }
+
+    // Find monorepo root
+    const monorepoRoot = await this.findMonorepoRoot(cwd);
+    if (!monorepoRoot) {
+      throw new Error(
+        'No monorepo found. Ensure package.json has "workspaces" field.',
+      );
+    }
+
+    if (verbose) {
+      logger.info(`   Monorepo root: ${monorepoRoot}`);
+    }
+
+    // Discover packages
+    this.packages = await this.discoverPackages(monorepoRoot);
+
+    if (verbose) {
+      logger.info(`   Found ${this.packages.length} packages`);
+    }
+
+    // Build dependency graph
+    this.dependencyGraph = await this.buildDependencyGraph();
+
+    // Analyze circular dependencies
+    const circularDependencies = this.findCircularDependencies();
+
+    // Calculate build order
+    const buildOrder = this.calculateBuildOrder();
+
+    // Find critical path
+    const criticalPath = this.findCriticalPath();
+
+    // Identify bottlenecks
+    const bottlenecks = this.identifyBottlenecks();
+
+    // Suggest optimal concurrency
+    const suggestedConcurrency = this.suggestOptimalConcurrency();
+
+    const analysisTime = Date.now() - startTime;
+
+    if (verbose) {
+      logger.info(`   Analysis completed in ${analysisTime}ms`);
+    }
+
+    return {
+      packages: this.packages,
+      dependencies: this.dependencyGraph,
+      circularDependencies,
+      criticalPath,
+      buildOrder,
+      bottlenecks,
+      suggestedConcurrency,
+      analysisTime,
+    };
+  }
+
+  private async findMonorepoRoot(startDir?: string): Promise<string | null> {
+    let currentDir = resolve(startDir ?? process.cwd());
+
+    while (currentDir !== "/") {
+      const pkgPath = join(currentDir, "package.json");
+
+      if (existsSync(pkgPath)) {
+        const pkg = await readPackageJSON(currentDir);
+        if (pkg && hasWorkspaces(pkg)) {
+          return currentDir;
+        }
+      }
+
+      const parentDir = resolve(currentDir, "..");
+      if (parentDir === currentDir) break;
+      currentDir = parentDir;
+    }
+
+    return null;
+  }
+
+  private async discoverPackages(monorepoRoot: string): Promise<PackageInfo[]> {
+    const rootPkg = await readPackageJSON(monorepoRoot);
+    if (!rootPkg) {
+      throw new Error("Could not read root package.json");
+    }
+
+    const patterns = getWorkspacePatterns(rootPkg);
+    if (!patterns.length) {
+      throw new Error("No workspace patterns found in package.json");
+    }
+
+    const packages: PackageInfo[] = [];
+    const seenPaths = new Set<string>();
+
+    for (const pattern of patterns) {
+      const glob = new Bun.Glob(pattern);
+      const matches = glob.scanSync({ cwd: monorepoRoot, onlyFiles: false });
+
+      for (const match of matches) {
+        const packagePath = resolve(monorepoRoot, match);
+        if (seenPaths.has(packagePath)) continue;
+        seenPaths.add(packagePath);
+
+        const pkgInfo = await this.resolvePackageInfo(packagePath);
+        if (pkgInfo) {
+          packages.push(pkgInfo);
+        }
+      }
+    }
+
+    // Apply ignore filters
+    if (this.options.ignore) {
+      const ignoreFilter = createIgnoreFilter(this.options.ignore);
+      return ignoreFilter(packages);
+    }
+
+    return packages;
+  }
+
+  private async resolvePackageInfo(
+    packagePath: string,
+  ): Promise<PackageInfo | null> {
+    const pkgJsonPath = join(packagePath, "package.json");
+    if (!existsSync(pkgJsonPath)) return null;
+
+    try {
+      const pkg = await readPackageJSON(packagePath);
+      if (!pkg?.name) return null;
+
+      const dependencies = [
+        ...Object.keys(pkg.dependencies ?? {}),
+        ...(this.options.includeDevDependencies
+          ? Object.keys(pkg.devDependencies ?? {})
+          : []),
+        ...Object.keys(pkg.peerDependencies ?? {}),
+      ];
+
+      return {
+        name: pkg.name,
+        path: packagePath,
+        dependencies,
+        dependents: [], // Will be filled later
+        buildTime: 0, // Would need to measure actual build time
+        size: 0, // Would need to calculate package size
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  private async buildDependencyGraph(): Promise<DependencyGraph> {
+    const nodes = this.packages.map((pkg) => pkg.name);
+    const edges: DependencyEdge[] = [];
+
+    // Build dependency edges
+    for (const pkg of this.packages) {
+      for (const dep of pkg.dependencies) {
+        // Check if dependency is within the monorepo
+        const depPkg = this.packages.find((p) => p.name === dep);
+        if (depPkg) {
+          edges.push({
+            from: pkg.name,
+            to: dep,
+            type: "dependency",
+          });
+
+          // Add to dependents
+          depPkg.dependents.push(pkg.name);
+        }
+      }
+    }
+
+    // Calculate levels (topological sort)
+    const levels = this.calculateLevels(nodes, edges);
+
+    return {
+      nodes,
+      edges,
+      levels,
+    };
+  }
+
+  private calculateLevels(
+    nodes: string[],
+    edges: DependencyEdge[],
+  ): string[][] {
+    const inDegree = new Map<string, number>();
+    const graph = new Map<string, string[]>();
+
+    // Initialize
+    for (const node of nodes) {
+      inDegree.set(node, 0);
+      graph.set(node, []);
+    }
+
+    // Build graph and calculate in-degrees
+    for (const edge of edges) {
+      const current = inDegree.get(edge.to) ?? 0;
+      inDegree.set(edge.to, current + 1);
+
+      const neighbors = graph.get(edge.from) ?? [];
+      neighbors.push(edge.to);
+      graph.set(edge.from, neighbors);
+    }
+
+    // Topological sort
+    const levels: string[][] = [];
+    const queue: string[] = [];
+
+    // Start with nodes that have no dependencies
+    for (const [node, degree] of inDegree) {
+      if (degree === 0) {
+        queue.push(node);
+      }
+    }
+
+    while (queue.length > 0) {
+      const currentLevel: string[] = [];
+      const nextQueue: string[] = [];
+
+      for (const node of queue) {
+        currentLevel.push(node);
+
+        // Process neighbors
+        const neighbors = graph.get(node) ?? [];
+        for (const neighbor of neighbors) {
+          const degree = inDegree.get(neighbor) ?? 0;
+          inDegree.set(neighbor, degree - 1);
+
+          if (degree - 1 === 0) {
+            nextQueue.push(neighbor);
+          }
+        }
+      }
+
+      levels.push(currentLevel);
+      queue.length = 0;
+      queue.push(...nextQueue);
+    }
+
+    return levels;
+  }
+
+  private findCircularDependencies(): CircularDependency[] {
+    const circular: CircularDependency[] = [];
+    const visited = new Set<string>();
+    const recursionStack = new Set<string>();
+
+    for (const pkg of this.packages) {
+      if (!visited.has(pkg.name)) {
+        const cycle = this.detectCycle(pkg.name, visited, recursionStack, []);
+        if (cycle.length > 0) {
+          circular.push({
+            packages: cycle,
+            cycle,
+            severity: this.calculateCycleSeverity(cycle),
+          });
+        }
+      }
+    }
+
+    return circular;
+  }
+
+  private detectCycle(
+    node: string,
+    visited: Set<string>,
+    recursionStack: Set<string>,
+    path: string[],
+  ): string[] {
+    visited.add(node);
+    recursionStack.add(node);
+    path.push(node);
+
+    const pkg = this.packages.find((p) => p.name === node);
+    if (pkg) {
+      for (const dep of pkg.dependencies) {
+        const depPkg = this.packages.find((p) => p.name === dep);
+        if (depPkg) {
+          if (!visited.has(dep)) {
+            const cycle = this.detectCycle(dep, visited, recursionStack, [
+              ...path,
+            ]);
+            if (cycle.length > 0) {
+              return cycle;
+            }
+          } else if (recursionStack.has(dep)) {
+            // Found a cycle
+            const cycleStart = path.indexOf(dep);
+            return path.slice(cycleStart);
+          }
+        }
+      }
+    }
+
+    recursionStack.delete(node);
+    return [];
+  }
+
+  private calculateCycleSeverity(cycle: string[]): "low" | "medium" | "high" {
+    if (cycle.length <= 2) return "low";
+    if (cycle.length <= 4) return "medium";
+    return "high";
+  }
+
+  private calculateBuildOrder(): string[] {
+    const order: string[] = [];
+
+    for (const level of this.dependencyGraph.levels) {
+      order.push(...level);
+    }
+
+    return order;
+  }
+
+  private findCriticalPath(): string[] {
+    // Simple heuristic: packages with the most dependents
+    const dependentCounts = new Map<string, number>();
+
+    for (const pkg of this.packages) {
+      dependentCounts.set(pkg.name, pkg.dependents.length);
+    }
+
+    return Array.from(dependentCounts.entries())
+      .sort(([, a], [, b]) => b - a)
+      .map(([name]) => name);
+  }
+
+  private identifyBottlenecks(): Bottleneck[] {
+    const bottlenecks: Bottleneck[] = [];
+
+    // Find packages with many dependencies
+    for (const pkg of this.packages) {
+      if (pkg.dependencies.length > 10) {
+        bottlenecks.push({
+          package: pkg.name,
+          type: "many-dependencies",
+          impact: pkg.dependencies.length,
+          suggestion: `Consider splitting ${pkg.name} - it has ${pkg.dependencies.length} dependencies`,
+        });
+      }
+    }
+
+    // Find circular dependencies
+    const circularDeps = this.findCircularDependencies();
+    for (const circular of circularDeps) {
+      bottlenecks.push({
+        package: circular.packages[0]!,
+        type: "circular-dependency",
+        impact: circular.packages.length,
+        suggestion: `Resolve circular dependency: ${circular.cycle.join(" → ")}`,
+      });
+    }
+
+    // Find slow packages (heuristic based on dependents)
+    for (const pkg of this.packages) {
+      if (pkg.dependents.length > 5) {
+        bottlenecks.push({
+          package: pkg.name,
+          type: "slow-build",
+          impact: pkg.dependents.length,
+          suggestion: `Optimize ${pkg.name} - it blocks ${pkg.dependents.length} other packages`,
+        });
+      }
+    }
+
+    return bottlenecks.sort((a, b) => b.impact - a.impact);
+  }
+
+  private suggestOptimalConcurrency(): number {
+    // Simple heuristic based on dependency levels
+    const maxLevel = this.dependencyGraph.levels.length;
+    const avgLevelSize = this.packages.length / maxLevel;
+
+    // Suggest concurrency based on level size and CPU cores
+    const cpuCores = require("node:os").cpus().length;
+    const suggested = Math.min(Math.ceil(avgLevelSize), cpuCores);
+
+    return Math.max(1, suggested);
+  }
+}
+
+export const analyzeMonorepo = async (
+  options: MonorepoAnalysisOptions,
+): Promise<MonorepoAnalysisResult> => {
+  const analyzer = new MonorepoAnalyzer(options);
+  return analyzer.analyze();
+};
+
+export const createMonorepoAnalyzer = (
+  options: MonorepoAnalysisOptions,
+): MonorepoAnalyzer => {
+  return new MonorepoAnalyzer(options);
+};

package/src/cmds/perf/benchmarks/command.ts

@@ -0,0 +1,230 @@
+// apps/dler/src/cmds/perf/benchmarks/command.ts
+
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { lookpath } from "lookpath";
+import type { Measurement, MemoryUsage } from "../types";
+
+export interface CommandExecutionOptions {
+  cwd?: string;
+  timeout?: number;
+  env?: Record<string, string>;
+}
+
+export interface CommandResult {
+  success: boolean;
+  duration: number;
+  memory: MemoryUsage;
+  stdout: string;
+  stderr: string;
+  error?: string;
+  exitCode: number;
+}
+
+export const executeCommand = async (
+  command: string,
+  options: CommandExecutionOptions = {},
+): Promise<CommandResult> => {
+  const startTime = process.hrtime.bigint();
+
+  try {
+    // Parse command and arguments
+    const [cmd, ...args] = parseCommand(command);
+
+    // Check if command exists
+    if (!cmd) {
+      throw new Error("Command is empty");
+    }
+
+    const commandPath = await findCommand(cmd);
+    if (!commandPath) {
+      throw new Error(`Command not found: ${cmd}`);
+    }
+
+    // Execute command
+    const proc = Bun.spawn([commandPath, ...args], {
+      cwd: options.cwd ?? process.cwd(),
+      env: { ...process.env, ...options.env },
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Set timeout if specified
+    let timeoutId: Timer | undefined;
+    if (options.timeout) {
+      timeoutId = setTimeout(() => {
+        proc.kill();
+      }, options.timeout);
+    }
+
+    // Wait for completion
+    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();
+
+    // Clear timeout
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+
+    const duration = Number(endTime - startTime) / 1_000_000; // Convert to milliseconds
+
+    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) / 1_000_000;
+
+    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: string,
+  options: CommandExecutionOptions = {},
+): Promise<Measurement> => {
+  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: string): string[] => {
+  // Simple command parsing - handles basic cases
+  // For more complex cases, consider using a proper shell parser
+  const parts: string[] = [];
+  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: string): Promise<string | null> => {
+  if (!cmd) {
+    return null;
+  }
+
+  // Check if it's a dler command first
+  if (cmd === "dler") {
+    return "bun";
+  }
+
+  // Check if it's a Bun command
+  if (cmd === "bun") {
+    return "bun";
+  }
+
+  // Check if it's a Node.js command
+  if (cmd === "node") {
+    return "node";
+  }
+
+  // Check if it's a direct executable
+  if (cmd.includes("/") || cmd.includes("\\")) {
+    const fullPath = resolve(cmd);
+    return existsSync(fullPath) ? fullPath : null;
+  }
+
+  // Use lookpath to find the command
+  try {
+    const path = await lookpath(cmd);
+    return path ?? null;
+  } catch {
+    return null;
+  }
+};
+
+export const isDlerCommand = (command: string): boolean => {
+  return command.startsWith("dler ") || command === "dler";
+};
+
+export const isBunCommand = (command: string): boolean => {
+  return command.startsWith("bun ") || command === "bun";
+};
+
+export const isNodeCommand = (command: string): boolean => {
+  return command.startsWith("node ") || command === "node";
+};
+
+export const getCommandType = (
+  command: string,
+): "dler" | "bun" | "node" | "external" => {
+  if (isDlerCommand(command)) return "dler";
+  if (isBunCommand(command)) return "bun";
+  if (isNodeCommand(command)) return "node";
+  return "external";
+};