@reliverse/dler 2.0.0 → 2.0.2

package/dist/cmds/clean/impl.js

@@ -0,0 +1,627 @@
+import { existsSync, rmSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+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 { confirmPrompt } from "@reliverse/dler-prompt";
+import {
+  LOCK_FILE_PATTERNS,
+  mergePatterns,
+  parseCustomPatterns,
+  parsePresets,
+  validatePatterns
+} from "./presets.js";
+const DEFAULT_CONCURRENCY = 5;
+const findMonorepoRoot = async (startDir, useCwd = false) => {
+  let currentDir = resolve(startDir ?? process.cwd());
+  if (useCwd) {
+    const pkgPath = join(currentDir, "package.json");
+    if (existsSync(pkgPath)) {
+      const pkg = await readPackageJSON(currentDir);
+      if (pkg && hasWorkspaces(pkg)) {
+        return currentDir;
+      }
+    }
+    return null;
+  }
+  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, isRoot = false) => {
+  const pkgJsonPath = join(packagePath, "package.json");
+  if (!existsSync(pkgJsonPath)) {
+    return null;
+  }
+  try {
+    const pkg = await readPackageJSON(packagePath);
+    if (!pkg?.name) {
+      return null;
+    }
+    return {
+      name: pkg.name,
+      path: packagePath,
+      isRoot
+    };
+  } catch {
+    return null;
+  }
+};
+const getWorkspacePackages = async (cwd, useCwd = false) => {
+  const monorepoRoot = await findMonorepoRoot(cwd, useCwd);
+  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 packages = [];
+  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);
+        const pkgInfo = await resolvePackageInfo(packagePath, false);
+        if (pkgInfo) {
+          packages.push(pkgInfo);
+        }
+      }
+    } else {
+      const packagePath = resolve(monorepoRoot, pattern);
+      if (seenPaths.has(packagePath)) continue;
+      seenPaths.add(packagePath);
+      const pkgInfo = await resolvePackageInfo(packagePath, false);
+      if (pkgInfo) {
+        packages.push(pkgInfo);
+      }
+    }
+  }
+  return packages;
+};
+const getSingleRepoPackages = async (cwd) => {
+  const currentDir = resolve(cwd ?? process.cwd());
+  const pkgInfo = await resolvePackageInfo(currentDir, true);
+  if (!pkgInfo) {
+    throw new Error("\u274C No package.json found in current directory");
+  }
+  return [pkgInfo];
+};
+const calculateSize = (path) => {
+  try {
+    const stats = statSync(path);
+    if (stats.isDirectory()) {
+      return calculateDirectorySize(path);
+    }
+    return stats.size;
+  } catch {
+    return 0;
+  }
+};
+const calculateDirectorySize = (dirPath) => {
+  try {
+    let totalSize = 0;
+    const entries = existsSync(dirPath) && statSync(dirPath).isDirectory() ? Array.from(
+      new Bun.Glob("**/*").scanSync({ cwd: dirPath, onlyFiles: true })
+    ) : [];
+    for (const entry of entries) {
+      try {
+        const fullPath = join(dirPath, entry);
+        const stats = statSync(fullPath);
+        totalSize += stats.size;
+      } catch {
+      }
+    }
+    return totalSize;
+  } catch {
+    return 0;
+  }
+};
+const isAbsolutePath = (path) => path.startsWith("/") || path.length > 1 && path[1] === ":";
+const findMatchingFiles = (targetDir, patterns, subdirs = false) => {
+  const matches = [];
+  const searchDirs = subdirs ? [targetDir] : [targetDir];
+  for (const pattern of patterns) {
+    if (isAbsolutePath(pattern)) {
+      if (existsSync(pattern)) {
+        const stats = statSync(pattern);
+        const size = calculateSize(pattern);
+        matches.push({
+          path: pattern,
+          size,
+          isDirectory: stats.isDirectory(),
+          category: getCategoryForPattern(pattern)
+        });
+      }
+      continue;
+    }
+    for (const searchDir of searchDirs) {
+      try {
+        const glob = new Bun.Glob(pattern);
+        const globMatches = glob.scanSync({
+          cwd: searchDir,
+          onlyFiles: false,
+          dot: true
+          // Include hidden files/directories
+        });
+        for (const match of globMatches) {
+          const fullPath = join(searchDir, match);
+          if (existsSync(fullPath)) {
+            const stats = statSync(fullPath);
+            const size = calculateSize(fullPath);
+            matches.push({
+              path: fullPath,
+              size,
+              isDirectory: stats.isDirectory(),
+              category: getCategoryForPattern(pattern)
+            });
+          }
+        }
+      } catch (error) {
+        if (process.env.DEBUG) {
+          console.warn(`Glob error for pattern ${pattern}:`, error);
+        }
+      }
+    }
+  }
+  return matches;
+};
+const getCategoryForPattern = (pattern) => {
+  if (pattern.includes("dist")) return "build";
+  if (pattern.includes("_generated")) return "db";
+  if (pattern.includes(".basehub")) return "cms";
+  if (pattern.includes(".next") || pattern.includes(".nuxt") || pattern.includes(".expo"))
+    return "frontend";
+  if (pattern.includes(".source")) return "docs";
+  if (pattern.includes(".react-email")) return "email";
+  if (pattern.includes(".turbo") || pattern.includes(".vercel") || pattern.includes(".wrangler"))
+    return "build-tools";
+  if (pattern.includes("node_modules")) return "deps";
+  return "other";
+};
+const deleteFile = (filePath) => {
+  try {
+    rmSync(filePath, { recursive: true, force: true });
+    return null;
+  } catch (error) {
+    return {
+      path: filePath,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+};
+const deleteFiles = async (files, dryRun = false) => {
+  if (dryRun) {
+    return {
+      deletedCount: files.length,
+      deletedSize: files.reduce((sum, file) => sum + file.size, 0),
+      errors: []
+    };
+  }
+  let deletedCount = 0;
+  let deletedSize = 0;
+  const errors = [];
+  for (const file of files) {
+    const error = deleteFile(file.path);
+    if (error) {
+      errors.push(error);
+    } else {
+      deletedCount++;
+      deletedSize += file.size;
+    }
+  }
+  return { deletedCount, deletedSize, errors };
+};
+const discoverPackageFiles = async (pkg, patterns, options) => {
+  const { subdirs = false, verbose = false } = options;
+  if (verbose) {
+    logger.info(`\u{1F50D} Scanning ${pkg.name}...`);
+  }
+  const files = findMatchingFiles(pkg.path, patterns, subdirs);
+  if (verbose && files.length > 0) {
+    logger.info(`   Found ${files.length} files/directories to clean`);
+  }
+  return {
+    package: pkg,
+    files,
+    deletedCount: 0,
+    deletedSize: 0,
+    errors: []
+  };
+};
+const cleanPackage = async (pkg, patterns, options) => {
+  const { subdirs = false, dryRun = false, verbose = false } = options;
+  if (verbose) {
+    logger.info(`\u{1F50D} Scanning ${pkg.name}...`);
+  }
+  const files = findMatchingFiles(pkg.path, patterns, subdirs);
+  if (verbose && files.length > 0) {
+    logger.info(`   Found ${files.length} files/directories to clean`);
+  }
+  const { deletedCount, deletedSize, errors } = await deleteFiles(
+    files,
+    dryRun
+  );
+  if (verbose) {
+    const status = errors.length === 0 ? "\u2705" : "\u26A0\uFE0F";
+    logger.log(
+      `${status} ${pkg.name}: ${deletedCount} deleted, ${errors.length} errors`
+    );
+  }
+  return {
+    package: pkg,
+    files,
+    deletedCount,
+    deletedSize,
+    errors
+  };
+};
+const cleanLockFiles = async (rootDir, deleteLockFiles, dryRun = false) => {
+  if (!deleteLockFiles) {
+    return { deletedCount: 0, deletedSize: 0, errors: [] };
+  }
+  const lockFiles = [];
+  for (const pattern of LOCK_FILE_PATTERNS) {
+    const fullPath = join(rootDir, pattern);
+    if (existsSync(fullPath)) {
+      const stats = statSync(fullPath);
+      lockFiles.push({
+        path: fullPath,
+        size: stats.size,
+        isDirectory: false,
+        category: "deps"
+      });
+    }
+  }
+  return deleteFiles(lockFiles, dryRun);
+};
+const formatBytes = (bytes) => {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
+};
+const displayPreview = (results, lockFilesResult) => {
+  logger.log("\u2501".repeat(60));
+  logger.log("\u{1F9F9} Clean Preview:");
+  logger.log("\u2501".repeat(60));
+  let totalFiles = 0;
+  let totalSize = 0;
+  for (const result of results) {
+    if (result.files.length === 0) continue;
+    logger.log(
+      `
+\u{1F4E6} ${result.package.name}${result.package.isRoot ? " (root)" : ""}:`
+    );
+    const byCategory = result.files.reduce(
+      (acc, file) => {
+        if (!acc[file.category]) acc[file.category] = [];
+        acc[file.category].push(file);
+        return acc;
+      },
+      {}
+    );
+    for (const [category, files] of Object.entries(byCategory)) {
+      const categorySize = files.reduce((sum, file) => sum + file.size, 0);
+      logger.log(
+        `   ${category}: ${files.length} files (${formatBytes(categorySize)})`
+      );
+      if (files.length <= 5) {
+        for (const file of files) {
+          const relativePath = file.path.replace(result.package.path + "/", "");
+          logger.log(`     \u2022 ${relativePath}`);
+        }
+      } else {
+        logger.log(`     \u2022 ... and ${files.length - 5} more files`);
+      }
+    }
+    totalFiles += result.files.length;
+    totalSize += result.files.reduce((sum, file) => sum + file.size, 0);
+  }
+  if (lockFilesResult.deletedCount > 0) {
+    logger.log(
+      `
+\u{1F512} Lock files: ${lockFilesResult.deletedCount} files (${formatBytes(lockFilesResult.deletedSize)})`
+    );
+    totalFiles += lockFilesResult.deletedCount;
+    totalSize += lockFilesResult.deletedSize;
+  }
+  logger.log(`
+\u{1F4CA} Total: ${totalFiles} files (${formatBytes(totalSize)})`);
+  logger.log("\u2501".repeat(60));
+};
+const askConfirmation = async (force) => {
+  if (force) {
+    return true;
+  }
+  try {
+    return await confirmPrompt("Proceed with deletion?", false);
+  } catch {
+    return false;
+  }
+};
+export const runCleanOnAllPackages = async (ignore, cwd, options = {}) => {
+  const {
+    presets: presetsString,
+    custom: customString,
+    dryRun = false,
+    force = false,
+    verbose = false,
+    deleteLockFiles = false
+  } = options;
+  const presets = parsePresets(presetsString);
+  const customPatterns = parseCustomPatterns(customString);
+  validatePatterns(presets, customPatterns);
+  const patterns = mergePatterns(presets, customPatterns);
+  const hasAbsolutePaths = customPatterns.some(
+    (pattern) => isAbsolutePath(pattern)
+  );
+  if (verbose) {
+    logger.info("\u{1F50D} Discovering files to clean...");
+  }
+  const result = await (async () => {
+    if (hasAbsolutePaths && presets.length === 0 && customPatterns.every((pattern) => isAbsolutePath(pattern))) {
+      if (verbose) {
+        logger.info(`   Processing absolute paths directly`);
+      }
+      const files = [];
+      for (const pattern of patterns) {
+        if (isAbsolutePath(pattern) && existsSync(pattern)) {
+          const stats = statSync(pattern);
+          const size = calculateSize(pattern);
+          files.push({
+            path: pattern,
+            size,
+            isDirectory: stats.isDirectory(),
+            category: getCategoryForPattern(pattern)
+          });
+        }
+      }
+      displayPreview(
+        [
+          {
+            package: { name: "Absolute paths", path: "", isRoot: true },
+            files,
+            deletedCount: 0,
+            deletedSize: 0,
+            errors: []
+          }
+        ],
+        { deletedCount: 0, deletedSize: 0 }
+      );
+      if (!dryRun) {
+        const shouldProceed = await askConfirmation(force);
+        if (!shouldProceed) {
+          logger.info("\u274C Clean cancelled by user");
+          process.exit(0);
+        }
+        const { deletedCount, deletedSize: deletedSize2, errors } = await deleteFiles(
+          files,
+          dryRun
+        );
+        const summary2 = {
+          totalPackages: 1,
+          processedPackages: 1,
+          totalFiles: files.length,
+          totalSize: files.reduce((sum, file) => sum + file.size, 0),
+          deletedFiles: deletedCount,
+          deletedSize: deletedSize2,
+          errors,
+          hasErrors: errors.length > 0,
+          results: [
+            {
+              package: { name: "Absolute paths", path: "", isRoot: true },
+              files,
+              deletedCount,
+              deletedSize: deletedSize2,
+              errors
+            }
+          ]
+        };
+        logger.log("\n" + "\u2501".repeat(60));
+        logger.log("\u{1F4CA} Clean Summary:");
+        logger.log(
+          `   Files ${dryRun ? "would be" : ""} deleted: ${summary2.deletedFiles}`
+        );
+        logger.log(
+          `   Size ${dryRun ? "would be" : ""} freed: ${formatBytes(summary2.deletedSize)}`
+        );
+        if (summary2.hasErrors) {
+          logger.log(`   Errors: ${summary2.errors.length}`);
+          logger.error("\n\u274C Errors occurred during cleanup:");
+          for (const error of summary2.errors) {
+            logger.error(`   \u2022 ${error.path}: ${error.error}`);
+          }
+        }
+        logger.log("\u2501".repeat(60));
+        return summary2;
+      }
+      if (dryRun) {
+        const summary2 = {
+          totalPackages: 1,
+          processedPackages: 1,
+          totalFiles: files.length,
+          totalSize: files.reduce((sum, file) => sum + file.size, 0),
+          deletedFiles: files.length,
+          deletedSize: files.reduce((sum, file) => sum + file.size, 0),
+          errors: [],
+          hasErrors: false,
+          results: [
+            {
+              package: { name: "Absolute paths", path: "", isRoot: true },
+              files,
+              deletedCount: files.length,
+              deletedSize: files.reduce((sum, file) => sum + file.size, 0),
+              errors: []
+            }
+          ]
+        };
+        logger.log("\n" + "\u2501".repeat(60));
+        logger.log("\u{1F4CA} Clean Summary:");
+        logger.log(`   Files would be deleted: ${summary2.deletedFiles}`);
+        logger.log(
+          `   Size would be freed: ${formatBytes(summary2.deletedSize)}`
+        );
+        logger.log("\u2501".repeat(60));
+        return summary2;
+      }
+    }
+    let packages;
+    let isMonorepo = false;
+    const useCwd = !!cwd;
+    try {
+      packages = await getWorkspacePackages(cwd, useCwd);
+      isMonorepo = true;
+      if (verbose) {
+        logger.info(`   Found ${packages.length} packages in monorepo`);
+      }
+    } catch {
+      packages = await getSingleRepoPackages(cwd);
+      if (verbose) {
+        logger.info(`   Single repo mode: ${packages[0]?.name}`);
+      }
+    }
+    if (isMonorepo && ignore) {
+      const ignoreFilter = createIgnoreFilter(ignore);
+      const filteredPackages = ignoreFilter(packages);
+      const ignoredCount = packages.length - filteredPackages.length;
+      if (ignoredCount > 0) {
+        const patterns2 = normalizePatterns(ignore);
+        logger.info(
+          `   Ignoring ${ignoredCount} packages matching: ${patterns2.join(", ")}`
+        );
+      }
+      packages = filteredPackages;
+    }
+    const results = await pMap(
+      packages,
+      async (pkg) => discoverPackageFiles(pkg, patterns, options),
+      {
+        concurrency: DEFAULT_CONCURRENCY,
+        stopOnError: false
+      }
+    );
+    const rootDir = cwd ?? process.cwd();
+    const lockFilesResult = await cleanLockFiles(
+      rootDir,
+      deleteLockFiles,
+      dryRun
+    );
+    displayPreview(results, lockFilesResult);
+    if (!dryRun) {
+      const shouldProceed = await askConfirmation(force);
+      if (!shouldProceed) {
+        logger.info("\u274C Clean cancelled by user");
+        process.exit(0);
+      }
+      const cleanedResults = await pMap(
+        packages,
+        async (pkg) => cleanPackage(pkg, patterns, options),
+        {
+          concurrency: DEFAULT_CONCURRENCY,
+          stopOnError: false
+        }
+      );
+      if (deleteLockFiles) {
+        await cleanLockFiles(rootDir, true, false);
+      }
+      const totalFiles2 = cleanedResults.reduce((sum, r) => sum + r.files.length, 0) + lockFilesResult.deletedCount;
+      const totalSize2 = cleanedResults.reduce(
+        (sum, r) => sum + r.files.reduce((s, f) => s + f.size, 0),
+        0
+      ) + lockFilesResult.deletedSize;
+      const deletedFiles2 = cleanedResults.reduce((sum, r) => sum + r.deletedCount, 0) + lockFilesResult.deletedCount;
+      const deletedSize2 = cleanedResults.reduce((sum, r) => sum + r.deletedSize, 0) + lockFilesResult.deletedSize;
+      const allErrors2 = cleanedResults.flatMap((r) => r.errors);
+      const summary2 = {
+        totalPackages: packages.length,
+        processedPackages: cleanedResults.length,
+        totalFiles: totalFiles2,
+        totalSize: totalSize2,
+        deletedFiles: deletedFiles2,
+        deletedSize: deletedSize2,
+        errors: allErrors2,
+        hasErrors: allErrors2.length > 0,
+        results: cleanedResults
+      };
+      logger.log("\n" + "\u2501".repeat(60));
+      logger.log("\u{1F4CA} Clean Summary:");
+      logger.log(`   Packages processed: ${summary2.processedPackages}`);
+      logger.log(
+        `   Files ${dryRun ? "would be" : ""} deleted: ${summary2.deletedFiles}`
+      );
+      logger.log(
+        `   Size ${dryRun ? "would be" : ""} freed: ${formatBytes(summary2.deletedSize)}`
+      );
+      if (summary2.hasErrors) {
+        logger.log(`   Errors: ${summary2.errors.length}`);
+        logger.error("\n\u274C Errors occurred during cleanup:");
+        for (const error of summary2.errors) {
+          logger.error(`   \u2022 ${error.path}: ${error.error}`);
+        }
+      }
+      logger.log("\u2501".repeat(60));
+      return summary2;
+    }
+    const totalFiles = results.reduce((sum, r) => sum + r.files.length, 0) + lockFilesResult.deletedCount;
+    const totalSize = results.reduce(
+      (sum, r) => sum + r.files.reduce((s, f) => s + f.size, 0),
+      0
+    ) + lockFilesResult.deletedSize;
+    const deletedFiles = results.reduce((sum, r) => sum + r.deletedCount, 0) + lockFilesResult.deletedCount;
+    const deletedSize = results.reduce((sum, r) => sum + r.deletedSize, 0) + lockFilesResult.deletedSize;
+    const allErrors = results.flatMap((r) => r.errors);
+    const summary = {
+      totalPackages: packages.length,
+      processedPackages: results.length,
+      totalFiles,
+      totalSize,
+      deletedFiles,
+      deletedSize,
+      errors: allErrors,
+      hasErrors: allErrors.length > 0,
+      results
+    };
+    logger.log("\n" + "\u2501".repeat(60));
+    logger.log("\u{1F4CA} Clean Summary:");
+    logger.log(`   Packages processed: ${summary.processedPackages}`);
+    logger.log(`   Files would be deleted: ${summary.deletedFiles}`);
+    logger.log(`   Size would be freed: ${formatBytes(summary.deletedSize)}`);
+    if (summary.hasErrors) {
+      logger.log(`   Errors: ${summary.errors.length}`);
+      logger.error("\n\u274C Errors occurred during cleanup:");
+      for (const error of summary.errors) {
+        logger.error(`   \u2022 ${error.path}: ${error.error}`);
+      }
+    }
+    logger.log("\u2501".repeat(60));
+    return summary;
+  })();
+  return result;
+};

package/dist/cmds/clean/presets.d.ts

@@ -0,0 +1,10 @@
+import type { PresetCategory } from "./types.js";
+export declare const PRESET_CATEGORIES: Record<string, PresetCategory>;
+export declare const LOCK_FILE_PATTERNS: string[];
+export declare const parsePresets: (presetsString?: string) => string[];
+export declare const parseCustomPatterns: (customString?: string) => string[];
+export declare const getPresetPatterns: (presets: string[]) => string[];
+export declare const getPresetOrder: (presets: string[]) => number[];
+export declare const getPresetDescription: (presets: string[]) => string;
+export declare const mergePatterns: (presets: string[], customPatterns: string[]) => string[];
+export declare const validatePatterns: (presets: string[], customPatterns: string[]) => void;