@reliverse/dler 2.2.5 → 2.2.10

package/dist/cmds/perf/analysis/monorepo.js

@@ -1,345 +0,0 @@
-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";
-export class MonorepoAnalyzer {
-  options;
-  packages = [];
-  dependencyGraph = {
-    nodes: [],
-    edges: [],
-    levels: []
-  };
-  constructor(options) {
-    this.options = options;
-  }
-  async analyze() {
-    const startTime = Date.now();
-    const { cwd, verbose } = this.options;
-    if (verbose) {
-      logger.info("\u{1F50D} Analyzing monorepo structure...");
-    }
-    const monorepoRoot = await this.findMonorepoRoot(cwd);
-    if (!monorepoRoot) {
-      const currentDir = cwd || process.cwd();
-      const singlePkg = await this.discoverSinglePackage(currentDir);
-      if (singlePkg) {
-        this.packages = [singlePkg];
-        if (verbose) {
-          logger.info(`   Single package root: ${currentDir}`);
-          logger.info("   Found 1 package");
-        }
-      } else {
-        throw new Error(
-          'No monorepo or valid package found. Ensure package.json has "workspaces" field or contains a valid "name" field.'
-        );
-      }
-    } else {
-      if (verbose) {
-        logger.info(`   Monorepo root: ${monorepoRoot}`);
-      }
-      this.packages = await this.discoverPackages(monorepoRoot);
-    }
-    if (verbose) {
-      logger.info(`   Found ${this.packages.length} packages`);
-    }
-    this.dependencyGraph = await this.buildDependencyGraph();
-    const circularDependencies = this.findCircularDependencies();
-    const buildOrder = this.calculateBuildOrder();
-    const criticalPath = this.findCriticalPath();
-    const bottlenecks = this.identifyBottlenecks();
-    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
-    };
-  }
-  async findMonorepoRoot(startDir) {
-    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;
-  }
-  async discoverPackages(monorepoRoot) {
-    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 = [];
-    const seenPaths = /* @__PURE__ */ new Set();
-    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);
-        }
-      }
-    }
-    const filteredPackages = packages.filter((pkg) => {
-      const normalizedPkgPath = resolve(pkg.path);
-      const normalizedRootPath = resolve(monorepoRoot);
-      return normalizedPkgPath !== normalizedRootPath;
-    });
-    if (this.options.ignore) {
-      const ignoreFilter = createIgnoreFilter(this.options.ignore);
-      return ignoreFilter(filteredPackages);
-    }
-    return filteredPackages;
-  }
-  async discoverSinglePackage(packagePath) {
-    try {
-      const pkg = await readPackageJSON(packagePath);
-      if (!pkg || !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,
-        size: 0
-      };
-    } catch {
-      return null;
-    }
-  }
-  async resolvePackageInfo(packagePath) {
-    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;
-    }
-  }
-  async buildDependencyGraph() {
-    const nodes = this.packages.map((pkg) => pkg.name);
-    const edges = [];
-    for (const pkg of this.packages) {
-      for (const dep of pkg.dependencies) {
-        const depPkg = this.packages.find((p) => p.name === dep);
-        if (depPkg) {
-          edges.push({
-            from: pkg.name,
-            to: dep,
-            type: "dependency"
-          });
-          depPkg.dependents.push(pkg.name);
-        }
-      }
-    }
-    const levels = this.calculateLevels(nodes, edges);
-    return {
-      nodes,
-      edges,
-      levels
-    };
-  }
-  calculateLevels(nodes, edges) {
-    const inDegree = /* @__PURE__ */ new Map();
-    const graph = /* @__PURE__ */ new Map();
-    for (const node of nodes) {
-      inDegree.set(node, 0);
-      graph.set(node, []);
-    }
-    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);
-    }
-    const levels = [];
-    const queue = [];
-    for (const [node, degree] of inDegree) {
-      if (degree === 0) {
-        queue.push(node);
-      }
-    }
-    while (queue.length > 0) {
-      const currentLevel = [];
-      const nextQueue = [];
-      for (const node of queue) {
-        currentLevel.push(node);
-        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;
-  }
-  findCircularDependencies() {
-    const circular = [];
-    const visited = /* @__PURE__ */ new Set();
-    const recursionStack = /* @__PURE__ */ new Set();
-    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;
-  }
-  detectCycle(node, visited, recursionStack, path) {
-    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)) {
-            const cycleStart = path.indexOf(dep);
-            return path.slice(cycleStart);
-          }
-        }
-      }
-    }
-    recursionStack.delete(node);
-    return [];
-  }
-  calculateCycleSeverity(cycle) {
-    if (cycle.length <= 2) return "low";
-    if (cycle.length <= 4) return "medium";
-    return "high";
-  }
-  calculateBuildOrder() {
-    const order = [];
-    for (const level of this.dependencyGraph.levels) {
-      order.push(...level);
-    }
-    return order;
-  }
-  findCriticalPath() {
-    const dependentCounts = /* @__PURE__ */ new Map();
-    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);
-  }
-  identifyBottlenecks() {
-    const bottlenecks = [];
-    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`
-        });
-      }
-    }
-    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(" \u2192 ")}`
-      });
-    }
-    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);
-  }
-  suggestOptimalConcurrency() {
-    const maxLevel = this.dependencyGraph.levels.length;
-    const avgLevelSize = this.packages.length / maxLevel;
-    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) => {
-  const analyzer = new MonorepoAnalyzer(options);
-  return analyzer.analyze();
-};
-export const createMonorepoAnalyzer = (options) => {
-  return new MonorepoAnalyzer(options);
-};

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

@@ -1,21 +0,0 @@
-import type { Measurement, MemoryUsage } from "../types.js";
-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 declare const executeCommand: (command: string, options?: CommandExecutionOptions) => Promise<CommandResult>;
-export declare const executeCommandWithMemoryTracking: (command: string, options?: CommandExecutionOptions) => Promise<Measurement>;
-export declare const isDlerCommand: (command: string) => boolean;
-export declare const isBunCommand: (command: string) => boolean;
-export declare const isNodeCommand: (command: string) => boolean;
-export declare const getCommandType: (command: string) => "dler" | "bun" | "node" | "external";

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

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

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