@reliverse/dler 2.0.0 → 2.0.1

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

@@ -0,0 +1,246 @@
+import { existsSync, statSync } from "node:fs";
+import { extname, join, resolve } from "node:path";
+import { logger } from "@reliverse/dler-logger";
+import { formatBytes } from "../utils/formatter.js";
+export class FileSystemAnalyzer {
+  options;
+  fileCount = 0;
+  totalSize = 0;
+  directoryCount = 0;
+  maxDepth = 0;
+  files = [];
+  directories = [];
+  fileTypes = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = options;
+  }
+  async analyze() {
+    const startTime = Date.now();
+    const { target, verbose } = this.options;
+    if (verbose) {
+      logger.info(`\u{1F50D} Analyzing filesystem: ${target}`);
+    }
+    const targetPath = resolve(target);
+    if (!existsSync(targetPath)) {
+      throw new Error(`Target not found: ${target}`);
+    }
+    const stat = statSync(targetPath);
+    if (stat.isFile()) {
+      await this.analyzeFile(targetPath, 0);
+    } else {
+      await this.analyzeDirectory(targetPath, 0);
+    }
+    this.files.sort((a, b) => b.size - a.size);
+    this.directories.sort((a, b) => b.size - a.size);
+    const fileTypeDistribution = Array.from(
+      this.fileTypes.entries()
+    ).map(([extension, info]) => ({
+      extension,
+      count: info.count,
+      totalSize: info.totalSize,
+      percentage: info.totalSize / this.totalSize * 100
+    })).sort((a, b) => b.totalSize - a.totalSize);
+    const compressionPotential = this.calculateCompressionPotential();
+    const analysisTime = Date.now() - startTime;
+    if (verbose) {
+      logger.info(`   Analysis completed in ${analysisTime}ms`);
+      logger.info(
+        `   Files: ${this.fileCount}, Directories: ${this.directoryCount}, Size: ${formatBytes(this.totalSize)}`
+      );
+    }
+    return {
+      target,
+      totalFiles: this.fileCount,
+      totalSize: this.totalSize,
+      directoryCount: this.directoryCount,
+      maxDepth: this.maxDepth,
+      largestFiles: this.files.slice(0, 20),
+      // Top 20
+      largestDirectories: this.directories.slice(0, 20),
+      // Top 20
+      fileTypes: fileTypeDistribution,
+      compressionPotential,
+      analysisTime
+    };
+  }
+  async analyzeFile(filePath, depth) {
+    try {
+      const stat = statSync(filePath);
+      const ext = extname(filePath);
+      if (this.shouldExclude(filePath)) {
+        return;
+      }
+      this.fileCount++;
+      this.totalSize += stat.size;
+      this.maxDepth = Math.max(this.maxDepth, depth);
+      this.files.push({
+        path: filePath,
+        size: stat.size,
+        percentage: 0,
+        // Will be calculated later
+        type: this.getFileType(ext)
+      });
+      const extension = ext || "no-extension";
+      const existing = this.fileTypes.get(extension);
+      if (existing) {
+        existing.count++;
+        existing.totalSize += stat.size;
+      } else {
+        this.fileTypes.set(extension, {
+          count: 1,
+          totalSize: stat.size
+        });
+      }
+    } catch (error) {
+      if (this.options.verbose) {
+        logger.warn(`Cannot access file ${filePath}:`, error);
+      }
+    }
+  }
+  async analyzeDirectory(dirPath, depth) {
+    try {
+      this.directoryCount++;
+      this.maxDepth = Math.max(this.maxDepth, depth);
+      if (this.shouldExclude(dirPath)) {
+        return;
+      }
+      let dirSize = 0;
+      let dirFileCount = 0;
+      const glob = new Bun.Glob("**/*");
+      const matches = glob.scanSync({
+        cwd: dirPath,
+        onlyFiles: false,
+        dot: this.options.includeHidden ?? false
+      });
+      for (const match of matches) {
+        const fullPath = join(dirPath, match);
+        try {
+          const stat = statSync(fullPath);
+          if (stat.isFile()) {
+            await this.analyzeFile(fullPath, depth + 1);
+            dirSize += stat.size;
+            dirFileCount++;
+          } else if (stat.isDirectory()) {
+            await this.analyzeDirectory(fullPath, depth + 1);
+          }
+        } catch (error) {
+          if (this.options.verbose) {
+            logger.warn(`Cannot access ${fullPath}:`, error);
+          }
+        }
+      }
+      this.directories.push({
+        path: dirPath,
+        size: dirSize,
+        fileCount: dirFileCount,
+        depth
+      });
+    } catch (error) {
+      if (this.options.verbose) {
+        logger.warn(`Cannot access directory ${dirPath}:`, error);
+      }
+    }
+  }
+  shouldExclude(path) {
+    const { excludePatterns = [] } = this.options;
+    for (const pattern of excludePatterns) {
+      if (path.includes(pattern)) {
+        return true;
+      }
+    }
+    const defaultExclusions = [
+      "node_modules",
+      ".git",
+      ".next",
+      ".nuxt",
+      ".expo",
+      "dist",
+      "build",
+      "coverage",
+      ".cache",
+      ".turbo"
+    ];
+    for (const exclusion of defaultExclusions) {
+      if (path.includes(exclusion)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getFileType(extension) {
+    const typeMap = {
+      ".js": "JavaScript",
+      ".mjs": "ES Module",
+      ".cjs": "CommonJS",
+      ".ts": "TypeScript",
+      ".jsx": "React JSX",
+      ".tsx": "React TSX",
+      ".json": "JSON",
+      ".css": "CSS",
+      ".scss": "SCSS",
+      ".sass": "Sass",
+      ".less": "Less",
+      ".html": "HTML",
+      ".svg": "SVG",
+      ".png": "PNG",
+      ".jpg": "JPEG",
+      ".jpeg": "JPEG",
+      ".gif": "GIF",
+      ".webp": "WebP",
+      ".woff": "WOFF",
+      ".woff2": "WOFF2",
+      ".ttf": "TrueType",
+      ".eot": "EOT",
+      ".map": "Source Map",
+      ".d.ts": "TypeScript Declarations",
+      ".md": "Markdown",
+      ".txt": "Text",
+      ".yml": "YAML",
+      ".yaml": "YAML",
+      ".xml": "XML",
+      ".pdf": "PDF",
+      ".zip": "ZIP",
+      ".tar": "TAR",
+      ".gz": "GZIP"
+    };
+    return typeMap[extension] ?? "Unknown";
+  }
+  calculateCompressionPotential() {
+    if (this.totalSize === 0) return 0;
+    let compressibleSize = 0;
+    for (const [extension, info] of this.fileTypes) {
+      const compressibleExtensions = [
+        ".js",
+        ".mjs",
+        ".cjs",
+        ".ts",
+        ".jsx",
+        ".tsx",
+        ".json",
+        ".css",
+        ".scss",
+        ".sass",
+        ".less",
+        ".html",
+        ".svg",
+        ".md",
+        ".txt",
+        ".yml",
+        ".yaml",
+        ".xml"
+      ];
+      if (compressibleExtensions.includes(extension)) {
+        compressibleSize += info.totalSize;
+      }
+    }
+    const estimatedCompression = compressibleSize * 0.7;
+    return estimatedCompression / this.totalSize * 100;
+  }
+}
+export const analyzeFileSystem = async (options) => {
+  const analyzer = new FileSystemAnalyzer(options);
+  return analyzer.analyze();
+};
+export const createFileSystemAnalyzer = (options) => {
+  return new FileSystemAnalyzer(options);
+};

package/dist/cmds/perf/analysis/monorepo.d.ts

@@ -0,0 +1,29 @@
+import type { MonorepoAnalysisResult } from "../types.js";
+export interface MonorepoAnalysisOptions {
+    cwd?: string;
+    ignore?: string | string[];
+    verbose?: boolean;
+    includeDevDependencies?: boolean;
+    analyzeBuildOrder?: boolean;
+}
+export declare class MonorepoAnalyzer {
+    private options;
+    private packages;
+    private dependencyGraph;
+    constructor(options: MonorepoAnalysisOptions);
+    analyze(): Promise<MonorepoAnalysisResult>;
+    private findMonorepoRoot;
+    private discoverPackages;
+    private resolvePackageInfo;
+    private buildDependencyGraph;
+    private calculateLevels;
+    private findCircularDependencies;
+    private detectCycle;
+    private calculateCycleSeverity;
+    private calculateBuildOrder;
+    private findCriticalPath;
+    private identifyBottlenecks;
+    private suggestOptimalConcurrency;
+}
+export declare const analyzeMonorepo: (options: MonorepoAnalysisOptions) => Promise<MonorepoAnalysisResult>;
+export declare const createMonorepoAnalyzer: (options: MonorepoAnalysisOptions) => MonorepoAnalyzer;

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

@@ -0,0 +1,307 @@
+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) {
+      throw new Error(
+        'No monorepo found. Ensure package.json has "workspaces" field.'
+      );
+    }
+    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);
+        }
+      }
+    }
+    if (this.options.ignore) {
+      const ignoreFilter = createIgnoreFilter(this.options.ignore);
+      return ignoreFilter(packages);
+    }
+    return packages;
+  }
+  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

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