test(bash-postool): platform-aware expected paths for Windows CI

Windows CI on PR #15 failed all 22 bash-postool assertions because
expected values were hard-coded as POSIX paths (`/proj/src/foo.ts`)
while the implementation calls `path.resolve()` which returns
platform-native paths — backslashes on Windows, forward slashes on
POSIX systems.

Fix: build expected values through `path.resolve` the same way the
implementation does. The test now captures the platform-native cwd
once and derives expected absolute paths from it, so the same source
asserts correctly on macOS, Linux, and Windows.

The implementation itself is unchanged — `pathResolve` already does
the right thing per platform. This was purely a cross-platform test
hygiene issue.

Also swapped the hard-coded `/tmp/foo.ts` absolute-path test for a
platform-resolved equivalent so Windows doesn't choke on missing
drive prefix.

Local verify: 25/25 bash-postool tests pass on macOS Node 25.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: NickCirv

tests/intercept/handlers/bash-postool.test.ts

@@ -1,136 +1,153 @@
 import { describe, it, expect } from "vitest";
+import { resolve as pathResolve } from "node:path";
 import {
   parseFileOps,
   handleBashPostTool,
 } from "../../../src/intercept/handlers/bash-postool.js";
 
+/**
+ * Path helpers: expected values are built via pathResolve to match the
+ * platform-native output of the implementation (Windows produces
+ * backslashes, macOS/Linux produces forward slashes). Hard-coding POSIX
+ * paths broke Windows CI on v2.1 PR #15 — this file is the fix.
+ *
+ * Uses a platform-appropriate "project root": on Windows pathResolve
+ * pins to the current drive, which is fine because the tests only
+ * compare against the same pathResolve output.
+ */
+const CWD = pathResolve("/proj");
+const expectedAbs = (rel: string) => pathResolve(CWD, rel);
+
 describe("bash-postool — parseFileOps: rm variants", () => {
   it("parses bare rm with single file", () => {
-    const r = parseFileOps("rm src/foo.ts", "/proj");
-    expect(r).toEqual([{ action: "prune", path: "/proj/src/foo.ts" }]);
+    const r = parseFileOps("rm src/foo.ts", CWD);
+    expect(r).toEqual([{ action: "prune", path: expectedAbs("src/foo.ts") }]);
   });
 
   it("parses rm -f", () => {
-    const r = parseFileOps("rm -f src/foo.ts", "/proj");
-    expect(r).toEqual([{ action: "prune", path: "/proj/src/foo.ts" }]);
+    const r = parseFileOps("rm -f src/foo.ts", CWD);
+    expect(r).toEqual([{ action: "prune", path: expectedAbs("src/foo.ts") }]);
   });
 
   it("parses rm -rf with multiple files", () => {
-    const r = parseFileOps("rm -rf src/a.ts src/b.ts", "/proj");
+    const r = parseFileOps("rm -rf src/a.ts src/b.ts", CWD);
     expect(r).toEqual([
-      { action: "prune", path: "/proj/src/a.ts" },
-      { action: "prune", path: "/proj/src/b.ts" },
+      { action: "prune", path: expectedAbs("src/a.ts") },
+      { action: "prune", path: expectedAbs("src/b.ts") },
     ]);
   });
 
   it("keeps absolute paths absolute", () => {
-    const r = parseFileOps("rm /tmp/foo.ts", "/proj");
-    expect(r).toEqual([{ action: "prune", path: "/tmp/foo.ts" }]);
+    // Use a platform-native absolute path so this test is consistent
+    // across macOS/Linux (/tmp) and Windows (resolves under current drive).
+    const abs = pathResolve("/tmp/foo.ts");
+    const r = parseFileOps(`rm ${abs}`, CWD);
+    expect(r).toEqual([{ action: "prune", path: abs }]);
   });
 });
 
 describe("bash-postool — parseFileOps: mv and cp", () => {
   it("mv prunes src and reindexes dst", () => {
-    const r = parseFileOps("mv src/old.ts src/new.ts", "/proj");
+    const r = parseFileOps("mv src/old.ts src/new.ts", CWD);
     expect(r).toEqual([
-      { action: "prune", path: "/proj/src/old.ts" },
-      { action: "reindex", path: "/proj/src/new.ts" },
+      { action: "prune", path: expectedAbs("src/old.ts") },
+      { action: "reindex", path: expectedAbs("src/new.ts") },
     ]);
   });
 
   it("mv with -v flag still parses", () => {
-    const r = parseFileOps("mv -v src/old.ts src/new.ts", "/proj");
+    const r = parseFileOps("mv -v src/old.ts src/new.ts", CWD);
     expect(r).toEqual([
-      { action: "prune", path: "/proj/src/old.ts" },
-      { action: "reindex", path: "/proj/src/new.ts" },
+      { action: "prune", path: expectedAbs("src/old.ts") },
+      { action: "reindex", path: expectedAbs("src/new.ts") },
     ]);
   });
 
   it("cp reindexes dst only", () => {
-    const r = parseFileOps("cp src/a.ts src/b.ts", "/proj");
-    expect(r).toEqual([{ action: "reindex", path: "/proj/src/b.ts" }]);
+    const r = parseFileOps("cp src/a.ts src/b.ts", CWD);
+    expect(r).toEqual([{ action: "reindex", path: expectedAbs("src/b.ts") }]);
   });
 
   it("mv with wrong arg count returns empty", () => {
-    expect(parseFileOps("mv a.ts", "/proj")).toEqual([]);
-    expect(parseFileOps("mv a.ts b.ts c.ts", "/proj")).toEqual([]);
+    expect(parseFileOps("mv a.ts", CWD)).toEqual([]);
+    expect(parseFileOps("mv a.ts b.ts c.ts", CWD)).toEqual([]);
   });
 });
 
 describe("bash-postool — parseFileOps: git variants", () => {
   it("git rm prunes", () => {
-    const r = parseFileOps("git rm src/foo.ts", "/proj");
-    expect(r).toEqual([{ action: "prune", path: "/proj/src/foo.ts" }]);
+    const r = parseFileOps("git rm src/foo.ts", CWD);
+    expect(r).toEqual([{ action: "prune", path: expectedAbs("src/foo.ts") }]);
   });
 
   it("git rm -r prunes", () => {
-    const r = parseFileOps("git rm -r src/foo.ts", "/proj");
-    expect(r).toEqual([{ action: "prune", path: "/proj/src/foo.ts" }]);
+    const r = parseFileOps("git rm -r src/foo.ts", CWD);
+    expect(r).toEqual([{ action: "prune", path: expectedAbs("src/foo.ts") }]);
   });
 
   it("git mv prunes src and reindexes dst", () => {
-    const r = parseFileOps("git mv old.ts new.ts", "/proj");
+    const r = parseFileOps("git mv old.ts new.ts", CWD);
     expect(r).toEqual([
-      { action: "prune", path: "/proj/old.ts" },
-      { action: "reindex", path: "/proj/new.ts" },
+      { action: "prune", path: expectedAbs("old.ts") },
+      { action: "reindex", path: expectedAbs("new.ts") },
     ]);
   });
 
   it("unknown git subcommand returns empty", () => {
-    expect(parseFileOps("git status", "/proj")).toEqual([]);
-    expect(parseFileOps("git commit -m foo", "/proj")).toEqual([]);
+    expect(parseFileOps("git status", CWD)).toEqual([]);
+    expect(parseFileOps("git commit -m foo", CWD)).toEqual([]);
   });
 });
 
 describe("bash-postool — parseFileOps: redirections", () => {
   it("cat with single > redirect reindexes dst", () => {
-    const r = parseFileOps("cat template.ts > out.ts", "/proj");
-    expect(r).toEqual([{ action: "reindex", path: "/proj/out.ts" }]);
+    const r = parseFileOps("cat template.ts > out.ts", CWD);
+    expect(r).toEqual([{ action: "reindex", path: expectedAbs("out.ts") }]);
   });
 
   it(">> append redirect reindexes dst", () => {
-    const r = parseFileOps("echo foo >> log.ts", "/proj");
-    expect(r).toEqual([{ action: "reindex", path: "/proj/log.ts" }]);
+    const r = parseFileOps("echo foo >> log.ts", CWD);
+    expect(r).toEqual([{ action: "reindex", path: expectedAbs("log.ts") }]);
   });
 });
 
 describe("bash-postool — parseFileOps: pass-through cases", () => {
   it("globs pass through", () => {
-    expect(parseFileOps("rm src/*.ts", "/proj")).toEqual([]);
+    expect(parseFileOps("rm src/*.ts", CWD)).toEqual([]);
   });
 
   it("pipes pass through", () => {
-    expect(parseFileOps("find . | xargs rm", "/proj")).toEqual([]);
+    expect(parseFileOps("find . | xargs rm", CWD)).toEqual([]);
   });
 
   it("subshells pass through", () => {
-    expect(parseFileOps("rm $(find . -name auth)", "/proj")).toEqual([]);
+    expect(parseFileOps("rm $(find . -name auth)", CWD)).toEqual([]);
   });
 
   it("backticks pass through", () => {
-    expect(parseFileOps("rm `find . -name auth`", "/proj")).toEqual([]);
+    expect(parseFileOps("rm `find . -name auth`", CWD)).toEqual([]);
   });
 
   it("unrelated commands pass through", () => {
-    expect(parseFileOps("ls src/", "/proj")).toEqual([]);
-    expect(parseFileOps("grep foo src/*", "/proj")).toEqual([]);
-    expect(parseFileOps("npm test", "/proj")).toEqual([]);
+    expect(parseFileOps("ls src/", CWD)).toEqual([]);
+    expect(parseFileOps("grep foo src/*", CWD)).toEqual([]);
+    expect(parseFileOps("npm test", CWD)).toEqual([]);
   });
 
   it("empty / invalid input passes through", () => {
-    expect(parseFileOps("", "/proj")).toEqual([]);
-    expect(parseFileOps("   ", "/proj")).toEqual([]);
+    expect(parseFileOps("", CWD)).toEqual([]);
+    expect(parseFileOps("   ", CWD)).toEqual([]);
     // @ts-expect-error — testing runtime guard
-    expect(parseFileOps(null, "/proj")).toEqual([]);
+    expect(parseFileOps(null, CWD)).toEqual([]);
   });
 
   it("oversized command passes through", () => {
     const huge = "rm " + "x".repeat(501);
-    expect(parseFileOps(huge, "/proj")).toEqual([]);
+    expect(parseFileOps(huge, CWD)).toEqual([]);
   });
 
   it("touch passes through (empty file, nothing to index)", () => {
-    expect(parseFileOps("touch foo.ts", "/proj")).toEqual([]);
+    expect(parseFileOps("touch foo.ts", CWD)).toEqual([]);
   });
 });
 
@@ -139,7 +156,7 @@ describe("bash-postool — handleBashPostTool", () => {
     const r = handleBashPostTool({
       tool_name: "Read",
       tool_input: { command: "rm foo.ts" },
-      cwd: "/proj",
+      cwd: CWD,
     });
     expect(r.ops).toEqual([]);
   });
@@ -148,7 +165,7 @@ describe("bash-postool — handleBashPostTool", () => {
     const r = handleBashPostTool({
       tool_name: "Bash",
       tool_input: {},
-      cwd: "/proj",
+      cwd: CWD,
     });
     expect(r.ops).toEqual([]);
   });
@@ -157,8 +174,8 @@ describe("bash-postool — handleBashPostTool", () => {
     const r = handleBashPostTool({
       tool_name: "Bash",
       tool_input: { command: "rm src/foo.ts" },
-      cwd: "/proj",
+      cwd: CWD,
     });
-    expect(r.ops).toEqual([{ action: "prune", path: "/proj/src/foo.ts" }]);
+    expect(r.ops).toEqual([{ action: "prune", path: expectedAbs("src/foo.ts") }]);
   });
 });