@reliverse/dler 2.0.0 → 2.0.2

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

@@ -0,0 +1,153 @@
+// apps/dler/src/cmds/perf/utils/stats.ts
+
+import type { Statistics } from "../types";
+
+export const calculateStatistics = (values: number[]): Statistics => {
+  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: number[], p: number): number => {
+  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: number,
+  final: number,
+): number => {
+  return final - initial;
+};
+
+export const calculateMemoryAverage = (measurements: number[]): number => {
+  if (measurements.length === 0) return 0;
+  return measurements.reduce((sum, val) => sum + val, 0) / measurements.length;
+};
+
+export const findPeakMemory = (measurements: number[]): number => {
+  return measurements.length === 0 ? 0 : Math.max(...measurements);
+};
+
+export const calculateImprovement = (
+  baseline: number,
+  current: number,
+): number => {
+  if (baseline === 0) return 0;
+  return ((baseline - current) / baseline) * 100;
+};
+
+export const calculateRegression = (
+  baseline: number,
+  current: number,
+): number => {
+  if (baseline === 0) return 0;
+  return ((current - baseline) / baseline) * 100;
+};
+
+export const isSignificantChange = (
+  baseline: number,
+  current: number,
+  threshold = 5,
+): boolean => {
+  const change = Math.abs(calculateImprovement(baseline, current));
+  return change >= threshold;
+};
+
+export const calculateConfidenceInterval = (
+  values: number[],
+  confidence = 0.95,
+): { lower: number; upper: number } => {
+  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);
+
+  // Using t-distribution approximation for small samples
+  const tValue = confidence === 0.95 ? 1.96 : 2.576; // 95% or 99%
+  const margin = tValue * standardError;
+
+  return {
+    lower: mean - margin,
+    upper: mean + margin,
+  };
+};
+
+export const detectOutliers = (values: number[], threshold = 2): number[] => {
+  if (values.length < 3) return [];
+
+  const stats = calculateStatistics(values);
+  const outliers: number[] = [];
+
+  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: number[], threshold = 2): number[] => {
+  const outliers = detectOutliers(values, threshold);
+  return values.filter((val) => !outliers.includes(val));
+};

package/src/cmds/publish/cmd.ts

@@ -0,0 +1,215 @@
+#!/usr/bin/env bun
+
+import type { BumpType } from "@reliverse/dler-bump";
+import {
+  defineCmd,
+  defineCmdArgs,
+  defineCmdCfg,
+} from "@reliverse/dler-launcher";
+import { logger } from "@reliverse/dler-logger";
+import {
+  type PackageKind,
+  type PublishOptions,
+  publishAllPackages,
+  type RegistryType,
+} from "@reliverse/dler-publish";
+
+const publishCmd = async (args: any): Promise<void> => {
+  try {
+    // Check if running in Bun
+    if (typeof process.versions.bun === "undefined") {
+      logger.error("❌ This command requires Bun runtime. Sorry.");
+      process.exit(1);
+    }
+
+    const options: PublishOptions = {
+      dryRun: args.dryRun,
+      tag: args.tag,
+      access: args.access as "public" | "restricted",
+      otp: args.otp,
+      authType: args.authType as "web" | "legacy",
+      verbose: args.verbose,
+      bump: args.bump as BumpType,
+      concurrency: args.concurrency,
+      registry: args.registry as RegistryType,
+      kind: args.kind as PackageKind,
+      bumpDisable: args.bumpDisable,
+    };
+
+    const results = await publishAllPackages(args.cwd, args.ignore, options);
+
+    // Log warnings (non-fatal)
+    if (results.warningCount > 0) {
+      for (const result of results.results) {
+        if (result.warning) {
+          logger.warn(`  ⚠️  ${result.packageName}: ${result.warning}`);
+        }
+      }
+    }
+
+    if (results.hasErrors) {
+      logger.error(
+        `\n❌ Publishing failed: ${results.errorCount} error(s), ${results.successCount} success(es)`,
+      );
+
+      // Log individual errors
+      for (const result of results.results) {
+        if (!result.success) {
+          logger.error(`  ❌ ${result.packageName}: ${result.error}`);
+        }
+      }
+
+      process.exit(1);
+    }
+
+    logger.success(
+      `\n✅ All packages published successfully! (${results.successCount} packages)`,
+    );
+
+    if (args.verbose) {
+      for (const result of results.results) {
+        if (result.success && !result.warning) {
+          logger.log(`  ✅ ${result.packageName}@${result.version}`);
+        }
+      }
+    }
+  } catch (error) {
+    logger.error("\n❌ Publish failed:");
+
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error(String(error));
+    }
+
+    process.exit(1);
+  }
+};
+
+const publishCmdArgs = defineCmdArgs({
+  ignore: {
+    type: "string",
+    description: "Package(s) to ignore (supports wildcards like @reliverse/*)",
+  },
+  cwd: {
+    type: "string",
+    description: "Working directory (monorepo root)",
+  },
+  bump: {
+    type: "string",
+    description:
+      "Version bump type: major, minor, patch, premajor, preminor, prepatch, prerelease",
+  },
+  tag: {
+    type: "string",
+    description: "npm dist-tag (default: latest)",
+  },
+  access: {
+    type: "string",
+    description: "Access level: public or restricted (default: public)",
+  },
+  dryRun: {
+    type: "boolean",
+    description:
+      "Simulate publishing without actually publishing (default: false)",
+  },
+  otp: {
+    type: "string",
+    description: "One-time password for 2FA authentication",
+  },
+  authType: {
+    type: "string",
+    description: "Authentication method: web or legacy (default: web)",
+  },
+  concurrency: {
+    type: "number",
+    description: "Number of packages to publish concurrently (default: 3)",
+  },
+  verbose: {
+    type: "boolean",
+    description: "Verbose mode (default: false)",
+  },
+  registry: {
+    type: "string",
+    description:
+      "Registry to publish to: npm, jsr, vercel, npm-jsr, or none (default: npm)",
+  },
+  kind: {
+    type: "string",
+    description:
+      "Package kind: library, browser-app, native-app, or cli (default: library)",
+  },
+  bumpDisable: {
+    type: "boolean",
+    description:
+      "Disable version bumping for all published packages, overwrites config (default: false)",
+  },
+});
+
+const publishCmdCfg = defineCmdCfg({
+  name: "publish",
+  description:
+    "Publish workspace packages to npm registry using Bun's native publish command. Automatically handles version bumping, package.json modification, and dist folder validation. Supports dler.ts configuration for per-package settings.",
+  examples: [
+    "dler publish",
+    'dler publish --ignore "@reliverse/*"',
+    'dler publish --ignore "@reliverse/dler-colors" --ignore "@reliverse/dler-v1"',
+    'dler publish --ignore "@reliverse/dler-colors @reliverse/dler-v1"',
+    "dler publish --cwd /path/to/monorepo",
+    "dler publish --cwd /path/to/monorepo --ignore @reliverse/*",
+    "dler publish --bump patch",
+    "dler publish --bump minor --tag next",
+    "dler publish --bump major --access public",
+    "dler publish --dry-run",
+    "dler publish --dry-run --verbose",
+    "dler publish --tag alpha",
+    "dler publish --access restricted",
+    "dler publish --otp 123456",
+    "dler publish --auth-type legacy",
+    "dler publish --concurrency 3",
+    "dler publish --verbose",
+    "dler publish --bump patch --tag next --dry-run --verbose",
+    "dler publish --ignore @reliverse/* --bump minor --concurrency 2",
+    "dler publish --registry npm",
+    "dler publish --registry jsr",
+    "dler publish --registry vercel",
+    "dler publish --registry npm-jsr",
+    "dler publish --registry none",
+    "dler publish --kind library",
+    "dler publish --kind browser-app",
+    "dler publish --kind native-app",
+    "dler publish --kind cli",
+    "dler publish --kind library --registry npm",
+    "dler publish --kind browser-app --registry vercel",
+    "dler publish --kind cli --registry jsr",
+    "dler publish --bumpDisable",
+    "dler publish --bumpDisable --dry-run",
+    "dler publish --bumpDisable --tag next",
+    "",
+    "# Configuration Examples:",
+    "# Create dler.ts in your monorepo root:",
+    "# export default {",
+    "#   publish: {",
+    "#     global: { access: 'public', tag: 'latest', registry: 'npm', kind: 'library' },",
+    "#     packages: { ",
+    "#       'my-library': { tag: 'next', bump: 'minor', registry: 'jsr', kind: 'library' },",
+    "#       'my-web-app': { registry: 'vercel', kind: 'browser-app' },",
+    "#       'my-native-app': { registry: 'none', kind: 'native-app' },",
+    "#       'my-cli-tool': { registry: 'npm', kind: 'cli' },",
+    "#       'my-library': { bumpDisable: true, tag: 'next' }",
+    "#     },",
+    "#     patterns: [{ pattern: '*example*', config: { dryRun: true, registry: 'vercel', kind: 'browser-app' } }]",
+    "#   }",
+    "# }",
+    "",
+    "# Note: Make sure to run 'dler build --prepareForPublish' first to:",
+    "# - Generate dist folders and declaration files",
+    "# - Transform package.json exports field for built files",
+    "# - Add bin field for CLI packages",
+    "# - Set private: false and publishConfig",
+    "# The publish command will then handle version bumping and registry publishing",
+    "# CLI flags override dler.ts configuration settings",
+  ],
+});
+
+export default defineCmd(publishCmd, publishCmdArgs, publishCmdCfg);

package/src/cmds/shell/cmd.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env bun
+
+import {
+  defineCmd,
+  defineCmdArgs,
+  defineCmdCfg,
+} from "@reliverse/dler-launcher";
+import { logger } from "@reliverse/dler-logger";
+import { $ } from "bun";
+
+const shellCmd = async (args: { x: string }): Promise<void> => {
+  try {
+    // Execute the command using Bun Shell
+    const commandParts = args.x.split(/\s+/);
+    const [command, ...commandArgs] = commandParts;
+
+    // Use template literal with arguments interpolation
+    await $`${command} ${commandArgs.join(" ")}`;
+  } catch (error) {
+    logger.error("\n❌ Command failed:");
+
+    if (error instanceof Error) {
+      // Check if it's a ShellError with exit code
+      if ("exitCode" in error) {
+        logger.error(`Exit code: ${(error as any).exitCode}`);
+        if ((error as any).stdout) {
+          logger.error(`STDOUT: ${(error as any).stdout.toString()}`);
+        }
+        if ((error as any).stderr) {
+          logger.error(`STDERR: ${(error as any).stderr.toString()}`);
+        }
+      } else {
+        logger.error(error.message);
+      }
+    } else {
+      logger.error(String(error));
+    }
+
+    process.exit(1);
+  }
+};
+
+const shellCmdArgs = defineCmdArgs({
+  x: {
+    type: "string",
+    required: true,
+    description: "Shell command to execute",
+  },
+});
+
+const shellCmdCfg = defineCmdCfg({
+  name: "shell",
+  description: "Execute shell commands using Bun Shell API",
+  examples: [
+    'dler shell --x "echo Hello World"',
+    'dler shell --x "ls -la"',
+    'dler shell --x "cat package.json | grep name"',
+  ],
+});
+
+export default defineCmd(shellCmd, shellCmdArgs, shellCmdCfg);

package/src/cmds/tsc/cache.ts

@@ -0,0 +1,237 @@
+// apps/dler/src/cmds/tsc/cache.ts
+
+import { existsSync, statSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { PackageInfo } from "./impl";
+import type {
+  CacheMetadata,
+  PackageCacheEntry,
+  SourceFileInfo,
+  TscCacheOptions,
+} from "./types";
+
+const CACHE_VERSION = "1.0.0";
+const DEFAULT_CACHE_DIR = "node_modules/.cache/dler-tsc";
+const DEFAULT_MAX_AGE = 24 * 60 * 60 * 1000; // 24 hours
+
+export class TscCache {
+  private options: TscCacheOptions;
+  private metadata: CacheMetadata | null = null;
+  private metadataPath: string;
+
+  constructor(options: Partial<TscCacheOptions> = {}) {
+    this.options = {
+      enabled: options.enabled ?? true,
+      cacheDir: options.cacheDir ?? DEFAULT_CACHE_DIR,
+      maxAge: options.maxAge ?? DEFAULT_MAX_AGE,
+    };
+    this.metadataPath = join(this.options.cacheDir, "metadata.json");
+  }
+
+  async initialize(): Promise<void> {
+    if (!this.options.enabled) return;
+
+    try {
+      await mkdir(this.options.cacheDir, { recursive: true });
+      await this.loadMetadata();
+    } catch (error) {
+      // Cache initialization failed, disable caching
+      this.options.enabled = false;
+    }
+  }
+
+  private async loadMetadata(): Promise<void> {
+    if (!existsSync(this.metadataPath)) {
+      this.metadata = {
+        version: CACHE_VERSION,
+        lastUpdated: Date.now(),
+        packages: {},
+      };
+      return;
+    }
+
+    try {
+      const content = await readFile(this.metadataPath, "utf-8");
+      this.metadata = JSON.parse(content) as CacheMetadata;
+
+      // Check if cache is too old
+      if (Date.now() - this.metadata.lastUpdated > this.options.maxAge) {
+        this.metadata = {
+          version: CACHE_VERSION,
+          lastUpdated: Date.now(),
+          packages: {},
+        };
+      }
+    } catch {
+      this.metadata = {
+        version: CACHE_VERSION,
+        lastUpdated: Date.now(),
+        packages: {},
+      };
+    }
+  }
+
+  private async saveMetadata(): Promise<void> {
+    if (!this.options.enabled || !this.metadata) return;
+
+    try {
+      this.metadata.lastUpdated = Date.now();
+      await writeFile(
+        this.metadataPath,
+        JSON.stringify(this.metadata, null, 2),
+        "utf-8",
+      );
+    } catch {
+      // Ignore save errors
+    }
+  }
+
+  private async getSourceFiles(packagePath: string): Promise<SourceFileInfo[]> {
+    const sourceFiles: SourceFileInfo[] = [];
+    const tsConfigPath = join(packagePath, "tsconfig.json");
+
+    if (!existsSync(tsConfigPath)) {
+      return sourceFiles;
+    }
+
+    try {
+      // Find all TypeScript files in the package
+      const glob = new Bun.Glob("**/*.{ts,tsx}");
+      const matches = glob.scanSync({
+        cwd: packagePath,
+        onlyFiles: true,
+      });
+
+      for (const match of matches) {
+        const filePath = join(packagePath, match);
+        if (existsSync(filePath)) {
+          const stats = statSync(filePath);
+          sourceFiles.push({
+            path: match,
+            mtime: stats.mtime.getTime(),
+            size: stats.size,
+          });
+        }
+      }
+    } catch {
+      // Ignore glob errors
+    }
+
+    return sourceFiles;
+  }
+
+  private hasSourceFilesChanged(
+    cached: SourceFileInfo[],
+    current: SourceFileInfo[],
+  ): boolean {
+    if (cached.length !== current.length) return true;
+
+    const currentMap = new Map(current.map((file) => [file.path, file]));
+
+    for (const cachedFile of cached) {
+      const currentFile = currentMap.get(cachedFile.path);
+      if (
+        !currentFile ||
+        currentFile.mtime !== cachedFile.mtime ||
+        currentFile.size !== cachedFile.size
+      ) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  async shouldSkipPackage(pkg: PackageInfo): Promise<boolean> {
+    if (!this.options.enabled || !this.metadata) return false;
+
+    const cacheEntry = this.metadata.packages[pkg.name];
+    if (!cacheEntry || !cacheEntry.lastSuccess) return false;
+
+    // Check if package was successfully checked recently
+    const timeSinceLastSuccess = Date.now() - cacheEntry.lastSuccess;
+    if (timeSinceLastSuccess > this.options.maxAge) return false;
+
+    // Check if source files have changed
+    const currentSourceFiles = await this.getSourceFiles(pkg.path);
+    if (
+      this.hasSourceFilesChanged(cacheEntry.sourceFiles, currentSourceFiles)
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  async getCachedResult(pkg: PackageInfo): Promise<PackageCacheEntry | null> {
+    if (!this.options.enabled || !this.metadata) return null;
+
+    const cacheEntry = this.metadata.packages[pkg.name];
+    if (!cacheEntry) return null;
+
+    // Check if source files have changed
+    const currentSourceFiles = await this.getSourceFiles(pkg.path);
+    if (
+      this.hasSourceFilesChanged(cacheEntry.sourceFiles, currentSourceFiles)
+    ) {
+      return null;
+    }
+
+    return cacheEntry;
+  }
+
+  async updatePackageCache(
+    pkg: PackageInfo,
+    result: {
+      success: boolean;
+      errorCount: number;
+      warningCount: number;
+      output?: string;
+      filteredOutput?: string;
+    },
+  ): Promise<void> {
+    if (!this.options.enabled || !this.metadata) return;
+
+    const sourceFiles = await this.getSourceFiles(pkg.path);
+    const now = Date.now();
+
+    this.metadata.packages[pkg.name] = {
+      lastCheck: now,
+      lastSuccess: result.success
+        ? now
+        : (this.metadata.packages[pkg.name]?.lastSuccess ?? null),
+      sourceFiles,
+      hasErrors: !result.success,
+      errorCount: result.errorCount,
+      warningCount: result.warningCount,
+      output: result.output,
+      filteredOutput: result.filteredOutput,
+    };
+
+    await this.saveMetadata();
+  }
+
+  async clearCache(): Promise<void> {
+    if (!this.options.enabled) return;
+
+    this.metadata = {
+      version: CACHE_VERSION,
+      lastUpdated: Date.now(),
+      packages: {},
+    };
+
+    await this.saveMetadata();
+  }
+
+  getCacheStats(): { totalPackages: number; successfulPackages: number } {
+    if (!this.metadata) return { totalPackages: 0, successfulPackages: 0 };
+
+    const totalPackages = Object.keys(this.metadata.packages).length;
+    const successfulPackages = Object.values(this.metadata.packages).filter(
+      (entry) => entry.lastSuccess !== null,
+    ).length;
+
+    return { totalPackages, successfulPackages };
+  }
+}