@reliverse/dler 2.0.6 → 2.0.8

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

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

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

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

@@ -1,190 +0,0 @@
-// 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]}`;
-};