@reliverse/dler 1.7.153 → 2.0.1

package/dist/cmds/tsc/impl.js

@@ -0,0 +1,572 @@
+import { existsSync } from "node:fs";
+import { cpus } from "node:os";
+import { join, relative, resolve } from "node:path";
+import { writeErrorLines } from "@reliverse/dler-helpers";
+import { logger } from "@reliverse/dler-logger";
+import pMap from "@reliverse/dler-mapper";
+import { createIgnoreFilter, normalizePatterns } from "@reliverse/dler-matcher";
+import {
+  getWorkspacePatterns,
+  hasWorkspaces,
+  readPackageJSON
+} from "@reliverse/dler-pkg-tsc";
+import clipboard from "clipboardy";
+import { TscCache } from "./cache.js";
+const DEFAULT_CONCURRENCY = Math.max(4, cpus().length);
+const DISCOVERY_CONCURRENCY = 10;
+const TS_ERROR_REGEX = /\([0-9]+,[0-9]+\): (error|warning) TS[0-9]+:/;
+const findMonorepoRoot = async (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;
+};
+const resolvePackageInfo = async (packagePath) => {
+  const pkgJsonPath = join(packagePath, "package.json");
+  const tsConfigPath = join(packagePath, "tsconfig.json");
+  if (!existsSync(pkgJsonPath)) {
+    return null;
+  }
+  if (!existsSync(tsConfigPath)) {
+    return null;
+  }
+  try {
+    const pkg = await readPackageJSON(packagePath);
+    if (!pkg?.name) {
+      return null;
+    }
+    return {
+      name: pkg.name,
+      path: packagePath,
+      hasTsConfig: true
+      // We already checked this above
+    };
+  } catch {
+    return null;
+  }
+};
+const getWorkspacePackages = async (cwd) => {
+  const startTime = Date.now();
+  const monorepoRoot = await findMonorepoRoot(cwd);
+  if (!monorepoRoot) {
+    throw new Error(
+      "\u274C No monorepo found. Ensure package.json has 'workspaces' field."
+    );
+  }
+  const rootPkg = await readPackageJSON(monorepoRoot);
+  if (!rootPkg) {
+    throw new Error("\u274C Could not read root package.json");
+  }
+  const patterns = getWorkspacePatterns(rootPkg);
+  if (!patterns.length) {
+    throw new Error("\u274C No workspace patterns found in package.json");
+  }
+  const allPackagePaths = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    if (pattern.includes("*")) {
+      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);
+        allPackagePaths.push(packagePath);
+      }
+    } else {
+      const packagePath = resolve(monorepoRoot, pattern);
+      if (seenPaths.has(packagePath)) continue;
+      seenPaths.add(packagePath);
+      allPackagePaths.push(packagePath);
+    }
+  }
+  const packageResults = await pMap(
+    allPackagePaths,
+    async (packagePath) => {
+      const pkgInfo = await resolvePackageInfo(packagePath);
+      return { packagePath, pkgInfo };
+    },
+    { concurrency: DISCOVERY_CONCURRENCY }
+  );
+  const packages = packageResults.filter((result) => result.pkgInfo !== null).map((result) => result.pkgInfo);
+  const discoveryTime = Date.now() - startTime;
+  return {
+    packages,
+    monorepoRoot,
+    discoveryTime,
+    cacheHits: 0,
+    // Will be updated by cache layer
+    cacheMisses: packages.length
+  };
+};
+const filterPackages = (packages, ignore) => {
+  const alwaysIgnored = ["@reliverse/dler-v1"];
+  const combinedIgnore = ignore ? Array.isArray(ignore) ? [...alwaysIgnored, ...ignore] : [...alwaysIgnored, ignore] : alwaysIgnored;
+  const ignoreFilter = createIgnoreFilter(combinedIgnore);
+  return ignoreFilter(packages);
+};
+const hasProjectReferences = async (packagePath) => {
+  try {
+    const tsConfigPath = join(packagePath, "tsconfig.json");
+    if (!existsSync(tsConfigPath)) return false;
+    const content = await Bun.file(tsConfigPath).text();
+    const config = JSON.parse(content);
+    return !!(config.references && Array.isArray(config.references) && config.references.length > 0);
+  } catch {
+    return false;
+  }
+};
+const runTscCommand = async (packagePath, options = {}) => {
+  try {
+    const { incremental = true, buildMode = false } = options;
+    let args;
+    if (buildMode && await hasProjectReferences(packagePath)) {
+      args = ["tsc", "--build"];
+      if (incremental) {
+        args.push("--incremental");
+      }
+    } else {
+      args = ["tsc", "--noEmit"];
+      if (incremental) {
+        args.push("--incremental");
+        const tsBuildInfoPath = join(
+          packagePath,
+          "node_modules/.cache/dler-tsc",
+          `${packagePath.split(/[/\\]/).pop()}.tsbuildinfo`
+        );
+        args.push("--tsBuildInfoFile", tsBuildInfoPath);
+      }
+    }
+    const proc = Bun.spawn(args, {
+      cwd: packagePath,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text()
+    ]);
+    const exitCode = await proc.exited;
+    return { stdout, stderr, exitCode };
+  } catch (error) {
+    throw new Error(
+      `Failed to spawn tsc: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+};
+const countErrorsAndWarnings = (output) => {
+  const lines = output.split("\n");
+  let errors = 0;
+  let warnings = 0;
+  for (const line of lines) {
+    if (TS_ERROR_REGEX.test(line)) {
+      if (line.includes(": error TS")) {
+        errors++;
+      } else if (line.includes(": warning TS")) {
+        warnings++;
+      }
+    }
+  }
+  return { errors, warnings };
+};
+const filterOutputLines = (output, packagePath, monorepoRoot) => {
+  const lines = output.split("\n");
+  const filtered = [];
+  const normalizedPackagePath = resolve(packagePath);
+  for (const line of lines) {
+    if (!TS_ERROR_REGEX.test(line)) {
+      filtered.push(line);
+      continue;
+    }
+    const match = line.match(/^(.+?)\(/);
+    if (match && match[1]) {
+      const relativePath = match[1];
+      const fullPath = resolve(packagePath, relativePath);
+      const normalizedFilePath = resolve(fullPath);
+      const isCrossPackageError = line.includes("../") || line.includes("..\\");
+      if (isCrossPackageError) {
+        if (normalizedFilePath.startsWith(normalizedPackagePath)) {
+          const relativeToMonorepo = relative(monorepoRoot, normalizedFilePath);
+          const updatedLine = line.replace(relativePath, relativeToMonorepo);
+          filtered.push(updatedLine);
+        }
+      } else {
+        const relativeToMonorepo = relative(monorepoRoot, normalizedFilePath);
+        const updatedLine = line.replace(relativePath, relativeToMonorepo);
+        filtered.push(updatedLine);
+      }
+    } else {
+      filtered.push(line);
+    }
+  }
+  return filtered.join("\n");
+};
+const runTscOnPackage = async (pkg, monorepoRoot, options = {}) => {
+  const {
+    verbose = false,
+    cache,
+    incremental = true,
+    buildMode = false
+  } = options;
+  const startTime = Date.now();
+  if (!pkg.hasTsConfig) {
+    if (verbose) {
+      logger.info(`\u23ED\uFE0F  Skipping ${pkg.name} (no tsconfig.json)`);
+    }
+    return {
+      package: pkg,
+      success: true,
+      skipped: true,
+      cached: false,
+      totalErrors: 0,
+      totalWarnings: 0,
+      filteredErrors: 0,
+      filteredWarnings: 0,
+      output: "",
+      filteredOutput: "",
+      executionTime: Date.now() - startTime
+    };
+  }
+  if (cache) {
+    const shouldSkip = await cache.shouldSkipPackage(pkg);
+    if (shouldSkip) {
+      if (verbose) {
+        logger.info(`\u26A1 Skipping ${pkg.name} (no changes since last check)`);
+      }
+      const cachedResult = await cache.getCachedResult(pkg);
+      return {
+        package: pkg,
+        success: !cachedResult?.hasErrors,
+        skipped: false,
+        cached: true,
+        totalErrors: cachedResult?.errorCount ?? 0,
+        totalWarnings: cachedResult?.warningCount ?? 0,
+        filteredErrors: cachedResult?.errorCount ?? 0,
+        filteredWarnings: cachedResult?.warningCount ?? 0,
+        output: cachedResult?.output ?? "Cached result",
+        filteredOutput: cachedResult?.filteredOutput ?? "Cached result",
+        executionTime: Date.now() - startTime
+      };
+    }
+  }
+  if (verbose) {
+    logger.info(`\u{1F50D} Checking ${pkg.name}...`);
+  }
+  try {
+    const result = await runTscCommand(pkg.path, { incremental, buildMode });
+    const output = result.stdout + result.stderr;
+    const filteredOutput = filterOutputLines(output, pkg.path, monorepoRoot);
+    const totalCounts = countErrorsAndWarnings(output);
+    const filteredCounts = countErrorsAndWarnings(filteredOutput);
+    if (verbose) {
+      const status = filteredCounts.errors === 0 ? "\u2705" : "\u274C";
+      logger.log(
+        `${status} ${pkg.name}: ${filteredCounts.errors} errors, ${filteredCounts.warnings} warnings`
+      );
+    }
+    const tscResult = {
+      package: pkg,
+      success: filteredCounts.errors === 0,
+      skipped: false,
+      cached: false,
+      totalErrors: totalCounts.errors,
+      totalWarnings: totalCounts.warnings,
+      filteredErrors: filteredCounts.errors,
+      filteredWarnings: filteredCounts.warnings,
+      output,
+      filteredOutput,
+      executionTime: Date.now() - startTime
+    };
+    if (cache) {
+      await cache.updatePackageCache(pkg, {
+        success: tscResult.success,
+        errorCount: tscResult.filteredErrors,
+        warningCount: tscResult.filteredWarnings,
+        output: tscResult.output,
+        filteredOutput: tscResult.filteredOutput
+      });
+    }
+    return tscResult;
+  } catch (error) {
+    logger.error(
+      `\u274C ${pkg.name}: Failed to run tsc - ${error instanceof Error ? error.message : String(error)}`
+    );
+    return {
+      package: pkg,
+      success: false,
+      skipped: false,
+      cached: false,
+      totalErrors: 1,
+      totalWarnings: 0,
+      filteredErrors: 1,
+      filteredWarnings: 0,
+      output: error instanceof Error ? error.message : String(error),
+      filteredOutput: error instanceof Error ? error.message : String(error),
+      executionTime: Date.now() - startTime
+    };
+  }
+};
+const collectAllResults = async (packages, monorepoRoot, options = {}, cache) => {
+  const {
+    concurrency = DEFAULT_CONCURRENCY,
+    stopOnError = false,
+    verbose = false,
+    incremental = true,
+    buildMode = false
+  } = options;
+  if (!verbose) {
+    logger.info(`Processing ${packages.length} packages...`);
+  }
+  try {
+    const tscResults = await pMap(
+      packages,
+      async (pkg, index) => {
+        if (!verbose) {
+          logger.info(
+            `Processing ${pkg.name} (${index + 1}/${packages.length})...`
+          );
+        }
+        return runTscOnPackage(pkg, monorepoRoot, {
+          verbose,
+          cache,
+          incremental,
+          buildMode
+        });
+      },
+      {
+        concurrency,
+        stopOnError
+      }
+    );
+    const failedPackages = tscResults.filter(
+      (r) => !r.success && !r.skipped
+    ).length;
+    const successfulPackages = tscResults.filter((r) => r.success).length;
+    const skippedPackages = tscResults.filter((r) => r.skipped).length;
+    const totalErrors = tscResults.reduce(
+      (sum, r) => sum + r.filteredErrors,
+      0
+    );
+    const totalWarnings = tscResults.reduce(
+      (sum, r) => sum + r.filteredWarnings,
+      0
+    );
+    return {
+      totalPackages: packages.length,
+      failedPackages,
+      successfulPackages,
+      skippedPackages,
+      totalErrors,
+      totalWarnings,
+      hasErrors: failedPackages > 0,
+      results: tscResults
+    };
+  } catch (error) {
+    if (error instanceof AggregateError) {
+      const tscResults = error.errors.map((err, index) => {
+        const pkg = packages[index];
+        if (!pkg) {
+          throw new Error(`Package at index ${index} not found`);
+        }
+        if (verbose) {
+          logger.error(
+            `\u274C ${pkg.name}: Aggregate error - ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        return {
+          package: pkg,
+          success: false,
+          skipped: false,
+          cached: false,
+          totalErrors: 1,
+          totalWarnings: 0,
+          filteredErrors: 1,
+          filteredWarnings: 0,
+          output: err instanceof Error ? err.message : String(err),
+          filteredOutput: err instanceof Error ? err.message : String(err),
+          executionTime: 0
+        };
+      });
+      const failedPackages = tscResults.filter(
+        (r) => !r.success && !r.skipped
+      ).length;
+      const successfulPackages = tscResults.filter((r) => r.success).length;
+      const skippedPackages = tscResults.filter((r) => r.skipped).length;
+      const totalErrors = tscResults.reduce(
+        (sum, r) => sum + r.filteredErrors,
+        0
+      );
+      const totalWarnings = tscResults.reduce(
+        (sum, r) => sum + r.filteredWarnings,
+        0
+      );
+      return {
+        totalPackages: packages.length,
+        failedPackages,
+        successfulPackages,
+        skippedPackages,
+        totalErrors,
+        totalWarnings,
+        hasErrors: failedPackages > 0,
+        results: tscResults
+      };
+    }
+    throw error;
+  }
+};
+const collectFailedPackageLogs = (summary) => {
+  const failed = summary.results.filter((r) => !r.success && !r.skipped);
+  if (failed.length === 0) {
+    return "";
+  }
+  const logs = [];
+  logs.push(
+    "I received the following TypeScript errors (please analyse the related code for each and correct them):"
+  );
+  logs.push("```");
+  logs.push("TypeScript Check (bun dler tsc)");
+  logs.push("");
+  for (const result of failed) {
+    logs.push(`\u{1F4E6} ${result.package.name}`);
+    logs.push(
+      `   Errors: ${result.filteredErrors}, Warnings: ${result.filteredWarnings}`
+    );
+    logs.push("   " + "\u2500".repeat(30));
+    if (result.filteredOutput.trim()) {
+      const lines = result.filteredOutput.trim().split("\n").map((line) => `   ${line}`);
+      logs.push(...lines);
+    }
+    logs.push("```");
+    logs.push("");
+    logs.push("");
+  }
+  return logs.join("\n");
+};
+const copyLogsToClipboard = async (summary) => {
+  try {
+    const logs = collectFailedPackageLogs(summary);
+    if (!logs) {
+      logger.info("\u2139\uFE0F  No failed packages to copy to clipboard");
+      return;
+    }
+    await clipboard.write(logs);
+    logger.success("\u{1F4CB} Failed package logs copied to clipboard!");
+  } catch (error) {
+    logger.error("\u274C Failed to copy logs to clipboard:");
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error(String(error));
+    }
+  }
+};
+const formatOutput = (summary, verbose) => {
+  const { totalPackages, failedPackages, successfulPackages, skippedPackages } = summary;
+  logger.log("\u2501".repeat(60));
+  logger.log(`\u{1F4CA} TypeScript Check Summary:`);
+  logger.log(`   Total packages: ${totalPackages}`);
+  logger.log(`   \u2705 Passed: ${successfulPackages}`);
+  logger.log(`   \u274C Failed: ${failedPackages}`);
+  logger.log(`   \u23ED\uFE0F  Skipped: ${skippedPackages}`);
+  logger.log(`   \u{1F41B} Total errors: ${summary.totalErrors}`);
+  logger.log(`   \u26A0\uFE0F  Total warnings: ${summary.totalWarnings}`);
+  logger.log("\u2501".repeat(60));
+  const failed = summary.results.filter((r) => !r.success && !r.skipped);
+  if (failed.length > 0) {
+    logger.error("\n\u274C Failed Packages:\n");
+    for (const result of failed) {
+      logger.error(`\u{1F4E6} ${result.package.name}`);
+      logger.error(
+        `   Errors: ${result.filteredErrors}, Warnings: ${result.filteredWarnings}`
+      );
+      if (result.filteredOutput.trim()) {
+        logger.error("   \u2500".repeat(30));
+        const lines = result.filteredOutput.trim().split("\n").map((line) => `   ${line}`);
+        writeErrorLines(lines);
+        logger.error("");
+      }
+    }
+  }
+  if (verbose) {
+    const successful = summary.results.filter((r) => r.success && !r.skipped);
+    if (successful.length > 0) {
+      logger.success("\n\u2705 Successful Packages:\n");
+      for (const result of successful) {
+        logger.success(`   \u2022 ${result.package.name}`);
+      }
+    }
+    const skipped = summary.results.filter((r) => r.skipped);
+    if (skipped.length > 0) {
+      logger.info("\n\u23ED\uFE0F  Skipped Packages (no tsconfig.json):\n");
+      for (const result of skipped) {
+        logger.info(`   \u2022 ${result.package.name}`);
+      }
+    }
+    logger.log("");
+  }
+};
+export const runTscOnAllPackages = async (ignore, cwd, options = {}) => {
+  const {
+    verbose = false,
+    copyLogs = false,
+    cache: enableCache = true,
+    autoConcurrency = false
+  } = options;
+  return (async () => {
+    const cache = enableCache ? new TscCache() : void 0;
+    if (cache) {
+      await cache.initialize();
+    }
+    const discoveryResult = await getWorkspacePackages(cwd);
+    const { packages: allPackages, discoveryTime } = discoveryResult;
+    if (verbose) {
+      logger.info(
+        `   Found ${allPackages.length} packages (${discoveryTime}ms)`
+      );
+      logger.info("   Packages found:");
+      for (const pkg of allPackages) {
+        const configStatus = pkg.hasTsConfig ? "\u2705" : "\u23ED\uFE0F";
+        logger.info(`     ${configStatus} ${pkg.name} (${pkg.path})`);
+      }
+      logger.info("");
+    }
+    const packages = filterPackages(allPackages, ignore);
+    const ignoredCount = allPackages.length - packages.length;
+    if (ignoredCount > 0) {
+      const alwaysIgnored = ["@reliverse/dler-v1"];
+      const combinedIgnore = ignore ? Array.isArray(ignore) ? [...alwaysIgnored, ...ignore] : [...alwaysIgnored, ignore] : alwaysIgnored;
+      const patterns = normalizePatterns(combinedIgnore);
+      logger.info(
+        `   Ignoring ${ignoredCount} packages matching: ${patterns.join(", ")}`
+      );
+    }
+    let concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
+    if (autoConcurrency) {
+      concurrency = Math.max(4, cpus().length * 2);
+    }
+    const { stopOnError = false } = options;
+    logger.info(
+      `   Checking ${packages.length} packages (concurrency: ${concurrency}, stopOnError: ${stopOnError})...
+`
+    );
+    if (verbose) {
+      logger.info("\u{1F680} Starting TypeScript checks...\n");
+    }
+    const summary = await collectAllResults(packages, discoveryResult.monorepoRoot, options, cache);
+    formatOutput(summary, verbose);
+    if (copyLogs && summary.hasErrors) {
+      await copyLogsToClipboard(summary);
+    }
+    return summary;
+  })();
+};

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

@@ -0,0 +1,57 @@
+import type { PackageInfo } from "./impl.js";
+export interface CacheMetadata {
+    version: string;
+    lastUpdated: number;
+    packages: Record<string, PackageCacheEntry>;
+}
+export interface PackageCacheEntry {
+    lastCheck: number;
+    lastSuccess: number | null;
+    sourceFiles: SourceFileInfo[];
+    hasErrors: boolean;
+    errorCount: number;
+    warningCount: number;
+    output?: string;
+    filteredOutput?: string;
+}
+export interface SourceFileInfo {
+    path: string;
+    mtime: number;
+    size: number;
+}
+export interface TscCacheOptions {
+    enabled: boolean;
+    cacheDir: string;
+    maxAge: number;
+}
+export interface OptimizedTscOptions {
+    concurrency?: number;
+    stopOnError?: boolean;
+    verbose?: boolean;
+    copyLogs?: boolean;
+    cache?: boolean;
+    incremental?: boolean;
+    autoConcurrency?: boolean;
+    skipUnchanged?: boolean;
+    buildMode?: boolean;
+}
+export interface PackageDiscoveryResult {
+    packages: PackageInfo[];
+    monorepoRoot: string;
+    discoveryTime: number;
+    cacheHits: number;
+    cacheMisses: number;
+}
+export interface TscExecutionResult {
+    package: PackageInfo;
+    success: boolean;
+    skipped: boolean;
+    cached: boolean;
+    totalErrors: number;
+    totalWarnings: number;
+    filteredErrors: number;
+    filteredWarnings: number;
+    output: string;
+    filteredOutput: string;
+    executionTime: number;
+}