@reliverse/dler 2.0.6 → 2.0.8

package/src/cmds/tsc/impl.ts

@@ -1,855 +0,0 @@
-// apps/dler/src/cmds/tsc/impl.ts
-
-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";
-import type { PackageDiscoveryResult } from "./types";
-
-const DEFAULT_CONCURRENCY = Math.max(4, cpus().length);
-const DISCOVERY_CONCURRENCY = 10;
-
-// ============================================================================
-// Types
-// ============================================================================
-
-export interface PackageInfo {
-  name: string;
-  path: string;
-  hasTsConfig: boolean;
-}
-
-interface TscResult {
-  package: PackageInfo;
-  success: boolean;
-  skipped: boolean;
-  cached: boolean;
-  totalErrors: number;
-  totalWarnings: number;
-  filteredErrors: number;
-  filteredWarnings: number;
-  output: string;
-  filteredOutput: string;
-  executionTime: number;
-}
-
-interface TscSummary {
-  totalPackages: number;
-  failedPackages: number;
-  successfulPackages: number;
-  skippedPackages: number;
-  totalErrors: number;
-  totalWarnings: number;
-  hasErrors: boolean;
-  results: TscResult[];
-}
-
-interface TscOptions {
-  concurrency?: number;
-  stopOnError?: boolean;
-  verbose?: boolean;
-  copyLogs?: boolean;
-  cache?: boolean;
-  incremental?: boolean;
-  autoConcurrency?: boolean;
-  skipUnchanged?: boolean;
-  buildMode?: boolean;
-}
-
-interface SpawnResult {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-}
-
-// ============================================================================
-// Constants
-// ============================================================================
-
-const TS_ERROR_REGEX = /\([0-9]+,[0-9]+\): (error|warning) TS[0-9]+:/;
-
-// ============================================================================
-// Package Discovery
-// ============================================================================
-
-const findMonorepoRoot = async (startDir?: string): Promise<string | null> => {
-  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: string,
-): Promise<PackageInfo | null> => {
-  const pkgJsonPath = join(packagePath, "package.json");
-  const tsConfigPath = join(packagePath, "tsconfig.json");
-
-  // Early skip if no package.json
-  if (!existsSync(pkgJsonPath)) {
-    return null;
-  }
-
-  // Early skip if no tsconfig.json (cheaper check first)
-  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?: string,
-): Promise<PackageDiscoveryResult> => {
-  const startTime = Date.now();
-  const monorepoRoot = await findMonorepoRoot(cwd);
-
-  if (!monorepoRoot) {
-    throw new Error(
-      "❌ No monorepo found. Ensure package.json has 'workspaces' field.",
-    );
-  }
-
-  const rootPkg = await readPackageJSON(monorepoRoot);
-  if (!rootPkg) {
-    throw new Error("❌ Could not read root package.json");
-  }
-
-  const patterns = getWorkspacePatterns(rootPkg);
-
-  if (!patterns.length) {
-    throw new Error("❌ No workspace patterns found in package.json");
-  }
-
-  // Collect all potential package paths first
-  const allPackagePaths: string[] = [];
-  const seenPaths = new Set<string>();
-
-  for (const pattern of patterns) {
-    // Check if pattern contains wildcards
-    if (pattern.includes('*')) {
-      // Pattern with wildcards - use glob
-      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 {
-      // Direct package path (no wildcards)
-      const packagePath = resolve(monorepoRoot, pattern);
-
-      if (seenPaths.has(packagePath)) continue;
-      seenPaths.add(packagePath);
-      allPackagePaths.push(packagePath);
-    }
-  }
-
-  // Resolve package info in parallel
-  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,
-  };
-};
-
-// ============================================================================
-// Package Filtering
-// ============================================================================
-
-const filterPackages = (
-  packages: PackageInfo[],
-  ignore?: string | string[],
-): PackageInfo[] => {
-  // Always ignore @reliverse/dler-v1 package
-  const alwaysIgnored = ["@reliverse/dler-v1"];
-
-  // Combine user-provided ignore patterns with always ignored packages
-  const combinedIgnore = ignore
-    ? Array.isArray(ignore)
-      ? [...alwaysIgnored, ...ignore]
-      : [...alwaysIgnored, ignore]
-    : alwaysIgnored;
-
-  const ignoreFilter = createIgnoreFilter(combinedIgnore);
-  return ignoreFilter(packages);
-};
-
-// ============================================================================
-// TypeScript Execution
-// ============================================================================
-
-const hasProjectReferences = async (packagePath: string): Promise<boolean> => {
-  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: string,
-  options: { incremental?: boolean; buildMode?: boolean } = {},
-): Promise<SpawnResult> => {
-  try {
-    const { incremental = true, buildMode = false } = options;
-
-    let args: string[];
-
-    if (buildMode && (await hasProjectReferences(packagePath))) {
-      // Use tsc --build for project references (faster for multi-package setups)
-      args = ["tsc", "--build"];
-      if (incremental) {
-        args.push("--incremental");
-      }
-    } else {
-      // Use regular tsc --noEmit for single packages
-      args = ["tsc", "--noEmit"];
-      if (incremental) {
-        args.push("--incremental");
-        // Add tsbuildinfo file path for incremental compilation
-        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)}`,
-    );
-  }
-};
-
-// ============================================================================
-// Output Filtering
-// ============================================================================
-
-const countErrorsAndWarnings = (
-  output: string,
-): { errors: number; warnings: number } => {
-  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: string, packagePath: string, monorepoRoot: string): string => {
-  const lines = output.split("\n");
-  const filtered: string[] = [];
-  const normalizedPackagePath = resolve(packagePath);
-
-  for (const line of lines) {
-    // Keep non-error lines
-    if (!TS_ERROR_REGEX.test(line)) {
-      filtered.push(line);
-      continue;
-    }
-
-    // Extract file path from error line and convert to full path
-    const match = line.match(/^(.+?)\(/);
-    
-    if (match && match[1]) {
-      const relativePath = match[1];
-      const fullPath = resolve(packagePath, relativePath);
-      const normalizedFilePath = resolve(fullPath);
-      
-      // Check if error is from another package
-      const isCrossPackageError = line.includes("../") || line.includes("..\\");
-
-      if (isCrossPackageError) {
-        // Only include if file is within current package
-        if (normalizedFilePath.startsWith(normalizedPackagePath)) {
-          // Convert relative path to full path from monorepo root
-          const relativeToMonorepo = relative(monorepoRoot, normalizedFilePath);
-          const updatedLine = line.replace(relativePath, relativeToMonorepo);
-          filtered.push(updatedLine);
-        }
-      } else {
-        // For same-package errors, also convert to full path from monorepo root
-        const relativeToMonorepo = relative(monorepoRoot, normalizedFilePath);
-        const updatedLine = line.replace(relativePath, relativeToMonorepo);
-        filtered.push(updatedLine);
-      }
-    } else {
-      filtered.push(line);
-    }
-  }
-
-  return filtered.join("\n");
-};
-
-// ============================================================================
-// Package Processing
-// ============================================================================
-
-const runTscOnPackage = async (
-  pkg: PackageInfo,
-  monorepoRoot: string,
-  options: {
-    verbose?: boolean;
-    cache?: TscCache;
-    incremental?: boolean;
-    buildMode?: boolean;
-  } = {},
-): Promise<TscResult> => {
-  const {
-    verbose = false,
-    cache,
-    incremental = true,
-    buildMode = false,
-  } = options;
-  const startTime = Date.now();
-
-  if (!pkg.hasTsConfig) {
-    if (verbose) {
-      logger.info(`⏭️  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,
-    };
-  }
-
-  // Check cache first
-  if (cache) {
-    const shouldSkip = await cache.shouldSkipPackage(pkg);
-    if (shouldSkip) {
-      if (verbose) {
-        logger.info(`⚡ 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(`🔍 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 ? "✅" : "❌";
-      logger.log(
-        `${status} ${pkg.name}: ${filteredCounts.errors} errors, ${filteredCounts.warnings} warnings`,
-      );
-    }
-
-    const tscResult: 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,
-    };
-
-    // Update cache
-    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(
-      `❌ ${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,
-    };
-  }
-};
-
-// ============================================================================
-// Result Collection
-// ============================================================================
-
-const collectAllResults = async (
-  packages: PackageInfo[],
-  monorepoRoot: string,
-  options: TscOptions = {},
-  cache?: TscCache,
-): Promise<TscSummary> => {
-  const {
-    concurrency = DEFAULT_CONCURRENCY,
-    stopOnError = false,
-    verbose = false,
-    incremental = true,
-    buildMode = false,
-  } = options;
-
-  // Log progress for package processing
-  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) {
-    // Handle aggregate errors from pMap when stopOnError is false
-    if (error instanceof AggregateError) {
-      const tscResults: TscResult[] = error.errors.map((err, index) => {
-        const pkg = packages[index];
-        if (!pkg) {
-          throw new Error(`Package at index ${index} not found`);
-        }
-
-        if (verbose) {
-          logger.error(
-            `❌ ${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,
-      };
-    }
-
-    // Re-throw other errors
-    throw error;
-  }
-};
-
-// ============================================================================
-// Clipboard Functionality
-// ============================================================================
-
-const collectFailedPackageLogs = (summary: TscSummary): string => {
-  const failed = summary.results.filter((r) => !r.success && !r.skipped);
-
-  if (failed.length === 0) {
-    return "";
-  }
-
-  const logs: string[] = [];
-  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(`📦 ${result.package.name}`);
-    logs.push(
-      `   Errors: ${result.filteredErrors}, Warnings: ${result.filteredWarnings}`,
-    );
-    logs.push("   " + "─".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: TscSummary): Promise<void> => {
-  try {
-    const logs = collectFailedPackageLogs(summary);
-
-    if (!logs) {
-      logger.info("ℹ️  No failed packages to copy to clipboard");
-      return;
-    }
-
-    await clipboard.write(logs);
-    logger.success("📋 Failed package logs copied to clipboard!");
-  } catch (error) {
-    logger.error("❌ Failed to copy logs to clipboard:");
-    if (error instanceof Error) {
-      logger.error(error.message);
-    } else {
-      logger.error(String(error));
-    }
-  }
-};
-
-// ============================================================================
-// Output Formatting
-// ============================================================================
-
-const formatOutput = (summary: TscSummary, verbose: boolean): void => {
-  const { totalPackages, failedPackages, successfulPackages, skippedPackages } =
-    summary;
-
-  // Summary header
-  logger.log("━".repeat(60));
-  logger.log(`📊 TypeScript Check Summary:`);
-  logger.log(`   Total packages: ${totalPackages}`);
-  logger.log(`   ✅ Passed: ${successfulPackages}`);
-  logger.log(`   ❌ Failed: ${failedPackages}`);
-  logger.log(`   ⏭️  Skipped: ${skippedPackages}`);
-  logger.log(`   🐛 Total errors: ${summary.totalErrors}`);
-  logger.log(`   ⚠️  Total warnings: ${summary.totalWarnings}`);
-  logger.log("━".repeat(60));
-
-  // Failed packages
-  const failed = summary.results.filter((r) => !r.success && !r.skipped);
-
-  if (failed.length > 0) {
-    logger.error("\n❌ Failed Packages:\n");
-
-    for (const result of failed) {
-      logger.error(`📦 ${result.package.name}`);
-      logger.error(
-        `   Errors: ${result.filteredErrors}, Warnings: ${result.filteredWarnings}`,
-      );
-
-      if (result.filteredOutput.trim()) {
-        logger.error("   ─".repeat(30));
-        const lines = result.filteredOutput
-          .trim()
-          .split("\n")
-          .map((line) => `   ${line}`);
-        writeErrorLines(lines);
-        logger.error("");
-      }
-    }
-  }
-
-  if (verbose) {
-    // Successful packages
-    const successful = summary.results.filter((r) => r.success && !r.skipped);
-
-    if (successful.length > 0) {
-      logger.success("\n✅ Successful Packages:\n");
-      for (const result of successful) {
-        logger.success(`   • ${result.package.name}`);
-      }
-    }
-
-    // Skipped packages
-    const skipped = summary.results.filter((r) => r.skipped);
-
-    if (skipped.length > 0) {
-      logger.info("\n⏭️  Skipped Packages (no tsconfig.json):\n");
-      for (const result of skipped) {
-        logger.info(`   • ${result.package.name}`);
-      }
-    }
-
-    logger.log("");
-  }
-};
-
-// ============================================================================
-// Main Entry Point
-// ============================================================================
-
-export const runTscOnAllPackages = async (
-  ignore?: string | string[],
-  cwd?: string,
-  options: TscOptions = {},
-): Promise<TscSummary> => {
-  const {
-    verbose = false,
-    copyLogs = false,
-    cache: enableCache = true,
-    autoConcurrency = false,
-  } = options;
-
-  return (async () => {
-    // Initialize cache
-    const cache = enableCache ? new TscCache() : undefined;
-    if (cache) {
-      await cache.initialize();
-    }
-
-    // Discover packages with timing
-    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 ? "✅" : "⏭️";
-        logger.info(`     ${configStatus} ${pkg.name} (${pkg.path})`);
-      }
-      logger.info("");
-    }
-
-    // Apply filters
-    const packages = filterPackages(allPackages, ignore);
-    const ignoredCount = allPackages.length - packages.length;
-
-    if (ignoredCount > 0) {
-      // Always ignore @reliverse/dler-v1 package
-      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(", ")}`,
-      );
-    }
-
-    // Auto-detect concurrency if requested
-    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})...\n`,
-    );
-
-    if (verbose) {
-      logger.info("🚀 Starting TypeScript checks...\n");
-    }
-
-    const summary = await collectAllResults(packages, discoveryResult.monorepoRoot, options, cache);
-
-    // Display results
-    formatOutput(summary, verbose);
-
-    // Copy logs to clipboard if requested and there are errors
-    if (copyLogs && summary.hasErrors) {
-      await copyLogsToClipboard(summary);
-    }
-
-    return summary;
-  })();
-};