🤖 Enable redundant path prefix validation for SSH runtime

Previously, validateNoRedundantPrefix() skipped validation for SSH runtimes
under the assumption that remote paths needed different handling. However,
the validation is equally valuable for SSH - absolute paths like
'/home/user/cmux/project/branch/src/file.ts' are just as redundant as
'/workspace/project/src/file.ts' on local runtime.

Changes:
- Remove SSH runtime bypass in validateNoRedundantPrefix()
- Use simple string matching instead of Node's path module (works for both)
- Handle trailing slashes and partial directory name matches correctly
- Add comprehensive tests for SSH runtime validation
- Add edge case tests (path equals cwd, partial name matches)

The validation now saves tokens on both local and SSH runtimes by
encouraging agents to use relative paths consistently.

_Generated with `cmux`_

Author: ammar-agent

src/services/tools/fileCommon.test.ts

@@ -194,5 +194,41 @@ describe("fileCommon", () => {
       expect(result).not.toBeNull();
       expect(result?.error).toContain("src/components/Button/index.ts");
     });
+
+    it("should reject path that equals cwd exactly", () => {
+      const result = validateNoRedundantPrefix("/workspace/project", cwd, runtime);
+      expect(result).not.toBeNull();
+      expect(result?.error).toContain("Redundant path prefix detected");
+      expect(result?.error).toContain("."); // Should suggest current directory
+    });
+
+    it("should not match partial directory names", () => {
+      // /workspace/project2 should NOT match /workspace/project
+      expect(validateNoRedundantPrefix("/workspace/project2/file.ts", cwd, runtime)).toBeNull();
+      expect(validateNoRedundantPrefix("/workspace/project-old/file.ts", cwd, runtime)).toBeNull();
+    });
+
+    it("should work with SSH runtime", () => {
+      const sshRuntime = createRuntime({
+        type: "ssh",
+        host: "user@localhost",
+        srcBaseDir: "/home/user/cmux",
+        identityFile: "/tmp/fake-key",
+      });
+      const sshCwd = "/home/user/cmux/project/branch";
+
+      // Should reject absolute paths with redundant prefix on SSH too
+      const result = validateNoRedundantPrefix(
+        "/home/user/cmux/project/branch/src/file.ts",
+        sshCwd,
+        sshRuntime
+      );
+      expect(result).not.toBeNull();
+      expect(result?.error).toContain("Redundant path prefix detected");
+      expect(result?.error).toContain("src/file.ts");
+
+      // Should allow relative paths on SSH
+      expect(validateNoRedundantPrefix("src/file.ts", sshCwd, sshRuntime)).toBeNull();
+    });
   });
 });

src/services/tools/fileCommon.ts

@@ -53,36 +53,42 @@ export function validateFileSize(stats: FileStat): { error: string } | null {
  * Returns an error object if the path contains the cwd prefix, null if valid.
  * This helps save tokens by encouraging relative paths.
  *
+ * Works for both local and SSH runtimes by using simple string matching
+ * for absolute paths instead of Node's path module (which only handles local paths).
+ *
  * @param filePath - The file path to validate
  * @param cwd - The working directory
- * @param runtime - The runtime (skip check for SSH since paths are remote)
+ * @param runtime - The runtime (unused, kept for consistency)
  * @returns Error object if redundant prefix found, null if valid
  */
 export function validateNoRedundantPrefix(
   filePath: string,
   cwd: string,
   runtime: Runtime
 ): { error: string } | null {
-  // Skip for SSH runtimes - remote paths don't apply
-  if (runtime instanceof SSHRuntime) {
+  // Only check absolute paths (start with /) - relative paths are fine
+  // This works for both local and SSH since both use Unix-style paths
+  if (!filePath.startsWith("/")) {
     return null;
   }
 
-  // Check if the path contains the cwd as a prefix (indicating redundancy)
-  // This catches cases like "/workspace/project/src/file.ts" when cwd is "/workspace/project"
-  const normalizedPath = path.normalize(filePath);
-  const normalizedCwd = path.normalize(cwd);
+  // Normalize both paths: remove trailing slashes for consistent comparison
+  const normalizedPath = filePath.replace(/\/+$/, "");
+  const normalizedCwd = cwd.replace(/\/+$/, "");
 
-  // Only check absolute paths - relative paths are fine
-  if (path.isAbsolute(normalizedPath)) {
-    // Check if the absolute path starts with the cwd
-    if (normalizedPath.startsWith(normalizedCwd)) {
-      // Calculate what the relative path would be
-      const relativePath = path.relative(normalizedCwd, normalizedPath);
-      return {
-        error: `Redundant path prefix detected. The path '${filePath}' contains the workspace directory. Please use relative paths to save tokens: '${relativePath}'`,
-      };
-    }
+  // Check if the absolute path starts with the cwd
+  // Use startsWith + check for path separator to avoid partial matches
+  // e.g., /workspace/project should match /workspace/project/src but not /workspace/project2
+  if (
+    normalizedPath === normalizedCwd ||
+    normalizedPath.startsWith(normalizedCwd + "/")
+  ) {
+    // Calculate what the relative path would be
+    const relativePath =
+      normalizedPath === normalizedCwd ? "." : normalizedPath.substring(normalizedCwd.length + 1);
+    return {
+      error: `Redundant path prefix detected. The path '${filePath}' contains the workspace directory. Please use relative paths to save tokens: '${relativePath}'`,
+    };
   }
 
   return null;