Add tests for pathUtils and fix regression found from new tests

Author: AlePouroullis

src/pathUtils.ts

@@ -21,44 +21,27 @@ import * as path from "path";
  * @param pathStr - The path to normalize. Can be a Windows or Unix-style path.
  * @param stripExtension - If true, removes the file extension (e.g. .prompt, .agent)
  * @returns Normalized path string in the format 'path/to/resource'
- *
- * @example
- * normalizePath("path/to/file.prompt")
- * // => 'path/to/file.prompt'
- *
- * @example
- * normalizePath("path/to/file.prompt", true)
- * // => 'path/to/file'
- *
- * @example
- * normalizePath("\\windows\\style\\path.prompt")
- * // => 'windows/style/path.prompt'
- *
- * @example
- * normalizePath("/leading/slash/path/")
- * // => 'leading/slash/path'
- *
- * @example
- * normalizePath("multiple//slashes//path")
- * // => 'multiple/slashes/path'
  */
 export function normalizePath(
     pathStr: string,
     stripExtension: boolean = false,
 ): string {
     // Convert Windows backslashes to forward slashes
-    const normalizedSeparators = pathStr.replace(/\\/g, "/");
+    let normalizedPath = pathStr.replace(/\\/g, "/");
+
+    // Use path.posix to handle path normalization (handles consecutive slashes and . /..)
+    normalizedPath = path.posix.normalize(normalizedPath);
 
-    // Use path.posix to handle path normalization (handles consecutive slashes)
-    // We use posix to ensure forward slashes are used consistently
-    let normalizedPath = path.posix.normalize(normalizedSeparators);
+    // Remove leading/trailing slashes
+    normalizedPath = normalizedPath.replace(/^\/+|\/+$/g, "");
 
-    // Strip extension if requested
-    if (stripExtension) {
-        const ext = path.posix.extname(normalizedPath);
-        normalizedPath = normalizedPath.slice(0, -ext.length);
+    // Strip extension if requested 
+    if (stripExtension && normalizedPath.includes(".")) {
+        normalizedPath = path.posix.join(
+            path.posix.dirname(normalizedPath),
+            path.posix.basename(normalizedPath, path.posix.extname(normalizedPath)),
+        );
     }
 
-    // Remove leading/trailing slashes
-    return normalizedPath.replace(/^\/+|\/+$/g, "");
+    return normalizedPath;
 }

tests/custom/unit/LRUCache.test.ts

@@ -1,4 +1,4 @@
-import LRUCache from "../../../../src/cache/LRUCache";
+import LRUCache from "../../../src/cache/LRUCache";
 
 describe("LRUCache", () => {
     let cache: LRUCache<string, number>;

tests/custom/unit/pathUtils.test.ts

@@ -0,0 +1,78 @@
+import { normalizePath } from "../../../src/pathUtils";
+
+describe("normalizePath", () => {
+    const testCases = [
+        // Basic cases
+        {
+            input: "path/to/file.prompt",
+            expectedWithExtension: "path/to/file.prompt",
+            expectedWithoutExtension: "path/to/file",
+        },
+        {
+            input: "path\\to\\file.agent",
+            expectedWithExtension: "path/to/file.agent",
+            expectedWithoutExtension: "path/to/file",
+        },
+        {
+            input: "/leading/slashes/file.prompt",
+            expectedWithExtension: "leading/slashes/file.prompt",
+            expectedWithoutExtension: "leading/slashes/file",
+        },
+        {
+            input: "trailing/slashes/file.agent/",
+            expectedWithExtension: "trailing/slashes/file.agent",
+            expectedWithoutExtension: "trailing/slashes/file",
+        },
+        {
+            input: "multiple//slashes//file.prompt",
+            expectedWithExtension: "multiple/slashes/file.prompt",
+            expectedWithoutExtension: "multiple/slashes/file",
+        },
+        // Edge cases
+        {
+            input: "path/to/file with spaces.prompt",
+            expectedWithExtension: "path/to/file with spaces.prompt",
+            expectedWithoutExtension: "path/to/file with spaces",
+        },
+        {
+            input: "path/to/file\\with\\backslashes.prompt",
+            expectedWithExtension: "path/to/file/with/backslashes.prompt",
+            expectedWithoutExtension: "path/to/file/with/backslashes",
+        },
+        {
+            input: "path/to/unicode/文件.prompt",
+            expectedWithExtension: "path/to/unicode/文件.prompt",
+            expectedWithoutExtension: "path/to/unicode/文件",
+        },
+        {
+            input: "path/to/special/chars/!@#$%^&*().prompt",
+            expectedWithExtension: "path/to/special/chars/!@#$%^&*().prompt",
+            expectedWithoutExtension: "path/to/special/chars/!@#$%^&*()",
+        },
+    ];
+
+    test.each(testCases)(
+        "normalizes path '$input' correctly",
+        ({ input, expectedWithExtension, expectedWithoutExtension }) => {
+            // Test without stripping extension
+            const resultWithExtension = normalizePath(input, false);
+            expect(resultWithExtension).toBe(expectedWithExtension);
+
+            // Test with extension stripping
+            const resultWithoutExtension = normalizePath(input, true);
+            expect(resultWithoutExtension).toBe(expectedWithoutExtension);
+
+            // Add custom failure messages if needed
+            if (resultWithExtension !== expectedWithExtension) {
+                throw new Error(
+                    `Failed with stripExtension=false for '${input}'. Expected '${expectedWithExtension}', got '${resultWithExtension}'`,
+                );
+            }
+            if (resultWithoutExtension !== expectedWithoutExtension) {
+                throw new Error(
+                    `Failed with stripExtension=true for '${input}'. Expected '${expectedWithoutExtension}', got '${resultWithoutExtension}'`,
+                );
+            }
+        },
+    );
+});