@bacnh85/pi-windows-tools 0.1.0 → 0.3.0

package/extensions/index.ts

@@ -12,7 +12,6 @@ import { execFileSync } from "node:child_process";
 const sk = Type.Union([Type.Literal("pwsh"), Type.Literal("powershell"), Type.Literal("cmd"), Type.Literal("git-bash"), Type.Literal("wsl")]);
 const tp = Type.Optional(Type.Number({ description: "Timeout in ms." }));
 const cs = { timeout_ms: tp };
-const EOL = "\n";
 
 function tr(text: string) { return Promise.resolve({ content: [{ type: "text" as const, text }], details: {} }); }
 function rs(shell?: WindowsShellKind): WindowsShellKind {
@@ -22,20 +21,21 @@ function rs(shell?: WindowsShellKind): WindowsShellKind {
 	return getDefaultShell().kind;
 }
 
-// ponytail: in-memory audit log, no cap, sequence-counter instead of timestamps
+// ponytail: in-memory audit log
 const _log: { shell: string; command: string; exitCode: number | null; timedOut: boolean }[] = [];
 function _fmt() {
 	if (!_log.length) return "No commands executed yet.";
 	return _log.map((e, i) => {
 		const tag = e.timedOut ? " [TIMED OUT]" : "";
-		const cmd = e.command.length > 300 ? e.command.slice(0, 300) + "…" : e.command;
+		const cmd = e.command.length > 300 ? e.command.slice(0, 300) + "\u2026" : e.command;
 		return `[${i + 1}] ${e.shell}  exit:${e.exitCode}${tag}\n    cmd: ${cmd}`;
-	}).join(EOL + EOL);
+	}).join("\n\n");
 }
 
 export default function piWindowsToolsExtension(pi: ExtensionAPI) {
+	// ── Shell tools ──
 	pi.registerTool({ name: "windows_shell_detect", label: "Windows: Detect Shells", description: "Detect available Windows shells.", promptSnippet: "Detect available Windows shells", promptGuidelines: ["Use to check what shells are available."], parameters: Type.Object({ ...cs }),
-		execute() { return tr(detectAllShells().map(s => `  ${s.available ? "✓" : "✗"} ${s.displayName}${s.version ? ` ${s.version}` : ""}`).join(EOL)); } });
+		execute() { return tr(detectAllShells().map(s => `  ${s.available ? "\u2713" : "\u2717"} ${s.displayName}${s.version ? " " + s.version : ""}`).join("\n")); } });
 
 	pi.registerTool({ name: "windows_shell_exec", label: "Windows: Execute Command", description: "Execute a command through a Windows shell.", promptSnippet: "Execute a command through a Windows shell",
 		promptGuidelines: ["Use instead of generic bash on Windows.", 'Use shell:"wsl" for WSL.', "Dangerous commands require confirmation."],
@@ -45,37 +45,44 @@ export default function piWindowsToolsExtension(pi: ExtensionAPI) {
 			const safe = classifyCommand(p.command);
 			const r = await execCmd(p.command, opts);
 			_log.push({ shell: opts.shell as string, command: p.command, exitCode: r.exitCode, timedOut: r.timedOut });
-			let o = `Exit code: ${r.exitCode}${EOL}`;
-			if (r.timedOut) o += "Status: TIMED OUT" + EOL;
-			if (r.cancelled) o += "Status: CANCELLED" + EOL;
-			if (r.stdout) o += `${EOL}── stdout ──${EOL}${r.stdout}${EOL}`;
-			if (r.stderr) o += `${EOL}── stderr ──${EOL}${r.stderr}${EOL}`;
-			if (safe.risk === "confirm") o += `${EOL}⚠️  ${safe.reasons.join("; ")}`;
+			let o = `Exit code: ${r.exitCode}\n`;
+			if (r.timedOut) o += "Status: TIMED OUT\n";
+			if (r.cancelled) o += "Status: CANCELLED\n";
+			if (r.stdout) o += `\n--- stdout ---\n${r.stdout}\n`;
+			if (r.stderr) o += `\n--- stderr ---\n${r.stderr}\n`;
+			if (safe.risk === "confirm") o += `\n\u26a0\ufe0f  ${safe.reasons.join("; ")}`;
 			return tr(o);
 		} });
 
+	// ── 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 }),
 		execute(_id, p) { const out = _fmt(); if (p.clear) _log.length = 0; return tr(out); } });
 
+	// ── Path tools ──
 	pi.registerTool({ name: "windows_path_to_windows", label: "Windows: Convert to Windows Format", description: "Convert POSIX/WSL path to C:\\...", promptSnippet: "Convert path to Windows", promptGuidelines: ["Use when you have /c/ or /mnt/c/ path."], parameters: Type.Object({ path: Type.String(), ...cs }),
 		execute(_id, p) { return tr(pathUtils.toWindowsPath(p.path)); } });
 	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))); } });
+
+	// ── Safety tools ──
 	pi.registerTool({ name: "windows_safety_classify", label: "Windows: Classify Safety", description: "Check if command is dangerous.", promptSnippet: "Classify command safety", promptGuidelines: ["Returns 'safe' or 'confirm'."], parameters: Type.Object({ command: Type.String(), ...cs }),
-		execute(_id, p) { const r = classifyCommand(p.command); return tr(`Risk: ${r.risk}${r.reasons.length ? "\nReasons:\n  × " + r.reasons.join("\n  × ") : ""}`); } });
+		execute(_id, p) { const r = classifyCommand(p.command); return tr(`Risk: ${r.risk}${r.reasons.length ? "\nReasons:\n  \u2022 " + r.reasons.join("\n  \u2022 ") : ""}`); } });
+
+	// ── Doctor tools ──
 	pi.registerTool({ name: "windows_doctor", label: "Windows: Doctor", description: "Detect installed developer tools.", promptSnippet: "Run Windows doctor", promptGuidelines: ["Checks PATH, WSL, long paths, dev mode."], parameters: Type.Object({ format: Type.Optional(Type.Union([Type.Literal("text"), Type.Literal("json")])), ...cs }),
 		execute(_id, p) { const r = runDoctor(); return tr(p.format === "json" ? JSON.stringify(r, null, 2) : formatDoctorReport(r)); } });
 	pi.registerTool({ name: "windows_tool_discover", label: "Windows: Discover Tool", description: "Check if a tool is in PATH.", promptSnippet: "Check tool availability", promptGuidelines: ["Use to verify a tool is installed."], parameters: Type.Object({ name: Type.String(), ...cs }),
-		execute(_id, p) { try { const r = execFileSync("where", [p.name], { encoding: "utf8", timeout: 3000 }); return tr(`✓ ${p.name} at:\n${r.split(/\r?\n/).filter(Boolean).map(x => `  ${x}`).join(EOL)}`); } catch { return tr(`✗ ${p.name} not in PATH`); } } });
+		execute(_id, p) { try { const r = execFileSync("where", [p.name], { encoding: "utf8", timeout: 3000 }); return tr(`\u2713 ${p.name} at:\n${r.split(/\r?\n/).filter(Boolean).map(x => "  " + x).join("\n")}`); } catch { return tr(`\u2717 ${p.name} not in PATH`); } } });
 	pi.registerTool({ name: "windows_wsl_list_distros", label: "Windows: List WSL Distros", description: "List installed WSL distros.", promptSnippet: "List WSL distros", promptGuidelines: ["See what distros are available."], parameters: Type.Object({ ...cs }),
-		execute() { try { const r = execFileSync("wsl.exe", ["-l", "-q"], { encoding: "utf8", timeout: 5000 }); const d = r.split(/\r?\n/).map(s => s.trim()).filter(s => s && !s.toLowerCase().includes("noinstall") && !s.startsWith("Windows")); return tr(d.length ? "Installed WSL distros:\n  × " + d.join("\n  × ") : "No WSL distros found."); } catch { return tr("WSL not available."); } } });
+		execute() { try { const r = execFileSync("wsl.exe", ["-l", "-q"], { encoding: "utf8", timeout: 5000 }); const d = r.split(/\r?\n/).map(s => s.trim()).filter(s => s && !s.toLowerCase().includes("noinstall") && !s.startsWith("Windows")); return tr(d.length ? "Installed WSL distros:\n  \u2022 " + d.join("\n  \u2022 ") : "No WSL distros found."); } catch { return tr("WSL not available."); } } });
 
-	pi.registerCommand("windows-doctor", { description: "Run Windows Tools Doctor.", handler: async (_a, ctx) => { ctx?.ui?.notify?.("Windows Doctor complete.", "info"); process.stdout.write(formatDoctorReport(runDoctor()) + EOL); } });
+	// ── Commands ──
+	pi.registerCommand("windows-doctor", { description: "Run Windows Tools Doctor.", handler: async (_a, ctx) => { ctx?.ui?.notify?.("Windows Doctor complete.", "info"); process.stdout.write(formatDoctorReport(runDoctor()) + "\n"); } });
 	pi.registerCommand("windows-shell", { description: "Show/set default shell.", handler: async (a, ctx) => {
 		const arg = (a || "").trim().toLowerCase();
 		if (arg) {
@@ -89,6 +96,7 @@ export default function piWindowsToolsExtension(pi: ExtensionAPI) {
 		process.stdout.write(`Current shell: ${c.displayName} (${c.kind})\nExecutable: ${c.executable}\n`);
 	} });
 
+	// ── Agent prompt ──
 	pi.on("before_agent_start", async (event) => {
 		if (process.env.PI_WINDOWS_TOOLS_ENABLED === "false" || process.platform !== "win32") return;
 		return { systemPrompt: `${event.systemPrompt}\n\n---\n\n## Windows Environment\n\n${buildShellGuidance(rs())}` };

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.1.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);
-		});
-	});
-});