fix: harden Windows compatibility validation

Author: codingstark-dev

.github/workflows/ci.yml

@@ -34,11 +34,5 @@ jobs:
       - name: Smoke test - help
         run: bun run src/cli.ts --help
 
-      - name: Smoke test - dry-run (Unix)
-        if: runner.os != 'Windows'
-        run: bun run src/cli.ts --dir ${{ github.workspace }} --dry-run --hide-errors
-
-      - name: Smoke test - dry-run (Windows)
-        if: runner.os == 'Windows'
-        run: bun run src/cli.ts --dir ${{ github.workspace }} --dry-run --hide-errors
-        shell: pwsh
+      - name: Smoke test - dry-run
+        run: bun run src/cli.ts --dir "${{ github.workspace }}" --dry-run --hide-errors

.github/workflows/publish.yml

@@ -21,12 +21,12 @@ jobs:
         run: bun install
 
       - name: Run tests
-        run: bun test
+        run: bun run test
 
       - name: Build package
         run: bun run build
 
       - name: Publish to npm
         run: bun publish
         env:
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

README.md

@@ -114,12 +114,14 @@ Search filters the already loaded list, so you can quickly narrow large result s
 | Platform | Status |
 |---|---|
 | macOS | ✅ Tested |
-| Linux | ⚠️ Not tested yet |
-| Windows 10/11 | ✅ Tested (Windows Terminal recommended) |
+| Linux | ✅ CI smoke tested |
+| Windows 10/11 | ✅ CI smoke tested (Windows Terminal recommended) |
 
 > **Windows note:** Interactive mode requires a terminal that supports ANSI escape codes and raw mode.
 > [Windows Terminal](https://aka.ms/terminal) works well. The legacy `cmd.exe` prompt is not supported.
 
+CI covers help output, type checking, builds, and dry-run scanning. Manual interactive terminal testing is still useful across terminals.
+
 ## Performance
 
 Recent real scan on `--dir /Users/himanshum`:

benchmark/three-way-benchmark.ts

@@ -6,7 +6,7 @@
  * This is now JS/Bun-only.
  */
 
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { scan } from "../src/scanner.ts";
 
 const args = Bun.argv.slice(2);
@@ -34,20 +34,46 @@ function shouldSkip(p: string): boolean {
   );
 }
 
+function shellQuote(value: string): string {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
 /** Convert a Windows absolute path to a WSL /mnt/... path. */
 function toWslPath(winPath: string): string {
-  // e.g. C:\Users\foo → /mnt/c/Users/foo
-  return winPath
-    .replace(/^([A-Za-z]):\\/, (_, drive) => `/mnt/${drive.toLowerCase()}/`)
-    .replaceAll("\\", "/");
+  const normalizedPath = resolve(winPath).replaceAll("\\", "/");
+  const driveMatch = /^([A-Za-z]):\/(.*)$/.exec(normalizedPath);
+  if (!driveMatch?.[1]) {
+    return normalizedPath;
+  }
+
+  const drive = driveMatch[1].toLowerCase();
+  const rest = driveMatch[2] ?? "";
+  return `/mnt/${drive}/${rest}`;
+}
+
+async function hasWslNpkill(): Promise<boolean> {
+  const probe = Bun.spawn({
+    cmd: [
+      "wsl",
+      "bash",
+      "-lc",
+      "command -v script >/dev/null && command -v npkill >/dev/null",
+    ],
+    stdout: "ignore",
+    stderr: "ignore",
+  });
+
+  return await probe.exited === 0;
 }
 
 async function npkillScan(dir: string, useWsl = false): Promise<number> {
-  // Use login shell so node/npkill are in PATH inside WSL.
-  // Only silence stderr (2>/dev/null) so stdout flows to proc.stdout for parsing.
-  // Terminal corruption from npkill's \r sequences is handled by printRow's \r\x1b[2K.
+  if (useWsl && !(await hasWslNpkill())) {
+    return -1;
+  }
+
+  const wslCommand = `npkill -d ${shellQuote(toWslPath(dir))} -nu --hide-errors`;
   const scriptCmd = useWsl
-    ? ["wsl", "bash", "-lc", `script -q /dev/null -c 'npkill -d "${toWslPath(dir)}" -nu --hide-errors' 2>/dev/null`]
+    ? ["wsl", "bash", "-lc", `script -q /dev/null -c ${shellQuote(wslCommand)} 2>/dev/null`]
     : ["script", "-q", "/dev/null", "npkill", "-d", dir, "-nu", "--hide-errors"];
 
   try {
@@ -76,6 +102,10 @@ async function npkillScan(dir: string, useWsl = false): Promise<number> {
     clearTimeout(killTimer);
     try { proc.kill(); } catch {}
 
+    if (await proc.exited !== 0) {
+      return -1;
+    }
+
     const raw = Buffer.concat(chunks).toString("utf8");
     const clean = raw.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\r/g, "");
 
@@ -99,22 +129,23 @@ async function bunGlobScan(dir: string): Promise<number> {
     onlyFiles: false,
     followSymlinks: false,
   })) {
-    // Normalize to forward slashes for consistent checks
     const normalized = relative.replaceAll("\\", "/");
     const fullPath = join(dir, relative);
     const fullNormalized = fullPath.replaceAll("\\", "/");
 
-    // Skip nested node_modules (same as bunkill)
-    if (fullNormalized.includes("/node_modules/")) continue;
+    const targetSegments = normalized.split("/")
+      .filter((segment) => segment === "node_modules");
+    if (targetSegments.length > 1) continue;
     if (shouldSkip(fullNormalized)) continue;
 
     const depth = normalized.split("/").filter(Boolean).length;
     if (depth > MAX_DEPTH) continue;
 
-    // Require a package.json in the parent directory (same as bunkill)
-    const parentPath = fullPath.slice(0, fullPath.length - "/node_modules".length);
-    const pkgJson = Bun.file(join(parentPath, "package.json"));
-    if (!(await pkgJson.exists())) continue;
+    const projectPath = join(fullPath, "..");
+    const packageJson = await Bun.file(join(projectPath, "package.json"))
+      .json()
+      .catch(() => null);
+    if (!packageJson) continue;
 
     results.push(fullPath);
   }
@@ -219,17 +250,19 @@ const npkillPath = isWindows
   ? await Bun.$.nothrow()`where npkill`.text().then((s) => s.trim().split("\n")[0]?.trim() ?? "").catch(() => "")
   : await Bun.$.nothrow()`which npkill`.text().then((s) => s.trim()).catch(() => "");
 
-// Detect WSL (Windows only)
 const wslAvailable = isWindows
   ? await Bun.$.nothrow()`where wsl`.text().then((s) => s.trim().length > 0).catch(() => false)
   : false;
+const wslNpkillAvailable = isWindows && wslAvailable
+  ? await hasWslNpkill()
+  : false;
 
 const npkillStatus = !npkillPath
   ? "NOT FOUND  (npm install -g npkill)"
-  : isWindows && wslAvailable
+  : isWindows && wslNpkillAvailable
     ? `${npkillPath} (via WSL)`
     : isWindows
-      ? `${npkillPath} (skipped: WSL not found — install WSL to enable)`
+      ? `${npkillPath} (skipped: WSL npkill/script unavailable)`
       : npkillPath;
 
 console.log(`  npkill    : ${npkillStatus}`);
@@ -244,13 +277,13 @@ const [globResult, bunkillResult] = await Promise.all([
 ]);
 
 // On Windows: run npkill via WSL if available; on Unix: run directly
-const canRunNpkill = npkillPath && (!isWindows || wslAvailable);
+const canRunNpkill = npkillPath && (!isWindows || wslNpkillAvailable);
 const npkillResult = canRunNpkill
   ? await bench("npkill", (d) => npkillScan(d, isWindows && wslAvailable), SCAN_DIR, 1)
   : {
       label: "npkill",
       avgMs: 0, minMs: 0, maxMs: 0, found: -1, available: false,
-      note: !npkillPath ? "not installed" : "WSL not found (install WSL to enable)",
+      note: !npkillPath ? "not installed" : "WSL npkill/script unavailable",
     };
 
 const available = [npkillResult, globResult, bunkillResult].filter((r) => r.available);

bun.lock

@@ -22,7 +22,8 @@
   },
   "devDependencies": {
     "@types/bun": "^1.3.10",
-    "@types/node": "^24.5.2"
+    "@types/node": "^24.5.2",
+    "typescript": "^6.0.3"
   },
   "scripts": {
     "test": "bun run src/cli.ts --help",

package.json

@@ -12,6 +12,7 @@ export const APP_CONFIG = {
       : 8;
     return Math.max(4, Math.min(16, cpuCount || 8));
   })(),
+  defaultDeleteConcurrency: 8,
 } as const;
 
 export const SCAN_PATHS = {