From a66433005044d0340934e22034ebb1cb05baf4b1 Mon Sep 17 00:00:00 2001
From: ali <mohammed18200118@gmail.com>
Date: Wed, 27 Aug 2025 11:34:13 +0300
Subject: [PATCH 1/8] save optimization patches metadata

---
 codeflash/code_utils/git_utils.py            | 76 ++++++++++++++++++--
 codeflash/lsp/beta.py                        | 53 +++++++++++---
 codeflash/optimization/function_optimizer.py | 15 ++--
 codeflash/optimization/optimizer.py          | 11 ++-
 4 files changed, 126 insertions(+), 29 deletions(-)

diff --git a/codeflash/code_utils/git_utils.py b/codeflash/code_utils/git_utils.py
index 92f2be8a1..6804f767b 100644
--- a/codeflash/code_utils/git_utils.py
+++ b/codeflash/code_utils/git_utils.py
@@ -1,17 +1,19 @@
 from __future__ import annotations
 
+import json
 import os
 import shutil
 import subprocess
 import sys
 import tempfile
 import time
-from functools import cache
+from functools import cache, lru_cache
 from io import StringIO
 from pathlib import Path
 from typing import TYPE_CHECKING, Optional
 
 import git
+from filelock import FileLock
 from rich.prompt import Confirm
 from unidiff import PatchSet
 
@@ -20,6 +22,8 @@
 from codeflash.code_utils.config_consts import N_CANDIDATES
 
 if TYPE_CHECKING:
+    from typing import Any
+
     from git import Repo
 
 
@@ -199,6 +203,14 @@ def get_last_commit_author_if_pr_exists(repo: Repo | None = None) -> str | None:
 patches_dir = codeflash_cache_dir / "patches"
 
 
+@lru_cache(maxsize=1)
+def get_git_project_id() -> str:
+    """Return the first commit sha of the repo."""
+    repo: Repo = git.Repo(search_parent_directories=True)
+    root_commits = list(repo.iter_commits(rev="HEAD", max_parents=0))
+    return root_commits[0].hexsha
+
+
 def create_worktree_snapshot_commit(worktree_dir: Path, commit_message: str) -> None:
     repository = git.Repo(worktree_dir, search_parent_directories=True)
     repository.git.add(".")
@@ -257,20 +269,70 @@ def remove_worktree(worktree_dir: Path) -> None:
         logger.exception(f"Failed to remove worktree: {worktree_dir}")
 
 
-def create_diff_patch_from_worktree(worktree_dir: Path, files: list[str], fto_name: str) -> Path:
+def get_patches_dir_for_project() -> Path:
+    project_id = get_git_project_id() or ""
+    return Path(patches_dir / project_id)
+
+
+def get_patches_metadata() -> dict[str, Any]:
+    project_patches_dir = get_patches_dir_for_project()
+    meta_file = project_patches_dir / "metadata.json"
+    if meta_file.exists():
+        return json.loads(meta_file.read_text())
+    return {"id": get_git_project_id() or "", "patches": []}
+
+
+def save_patches_metadata(patch_metadata: dict) -> dict:
+    project_patches_dir = get_patches_dir_for_project()
+    meta_file = project_patches_dir / "metadata.json"
+    lock_file = project_patches_dir / "metadata.json.lock"
+
+    with FileLock(lock_file, timeout=10):
+        metadata = get_patches_metadata()
+
+        patch_metadata["id"] = time.strftime("%Y%m%d-%H%M%S")
+        metadata["patches"].append(patch_metadata)
+
+        meta_file.write_text(json.dumps(metadata, indent=2))
+
+    return patch_metadata
+
+
+def overwrite_patch_metadata(patches: list[dict]) -> bool:
+    project_patches_dir = get_patches_dir_for_project()
+    meta_file = project_patches_dir / "metadata.json"
+    lock_file = project_patches_dir / "metadata.json.lock"
+
+    with FileLock(lock_file, timeout=10):
+        metadata = get_patches_metadata()
+        metadata["patches"] = patches
+        meta_file.write_text(json.dumps(metadata, indent=2))
+    return True
+
+
+def create_diff_patch_from_worktree(
+    worktree_dir: Path, files: list[str], metadata_input: dict[str, Any]
+) -> dict[str, Any]:
     repository = git.Repo(worktree_dir, search_parent_directories=True)
     uni_diff_text = repository.git.diff(None, "HEAD", *files, ignore_blank_lines=True, ignore_space_at_eol=True)
 
     if not uni_diff_text:
         logger.warning("No changes found in worktree.")
-        return None
+        return {}
 
     if not uni_diff_text.endswith("\n"):
         uni_diff_text += "\n"
 
-    # write to patches_dir
-    patches_dir.mkdir(parents=True, exist_ok=True)
-    patch_path = patches_dir / f"{worktree_dir.name}.{fto_name}.patch"
+    project_patches_dir = get_patches_dir_for_project()
+    project_patches_dir.mkdir(parents=True, exist_ok=True)
+
+    patch_path = project_patches_dir / f"{worktree_dir.name}.{metadata_input['fto_name']}.patch"
     with patch_path.open("w", encoding="utf8") as f:
         f.write(uni_diff_text)
-    return patch_path
+
+    final_metadata = {}
+    if metadata_input:
+        metadata_input["patch_path"] = str(patch_path)
+        final_metadata = save_patches_metadata(metadata_input)
+
+    return final_metadata
diff --git a/codeflash/lsp/beta.py b/codeflash/lsp/beta.py
index 77d87e8a6..e9026e5df 100644
--- a/codeflash/lsp/beta.py
+++ b/codeflash/lsp/beta.py
@@ -11,7 +11,11 @@
 
 from codeflash.api.cfapi import get_codeflash_api_key, get_user_id
 from codeflash.cli_cmds.cli import process_pyproject_config
-from codeflash.code_utils.git_utils import create_diff_patch_from_worktree
+from codeflash.code_utils.git_utils import (
+    create_diff_patch_from_worktree,
+    get_patches_metadata,
+    overwrite_patch_metadata,
+)
 from codeflash.code_utils.shell_utils import save_api_key_to_rc
 from codeflash.discovery.functions_to_optimize import filter_functions, get_functions_within_git_diff
 from codeflash.either import is_successful
@@ -216,6 +220,29 @@ def provide_api_key(server: CodeflashLanguageServer, params: ProvideApiKeyParams
         return {"status": "error", "message": "something went wrong while saving the api key"}
 
 
+@server.feature("onPatchApplied")
+def on_patch_applied(_server: CodeflashLanguageServer, params: dict[str, str]) -> dict[str, str]:
+    # first remove the patch from the metadata
+    patch_id = params["patch_id"]
+    metadata = get_patches_metadata()
+
+    deleted_patch_file = None
+    new_patches = []
+    for patch in metadata["patches"]:
+        if patch["id"] == patch_id:
+            deleted_patch_file = patch["patch_path"]
+            continue
+        new_patches.append(patch)
+
+    overwrite_patch_metadata(new_patches)
+    # then remove the patch file
+    if deleted_patch_file:
+        patch_path = Path(deleted_patch_file)
+        patch_path.unlink(missing_ok=True)
+        return {"status": "success"}
+    return {"status": "error", "message": "Patch not found"}
+
+
 @server.feature("performFunctionOptimization")
 @server.thread()
 def perform_function_optimization(  # noqa: PLR0911
@@ -317,15 +344,25 @@ def perform_function_optimization(  # noqa: PLR0911
 
         # generate a patch for the optimization
         relative_file_paths = [code_string.file_path for code_string in code_context.read_writable_code.code_strings]
-        patch_file = create_diff_patch_from_worktree(
+
+        speedup = original_code_baseline.runtime / best_optimization.runtime
+
+        # get the original file path in the actual project (not in the worktree)
+        original_args, _ = server.optimizer.original_args_and_test_cfg
+        relative_file_path = current_function.file_path.relative_to(server.args.project_root)
+        original_file_path = Path(original_args.project_root / relative_file_path).resolve()
+
+        metadata = create_diff_patch_from_worktree(
             server.optimizer.current_worktree,
             relative_file_paths,
-            server.optimizer.current_function_optimizer.function_to_optimize.qualified_name,
+            metadata_input={
+                "fto_name": function_to_optimize_qualified_name,
+                "explanation": best_optimization.explanation_v2,
+                "file_path": str(original_file_path),
+                "speedup": speedup,
+            },
         )
 
-        optimized_source = best_optimization.candidate.source_code.markdown
-        speedup = original_code_baseline.runtime / best_optimization.runtime
-
         server.show_message_log(f"Optimization completed for {params.functionName} with {speedup:.2f}x speedup", "Info")
 
         return {
@@ -333,8 +370,8 @@ def perform_function_optimization(  # noqa: PLR0911
             "status": "success",
             "message": "Optimization completed successfully",
             "extra": f"Speedup: {speedup:.2f}x faster",
-            "optimization": optimized_source,
-            "patch_file": str(patch_file),
+            "patch_file": metadata["patch_path"],
+            "patch_id": metadata["id"],
             "explanation": best_optimization.explanation_v2,
         }
     finally:
diff --git a/codeflash/optimization/function_optimizer.py b/codeflash/optimization/function_optimizer.py
index c523dcbce..b1808cdd7 100644
--- a/codeflash/optimization/function_optimizer.py
+++ b/codeflash/optimization/function_optimizer.py
@@ -631,14 +631,13 @@ def determine_best_candidate(
                                     executor=self.executor,
                                 )
                             )
-                    else:
-                        tree.add(
-                            f"Summed runtime: {humanize_runtime(best_test_runtime)} "
-                            f"(measured over {candidate_result.max_loop_count} "
-                            f"loop{'s' if candidate_result.max_loop_count > 1 else ''})"
-                        )
-                        tree.add(f"Speedup percentage: {perf_gain * 100:.1f}%")
-                        tree.add(f"Speedup ratio: {perf_gain + 1:.3f}X")
+                    tree.add(
+                        f"Summed runtime: {humanize_runtime(best_test_runtime)} "
+                        f"(measured over {candidate_result.max_loop_count} "
+                        f"loop{'s' if candidate_result.max_loop_count > 1 else ''})"
+                    )
+                    tree.add(f"Speedup percentage: {perf_gain * 100:.1f}%")
+                    tree.add(f"Speedup ratio: {perf_gain + 1:.3f}X")
                     console.print(tree)
                     if self.args.benchmark and benchmark_tree:
                         console.print(benchmark_tree)
diff --git a/codeflash/optimization/optimizer.py b/codeflash/optimization/optimizer.py
index 941705cfd..ffda905cc 100644
--- a/codeflash/optimization/optimizer.py
+++ b/codeflash/optimization/optimizer.py
@@ -343,16 +343,15 @@ def run(self) -> None:
                             optimizations_found += 1
                             # create a diff patch for successful optimization
                             if self.current_worktree:
-                                read_writable_code = best_optimization.unwrap().code_context.read_writable_code
+                                best_opt = best_optimization.unwrap()
+                                read_writable_code = best_opt.code_context.read_writable_code
                                 relative_file_paths = [
                                     code_string.file_path for code_string in read_writable_code.code_strings
                                 ]
-                                patch_path = create_diff_patch_from_worktree(
-                                    self.current_worktree,
-                                    relative_file_paths,
-                                    self.current_function_optimizer.function_to_optimize.qualified_name,
+                                metadata = create_diff_patch_from_worktree(
+                                    self.current_worktree, relative_file_paths, metadata_input={}
                                 )
-                                self.patch_files.append(patch_path)
+                                self.patch_files.append(metadata["patch_path"])
                                 if i < len(functions_to_optimize) - 1:
                                     create_worktree_snapshot_commit(
                                         self.current_worktree,

From db963938a4a54ef54e79655ca9c3cc3e115b39bf Mon Sep 17 00:00:00 2001
From: ali <mohammed18200118@gmail.com>
Date: Wed, 27 Aug 2025 11:38:21 +0300
Subject: [PATCH 2/8] typo

---
 codeflash/optimization/function_optimizer.py | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/codeflash/optimization/function_optimizer.py b/codeflash/optimization/function_optimizer.py
index b1808cdd7..c523dcbce 100644
--- a/codeflash/optimization/function_optimizer.py
+++ b/codeflash/optimization/function_optimizer.py
@@ -631,13 +631,14 @@ def determine_best_candidate(
                                     executor=self.executor,
                                 )
                             )
-                    tree.add(
-                        f"Summed runtime: {humanize_runtime(best_test_runtime)} "
-                        f"(measured over {candidate_result.max_loop_count} "
-                        f"loop{'s' if candidate_result.max_loop_count > 1 else ''})"
-                    )
-                    tree.add(f"Speedup percentage: {perf_gain * 100:.1f}%")
-                    tree.add(f"Speedup ratio: {perf_gain + 1:.3f}X")
+                    else:
+                        tree.add(
+                            f"Summed runtime: {humanize_runtime(best_test_runtime)} "
+                            f"(measured over {candidate_result.max_loop_count} "
+                            f"loop{'s' if candidate_result.max_loop_count > 1 else ''})"
+                        )
+                        tree.add(f"Speedup percentage: {perf_gain * 100:.1f}%")
+                        tree.add(f"Speedup ratio: {perf_gain + 1:.3f}X")
                     console.print(tree)
                     if self.args.benchmark and benchmark_tree:
                         console.print(benchmark_tree)

From cd7e1e143c95800c2430b3ed03fa726d2eb1ad27 Mon Sep 17 00:00:00 2001
From: ali <mohammed18200118@gmail.com>
Date: Wed, 27 Aug 2025 18:40:15 +0300
Subject: [PATCH 3/8] lsp: get previous optimizations

---
 codeflash/code_utils/git_utils.py |  1 +
 codeflash/lsp/beta.py             | 18 ++++++++++++++----
 2 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/codeflash/code_utils/git_utils.py b/codeflash/code_utils/git_utils.py
index 6804f767b..3243cfe74 100644
--- a/codeflash/code_utils/git_utils.py
+++ b/codeflash/code_utils/git_utils.py
@@ -287,6 +287,7 @@ def save_patches_metadata(patch_metadata: dict) -> dict:
     meta_file = project_patches_dir / "metadata.json"
     lock_file = project_patches_dir / "metadata.json.lock"
 
+    # we are not supporting multiple concurrent optimizations within the same process, but keep that in case we decide to do so in the future.
     with FileLock(lock_file, timeout=10):
         metadata = get_patches_metadata()
 
diff --git a/codeflash/lsp/beta.py b/codeflash/lsp/beta.py
index e9026e5df..9d395c789 100644
--- a/codeflash/lsp/beta.py
+++ b/codeflash/lsp/beta.py
@@ -43,6 +43,11 @@ class ProvideApiKeyParams:
     api_key: str
 
 
+@dataclass
+class OnPatchAppliedParams:
+    patch_id: str
+
+
 server = CodeflashLanguageServer("codeflash-language-server", "v1.0", protocol_cls=CodeflashLanguageServerProtocol)
 
 
@@ -220,16 +225,21 @@ def provide_api_key(server: CodeflashLanguageServer, params: ProvideApiKeyParams
         return {"status": "error", "message": "something went wrong while saving the api key"}
 
 
+@server.feature("retrieveSuccessfulOptimizations")
+def retrieve_successful_optimizations(_server: CodeflashLanguageServer, _params: any) -> dict[str, str]:
+    metadata = get_patches_metadata()
+    return {"status": "success", "patches": metadata["patches"]}
+
+
 @server.feature("onPatchApplied")
-def on_patch_applied(_server: CodeflashLanguageServer, params: dict[str, str]) -> dict[str, str]:
+def on_patch_applied(_server: CodeflashLanguageServer, params: OnPatchAppliedParams) -> dict[str, str]:
     # first remove the patch from the metadata
-    patch_id = params["patch_id"]
     metadata = get_patches_metadata()
 
     deleted_patch_file = None
     new_patches = []
     for patch in metadata["patches"]:
-        if patch["id"] == patch_id:
+        if patch["id"] == params.patch_id:
             deleted_patch_file = patch["patch_path"]
             continue
         new_patches.append(patch)
@@ -349,7 +359,7 @@ def perform_function_optimization(  # noqa: PLR0911
 
         # get the original file path in the actual project (not in the worktree)
         original_args, _ = server.optimizer.original_args_and_test_cfg
-        relative_file_path = current_function.file_path.relative_to(server.args.project_root)
+        relative_file_path = current_function.file_path.relative_to(server.optimizer.current_worktree)
         original_file_path = Path(original_args.project_root / relative_file_path).resolve()
 
         metadata = create_diff_patch_from_worktree(

From 4b7bf760e9ff576f14aa238100fed72f3fb3a9b7 Mon Sep 17 00:00:00 2001
From: ali <mohammed18200118@gmail.com>
Date: Wed, 27 Aug 2025 18:44:52 +0300
Subject: [PATCH 4/8] fix patch name in non-lsp mode

---
 codeflash/code_utils/git_utils.py   | 8 ++++++--
 codeflash/optimization/optimizer.py | 5 ++++-
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/codeflash/code_utils/git_utils.py b/codeflash/code_utils/git_utils.py
index 3243cfe74..12b213eff 100644
--- a/codeflash/code_utils/git_utils.py
+++ b/codeflash/code_utils/git_utils.py
@@ -312,7 +312,10 @@ def overwrite_patch_metadata(patches: list[dict]) -> bool:
 
 
 def create_diff_patch_from_worktree(
-    worktree_dir: Path, files: list[str], metadata_input: dict[str, Any]
+    worktree_dir: Path,
+    files: list[str],
+    fto_name: Optional[str] = None,
+    metadata_input: Optional[dict[str, Any]] = None,
 ) -> dict[str, Any]:
     repository = git.Repo(worktree_dir, search_parent_directories=True)
     uni_diff_text = repository.git.diff(None, "HEAD", *files, ignore_blank_lines=True, ignore_space_at_eol=True)
@@ -327,7 +330,8 @@ def create_diff_patch_from_worktree(
     project_patches_dir = get_patches_dir_for_project()
     project_patches_dir.mkdir(parents=True, exist_ok=True)
 
-    patch_path = project_patches_dir / f"{worktree_dir.name}.{metadata_input['fto_name']}.patch"
+    final_function_name = fto_name or metadata_input.get("fto_name", "unknown")
+    patch_path = project_patches_dir / f"{worktree_dir.name}.{final_function_name}.patch"
     with patch_path.open("w", encoding="utf8") as f:
         f.write(uni_diff_text)
 
diff --git a/codeflash/optimization/optimizer.py b/codeflash/optimization/optimizer.py
index ffda905cc..4f6fe3fdc 100644
--- a/codeflash/optimization/optimizer.py
+++ b/codeflash/optimization/optimizer.py
@@ -349,7 +349,10 @@ def run(self) -> None:
                                     code_string.file_path for code_string in read_writable_code.code_strings
                                 ]
                                 metadata = create_diff_patch_from_worktree(
-                                    self.current_worktree, relative_file_paths, metadata_input={}
+                                    self.current_worktree,
+                                    relative_file_paths,
+                                    fto_name=function_to_optimize.qualified_name,
+                                    metadata_input={},
                                 )
                                 self.patch_files.append(metadata["patch_path"])
                                 if i < len(functions_to_optimize) - 1:

From 503fa94bf33147a8d333f887e9ebe0a583a3fccf Mon Sep 17 00:00:00 2001
From: "codeflash-ai[bot]"
 <148906541+codeflash-ai[bot]@users.noreply.github.com>
Date: Wed, 27 Aug 2025 15:58:47 +0000
Subject: [PATCH 5/8] =?UTF-8?q?=E2=9A=A1=EF=B8=8F=20Speed=20up=20function?=
 =?UTF-8?q?=20`get=5Fpatches=5Fmetadata`=20by=2045%=20in=20PR=20#690=20(`w?=
 =?UTF-8?q?orktree/persist-optimization-patches`)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The optimized code achieves a **44% speedup** through two key optimizations:

**1. Added `@lru_cache(maxsize=1)` to `get_patches_dir_for_project()`**
- This caches the Path object construction, avoiding repeated calls to `get_git_project_id()` and `Path()` creation
- The line profiler shows this function's total time dropped from 5.32ms to being completely eliminated from the hot path in `get_patches_metadata()`
- Since `get_git_project_id()` was already cached but still being called repeatedly, this second-level caching eliminates that redundancy

**2. Replaced `read_text()` + `json.loads()` with `open()` + `json.load()`**
- Using `json.load()` with a file handle is more efficient than reading the entire file into memory first with `read_text()` then parsing it
- This avoids the intermediate string creation and is particularly beneficial for larger JSON files
- Added explicit UTF-8 encoding for consistency

**Performance Impact by Test Type:**
- **Basic cases** (small/missing files): 45-65% faster - benefits primarily from the caching optimization
- **Edge cases** (malformed JSON): 38-47% faster - still benefits from both optimizations
- **Large scale cases** (1000+ patches, large files): 39-52% faster - the file I/O optimization becomes more significant with larger JSON files

The caching optimization provides the most consistent gains across all scenarios since it eliminates repeated expensive operations, while the file I/O optimization scales with file size.
---
 codeflash/code_utils/git_utils.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/codeflash/code_utils/git_utils.py b/codeflash/code_utils/git_utils.py
index 3243cfe74..8739266f0 100644
--- a/codeflash/code_utils/git_utils.py
+++ b/codeflash/code_utils/git_utils.py
@@ -269,6 +269,7 @@ def remove_worktree(worktree_dir: Path) -> None:
         logger.exception(f"Failed to remove worktree: {worktree_dir}")
 
 
+@lru_cache(maxsize=1)
 def get_patches_dir_for_project() -> Path:
     project_id = get_git_project_id() or ""
     return Path(patches_dir / project_id)
@@ -278,7 +279,8 @@ def get_patches_metadata() -> dict[str, Any]:
     project_patches_dir = get_patches_dir_for_project()
     meta_file = project_patches_dir / "metadata.json"
     if meta_file.exists():
-        return json.loads(meta_file.read_text())
+        with meta_file.open("r", encoding="utf-8") as f:
+            return json.load(f)
     return {"id": get_git_project_id() or "", "patches": []}
 
 

From b6f666153a90db93e1a4f09a1e38363ae84fae3e Mon Sep 17 00:00:00 2001
From: ali <mohammed18200118@gmail.com>
Date: Wed, 27 Aug 2025 19:13:39 +0300
Subject: [PATCH 6/8] fix: patch path

---
 codeflash/code_utils/git_utils.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/codeflash/code_utils/git_utils.py b/codeflash/code_utils/git_utils.py
index 12b213eff..7c58f23f0 100644
--- a/codeflash/code_utils/git_utils.py
+++ b/codeflash/code_utils/git_utils.py
@@ -335,9 +335,9 @@ def create_diff_patch_from_worktree(
     with patch_path.open("w", encoding="utf8") as f:
         f.write(uni_diff_text)
 
-    final_metadata = {}
+    final_metadata = {"patch_path": str(patch_path)}
     if metadata_input:
-        metadata_input["patch_path"] = str(patch_path)
-        final_metadata = save_patches_metadata(metadata_input)
+        final_metadata.update(metadata_input)
+        final_metadata = save_patches_metadata(final_metadata)
 
     return final_metadata

From 40b91f05f7b5982b21562e533b6a80a4ba373bb4 Mon Sep 17 00:00:00 2001
From: ali <mohammed18200118@gmail.com>
Date: Thu, 28 Aug 2025 16:41:33 +0300
Subject: [PATCH 7/8] codeflash suggestions

---
 codeflash/code_utils/git_utils.py | 7 ++++---
 codeflash/lsp/beta.py             | 2 +-
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/codeflash/code_utils/git_utils.py b/codeflash/code_utils/git_utils.py
index 7c58f23f0..394327427 100644
--- a/codeflash/code_utils/git_utils.py
+++ b/codeflash/code_utils/git_utils.py
@@ -270,15 +270,16 @@ def remove_worktree(worktree_dir: Path) -> None:
 
 
 def get_patches_dir_for_project() -> Path:
-    project_id = get_git_project_id() or ""
-    return Path(patches_dir / project_id)
+    project_id = get_git_project_id()
+    return patches_dir / project_id
 
 
 def get_patches_metadata() -> dict[str, Any]:
     project_patches_dir = get_patches_dir_for_project()
     meta_file = project_patches_dir / "metadata.json"
     if meta_file.exists():
-        return json.loads(meta_file.read_text())
+        with meta_file.open("r", encoding="utf-8") as f:
+            return json.load(f)
     return {"id": get_git_project_id() or "", "patches": []}
 
 
diff --git a/codeflash/lsp/beta.py b/codeflash/lsp/beta.py
index 9d395c789..3467b3fb8 100644
--- a/codeflash/lsp/beta.py
+++ b/codeflash/lsp/beta.py
@@ -244,9 +244,9 @@ def on_patch_applied(_server: CodeflashLanguageServer, params: OnPatchAppliedPar
             continue
         new_patches.append(patch)
 
-    overwrite_patch_metadata(new_patches)
     # then remove the patch file
     if deleted_patch_file:
+        overwrite_patch_metadata(new_patches)
         patch_path = Path(deleted_patch_file)
         patch_path.unlink(missing_ok=True)
         return {"status": "success"}

From 0de7ebd74b5daab813df26e1136bbf011f12e074 Mon Sep 17 00:00:00 2001
From: ali <mohammed18200118@gmail.com>
Date: Thu, 28 Aug 2025 18:11:35 +0300
Subject: [PATCH 8/8] split the worktree utils in a separate file

---
 codeflash/code_utils/git_utils.py          | 154 +------------------
 codeflash/code_utils/git_worktree_utils.py | 169 +++++++++++++++++++++
 codeflash/lsp/beta.py                      |   2 +-
 codeflash/optimization/optimizer.py        |   4 +-
 4 files changed, 174 insertions(+), 155 deletions(-)
 create mode 100644 codeflash/code_utils/git_worktree_utils.py

diff --git a/codeflash/code_utils/git_utils.py b/codeflash/code_utils/git_utils.py
index 394327427..00f9f5e28 100644
--- a/codeflash/code_utils/git_utils.py
+++ b/codeflash/code_utils/git_utils.py
@@ -1,29 +1,24 @@
 from __future__ import annotations
 
-import json
 import os
 import shutil
 import subprocess
 import sys
 import tempfile
 import time
-from functools import cache, lru_cache
+from functools import cache
 from io import StringIO
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 import git
-from filelock import FileLock
 from rich.prompt import Confirm
 from unidiff import PatchSet
 
 from codeflash.cli_cmds.console import logger
-from codeflash.code_utils.compat import codeflash_cache_dir
 from codeflash.code_utils.config_consts import N_CANDIDATES
 
 if TYPE_CHECKING:
-    from typing import Any
-
     from git import Repo
 
 
@@ -197,148 +192,3 @@ def get_last_commit_author_if_pr_exists(repo: Repo | None = None) -> str | None:
         return None
     else:
         return last_commit.author.name
-
-
-worktree_dirs = codeflash_cache_dir / "worktrees"
-patches_dir = codeflash_cache_dir / "patches"
-
-
-@lru_cache(maxsize=1)
-def get_git_project_id() -> str:
-    """Return the first commit sha of the repo."""
-    repo: Repo = git.Repo(search_parent_directories=True)
-    root_commits = list(repo.iter_commits(rev="HEAD", max_parents=0))
-    return root_commits[0].hexsha
-
-
-def create_worktree_snapshot_commit(worktree_dir: Path, commit_message: str) -> None:
-    repository = git.Repo(worktree_dir, search_parent_directories=True)
-    repository.git.add(".")
-    repository.git.commit("-m", commit_message, "--no-verify")
-
-
-def create_detached_worktree(module_root: Path) -> Optional[Path]:
-    if not check_running_in_git_repo(module_root):
-        logger.warning("Module is not in a git repository. Skipping worktree creation.")
-        return None
-    git_root = git_root_dir()
-    current_time_str = time.strftime("%Y%m%d-%H%M%S")
-    worktree_dir = worktree_dirs / f"{git_root.name}-{current_time_str}"
-
-    repository = git.Repo(git_root, search_parent_directories=True)
-
-    repository.git.worktree("add", "-d", str(worktree_dir))
-
-    # Get uncommitted diff from the original repo
-    repository.git.add("-N", ".")  # add the index for untracked files to be included in the diff
-    exclude_binary_files = [":!*.pyc", ":!*.pyo", ":!*.pyd", ":!*.so", ":!*.dll", ":!*.whl", ":!*.egg", ":!*.egg-info", ":!*.pyz", ":!*.pkl", ":!*.pickle", ":!*.joblib", ":!*.npy", ":!*.npz", ":!*.h5", ":!*.hdf5", ":!*.pth", ":!*.pt", ":!*.pb", ":!*.onnx", ":!*.db", ":!*.sqlite", ":!*.sqlite3", ":!*.feather", ":!*.parquet", ":!*.jpg", ":!*.jpeg", ":!*.png", ":!*.gif", ":!*.bmp", ":!*.tiff", ":!*.webp", ":!*.wav", ":!*.mp3", ":!*.ogg", ":!*.flac", ":!*.mp4", ":!*.avi", ":!*.mov", ":!*.mkv", ":!*.pdf", ":!*.doc", ":!*.docx", ":!*.xls", ":!*.xlsx", ":!*.ppt", ":!*.pptx", ":!*.zip", ":!*.rar", ":!*.tar", ":!*.tar.gz", ":!*.tgz", ":!*.bz2", ":!*.xz"]  # fmt: off
-    uni_diff_text = repository.git.diff(
-        None, "HEAD", "--", *exclude_binary_files, ignore_blank_lines=True, ignore_space_at_eol=True
-    )
-
-    if not uni_diff_text.strip():
-        logger.info("No uncommitted changes to copy to worktree.")
-        return worktree_dir
-
-    # Write the diff to a temporary file
-    with tempfile.NamedTemporaryFile(mode="w", suffix=".codeflash.patch", delete=False) as tmp_patch_file:
-        tmp_patch_file.write(uni_diff_text + "\n")  # the new line here is a must otherwise the last hunk won't be valid
-        tmp_patch_file.flush()
-
-        patch_path = Path(tmp_patch_file.name).resolve()
-
-        # Apply the patch inside the worktree
-        try:
-            subprocess.run(
-                ["git", "apply", "--ignore-space-change", "--ignore-whitespace", "--whitespace=nowarn", patch_path],
-                cwd=worktree_dir,
-                check=True,
-            )
-            create_worktree_snapshot_commit(worktree_dir, "Initial Snapshot")
-        except subprocess.CalledProcessError as e:
-            logger.error(f"Failed to apply patch to worktree: {e}")
-
-        return worktree_dir
-
-
-def remove_worktree(worktree_dir: Path) -> None:
-    try:
-        repository = git.Repo(worktree_dir, search_parent_directories=True)
-        repository.git.worktree("remove", "--force", worktree_dir)
-    except Exception:
-        logger.exception(f"Failed to remove worktree: {worktree_dir}")
-
-
-def get_patches_dir_for_project() -> Path:
-    project_id = get_git_project_id()
-    return patches_dir / project_id
-
-
-def get_patches_metadata() -> dict[str, Any]:
-    project_patches_dir = get_patches_dir_for_project()
-    meta_file = project_patches_dir / "metadata.json"
-    if meta_file.exists():
-        with meta_file.open("r", encoding="utf-8") as f:
-            return json.load(f)
-    return {"id": get_git_project_id() or "", "patches": []}
-
-
-def save_patches_metadata(patch_metadata: dict) -> dict:
-    project_patches_dir = get_patches_dir_for_project()
-    meta_file = project_patches_dir / "metadata.json"
-    lock_file = project_patches_dir / "metadata.json.lock"
-
-    # we are not supporting multiple concurrent optimizations within the same process, but keep that in case we decide to do so in the future.
-    with FileLock(lock_file, timeout=10):
-        metadata = get_patches_metadata()
-
-        patch_metadata["id"] = time.strftime("%Y%m%d-%H%M%S")
-        metadata["patches"].append(patch_metadata)
-
-        meta_file.write_text(json.dumps(metadata, indent=2))
-
-    return patch_metadata
-
-
-def overwrite_patch_metadata(patches: list[dict]) -> bool:
-    project_patches_dir = get_patches_dir_for_project()
-    meta_file = project_patches_dir / "metadata.json"
-    lock_file = project_patches_dir / "metadata.json.lock"
-
-    with FileLock(lock_file, timeout=10):
-        metadata = get_patches_metadata()
-        metadata["patches"] = patches
-        meta_file.write_text(json.dumps(metadata, indent=2))
-    return True
-
-
-def create_diff_patch_from_worktree(
-    worktree_dir: Path,
-    files: list[str],
-    fto_name: Optional[str] = None,
-    metadata_input: Optional[dict[str, Any]] = None,
-) -> dict[str, Any]:
-    repository = git.Repo(worktree_dir, search_parent_directories=True)
-    uni_diff_text = repository.git.diff(None, "HEAD", *files, ignore_blank_lines=True, ignore_space_at_eol=True)
-
-    if not uni_diff_text:
-        logger.warning("No changes found in worktree.")
-        return {}
-
-    if not uni_diff_text.endswith("\n"):
-        uni_diff_text += "\n"
-
-    project_patches_dir = get_patches_dir_for_project()
-    project_patches_dir.mkdir(parents=True, exist_ok=True)
-
-    final_function_name = fto_name or metadata_input.get("fto_name", "unknown")
-    patch_path = project_patches_dir / f"{worktree_dir.name}.{final_function_name}.patch"
-    with patch_path.open("w", encoding="utf8") as f:
-        f.write(uni_diff_text)
-
-    final_metadata = {"patch_path": str(patch_path)}
-    if metadata_input:
-        final_metadata.update(metadata_input)
-        final_metadata = save_patches_metadata(final_metadata)
-
-    return final_metadata
diff --git a/codeflash/code_utils/git_worktree_utils.py b/codeflash/code_utils/git_worktree_utils.py
new file mode 100644
index 000000000..3668dc398
--- /dev/null
+++ b/codeflash/code_utils/git_worktree_utils.py
@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import tempfile
+import time
+from functools import lru_cache
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional
+
+import git
+from filelock import FileLock
+
+from codeflash.cli_cmds.console import logger
+from codeflash.code_utils.compat import codeflash_cache_dir
+from codeflash.code_utils.git_utils import check_running_in_git_repo, git_root_dir
+
+if TYPE_CHECKING:
+    from typing import Any
+
+    from git import Repo
+
+
+worktree_dirs = codeflash_cache_dir / "worktrees"
+patches_dir = codeflash_cache_dir / "patches"
+
+if TYPE_CHECKING:
+    from git import Repo
+
+
+@lru_cache(maxsize=1)
+def get_git_project_id() -> str:
+    """Return the first commit sha of the repo."""
+    repo: Repo = git.Repo(search_parent_directories=True)
+    root_commits = list(repo.iter_commits(rev="HEAD", max_parents=0))
+    return root_commits[0].hexsha
+
+
+def create_worktree_snapshot_commit(worktree_dir: Path, commit_message: str) -> None:
+    repository = git.Repo(worktree_dir, search_parent_directories=True)
+    repository.git.add(".")
+    repository.git.commit("-m", commit_message, "--no-verify")
+
+
+def create_detached_worktree(module_root: Path) -> Optional[Path]:
+    if not check_running_in_git_repo(module_root):
+        logger.warning("Module is not in a git repository. Skipping worktree creation.")
+        return None
+    git_root = git_root_dir()
+    current_time_str = time.strftime("%Y%m%d-%H%M%S")
+    worktree_dir = worktree_dirs / f"{git_root.name}-{current_time_str}"
+
+    repository = git.Repo(git_root, search_parent_directories=True)
+
+    repository.git.worktree("add", "-d", str(worktree_dir))
+
+    # Get uncommitted diff from the original repo
+    repository.git.add("-N", ".")  # add the index for untracked files to be included in the diff
+    exclude_binary_files = [":!*.pyc", ":!*.pyo", ":!*.pyd", ":!*.so", ":!*.dll", ":!*.whl", ":!*.egg", ":!*.egg-info", ":!*.pyz", ":!*.pkl", ":!*.pickle", ":!*.joblib", ":!*.npy", ":!*.npz", ":!*.h5", ":!*.hdf5", ":!*.pth", ":!*.pt", ":!*.pb", ":!*.onnx", ":!*.db", ":!*.sqlite", ":!*.sqlite3", ":!*.feather", ":!*.parquet", ":!*.jpg", ":!*.jpeg", ":!*.png", ":!*.gif", ":!*.bmp", ":!*.tiff", ":!*.webp", ":!*.wav", ":!*.mp3", ":!*.ogg", ":!*.flac", ":!*.mp4", ":!*.avi", ":!*.mov", ":!*.mkv", ":!*.pdf", ":!*.doc", ":!*.docx", ":!*.xls", ":!*.xlsx", ":!*.ppt", ":!*.pptx", ":!*.zip", ":!*.rar", ":!*.tar", ":!*.tar.gz", ":!*.tgz", ":!*.bz2", ":!*.xz"]  # fmt: off
+    uni_diff_text = repository.git.diff(
+        None, "HEAD", "--", *exclude_binary_files, ignore_blank_lines=True, ignore_space_at_eol=True
+    )
+
+    if not uni_diff_text.strip():
+        logger.info("No uncommitted changes to copy to worktree.")
+        return worktree_dir
+
+    # Write the diff to a temporary file
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".codeflash.patch", delete=False) as tmp_patch_file:
+        tmp_patch_file.write(uni_diff_text + "\n")  # the new line here is a must otherwise the last hunk won't be valid
+        tmp_patch_file.flush()
+
+        patch_path = Path(tmp_patch_file.name).resolve()
+
+        # Apply the patch inside the worktree
+        try:
+            subprocess.run(
+                ["git", "apply", "--ignore-space-change", "--ignore-whitespace", "--whitespace=nowarn", patch_path],
+                cwd=worktree_dir,
+                check=True,
+            )
+            create_worktree_snapshot_commit(worktree_dir, "Initial Snapshot")
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Failed to apply patch to worktree: {e}")
+
+        return worktree_dir
+
+
+def remove_worktree(worktree_dir: Path) -> None:
+    try:
+        repository = git.Repo(worktree_dir, search_parent_directories=True)
+        repository.git.worktree("remove", "--force", worktree_dir)
+    except Exception:
+        logger.exception(f"Failed to remove worktree: {worktree_dir}")
+
+
+def get_patches_dir_for_project() -> Path:
+    project_id = get_git_project_id()
+    return patches_dir / project_id
+
+
+def get_patches_metadata() -> dict[str, Any]:
+    project_patches_dir = get_patches_dir_for_project()
+    meta_file = project_patches_dir / "metadata.json"
+    if meta_file.exists():
+        with meta_file.open("r", encoding="utf-8") as f:
+            return json.load(f)
+    return {"id": get_git_project_id() or "", "patches": []}
+
+
+def save_patches_metadata(patch_metadata: dict) -> dict:
+    project_patches_dir = get_patches_dir_for_project()
+    meta_file = project_patches_dir / "metadata.json"
+    lock_file = project_patches_dir / "metadata.json.lock"
+
+    # we are not supporting multiple concurrent optimizations within the same process, but keep that in case we decide to do so in the future.
+    with FileLock(lock_file, timeout=10):
+        metadata = get_patches_metadata()
+
+        patch_metadata["id"] = time.strftime("%Y%m%d-%H%M%S")
+        metadata["patches"].append(patch_metadata)
+
+        meta_file.write_text(json.dumps(metadata, indent=2))
+
+    return patch_metadata
+
+
+def overwrite_patch_metadata(patches: list[dict]) -> bool:
+    project_patches_dir = get_patches_dir_for_project()
+    meta_file = project_patches_dir / "metadata.json"
+    lock_file = project_patches_dir / "metadata.json.lock"
+
+    with FileLock(lock_file, timeout=10):
+        metadata = get_patches_metadata()
+        metadata["patches"] = patches
+        meta_file.write_text(json.dumps(metadata, indent=2))
+    return True
+
+
+def create_diff_patch_from_worktree(
+    worktree_dir: Path,
+    files: list[str],
+    fto_name: Optional[str] = None,
+    metadata_input: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    repository = git.Repo(worktree_dir, search_parent_directories=True)
+    uni_diff_text = repository.git.diff(None, "HEAD", *files, ignore_blank_lines=True, ignore_space_at_eol=True)
+
+    if not uni_diff_text:
+        logger.warning("No changes found in worktree.")
+        return {}
+
+    if not uni_diff_text.endswith("\n"):
+        uni_diff_text += "\n"
+
+    project_patches_dir = get_patches_dir_for_project()
+    project_patches_dir.mkdir(parents=True, exist_ok=True)
+
+    final_function_name = fto_name or metadata_input.get("fto_name", "unknown")
+    patch_path = project_patches_dir / f"{worktree_dir.name}.{final_function_name}.patch"
+    with patch_path.open("w", encoding="utf8") as f:
+        f.write(uni_diff_text)
+
+    final_metadata = {"patch_path": str(patch_path)}
+    if metadata_input:
+        final_metadata.update(metadata_input)
+        final_metadata = save_patches_metadata(final_metadata)
+
+    return final_metadata
diff --git a/codeflash/lsp/beta.py b/codeflash/lsp/beta.py
index 3467b3fb8..e626b7b55 100644
--- a/codeflash/lsp/beta.py
+++ b/codeflash/lsp/beta.py
@@ -11,7 +11,7 @@
 
 from codeflash.api.cfapi import get_codeflash_api_key, get_user_id
 from codeflash.cli_cmds.cli import process_pyproject_config
-from codeflash.code_utils.git_utils import (
+from codeflash.code_utils.git_worktree_utils import (
     create_diff_patch_from_worktree,
     get_patches_metadata,
     overwrite_patch_metadata,
diff --git a/codeflash/optimization/optimizer.py b/codeflash/optimization/optimizer.py
index 4f6fe3fdc..e1a0c4186 100644
--- a/codeflash/optimization/optimizer.py
+++ b/codeflash/optimization/optimizer.py
@@ -15,8 +15,8 @@
 from codeflash.code_utils import env_utils
 from codeflash.code_utils.code_utils import cleanup_paths, get_run_tmp_file
 from codeflash.code_utils.env_utils import get_pr_number, is_pr_draft
-from codeflash.code_utils.git_utils import (
-    check_running_in_git_repo,
+from codeflash.code_utils.git_utils import check_running_in_git_repo
+from codeflash.code_utils.git_worktree_utils import (
     create_detached_worktree,
     create_diff_patch_from_worktree,
     create_worktree_snapshot_commit,