repo-clean 1.0.2 → 1.2.0

package/README.md

@@ -22,10 +22,14 @@ repo-clean
 Use the command patterns below with either `npx repo-clean` or `repo-clean` (after global install).
 
 ```bash
-repo-clean [--dry-run] [--node-modules] [--pm-cache] [--logs] [--editor] [--tmp]
+repo-clean [--dry-run] [--node-modules] [--pm-cache] [--logs] [--editor] [--tmp] [--force]
 repo-clean --all [--keep-nm] [--dry-run]
+repo-clean --help | -h
+repo-clean --version | -v
 ```
 
+`repo-clean` accepts flags only. Positional arguments are rejected with an error.
+
 ### Default behavior (no flags)
 
 Removes:
@@ -43,6 +47,7 @@ Removes:
 
 - `--dry-run` Print what would be removed without deleting anything.
 - `--node-modules` Also remove `node_modules`.
+- `--force` Skip confirmation prompt for `node_modules` removal.
 - `--pm-cache` Also remove package manager caches/stores:
   - `.yarn/cache`
   - `.yarn/unplugged`
@@ -59,6 +64,8 @@ Removes:
 - `--tmp` Also remove `tmp` and `temp`.
 - `--all` Include all optional cleanup categories above.
 - `--keep-nm` With `--all`, keep `node_modules`.
+- `--help`, `-h` Print usage and flags.
+- `--version`, `-v` Print the CLI version.
 
 ## Examples
 
@@ -67,10 +74,19 @@ Removes:
 npx repo-clean --dry-run
 
 # Remove default targets + node_modules
+npx repo-clean --node-modules --force
+
+# Prompted node_modules removal (confirm with y/yes)
 npx repo-clean --node-modules
 
 # Full cleanup except node_modules
 npx repo-clean --all --keep-nm
+
+# Print installed version
+npx repo-clean --version
+
+# Invalid (positional argument): exits with code 2
+npx repo-clean my-folder
 ```
 
 ## Issues and Support
@@ -101,6 +117,7 @@ Contributions are welcome.
 ```bash
 git clone https://github.com/arbenkryemadhi/repo-clean.git
 cd repo-clean
+npm test
 node ./bin/repo-clean.js --help
 node ./bin/repo-clean.js --dry-run
 ```

package/bin/repo-clean.js

@@ -1,30 +1,34 @@
 #!/usr/bin/env node
 /* repo-clean: remove common repo build outputs and caches */
 
-const fs = require("node:fs");
-const path = require("node:path");
+const { parseCliArgs } = require("../lib/args");
+const { buildCleanupPlan } = require("../lib/targets");
+const { removeTargets, removeRootLogs } = require("../lib/cleanup");
+const { confirmNodeModulesRemoval } = require("../lib/confirm");
+const { version: packageVersion } = require("../package.json");
 
 const argv = process.argv.slice(2);
-const args = new Set(argv);
+const parsed = parseCliArgs(argv);
 
-const dryRun = args.has("--dry-run");
-const help = args.has("--help") || args.has("-h");
+if (!parsed.ok) {
+  console.error(parsed.error);
+  process.exit(parsed.exitCode);
+}
 
-const flagAll = args.has("--all");
-const keepNm = args.has("--keep-nm");
+const { dryRun, help, version, force, flagAll, keepNm } = parsed.options;
 
-const flagNodeModules = args.has("--node-modules");
-const flagPmCache = args.has("--pm-cache");
-const flagLogs = args.has("--logs");
-const flagEditor = args.has("--editor");
-const flagTmp = args.has("--tmp");
+if (version) {
+  console.log(packageVersion);
+  process.exit(0);
+}
 
 if (help) {
   console.log(`repo-clean
 
 Usage:
-  repo-clean [--dry-run] [--node-modules] [--pm-cache] [--logs] [--editor] [--tmp]
+  repo-clean [--dry-run] [--node-modules] [--pm-cache] [--logs] [--editor] [--tmp] [--force]
   repo-clean --all [--keep-nm] [--dry-run]
+  repo-clean --version | -v
 
 Defaults (no flags):
   Removes build outputs + framework caches:
@@ -39,134 +43,46 @@ Flags:
   --tmp            Also remove tmp/temp folders
   --all            Default + all flags above
   --keep-nm        With --all, keep node_modules (do not remove it)
+  --force          Skip confirmation prompt for node_modules removal
+  --version, -v    Print CLI version
 `);
   process.exit(0);
 }
 
 const cwd = process.cwd();
 
-const defaultTargets = [
-  "dist",
-  "build",
-  "coverage",
-  ".next",
-  ".turbo",
-  ".vite",
-  ".parcel-cache",
-  ".cache",
-];
-
-const editorTargets = [".vscode", ".idea"];
-const tmpTargets = ["tmp", "temp"];
-
-// Mix of directories + files that can exist in a repo for Yarn/Pnpm setups.
-// (No globs; exact known paths only.)
-const pmCacheTargets = [
-  ".yarn/cache",
-  ".yarn/unplugged",
-  ".yarn/install-state.gz",
-  ".pnp.cjs",
-  ".pnp.loader.mjs",
-  ".pnpm-store",
-];
-
-// Log file prefixes to delete in repo root (covers e.g. npm-debug.log.123)
-const logPrefixes = [
-  "npm-debug.log",
-  "yarn-error.log",
-  "pnpm-debug.log",
-  "lerna-debug.log",
-];
-
-function exists(p) {
-  try {
-    fs.accessSync(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function removePath(absPath) {
-  if (!exists(absPath)) return false;
-
-  if (dryRun) {
-    console.log(`[dry-run] would remove: ${absPath}`);
-    return true;
-  }
-
-  fs.rmSync(absPath, {
-    recursive: true,
-    force: true,
-    maxRetries: 2,
-    retryDelay: 50,
-  });
-  console.log(`removed: ${absPath}`);
-  return true;
-}
-
-function gatherRootLogs() {
-  const found = [];
-  let entries;
-  try {
-    entries = fs.readdirSync(cwd, { withFileTypes: true });
-  } catch {
-    return found;
-  }
+async function main() {
+  const cleanupPlan = buildCleanupPlan(parsed.options);
+  const { targets, includeLogs, includeNodeModules, logPrefixes } = cleanupPlan;
 
-  for (const ent of entries) {
-    if (!ent.isFile()) continue;
-    const name = ent.name;
-    if (logPrefixes.some((p) => name === p || name.startsWith(p))) {
-      found.push(name);
+  if (includeNodeModules && !dryRun && !force) {
+    const confirmed = await confirmNodeModulesRemoval();
+    if (!confirmed) {
+      console.log("Aborted. No files were removed.");
+      process.exit(1);
     }
   }
-  return found;
-}
-
-// Determine what to remove
-const targets = new Set(defaultTargets);
-
-const includePmCache = flagAll || flagPmCache;
-const includeLogs = flagAll || flagLogs;
-const includeEditor = flagAll || flagEditor;
-const includeTmp = flagAll || flagTmp;
 
-// node_modules inclusion logic:
-// - default: off
-// - --node-modules: on
-// - --all: on, unless --keep-nm is also present
-const includeNodeModules = (flagAll || flagNodeModules) && !(flagAll && keepNm);
+  let removedCount = removeTargets(cwd, targets, dryRun);
 
-if (includePmCache) for (const t of pmCacheTargets) targets.add(t);
-if (includeEditor) for (const t of editorTargets) targets.add(t);
-if (includeTmp) for (const t of tmpTargets) targets.add(t);
-if (includeNodeModules) targets.add("node_modules");
-
-// Remove fixed targets
-let removedCount = 0;
-
-for (const rel of Array.from(targets).sort()) {
-  const abs = path.join(cwd, rel);
-  if (removePath(abs)) removedCount += 1;
-}
-
-// Remove root log files (if enabled)
-if (includeLogs) {
-  const logs = gatherRootLogs();
-  for (const name of logs.sort()) {
-    const abs = path.join(cwd, name);
-    if (removePath(abs)) removedCount += 1;
+  if (includeLogs) {
+    removedCount += removeRootLogs(cwd, logPrefixes, dryRun);
   }
+
+  const nmNote =
+    flagAll && keepNm
+      ? " (kept node_modules)"
+      : includeNodeModules
+        ? " (includes node_modules)"
+        : "";
+  const mode = dryRun ? "done (dry-run)" : "done";
+  console.log(
+    `${mode}. ${dryRun ? "would remove" : "removed"} ${removedCount} item(s).${nmNote}`,
+  );
 }
 
-const nmNote =
-  flagAll && keepNm
-    ? " (kept node_modules)"
-    : includeNodeModules
-      ? " (includes node_modules)"
-      : "";
-const mode = dryRun ? "done (dry-run)" : "done";
-console.log(
-  `${mode}. ${dryRun ? "would remove" : "removed"} ${removedCount} item(s).${nmNote}`,
-);
+main().catch((err) => {
+  const msg = err && err.message ? err.message : String(err);
+  console.error(`Error: ${msg}`);
+  process.exit(1);
+});

package/lib/args.js

@@ -0,0 +1,135 @@
+const allowedFlags = new Set([
+  "--dry-run",
+  "--help",
+  "-h",
+  "--version",
+  "-v",
+  "--force",
+  "--all",
+  "--keep-nm",
+  "--node-modules",
+  "--pm-cache",
+  "--logs",
+  "--editor",
+  "--tmp",
+]);
+
+const EXIT_INVALID_ARGS = 2;
+
+function isFlagToken(arg) {
+  return arg.startsWith("-");
+}
+
+function editDistance(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+
+  for (let i = 0; i <= m; i += 1) dp[i][0] = i;
+  for (let j = 0; j <= n; j += 1) dp[0][j] = j;
+
+  for (let i = 1; i <= m; i += 1) {
+    for (let j = 1; j <= n; j += 1) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1,
+        dp[i][j - 1] + 1,
+        dp[i - 1][j - 1] + cost,
+      );
+    }
+  }
+
+  return dp[m][n];
+}
+
+function getClosestFlag(input) {
+  let best = null;
+  let bestDistance = Number.POSITIVE_INFINITY;
+
+  for (const flag of allowedFlags) {
+    const dist = editDistance(input, flag);
+    if (dist < bestDistance) {
+      best = flag;
+      bestDistance = dist;
+    }
+  }
+
+  if (!best) return null;
+  if (bestDistance > 3) return null;
+  return best;
+}
+
+function formatUnknownFlagError(unknownFlags) {
+  const unknownList = unknownFlags.join(", ");
+  const flagLabel = unknownFlags.length === 1 ? "flag" : "flags";
+  const suggestions = unknownFlags
+    .map((flag) => {
+      const suggestion = getClosestFlag(flag);
+      return suggestion ? { flag, suggestion } : null;
+    })
+    .filter(Boolean);
+
+  let suggestionText = "";
+  if (suggestions.length === 1 && unknownFlags.length === 1) {
+    suggestionText = ` Did you mean ${suggestions[0].suggestion}?`;
+  } else if (suggestions.length > 0) {
+    const pairs = suggestions.map(
+      (item) => `${item.flag} -> ${item.suggestion}`,
+    );
+    suggestionText = ` Did you mean: ${pairs.join(", ")}?`;
+  }
+
+  return `Unknown ${flagLabel}: ${unknownList}. This looks like a typo.${suggestionText} Run repo-clean --help for valid options.`;
+}
+
+function formatPositionalArgError(positionalArgs) {
+  const argLabel = positionalArgs.length === 1 ? "argument" : "arguments";
+  const list = positionalArgs.join(", ");
+  return `Unexpected positional ${argLabel}: ${list}. repo-clean accepts flags only. Run repo-clean --help for usage.`;
+}
+
+function parseCliArgs(argv) {
+  const args = new Set(argv);
+
+  const unknownFlags = argv.filter(
+    (arg) => isFlagToken(arg) && !allowedFlags.has(arg),
+  );
+  if (unknownFlags.length > 0) {
+    return {
+      ok: false,
+      exitCode: EXIT_INVALID_ARGS,
+      error: formatUnknownFlagError(unknownFlags),
+    };
+  }
+
+  const positionalArgs = argv.filter((arg) => !isFlagToken(arg));
+  if (positionalArgs.length > 0) {
+    return {
+      ok: false,
+      exitCode: EXIT_INVALID_ARGS,
+      error: formatPositionalArgError(positionalArgs),
+    };
+  }
+
+  return {
+    ok: true,
+    options: {
+      dryRun: args.has("--dry-run"),
+      help: args.has("--help") || args.has("-h"),
+      version: args.has("--version") || args.has("-v"),
+      force: args.has("--force"),
+      flagAll: args.has("--all"),
+      keepNm: args.has("--keep-nm"),
+      flagNodeModules: args.has("--node-modules"),
+      flagPmCache: args.has("--pm-cache"),
+      flagLogs: args.has("--logs"),
+      flagEditor: args.has("--editor"),
+      flagTmp: args.has("--tmp"),
+    },
+  };
+}
+
+module.exports = {
+  allowedFlags,
+  parseCliArgs,
+};

package/lib/cleanup.js

@@ -0,0 +1,85 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+function exists(filePath) {
+  try {
+    fs.accessSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function removePath(absPath, dryRun) {
+  if (!exists(absPath)) return false;
+
+  if (dryRun) {
+    console.log(`[dry-run] would remove: ${absPath}`);
+    return true;
+  }
+
+  fs.rmSync(absPath, {
+    recursive: true,
+    force: true,
+    maxRetries: 2,
+    retryDelay: 50,
+  });
+  console.log(`removed: ${absPath}`);
+  return true;
+}
+
+function gatherRootLogs(cwd, logPrefixes) {
+  const found = [];
+  let entries;
+
+  try {
+    entries = fs.readdirSync(cwd, { withFileTypes: true });
+  } catch {
+    return found;
+  }
+
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    if (
+      logPrefixes.some(
+        (prefix) => entry.name === prefix || entry.name.startsWith(prefix),
+      )
+    ) {
+      found.push(entry.name);
+    }
+  }
+
+  return found;
+}
+
+function removeTargets(cwd, targets, dryRun) {
+  let removedCount = 0;
+
+  for (const rel of Array.from(targets).sort()) {
+    const absPath = path.join(cwd, rel);
+    if (removePath(absPath, dryRun)) {
+      removedCount += 1;
+    }
+  }
+
+  return removedCount;
+}
+
+function removeRootLogs(cwd, logPrefixes, dryRun) {
+  let removedCount = 0;
+  const logs = gatherRootLogs(cwd, logPrefixes);
+
+  for (const name of logs.sort()) {
+    const absPath = path.join(cwd, name);
+    if (removePath(absPath, dryRun)) {
+      removedCount += 1;
+    }
+  }
+
+  return removedCount;
+}
+
+module.exports = {
+  removeTargets,
+  removeRootLogs,
+};

package/lib/confirm.js

@@ -0,0 +1,37 @@
+const fs = require("node:fs");
+const readline = require("node:readline/promises");
+
+async function confirmNodeModulesRemoval() {
+  if (!process.stdin.isTTY) {
+    let input = "";
+    try {
+      input = fs.readFileSync(0, "utf8");
+    } catch {
+      input = "";
+    }
+    const answer = input.trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    const answer = (
+      await rl.question(
+        "Safety check: this will remove node_modules. Are you sure? [y/N]: ",
+      )
+    )
+      .trim()
+      .toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+module.exports = {
+  confirmNodeModulesRemoval,
+};

package/lib/targets.js

@@ -0,0 +1,74 @@
+const defaultTargets = [
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".turbo",
+  ".vite",
+  ".parcel-cache",
+  ".cache",
+];
+
+const editorTargets = [".vscode", ".idea"];
+const tmpTargets = ["tmp", "temp"];
+
+const pmCacheTargets = [
+  ".yarn/cache",
+  ".yarn/unplugged",
+  ".yarn/install-state.gz",
+  ".pnp.cjs",
+  ".pnp.loader.mjs",
+  ".pnpm-store",
+];
+
+const logPrefixes = [
+  "npm-debug.log",
+  "yarn-error.log",
+  "pnpm-debug.log",
+  "lerna-debug.log",
+];
+
+function buildCleanupPlan(options) {
+  const targets = new Set(defaultTargets);
+
+  const includePmCache = options.flagAll || options.flagPmCache;
+  const includeLogs = options.flagAll || options.flagLogs;
+  const includeEditor = options.flagAll || options.flagEditor;
+  const includeTmp = options.flagAll || options.flagTmp;
+  const includeNodeModules =
+    (options.flagAll || options.flagNodeModules) &&
+    !(options.flagAll && options.keepNm);
+
+  if (includePmCache) {
+    for (const target of pmCacheTargets) {
+      targets.add(target);
+    }
+  }
+
+  if (includeEditor) {
+    for (const target of editorTargets) {
+      targets.add(target);
+    }
+  }
+
+  if (includeTmp) {
+    for (const target of tmpTargets) {
+      targets.add(target);
+    }
+  }
+
+  if (includeNodeModules) {
+    targets.add("node_modules");
+  }
+
+  return {
+    targets,
+    includeLogs,
+    includeNodeModules,
+    logPrefixes,
+  };
+}
+
+module.exports = {
+  buildCleanupPlan,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repo-clean",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "Clean common build and cache folders from a repository.",
   "license": "MIT",
   "bin": {
@@ -10,15 +10,26 @@
     "type": "git",
     "url": "git+https://github.com/arbenkryemadhi/repo-clean.git"
   },
-  "keywords": [],
+  "keywords": [
+    "cli",
+    "repo",
+    "workspace",
+    "cleanup",
+    "clean",
+    "cache"
+  ],
   "author": "Arben Kryemadhi",
   "type": "commonjs",
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
   "bugs": {
     "url": "https://github.com/arbenkryemadhi/repo-clean/issues"
   },
   "homepage": "https://github.com/arbenkryemadhi/repo-clean#readme",
   "files": [
     "bin",
+    "lib",
     "README.md",
     "LICENSE"
   ]