Fix for VSC windows

codeflash/discovery/functions_to_optimize.py

@@ -671,28 +671,32 @@ def filter_functions(
     previous_checkpoint_functions_removed_count: int = 0
     tests_root_str = str(tests_root)
     module_root_str = str(module_root)
+    # Normalize paths for case-insensitive comparison on Windows
+    tests_root_normalized = os.path.normcase(tests_root_str)
+    module_root_normalized = os.path.normcase(module_root_str)
 
     # We desperately need Python 3.10+ only support to make this code readable with structural pattern matching
     for file_path_path, functions in modified_functions.items():
         _functions = functions
         file_path = str(file_path_path)
-        if file_path.startswith(tests_root_str + os.sep):
+        file_path_normalized = os.path.normcase(file_path)
+        if file_path_normalized.startswith(tests_root_normalized + os.sep):
             test_functions_removed_count += len(_functions)
             continue
         if file_path in ignore_paths or any(
-            file_path.startswith(str(ignore_path) + os.sep) for ignore_path in ignore_paths
+            file_path_normalized.startswith(os.path.normcase(str(ignore_path)) + os.sep) for ignore_path in ignore_paths
         ):
             ignore_paths_removed_count += 1
             continue
         if file_path in submodule_paths or any(
-            file_path.startswith(str(submodule_path) + os.sep) for submodule_path in submodule_paths
+            file_path_normalized.startswith(os.path.normcase(str(submodule_path)) + os.sep) for submodule_path in submodule_paths
         ):
             submodule_ignored_paths_count += 1
             continue
         if path_belongs_to_site_packages(Path(file_path)):
             site_packages_removed_count += len(_functions)
             continue
-        if not file_path.startswith(module_root_str + os.sep):
+        if not file_path_normalized.startswith(module_root_normalized + os.sep):
             non_modules_removed_count += len(_functions)
             continue
         try:

codeflash/lsp/beta.py

@@ -479,10 +479,13 @@ def initialize_function_optimization(params: FunctionOptimizationInitParams) ->
         server.current_optimization_init_result = initialization_result.unwrap()
         server.show_message_log(f"Successfully initialized optimization for {params.functionName}", "Info")
 
-        files = [document.path]
+        # Use the worktree file path (which is normalized) instead of document.path
+        # document.path might be malformed on Windows (missing drive letter)
+        worktree_file_path = str(server.optimizer.args.file.resolve())
+        files = [worktree_file_path]
 
         _, _, original_helpers = server.current_optimization_init_result
-        files.extend([str(helper_path) for helper_path in original_helpers])
+        files.extend([str(helper_path.resolve()) for helper_path in original_helpers])
 
         return {"functionName": params.functionName, "status": "success", "files_inside_context": files}
 

codeflash/optimization/optimizer.py

@@ -485,7 +485,48 @@ def mirror_paths_for_worktree_mode(self, worktree_dir: Path) -> None:
 
 
 def mirror_path(path: Path, src_root: Path, dest_root: Path) -> Path:
-    relative_path = path.relative_to(src_root)
+    # Resolve both paths to absolute paths to handle Windows path normalization issues
+    # This ensures paths with/without drive letters are handled correctly
+    try:
+        path_resolved = path.resolve()
+    except (OSError, RuntimeError):
+        # If resolve fails (e.g., path doesn't exist or is malformed), try absolute()
+        path_resolved = path.absolute() if not path.is_absolute() else path
+
+    try:
+        src_root_resolved = src_root.resolve()
+    except (OSError, RuntimeError):
+        src_root_resolved = src_root.absolute() if not src_root.is_absolute() else src_root
+
+    # Normalize paths using os.path.normpath and normcase for cross-platform compatibility
+    path_str = os.path.normpath(str(path_resolved))
+    src_root_str = os.path.normpath(str(src_root_resolved))
+
+    # Convert to lowercase for case-insensitive comparison on Windows
+    path_normalized = os.path.normcase(path_str)
+    src_root_normalized = os.path.normcase(src_root_str)
+
+    # Try using Path.relative_to with resolved paths first
+    try:
+        relative_path = path_resolved.relative_to(src_root_resolved)
+    except ValueError:
+        # If relative_to fails, manually extract the relative path using normalized strings
+        if path_normalized.startswith(src_root_normalized):
+            # Extract relative path manually
+            # Use the original path_str to preserve proper path format
+            if path_str.startswith(src_root_str):
+                relative_str = path_str[len(src_root_str) :].lstrip(os.sep)
+                relative_path = Path(relative_str)
+            else:
+                # Fallback: use normalized paths
+                relative_str = path_normalized[len(src_root_normalized) :].lstrip(os.sep)
+                relative_path = Path(relative_str)
+        else:
+            raise ValueError(
+                f"Path {path_resolved} (normalized: {path_normalized}) is not relative to "
+                f"{src_root_resolved} (normalized: {src_root_normalized})"
+            )
+
     return dest_root / relative_path