@reliverse/dler 1.7.153 → 2.0.1

package/dist/cmds/perf/reporters/json.d.ts

@@ -0,0 +1,9 @@
+import type { PerfReport } from "../types.js";
+export declare class JsonReporter {
+    private outputPath?;
+    constructor(outputPath?: string);
+    report(report: PerfReport): void;
+    static save(report: PerfReport, outputPath: string): void;
+    static print(report: PerfReport): void;
+}
+export declare const createJsonReporter: (outputPath?: string) => JsonReporter;

package/dist/cmds/perf/reporters/json.js

@@ -0,0 +1,32 @@
+import { writeFileSync } from "node:fs";
+import { logger } from "@reliverse/dler-logger";
+export class JsonReporter {
+  outputPath;
+  constructor(outputPath) {
+    this.outputPath = outputPath;
+  }
+  report(report) {
+    const json = JSON.stringify(report, null, 2);
+    if (this.outputPath) {
+      try {
+        writeFileSync(this.outputPath, json, "utf-8");
+        logger.success(`\u{1F4C4} JSON report saved to: ${this.outputPath}`);
+      } catch (error) {
+        logger.error(`Failed to save JSON report: ${error}`);
+      }
+    } else {
+      console.log(json);
+    }
+  }
+  static save(report, outputPath) {
+    const reporter = new JsonReporter(outputPath);
+    reporter.report(report);
+  }
+  static print(report) {
+    const reporter = new JsonReporter();
+    reporter.report(report);
+  }
+}
+export const createJsonReporter = (outputPath) => {
+  return new JsonReporter(outputPath);
+};

package/dist/cmds/perf/types.d.ts

@@ -0,0 +1,184 @@
+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/dist/cmds/perf/utils/cache.d.ts

@@ -0,0 +1,23 @@
+import type { CacheOptions, PerfReport } from "../types.js";
+export declare class PerfCache {
+    private options;
+    private cacheDir;
+    constructor(options: CacheOptions);
+    private ensureCacheDir;
+    private generateHash;
+    private getCachePath;
+    private isExpired;
+    save(report: PerfReport): Promise<void>;
+    load(target: string, type?: string): Promise<PerfReport | null>;
+    findBaseline(target: string, type?: string): Promise<PerfReport | null>;
+    listBaselines(): Promise<Array<{
+        target: string;
+        type?: string;
+        timestamp: number;
+        hash: string;
+    }>>;
+    clear(): Promise<void>;
+    cleanup(): Promise<void>;
+    getCacheSize(): number;
+}
+export declare const createPerfCache: (options?: Partial<CacheOptions>) => PerfCache;

package/dist/cmds/perf/utils/cache.js

@@ -0,0 +1,171 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+export class PerfCache {
+  options;
+  cacheDir;
+  constructor(options) {
+    this.options = options;
+    this.cacheDir = resolve(options.cacheDir);
+    this.ensureCacheDir();
+  }
+  ensureCacheDir() {
+    if (!existsSync(this.cacheDir)) {
+      mkdirSync(this.cacheDir, { recursive: true });
+    }
+  }
+  generateHash(report) {
+    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
+      } : void 0
+    });
+    return createHash("sha256").update(content).digest("hex").substring(0, 16);
+  }
+  getCachePath(hash) {
+    return join(this.cacheDir, `${hash}.json`);
+  }
+  isExpired(entry) {
+    if (!this.options.enabled) return true;
+    const age = Date.now() - entry.timestamp;
+    return age > this.options.maxAge;
+  }
+  async save(report) {
+    if (!this.options.enabled) return;
+    try {
+      const hash = this.generateHash(report);
+      const entry = {
+        timestamp: Date.now(),
+        report,
+        hash
+      };
+      const cachePath = this.getCachePath(hash);
+      writeFileSync(cachePath, JSON.stringify(entry, null, 2));
+    } catch (error) {
+      console.warn("Failed to save performance cache:", error);
+    }
+  }
+  async load(target, type) {
+    if (!this.options.enabled) return null;
+    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 = JSON.parse(content);
+          if (this.isExpired(entry)) {
+            continue;
+          }
+          if (entry.report.options.target === target && (!type || entry.report.options.type === type)) {
+            return entry.report;
+          }
+        } catch {
+          continue;
+        }
+      }
+      return null;
+    } catch (error) {
+      console.warn("Failed to load performance cache:", error);
+      return null;
+    }
+  }
+  async findBaseline(target, type) {
+    return this.load(target, type);
+  }
+  async listBaselines() {
+    if (!this.options.enabled) return [];
+    try {
+      const cacheFiles = Array.from(
+        new Bun.Glob("*.json").scanSync({ cwd: this.cacheDir })
+      );
+      const baselines = [];
+      for (const file of cacheFiles) {
+        const cachePath = join(this.cacheDir, file);
+        try {
+          const content = readFileSync(cachePath, "utf-8");
+          const entry = 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 {
+          continue;
+        }
+      }
+      return baselines.sort((a, b) => b.timestamp - a.timestamp);
+    } catch (error) {
+      console.warn("Failed to list performance baselines:", error);
+      return [];
+    }
+  }
+  async clear() {
+    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 {
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to clear performance cache:", error);
+    }
+  }
+  async cleanup() {
+    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 = JSON.parse(content);
+          if (this.isExpired(entry)) {
+            Bun.write(cachePath, "");
+          }
+        } catch {
+          continue;
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to cleanup performance cache:", error);
+    }
+  }
+  getCacheSize() {
+    try {
+      const cacheFiles = Array.from(
+        new Bun.Glob("*.json").scanSync({ cwd: this.cacheDir })
+      );
+      return cacheFiles.length;
+    } catch {
+      return 0;
+    }
+  }
+}
+export const createPerfCache = (options = {}) => {
+  const defaultOptions = {
+    enabled: true,
+    cacheDir: ".dler-cache/perf",
+    maxAge: 7 * 24 * 60 * 60 * 1e3
+    // 7 days
+  };
+  return new PerfCache({ ...defaultOptions, ...options });
+};

package/dist/cmds/perf/utils/formatter.d.ts

@@ -0,0 +1,17 @@
+export declare const formatDuration: (ms: number) => string;
+export declare const formatBytes: (bytes: number) => string;
+export declare const formatPercentage: (value: number, total: number) => string;
+export declare const formatNumber: (num: number) => string;
+export declare const formatMemory: (bytes: number) => string;
+export declare const formatImprovement: (improvement: number) => string;
+export declare const formatRegression: (regression: number) => string;
+export declare const formatConfidenceInterval: (lower: number, upper: number, formatter?: (ms: number) => string) => string;
+export declare const formatProgress: (current: number, total: number) => string;
+export declare const formatTable: (headers: string[], rows: string[][]) => string;
+export declare const formatDurationBar: (value: number, max: number, width?: number) => string;
+export declare const formatSizeBar: (value: number, max: number, width?: number) => string;
+export declare const formatRelativeChange: (baseline: number, current: number) => string;
+export declare const truncatePath: (path: string, maxLength?: number) => string;
+export declare const formatFileType: (extension: string) => string;
+export declare const formatSeverity: (severity: "low" | "medium" | "high") => string;
+export declare const formatBottleneckType: (type: "slow-build" | "many-dependencies" | "circular-dependency") => string;

package/dist/cmds/perf/utils/formatter.js

@@ -0,0 +1,134 @@
+export const formatDuration = (ms) => {
+  if (ms < 1e3) {
+    return `${ms.toFixed(2)}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(2)}s`;
+  }
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = (ms % 6e4 / 1e3).toFixed(2);
+  return `${minutes}m ${seconds}s`;
+};
+export const formatBytes = (bytes) => {
+  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, total) => {
+  if (total === 0) return "0.00%";
+  return `${(value / total * 100).toFixed(2)}%`;
+};
+export const formatNumber = (num) => {
+  if (num < 1e3) return num.toString();
+  if (num < 1e6) return `${(num / 1e3).toFixed(1)}K`;
+  if (num < 1e9) return `${(num / 1e6).toFixed(1)}M`;
+  return `${(num / 1e9).toFixed(1)}B`;
+};
+export const formatMemory = (bytes) => {
+  return formatBytes(bytes);
+};
+export const formatImprovement = (improvement) => {
+  const sign = improvement > 0 ? "+" : "";
+  return `${sign}${improvement.toFixed(2)}%`;
+};
+export const formatRegression = (regression) => {
+  return `+${regression.toFixed(2)}%`;
+};
+export const formatConfidenceInterval = (lower, upper, formatter = formatDuration) => {
+  return `${formatter(lower)} - ${formatter(upper)}`;
+};
+export const formatProgress = (current, total) => {
+  const percentage = total === 0 ? 0 : current / total * 100;
+  const barLength = 20;
+  const filled = Math.floor(percentage / 100 * barLength);
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(barLength - filled);
+  return `[${bar}] ${percentage.toFixed(1)}% (${current}/${total})`;
+};
+export const formatTable = (headers, rows) => {
+  if (rows.length === 0) return "";
+  const widths = headers.map((header, i) => {
+    const maxRowWidth = Math.max(...rows.map((row) => row[i]?.length ?? 0));
+    return Math.max(header.length, maxRowWidth);
+  });
+  const separator = "\u2500".repeat(widths.reduce((sum, w) => sum + w + 3, 0) - 1);
+  const headerRow = headers.map((header, i) => header.padEnd(widths[i])).join(" \u2502 ");
+  const dataRows = rows.map(
+    (row) => row.map((cell, i) => (cell ?? "").padEnd(widths[i])).join(" \u2502 ")
+  );
+  return [headerRow, separator, ...dataRows].join("\n");
+};
+export const formatDurationBar = (value, max, width = 20) => {
+  const percentage = max === 0 ? 0 : value / max * 100;
+  const filled = Math.floor(percentage / 100 * width);
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+  return `${bar} ${formatDuration(value)}`;
+};
+export const formatSizeBar = (value, max, width = 20) => {
+  const percentage = max === 0 ? 0 : value / max * 100;
+  const filled = Math.floor(percentage / 100 * width);
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+  return `${bar} ${formatBytes(value)}`;
+};
+export const formatRelativeChange = (baseline, current) => {
+  if (baseline === 0) return "N/A";
+  const change = (current - baseline) / baseline * 100;
+  const sign = change > 0 ? "+" : "";
+  const color = change > 0 ? "\u{1F534}" : change < 0 ? "\u{1F7E2}" : "\u26AA";
+  return `${color} ${sign}${change.toFixed(2)}%`;
+};
+export const truncatePath = (path, maxLength = 50) => {
+  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) => {
+  const typeMap = {
+    ".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) => {
+  const icons = {
+    low: "\u{1F7E1}",
+    medium: "\u{1F7E0}",
+    high: "\u{1F534}"
+  };
+  return `${icons[severity]} ${severity.toUpperCase()}`;
+};
+export const formatBottleneckType = (type) => {
+  const icons = {
+    "slow-build": "\u23F1\uFE0F",
+    "many-dependencies": "\u{1F517}",
+    "circular-dependency": "\u{1F504}"
+  };
+  const labels = {
+    "slow-build": "Slow Build",
+    "many-dependencies": "Many Dependencies",
+    "circular-dependency": "Circular Dependency"
+  };
+  return `${icons[type]} ${labels[type]}`;
+};

package/dist/cmds/perf/utils/stats.d.ts

@@ -0,0 +1,15 @@
+import type { Statistics } from "../types.js";
+export declare const calculateStatistics: (values: number[]) => Statistics;
+export declare const percentile: (sorted: number[], p: number) => number;
+export declare const calculateMemoryGrowth: (initial: number, final: number) => number;
+export declare const calculateMemoryAverage: (measurements: number[]) => number;
+export declare const findPeakMemory: (measurements: number[]) => number;
+export declare const calculateImprovement: (baseline: number, current: number) => number;
+export declare const calculateRegression: (baseline: number, current: number) => number;
+export declare const isSignificantChange: (baseline: number, current: number, threshold?: number) => boolean;
+export declare const calculateConfidenceInterval: (values: number[], confidence?: number) => {
+    lower: number;
+    upper: number;
+};
+export declare const detectOutliers: (values: number[], threshold?: number) => number[];
+export declare const removeOutliers: (values: number[], threshold?: number) => number[];

package/dist/cmds/perf/utils/stats.js

@@ -0,0 +1,101 @@
+export const calculateStatistics = (values) => {
+  if (values.length === 0) {
+    return {
+      min: 0,
+      max: 0,
+      mean: 0,
+      median: 0,
+      p95: 0,
+      p99: 0,
+      variance: 0,
+      standardDeviation: 0,
+      coefficientOfVariation: 0
+    };
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  const n = values.length;
+  const min = sorted[0];
+  const max = sorted[n - 1];
+  const mean = values.reduce((sum, val) => sum + val, 0) / n;
+  const median = n % 2 === 0 ? (sorted[n / 2 - 1] + sorted[n / 2]) / 2 : sorted[Math.floor(n / 2)];
+  const p95 = percentile(sorted, 0.95);
+  const p99 = percentile(sorted, 0.99);
+  const variance = values.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / n;
+  const standardDeviation = Math.sqrt(variance);
+  const coefficientOfVariation = mean === 0 ? 0 : standardDeviation / mean;
+  return {
+    min,
+    max,
+    mean,
+    median,
+    p95,
+    p99,
+    variance,
+    standardDeviation,
+    coefficientOfVariation
+  };
+};
+export const percentile = (sorted, p) => {
+  if (sorted.length === 0) return 0;
+  if (sorted.length === 1) return sorted[0];
+  const index = p * (sorted.length - 1);
+  const lower = Math.floor(index);
+  const upper = Math.ceil(index);
+  if (lower === upper) {
+    return sorted[lower];
+  }
+  const weight = index - lower;
+  return sorted[lower] * (1 - weight) + sorted[upper] * weight;
+};
+export const calculateMemoryGrowth = (initial, final) => {
+  return final - initial;
+};
+export const calculateMemoryAverage = (measurements) => {
+  if (measurements.length === 0) return 0;
+  return measurements.reduce((sum, val) => sum + val, 0) / measurements.length;
+};
+export const findPeakMemory = (measurements) => {
+  return measurements.length === 0 ? 0 : Math.max(...measurements);
+};
+export const calculateImprovement = (baseline, current) => {
+  if (baseline === 0) return 0;
+  return (baseline - current) / baseline * 100;
+};
+export const calculateRegression = (baseline, current) => {
+  if (baseline === 0) return 0;
+  return (current - baseline) / baseline * 100;
+};
+export const isSignificantChange = (baseline, current, threshold = 5) => {
+  const change = Math.abs(calculateImprovement(baseline, current));
+  return change >= threshold;
+};
+export const calculateConfidenceInterval = (values, confidence = 0.95) => {
+  if (values.length < 2) {
+    return { lower: values[0] ?? 0, upper: values[0] ?? 0 };
+  }
+  const mean = values.reduce((sum, val) => sum + val, 0) / values.length;
+  const variance = values.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / (values.length - 1);
+  const standardError = Math.sqrt(variance / values.length);
+  const tValue = confidence === 0.95 ? 1.96 : 2.576;
+  const margin = tValue * standardError;
+  return {
+    lower: mean - margin,
+    upper: mean + margin
+  };
+};
+export const detectOutliers = (values, threshold = 2) => {
+  if (values.length < 3) return [];
+  const stats = calculateStatistics(values);
+  const outliers = [];
+  for (const value of values) {
+    const zScore = Math.abs((value - stats.mean) / stats.standardDeviation);
+    if (zScore > threshold) {
+      outliers.push(value);
+    }
+  }
+  return outliers;
+};
+export const removeOutliers = (values, threshold = 2) => {
+  const outliers = detectOutliers(values, threshold);
+  return values.filter((val) => !outliers.includes(val));
+};

package/dist/cmds/publish/cmd.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+declare const _default: any;
+export default _default;