@bacnh85/pi-windows-tools 0.2.0 → 0.3.0

package/extensions/index.ts

@@ -1,7 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { readFileSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
 import { detectShell, detectAllShells, getDefaultShell } from "./lib/shell-detect";
 import type { WindowsShellKind } from "./lib/shell-detect";
 import { executeCommand as execCmd } from "./lib/shell-exec";
@@ -56,30 +54,6 @@ export default function piWindowsToolsExtension(pi: ExtensionAPI) {
 			return tr(o);
 		} });
 
-	// ── File edit tool (reliable replacement for built-in edit) ──
-	pi.registerTool({ name: "windows_file_edit", label: "Windows: Edit File", description: "Replace literal text in a file. Reads actual file bytes so no line-ending/whitespace mismatch issues.",
-		promptSnippet: "Edit a file reliably using Node.js",
-		promptGuidelines: [
-			"Use instead of the built-in edit tool on all platforms.",
-			"Reads actual file bytes so replacements always match regardless of line endings.",
-			"Throws a clear error if oldText is not found.",
-		],
-		parameters: Type.Object({
-			path: Type.String({ description: "Path to the file (absolute or relative to cwd)." }),
-			oldText: Type.String({ description: "Literal text to find and replace." }),
-			newText: Type.String({ description: "Replacement text." }),
-			...cs,
-		}),
-		execute(_id, p, _s, _u, ctx) {
-			const filePath = resolve(ctx?.cwd || process.cwd(), p.path);
-			const content = readFileSync(filePath, "utf8");
-			const updated = content.replace(p.oldText, p.newText);
-			if (updated === content) throw new Error(`Not found or no change: ${filePath}`);
-
-			writeFileSync(filePath, updated, "utf8");
-			return tr(`Edited ${filePath}`);
-		} });
-
 	// ── Audit tools ──
 	pi.registerTool({ name: "windows_audit_log", label: "Windows: Audit Log", description: "Show command history and exit codes.", promptSnippet: "Show Windows command audit log", promptGuidelines: ["Use to see what was executed."],
 		parameters: Type.Object({ clear: Type.Optional(Type.Boolean({ description: "Clear after viewing." })), ...cs }),
@@ -91,7 +65,7 @@ export default function piWindowsToolsExtension(pi: ExtensionAPI) {
 	pi.registerTool({ name: "windows_path_to_wsl", label: "Windows: Convert to WSL", description: "Convert Windows path to /mnt/c/...", promptSnippet: "Convert path to WSL", promptGuidelines: ["Use to pass Windows path to WSL."], parameters: Type.Object({ path: Type.String(), ...cs }),
 		execute(_id, p) { return tr(pathUtils.toWslPath(p.path)); } });
 	pi.registerTool({ name: "windows_path_to_gitbash", label: "Windows: Convert to Git Bash", description: "Convert Windows path to /c/...", promptSnippet: "Convert path to Git Bash", promptGuidelines: ["Use to pass Windows path to Git Bash."], parameters: Type.Object({ path: Type.String(), ...cs }),
-		execute(_id, p) { return tr(pathUtils.toGitBashPath(p.path)); } });
+		execute(_id, p) { return tr(pathUtils.toPosixPath(p.path)); } });
 	pi.registerTool({ name: "windows_path_quote", label: "Windows: Quote Path", description: "Quote a path for a Windows shell.", promptSnippet: "Quote path for shell", promptGuidelines: ["Each shell has different quoting rules."], parameters: Type.Object({ path: Type.String(), shell: Type.Optional(sk), ...cs }),
 		execute(_id, p) { return tr(pathUtils.quoteForShell(p.path, rs(p.shell as WindowsShellKind | undefined))); } });
 

package/extensions/lib/path-utils.ts

@@ -40,13 +40,6 @@ export function toWindowsPath(posixPath: string): string {
 	return posixPath.replace(/\//g, "\\");
 }
 
-/**
- * Convert a Windows path to Git Bash format (/c/Users/...).
- */
-export function toGitBashPath(windowsPath: string): string {
-	return toPosixPath(windowsPath);
-}
-
 /**
  * Convert a Windows path to WSL format (/mnt/c/Users/...).
  * Ignores input already in WSL or POSIX format.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bacnh85/pi-windows-tools",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Pi extension for Windows-native tool manipulation — shell profiles, path conversion, command execution, WSL bridge, safety policy, and developer tool discovery.",
   "type": "module",
   "license": "MIT",
@@ -29,7 +29,9 @@
   },
   "files": [
     "README.md",
-    "extensions/",
+    "extensions/index.ts",
+    "extensions/lib/",
+    "extensions/package.json",
     "skills/",
     "docs/"
   ],

package/extensions/test/audit.test.ts

@@ -1,47 +0,0 @@
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import { record, entries, clear, format } from "../lib/audit";
-
-describe("audit", () => {
-  beforeEach(() => clear());
-
-  it("starts empty", () => {
-    expect(format()).to.equal("No commands executed yet.");
-  });
-
-  it("records an entry", () => {
-    record({ timestamp: "a", shell: "pwsh", command: "echo hi", cwd: "/", exitCode: 0, timedOut: false, cancelled: false });
-    expect(entries()).to.have.length(1);
-    expect(entries()[0].command).to.equal("echo hi");
-  });
-
-  it("clear removes all entries", () => {
-    record({ timestamp: "a", shell: "pwsh", command: "c1", cwd: "/", exitCode: 0, timedOut: false, cancelled: false });
-    clear();
-    expect(entries()).to.have.length(0);
-  });
-
-  it("format shows command and exit code", () => {
-    record({ timestamp: "t", shell: "pwsh", command: "echo hi", cwd: "/", exitCode: 0, timedOut: false, cancelled: false });
-    const out = format();
-    expect(out).to.include("echo hi");
-    expect(out).to.include("exit:0");
-  });
-
-  it("format shows timed out flag", () => {
-    record({ timestamp: "a", shell: "cmd", command: "sleep 10", cwd: "/", exitCode: null, timedOut: true, cancelled: false });
-    const out = format();
-    expect(out).to.include("TIMED OUT");
-  });
-
-  it("format shows cancelled flag", () => {
-    record({ timestamp: "a", shell: "cmd", command: "x", cwd: "/", exitCode: null, timedOut: false, cancelled: true });
-    const out = format();
-    expect(out).to.include("CANCELLED");
-  });
-
-  it("truncates long commands", () => {
-    record({ timestamp: "a", shell: "pwsh", command: "x".repeat(500), cwd: "/", exitCode: 0, timedOut: false, cancelled: false });
-    expect(format()).to.include("\u2026");
-  });
-});

package/extensions/test/doctor.test.ts

@@ -1,89 +0,0 @@
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import { formatDoctorReport } from "../lib/doctor";
-import type { DoctorReport } from "../lib/doctor";
-
-describe("doctor", () => {
-
-	const sampleReport: DoctorReport = {
-		os: "Windows_NT",
-		osVersion: "10.0.22631",
-		architecture: "x64",
-		defaultShell: "pwsh",
-		tools: [
-			{ name: "pwsh", found: true, path: "C:\\Program Files\\PowerShell\\7\\pwsh.exe", version: "7.4.0" },
-			{ name: "powershell", found: true, path: "C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe", version: "5.1.22621" },
-			{ name: "cmd", found: true, path: "C:\\Windows\\System32\\cmd.exe" },
-			{ name: "git", found: true, path: "C:\\Program Files\\Git\\cmd\\git.exe", version: "2.42.0.windows.2" },
-			{ name: "bash (Git Bash)", found: true, path: "C:\\Program Files\\Git\\bin\\bash.exe", version: "5.2.15" },
-			{ name: "wsl", found: true, path: "C:\\Windows\\System32\\wsl.exe" },
-			{ name: "node", found: true, path: "C:\\Program Files\\nodejs\\node.exe", version: "v22.0.0" },
-			{ name: "npm", found: true, path: "C:\\Program Files\\nodejs\\npm.cmd", version: "10.5.0" },
-			{ name: "pnpm", found: false },
-			{ name: "yarn", found: false },
-			{ name: "python", found: true, path: "C:\\Python312\\python.exe", version: "3.12.0" },
-			{ name: "py launcher", found: true, path: "C:\\Windows\\py.exe", version: "3.12" },
-			{ name: "dotnet", found: true, path: "C:\\Program Files\\dotnet\\dotnet.exe", version: "8.0.100" },
-			{ name: "cmake", found: false },
-			{ name: "ninja", found: false },
-			{ name: "winget", found: true, path: "C:\\Users\\me\\AppData\\Local\\Microsoft\\WindowsApps\\winget.exe" },
-			{ name: "choco", found: false },
-			{ name: "scoop", found: false },
-			{ name: "ssh", found: true, path: "C:\\Windows\\System32\\OpenSSH\\ssh.exe" },
-			{ name: "msbuild", found: false },
-			{ name: "cl", found: false },
-			{ name: "devenv", found: false },
-			{ name: "reg", found: true, path: "C:\\Windows\\System32\\reg.exe" },
-			{ name: "sc", found: true, path: "C:\\Windows\\System32\\sc.exe" },
-			{ name: "netsh", found: true, path: "C:\\Windows\\System32\\netsh.exe" },
-		],
-		wslDistros: ["Ubuntu-24.04", "Debian"],
-		longPathsEnabled: true,
-		developerMode: true,
-	};
-
-	it("formatDoctorReport produces expected header", () => {
-		const output = formatDoctorReport(sampleReport);
-		expect(output).to.include("Windows Tools Doctor");
-		expect(output).to.include("OS: Windows_NT 10.0.22631");
-		expect(output).to.include("Architecture: x64");
-	});
-
-	it("includes tool status with ✓ and ✗", () => {
-		const output = formatDoctorReport(sampleReport);
-		expect(output).to.include("✓ pwsh");
-		expect(output).to.include("✗ pnpm");
-	});
-
-	it("includes WSL distros", () => {
-		const output = formatDoctorReport(sampleReport);
-		expect(output).to.include("Ubuntu-24.04");
-		expect(output).to.include("Debian");
-	});
-
-	it("includes long paths and dev mode", () => {
-		const output = formatDoctorReport(sampleReport);
-		expect(output).to.include("Long paths: enabled");
-		expect(output).to.include("Developer Mode: enabled");
-	});
-
-	it("handles empty tools list", () => {
-		const empty: DoctorReport = {
-			os: "Windows_NT",
-			osVersion: "",
-			architecture: "x64",
-			defaultShell: "cmd",
-			tools: [],
-			wslDistros: [],
-			longPathsEnabled: null,
-			developerMode: null,
-		};
-		const output = formatDoctorReport(empty);
-		expect(output).to.include("Long paths: unknown");
-	});
-
-	it("includes version when present", () => {
-		const output = formatDoctorReport(sampleReport);
-		expect(output).to.include("7.4.0");
-	});
-});

package/extensions/test/path-utils.test.ts

@@ -1,144 +0,0 @@
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import {
-	toPosixPath,
-	toWindowsPath,
-	toWslPath,
-	toGitBashPath,
-	normalizeWindowsPath,
-	isWindowsAbsolutePath,
-	quoteForShell,
-} from "../lib/path-utils";
-import type { WindowsShellKind } from "../lib/shell-detect";
-
-describe("path-utils", () => {
-
-	describe("toPosixPath", () => {
-		it("converts C:\\foo\\bar to /c/foo/bar", () => {
-			expect(toPosixPath("C:\\foo\\bar")).to.equal("/c/foo/bar");
-		});
-		it("converts C:/foo/bar to /c/foo/bar", () => {
-			expect(toPosixPath("C:/foo/bar")).to.equal("/c/foo/bar");
-		});
-		it("converts D:\\path with spaces to /d/path with spaces", () => {
-			expect(toPosixPath("D:\\path with spaces")).to.equal("/d/path with spaces");
-		});
-		it("handles lowercase drive letter", () => {
-			expect(toPosixPath("c:\\windows\\system32")).to.equal("/c/windows/system32");
-		});
-		it("strips \\\\?\\ long-path prefix", () => {
-			expect(toPosixPath("\\\\?\\C:\\foo")).to.equal("/c/foo");
-		});
-		it("handles drive-relative path C:foo\\bar", () => {
-			expect(toPosixPath("C:foo\\bar")).to.equal("/c/foo/bar");
-		});
-	});
-
-	describe("toWindowsPath", () => {
-		it("converts /c/foo/bar to C:\\foo\\bar", () => {
-			expect(toWindowsPath("/c/foo/bar")).to.equal("C:\\foo\\bar");
-		});
-		it("converts /mnt/c/foo/bar to C:\\foo\\bar", () => {
-			expect(toWindowsPath("/mnt/c/foo/bar")).to.equal("C:\\foo\\bar");
-		});
-		it("preserves relative paths", () => {
-			expect(toWindowsPath("relative/path")).to.equal("relative\\path");
-		});
-		it("handles lowercase drive", () => {
-			expect(toWindowsPath("/d/work/repo")).to.equal("D:\\work\\repo");
-		});
-		it("preserves Windows-native paths already in C:\\ format", () => {
-			expect(toWindowsPath("C:\\Users\\me")).to.equal("C:\\Users\\me");
-		});
-	});
-
-	describe("toWslPath", () => {
-		it("converts C:\\Users\\me to /mnt/c/Users/me", () => {
-			expect(toWslPath("C:\\Users\\me")).to.equal("/mnt/c/Users/me");
-		});
-		it("converts D:\\work to /mnt/d/work", () => {
-			expect(toWslPath("D:\\work")).to.equal("/mnt/d/work");
-		});
-		it("does not double-wrap already-WSL paths", () => {
-			expect(toWslPath("/mnt/c/Users/me")).to.equal("/mnt/c/Users/me");
-		});
-		it("wraps Git Bash paths to /mnt/", () => {
-			expect(toWslPath("/c/foo")).to.equal("/mnt/c/foo");
-		});
-	});
-
-	describe("toGitBashPath", () => {
-		it("converts C:\\Users to /c/Users", () => {
-			expect(toGitBashPath("C:\\Users")).to.equal("/c/Users");
-		});
-		it("same as toPosixPath", () => {
-			expect(toGitBashPath("D:\\temp")).to.equal(toPosixPath("D:\\temp"));
-		});
-	});
-
-	describe("normalizeWindowsPath", () => {
-		it("converts forward slashes to backslashes", () => {
-			expect(normalizeWindowsPath("C:/foo/bar")).to.equal("C:\\foo\\bar");
-		});
-		it("uppercases drive letter", () => {
-			expect(normalizeWindowsPath("c:\\windows")).to.equal("C:\\windows");
-		});
-		it("resolves . and ..", () => {
-			expect(normalizeWindowsPath("C:\\foo\\.\\bar\\..\\baz")).to.equal("C:\\foo\\baz");
-		});
-		it("deduplicates backslashes", () => {
-			expect(normalizeWindowsPath("C:\\foo\\\\\\bar")).to.equal("C:\\foo\\bar");
-		});
-	});
-
-	describe("isWindowsAbsolutePath", () => {
-		it("detects C:\\ as absolute", () => {
-			expect(isWindowsAbsolutePath("C:\\foo")).to.be.true;
-		});
-		it("detects C:/ as absolute", () => {
-			expect(isWindowsAbsolutePath("C:/foo")).to.be.true;
-		});
-		it("detects UNC as absolute", () => {
-			expect(isWindowsAbsolutePath("\\\\server\\share")).to.be.true;
-		});
-		it("detects \\\\?\\ long path prefix as absolute", () => {
-			expect(isWindowsAbsolutePath("\\\\?\\C:\\foo")).to.be.true;
-		});
-		it("detects \\\\.\\ device paths as absolute", () => {
-			expect(isWindowsAbsolutePath("\\\\.\\COM1")).to.be.true;
-		});
-		it("rejects relative paths", () => {
-			expect(isWindowsAbsolutePath("relative\\path")).to.be.false;
-		});
-		it("rejects POSIX absolute paths", () => {
-			expect(isWindowsAbsolutePath("/c/foo")).to.be.false;
-		});
-	});
-
-	describe("quoteForShell", () => {
-		const shells: WindowsShellKind[] = ["pwsh", "powershell", "cmd", "git-bash", "wsl"];
-
-		it("does not quote paths without spaces", () => {
-			for (const s of shells) {
-				expect(quoteForShell("C:\\foo\\bar", s)).to.equal("C:\\foo\\bar");
-			}
-		});
-		it("quotes paths with spaces for PowerShell", () => {
-			expect(quoteForShell("C:\\Program Files\\Git", "pwsh")).to.include("'");
-		});
-		it("quotes paths with spaces for cmd", () => {
-			expect(quoteForShell("C:\\Program Files\\Git", "cmd")).to.include('"');
-		});
-		it("quotes paths with spaces for git-bash", () => {
-			expect(quoteForShell("/c/Program Files", "git-bash")).to.include("'");
-		});
-		it("quotes paths with spaces for wsl", () => {
-			expect(quoteForShell("/mnt/c/Program Files", "wsl")).to.include("'");
-		});
-		it("handles empty path", () => {
-			for (const s of shells) {
-				expect(quoteForShell("", s)).to.equal('""');
-			}
-		});
-	});
-});

package/extensions/test/safety.test.ts

@@ -1,96 +0,0 @@
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import { classifyCommand, isSensitivePath } from "../lib/safety";
-
-describe("safety", () => {
-
-	describe("classifyCommand", () => {
-		it("returns safe for echo", () => {
-			const r = classifyCommand("echo hello");
-			expect(r.risk).to.equal("safe");
-		});
-
-		it("returns confirm for rm -rf", () => {
-			const r = classifyCommand("rm -rf /some/dir");
-			expect(r.risk).to.equal("confirm");
-			expect(r.reasons.length).to.be.greaterThan(0);
-		});
-
-		it("returns confirm for Remove-Item -Recurse -Force", () => {
-			const r = classifyCommand("Remove-Item -Recurse -Force C:\\temp");
-			expect(r.risk).to.equal("confirm");
-		});
-
-		it("returns confirm for git push --force", () => {
-			const r = classifyCommand("git push --force origin main");
-			expect(r.risk).to.equal("confirm");
-		});
-
-		it("returns confirm for git clean -fdx", () => {
-			const r = classifyCommand("git clean -fdx");
-			expect(r.risk).to.equal("confirm");
-		});
-
-		it("returns confirm for npm publish", () => {
-			const r = classifyCommand("npm publish");
-			expect(r.risk).to.equal("confirm");
-		});
-
-		it("returns confirm for diskpart", () => {
-			const r = classifyCommand("diskpart");
-			expect(r.risk).to.equal("confirm");
-		});
-
-		it("returns confirm for format command", () => {
-			const r = classifyCommand("format D: /fs:ntfs");
-			expect(r.risk).to.equal("confirm");
-		});
-
-		it("returns confirm for takeown", () => {
-			const r = classifyCommand("takeown /f C:\\somefile");
-			expect(r.risk).to.equal("confirm");
-		});
-
-		it("detects sensitive file paths in command", () => {
-			const r = classifyCommand("cat .env");
-			expect(r.risk).to.equal("confirm");
-			expect(r.reasons.some(r => r.includes("Environment"))).to.be.true;
-		});
-
-		it("detects SSH key paths", () => {
-			const r = classifyCommand("cat ~/.ssh/id_rsa");
-			expect(r.risk).to.equal("confirm");
-		});
-
-		it("returns safe for dir listing", () => {
-			const r = classifyCommand("Get-ChildItem -Recurse -Filter *.ts");
-			expect(r.risk).to.equal("safe");
-		});
-
-		it("returns safe for git status", () => {
-			const r = classifyCommand("git status");
-			expect(r.risk).to.equal("safe");
-		});
-	});
-
-	describe("isSensitivePath", () => {
-		it("detects .env", () => {
-			expect(isSensitivePath("C:\\project\\.env")).to.be.true;
-		});
-		it("detects .env.local", () => {
-			expect(isSensitivePath("C:\\project\\.env.local")).to.be.true;
-		});
-		it("detects .pem files", () => {
-			expect(isSensitivePath("C:\\keys\\cert.pem")).to.be.true;
-		});
-		it("detects .ssh dir", () => {
-			expect(isSensitivePath("C:\\Users\\me\\.ssh\\config")).to.be.true;
-		});
-		it("detects .aws dir", () => {
-			expect(isSensitivePath("/home/me/.aws/credentials")).to.be.true;
-		});
-		it("allows normal files", () => {
-			expect(isSensitivePath("C:\\project\\src\\index.ts")).to.be.false;
-		});
-	});
-});

package/extensions/test/shell-detect.test.ts

@@ -1,53 +0,0 @@
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import { detectAllShells, detectShell, getAvailableShells, getDefaultShell } from "../lib/shell-detect";
-import type { WindowsShellKind } from "../lib/shell-detect";
-
-describe("shell-detect", () => {
-	it("detectAllShells returns 5 entries", () => {
-		const shells = detectAllShells();
-		expect(shells).to.have.length(5);
-		const kinds = shells.map(s => s.kind);
-		expect(kinds).to.include.members(["pwsh", "powershell", "cmd", "git-bash", "wsl"]);
-	});
-
-	it("each shell has kind, displayName, executable, available", () => {
-		for (const s of detectAllShells()) {
-			expect(s.kind).to.be.a("string");
-			expect(s.displayName).to.be.a("string");
-			expect(s.executable).to.be.a("string");
-			expect(s.available).to.be.a("boolean");
-		}
-	});
-
-	it("cmd is available on Windows", function () {
-		if (process.platform !== "win32") this.skip();
-		const cmd = detectShell("cmd");
-		expect(cmd.available).to.be.true;
-		expect(cmd.executable).to.match(/cmd(\.exe)?$/i);
-	});
-
-	it("detectShell returns info for each kind", () => {
-		const kinds: WindowsShellKind[] = ["pwsh", "powershell", "cmd", "git-bash", "wsl"];
-		for (const k of kinds) {
-			const info = detectShell(k);
-			expect(info.kind).to.equal(k);
-			expect(info.executable).to.be.a("string").and.not.empty;
-		}
-	});
-
-	it("getAvailableShells returns only available shells", function () {
-		if (process.platform !== "win32") this.skip();
-		const avail = getAvailableShells();
-		for (const s of avail) {
-			expect(s.available).to.be.true;
-		}
-	});
-
-	it("getDefaultShell returns a shell", function () {
-		if (process.platform !== "win32") this.skip();
-		const def = getDefaultShell();
-		expect(def.kind).to.be.a("string");
-		expect(def.available).to.be.true;
-	});
-});

package/extensions/test/shell-exec.test.ts

@@ -1,76 +0,0 @@
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import { buildShellArgs, mergeEnv } from "../lib/shell-exec";
-
-describe("shell-exec", () => {
-
-	describe("buildShellArgs", () => {
-		it("pwsh: builds correct args", () => {
-			const { exe, args } = buildShellArgs("pwsh", "echo hello");
-			expect(exe).to.match(/pwsh(\.exe)?$/i);
-			expect(args).to.include("-NoLogo");
-			expect(args).to.include("-NoProfile");
-			expect(args).to.include("-NonInteractive");
-			expect(args).to.include("-ExecutionPolicy");
-			expect(args).to.include("Bypass");
-			expect(args).to.include("-Command");
-			expect(args).to.include("echo hello");
-		});
-
-		it("powershell: same args as pwsh", () => {
-			const { exe, args } = buildShellArgs("powershell", "Get-ChildItem");
-			expect(exe).to.match(/powershell(\.exe)?$/i);
-			expect(args).to.include("-NoLogo");
-			expect(args).to.include("-Command");
-			expect(args).to.include("Get-ChildItem");
-		});
-
-		it("cmd: builds /c command", () => {
-			const { exe, args } = buildShellArgs("cmd", "dir");
-			expect(args).to.deep.equal(["/c", "dir"]);
-		});
-
-		it("git-bash: builds -lc command", () => {
-			const { exe, args } = buildShellArgs("git-bash", "ls -la");
-			expect(args).to.deep.equal(["-lc", "ls -la"]);
-		});
-
-		it("wsl: builds wsl.exe bash -lc command", () => {
-			const { exe, args } = buildShellArgs("wsl", "uname -a");
-			expect(exe).to.equal("wsl.exe");
-			expect(args).to.deep.equal(["--", "bash", "-lc", "uname -a"]);
-		});
-
-		it("wsl with distro: includes -d flag", () => {
-			const { args } = buildShellArgs("wsl", "echo hi", "Ubuntu-24.04");
-			expect(args).to.deep.equal(["-d", "Ubuntu-24.04", "--", "bash", "-lc", "echo hi"]);
-		});
-	});
-
-	describe("mergeEnv", () => {
-		it("includes all process.env keys", () => {
-			const merged = mergeEnv({});
-			expect(merged.PATH || merged.Path).to.be.a("string");
-		});
-
-		it("custom env overrides process.env", () => {
-			const merged = mergeEnv({ NODE_ENV: "test" });
-			expect(merged.NODE_ENV).to.equal("test");
-		});
-
-		it("deduplicates case-insensitively", () => {
-			// Simulate process.env having "PATH" and custom having "Path"
-			// mergeEnv should not produce both
-			const merged = mergeEnv({ Path: "/custom/path" });
-			// Should have either PATH or Path, not both duplicated
-			const pathKeys = Object.keys(merged).filter(k => k.toLowerCase() === "path");
-			expect(pathKeys.length).to.equal(1);
-			expect(merged[pathKeys[0]]).to.equal("/custom/path");
-		});
-
-		it("handles empty custom env", () => {
-			const merged = mergeEnv({});
-			expect(Object.keys(merged).length).to.be.greaterThan(0);
-		});
-	});
-});