@reliverse/dler 1.7.153 → 2.0.1

package/src/cmds/perf/reporters/json.ts

@@ -0,0 +1,42 @@
+// apps/dler/src/cmds/perf/reporters/json.ts
+
+import { writeFileSync } from "node:fs";
+import { logger } from "@reliverse/dler-logger";
+import type { PerfReport } from "../types";
+
+export class JsonReporter {
+  private outputPath?: string;
+
+  constructor(outputPath?: string) {
+    this.outputPath = outputPath;
+  }
+
+  report(report: PerfReport): void {
+    const json = JSON.stringify(report, null, 2);
+
+    if (this.outputPath) {
+      try {
+        writeFileSync(this.outputPath, json, "utf-8");
+        logger.success(`📄 JSON report saved to: ${this.outputPath}`);
+      } catch (error) {
+        logger.error(`Failed to save JSON report: ${error}`);
+      }
+    } else {
+      console.log(json);
+    }
+  }
+
+  static save(report: PerfReport, outputPath: string): void {
+    const reporter = new JsonReporter(outputPath);
+    reporter.report(report);
+  }
+
+  static print(report: PerfReport): void {
+    const reporter = new JsonReporter();
+    reporter.report(report);
+  }
+}
+
+export const createJsonReporter = (outputPath?: string): JsonReporter => {
+  return new JsonReporter(outputPath);
+};

package/src/cmds/perf/types.ts

@@ -0,0 +1,220 @@
+// apps/dler/src/cmds/perf/types.ts
+
+export interface PerfOptions {
+  target?: string;
+  type?: string;
+  runs?: number;
+  warmup?: number;
+  concurrency?: number;
+  compare?: boolean;
+  output?: string;
+  save?: boolean;
+  verbose?: boolean;
+  cwd?: string;
+  ignore?: string | string[];
+}
+
+export type PerfAnalysisType =
+  | "command"
+  | "bundle"
+  | "file"
+  | "monorepo"
+  | "auto";
+export type PerfOutputFormat = "console" | "json" | "html" | "all";
+
+export interface BenchmarkResult {
+  command: string;
+  runs: number;
+  warmup: number;
+  concurrency: number;
+  measurements: Measurement[];
+  statistics: Statistics;
+  memory: MemoryStats;
+  executionTime: number;
+  success: boolean;
+  error?: string;
+}
+
+export interface Measurement {
+  run: number;
+  duration: number;
+  memory: MemoryUsage;
+  success: boolean;
+  error?: string;
+  stdout?: string;
+  stderr?: string;
+}
+
+export interface Statistics {
+  min: number;
+  max: number;
+  mean: number;
+  median: number;
+  p95: number;
+  p99: number;
+  variance: number;
+  standardDeviation: number;
+  coefficientOfVariation: number;
+}
+
+export interface MemoryUsage {
+  rss: number;
+  heapTotal: number;
+  heapUsed: number;
+  external: number;
+  arrayBuffers: number;
+}
+
+export interface MemoryStats {
+  peak: MemoryUsage;
+  average: MemoryUsage;
+  growth: number;
+}
+
+export interface BundleAnalysisResult {
+  target: string;
+  totalSize: number;
+  fileCount: number;
+  largestFiles: FileSize[];
+  modules: ModuleInfo[];
+  duplicates: DuplicateInfo[];
+  compressionPotential: number;
+  analysisTime: number;
+}
+
+export interface FileSize {
+  path: string;
+  size: number;
+  percentage: number;
+  type: string;
+}
+
+export interface ModuleInfo {
+  name: string;
+  size: number;
+  percentage: number;
+  dependencies: string[];
+  isExternal: boolean;
+}
+
+export interface DuplicateInfo {
+  name: string;
+  count: number;
+  totalSize: number;
+  locations: string[];
+}
+
+export interface FileSystemAnalysisResult {
+  target: string;
+  totalFiles: number;
+  totalSize: number;
+  directoryCount: number;
+  maxDepth: number;
+  largestFiles: FileSize[];
+  largestDirectories: DirectorySize[];
+  fileTypes: FileTypeDistribution[];
+  compressionPotential: number;
+  analysisTime: number;
+}
+
+export interface DirectorySize {
+  path: string;
+  size: number;
+  fileCount: number;
+  depth: number;
+}
+
+export interface FileTypeDistribution {
+  extension: string;
+  count: number;
+  totalSize: number;
+  percentage: number;
+}
+
+export interface MonorepoAnalysisResult {
+  packages: PackageInfo[];
+  dependencies: DependencyGraph;
+  circularDependencies: CircularDependency[];
+  criticalPath: string[];
+  buildOrder: string[];
+  bottlenecks: Bottleneck[];
+  suggestedConcurrency: number;
+  analysisTime: number;
+}
+
+export interface PackageInfo {
+  name: string;
+  path: string;
+  dependencies: string[];
+  dependents: string[];
+  buildTime?: number;
+  size?: number;
+}
+
+export interface DependencyGraph {
+  nodes: string[];
+  edges: DependencyEdge[];
+  levels: string[][];
+}
+
+export interface DependencyEdge {
+  from: string;
+  to: string;
+  type: "dependency" | "devDependency" | "peerDependency";
+}
+
+export interface CircularDependency {
+  packages: string[];
+  cycle: string[];
+  severity: "low" | "medium" | "high";
+}
+
+export interface Bottleneck {
+  package: string;
+  type: "slow-build" | "many-dependencies" | "circular-dependency";
+  impact: number;
+  suggestion: string;
+}
+
+export interface PerfReport {
+  timestamp: number;
+  options: PerfOptions;
+  benchmark?: BenchmarkResult;
+  bundleAnalysis?: BundleAnalysisResult;
+  fileSystemAnalysis?: FileSystemAnalysisResult;
+  monorepoAnalysis?: MonorepoAnalysisResult;
+  baseline?: BaselineComparison;
+}
+
+export interface BaselineComparison {
+  exists: boolean;
+  improvement?: number;
+  regression?: number;
+  changes?: ChangeSummary;
+}
+
+export interface ChangeSummary {
+  duration?: number;
+  memory?: number;
+  size?: number;
+  files?: number;
+}
+
+export interface CacheEntry {
+  timestamp: number;
+  report: PerfReport;
+  hash: string;
+}
+
+export interface CacheOptions {
+  enabled: boolean;
+  cacheDir: string;
+  maxAge: number;
+}
+
+export type AnalysisResult =
+  | BundleAnalysisResult
+  | FileSystemAnalysisResult
+  | MonorepoAnalysisResult;
+
+export type OutputFormat = PerfOutputFormat;

package/src/cmds/perf/utils/cache.ts

@@ -0,0 +1,234 @@
+// apps/dler/src/cmds/perf/utils/cache.ts
+
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import type { CacheEntry, CacheOptions, PerfReport } from "../types";
+
+export class PerfCache {
+  private options: CacheOptions;
+  private cacheDir: string;
+
+  constructor(options: CacheOptions) {
+    this.options = options;
+    this.cacheDir = resolve(options.cacheDir);
+    this.ensureCacheDir();
+  }
+
+  private ensureCacheDir(): void {
+    if (!existsSync(this.cacheDir)) {
+      mkdirSync(this.cacheDir, { recursive: true });
+    }
+  }
+
+  private generateHash(report: PerfReport): string {
+    const content = JSON.stringify({
+      target: report.options.target,
+      type: report.options.type,
+      // Exclude timestamp and other volatile fields
+      benchmark: report.benchmark
+        ? {
+            command: report.benchmark.command,
+            runs: report.benchmark.runs,
+            concurrency: report.benchmark.concurrency,
+          }
+        : undefined,
+    });
+
+    return createHash("sha256").update(content).digest("hex").substring(0, 16);
+  }
+
+  private getCachePath(hash: string): string {
+    return join(this.cacheDir, `${hash}.json`);
+  }
+
+  private isExpired(entry: CacheEntry): boolean {
+    if (!this.options.enabled) return true;
+
+    const age = Date.now() - entry.timestamp;
+    return age > this.options.maxAge;
+  }
+
+  async save(report: PerfReport): Promise<void> {
+    if (!this.options.enabled) return;
+
+    try {
+      const hash = this.generateHash(report);
+      const entry: CacheEntry = {
+        timestamp: Date.now(),
+        report,
+        hash,
+      };
+
+      const cachePath = this.getCachePath(hash);
+      writeFileSync(cachePath, JSON.stringify(entry, null, 2));
+    } catch (error) {
+      // Silently fail cache operations
+      console.warn("Failed to save performance cache:", error);
+    }
+  }
+
+  async load(target: string, type?: string): Promise<PerfReport | null> {
+    if (!this.options.enabled) return null;
+
+    try {
+      // Find all cache files
+      const cacheFiles = Array.from(
+        new Bun.Glob("*.json").scanSync({ cwd: this.cacheDir }),
+      );
+
+      for (const file of cacheFiles) {
+        const cachePath = join(this.cacheDir, file);
+
+        try {
+          const content = readFileSync(cachePath, "utf-8");
+          const entry: CacheEntry = JSON.parse(content);
+
+          if (this.isExpired(entry)) {
+            continue;
+          }
+
+          // Check if this matches our target
+          if (
+            entry.report.options.target === target &&
+            (!type || entry.report.options.type === type)
+          ) {
+            return entry.report;
+          }
+        } catch {
+          // Skip invalid cache files
+          continue;
+        }
+      }
+
+      return null;
+    } catch (error) {
+      // Silently fail cache operations
+      console.warn("Failed to load performance cache:", error);
+      return null;
+    }
+  }
+
+  async findBaseline(
+    target: string,
+    type?: string,
+  ): Promise<PerfReport | null> {
+    return this.load(target, type);
+  }
+
+  async listBaselines(): Promise<
+    Array<{ target: string; type?: string; timestamp: number; hash: string }>
+  > {
+    if (!this.options.enabled) return [];
+
+    try {
+      const cacheFiles = Array.from(
+        new Bun.Glob("*.json").scanSync({ cwd: this.cacheDir }),
+      );
+      const baselines: Array<{
+        target: string;
+        type?: string;
+        timestamp: number;
+        hash: string;
+      }> = [];
+
+      for (const file of cacheFiles) {
+        const cachePath = join(this.cacheDir, file);
+
+        try {
+          const content = readFileSync(cachePath, "utf-8");
+          const entry: CacheEntry = JSON.parse(content);
+
+          if (!this.isExpired(entry)) {
+            baselines.push({
+              target: entry.report.options.target ?? "unknown",
+              type: entry.report.options.type,
+              timestamp: entry.timestamp,
+              hash: entry.hash,
+            });
+          }
+        } catch {
+          // Skip invalid cache files
+          continue;
+        }
+      }
+
+      return baselines.sort((a, b) => b.timestamp - a.timestamp);
+    } catch (error) {
+      console.warn("Failed to list performance baselines:", error);
+      return [];
+    }
+  }
+
+  async clear(): Promise<void> {
+    if (!this.options.enabled) return;
+
+    try {
+      const cacheFiles = Array.from(
+        new Bun.Glob("*.json").scanSync({ cwd: this.cacheDir }),
+      );
+
+      for (const file of cacheFiles) {
+        const cachePath = join(this.cacheDir, file);
+        try {
+          Bun.write(cachePath, "");
+        } catch {
+          // Ignore deletion errors
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to clear performance cache:", error);
+    }
+  }
+
+  async cleanup(): Promise<void> {
+    if (!this.options.enabled) return;
+
+    try {
+      const cacheFiles = Array.from(
+        new Bun.Glob("*.json").scanSync({ cwd: this.cacheDir }),
+      );
+
+      for (const file of cacheFiles) {
+        const cachePath = join(this.cacheDir, file);
+
+        try {
+          const content = readFileSync(cachePath, "utf-8");
+          const entry: CacheEntry = JSON.parse(content);
+
+          if (this.isExpired(entry)) {
+            Bun.write(cachePath, "");
+          }
+        } catch {
+          // Skip invalid cache files
+          continue;
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to cleanup performance cache:", error);
+    }
+  }
+
+  getCacheSize(): number {
+    try {
+      const cacheFiles = Array.from(
+        new Bun.Glob("*.json").scanSync({ cwd: this.cacheDir }),
+      );
+      return cacheFiles.length;
+    } catch {
+      return 0;
+    }
+  }
+}
+
+export const createPerfCache = (
+  options: Partial<CacheOptions> = {},
+): PerfCache => {
+  const defaultOptions: CacheOptions = {
+    enabled: true,
+    cacheDir: ".dler-cache/perf",
+    maxAge: 7 * 24 * 60 * 60 * 1000, // 7 days
+  };
+
+  return new PerfCache({ ...defaultOptions, ...options });
+};

package/src/cmds/perf/utils/formatter.ts

@@ -0,0 +1,190 @@
+// apps/dler/src/cmds/perf/utils/formatter.ts
+
+export const formatDuration = (ms: number): string => {
+  if (ms < 1000) {
+    return `${ms.toFixed(2)}ms`;
+  }
+  if (ms < 60000) {
+    return `${(ms / 1000).toFixed(2)}s`;
+  }
+  const minutes = Math.floor(ms / 60000);
+  const seconds = ((ms % 60000) / 1000).toFixed(2);
+  return `${minutes}m ${seconds}s`;
+};
+
+export const formatBytes = (bytes: number): string => {
+  if (bytes === 0) return "0 B";
+
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+};
+
+export const formatPercentage = (value: number, total: number): string => {
+  if (total === 0) return "0.00%";
+  return `${((value / total) * 100).toFixed(2)}%`;
+};
+
+export const formatNumber = (num: number): string => {
+  if (num < 1000) return num.toString();
+  if (num < 1000000) return `${(num / 1000).toFixed(1)}K`;
+  if (num < 1000000000) return `${(num / 1000000).toFixed(1)}M`;
+  return `${(num / 1000000000).toFixed(1)}B`;
+};
+
+export const formatMemory = (bytes: number): string => {
+  return formatBytes(bytes);
+};
+
+export const formatImprovement = (improvement: number): string => {
+  const sign = improvement > 0 ? "+" : "";
+  return `${sign}${improvement.toFixed(2)}%`;
+};
+
+export const formatRegression = (regression: number): string => {
+  return `+${regression.toFixed(2)}%`;
+};
+
+export const formatConfidenceInterval = (
+  lower: number,
+  upper: number,
+  formatter = formatDuration,
+): string => {
+  return `${formatter(lower)} - ${formatter(upper)}`;
+};
+
+export const formatProgress = (current: number, total: number): string => {
+  const percentage = total === 0 ? 0 : (current / total) * 100;
+  const barLength = 20;
+  const filled = Math.floor((percentage / 100) * barLength);
+  const bar = "█".repeat(filled) + "░".repeat(barLength - filled);
+  return `[${bar}] ${percentage.toFixed(1)}% (${current}/${total})`;
+};
+
+export const formatTable = (headers: string[], rows: string[][]): string => {
+  if (rows.length === 0) return "";
+
+  // Calculate column widths
+  const widths = headers.map((header, i) => {
+    const maxRowWidth = Math.max(...rows.map((row) => row[i]?.length ?? 0));
+    return Math.max(header.length, maxRowWidth);
+  });
+
+  // Create separator
+  const separator = "─".repeat(widths.reduce((sum, w) => sum + w + 3, 0) - 1);
+
+  // Format header
+  const headerRow = headers
+    .map((header, i) => header.padEnd(widths[i]!))
+    .join(" │ ");
+
+  // Format rows
+  const dataRows = rows.map((row) =>
+    row.map((cell, i) => (cell ?? "").padEnd(widths[i]!)).join(" │ "),
+  );
+
+  return [headerRow, separator, ...dataRows].join("\n");
+};
+
+export const formatDurationBar = (
+  value: number,
+  max: number,
+  width = 20,
+): string => {
+  const percentage = max === 0 ? 0 : (value / max) * 100;
+  const filled = Math.floor((percentage / 100) * width);
+  const bar = "█".repeat(filled) + "░".repeat(width - filled);
+  return `${bar} ${formatDuration(value)}`;
+};
+
+export const formatSizeBar = (
+  value: number,
+  max: number,
+  width = 20,
+): string => {
+  const percentage = max === 0 ? 0 : (value / max) * 100;
+  const filled = Math.floor((percentage / 100) * width);
+  const bar = "█".repeat(filled) + "░".repeat(width - filled);
+  return `${bar} ${formatBytes(value)}`;
+};
+
+export const formatRelativeChange = (
+  baseline: number,
+  current: number,
+): string => {
+  if (baseline === 0) return "N/A";
+
+  const change = ((current - baseline) / baseline) * 100;
+  const sign = change > 0 ? "+" : "";
+  const color = change > 0 ? "🔴" : change < 0 ? "🟢" : "⚪";
+
+  return `${color} ${sign}${change.toFixed(2)}%`;
+};
+
+export const truncatePath = (path: string, maxLength = 50): string => {
+  if (path.length <= maxLength) return path;
+
+  const start = path.substring(0, Math.floor(maxLength / 2) - 2);
+  const end = path.substring(path.length - Math.floor(maxLength / 2) + 2);
+
+  return `${start}...${end}`;
+};
+
+export const formatFileType = (extension: string): string => {
+  const typeMap: Record<string, string> = {
+    ".js": "JavaScript",
+    ".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",
+  };
+
+  return typeMap[extension] ?? extension.toUpperCase();
+};
+
+export const formatSeverity = (severity: "low" | "medium" | "high"): string => {
+  const icons = {
+    low: "🟡",
+    medium: "🟠",
+    high: "🔴",
+  };
+
+  return `${icons[severity]} ${severity.toUpperCase()}`;
+};
+
+export const formatBottleneckType = (
+  type: "slow-build" | "many-dependencies" | "circular-dependency",
+): string => {
+  const icons = {
+    "slow-build": "⏱️",
+    "many-dependencies": "🔗",
+    "circular-dependency": "🔄",
+  };
+
+  const labels = {
+    "slow-build": "Slow Build",
+    "many-dependencies": "Many Dependencies",
+    "circular-dependency": "Circular Dependency",
+  };
+
+  return `${icons[type]} ${labels[type]}`;
+};