Merge branch 'main' into feat/hypothesis-tests

Author: KRRT7

codeflash/api/cfapi.py

@@ -91,7 +91,7 @@ def get_user_id(api_key: Optional[str] = None) -> Optional[str]:
 
     :return: The userid or None if the request fails.
     """
-    if not ensure_codeflash_api_key():
+    if not api_key and not ensure_codeflash_api_key():
         return None
 
     response = make_cfapi_request(

codeflash/code_utils/edit_generated_tests.py

@@ -4,7 +4,7 @@
 import os
 import re
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 import libcst as cst
 from libcst import MetadataWrapper
@@ -149,18 +149,19 @@ def leave_SimpleStatementSuite(
         return updated_node
 
 
-def unique_inv_id(inv_id_runtimes: dict[InvocationId, list[int]]) -> dict[str, int]:
+def unique_inv_id(inv_id_runtimes: dict[InvocationId, list[int]], tests_project_rootdir: Path) -> dict[str, int]:
     unique_inv_ids: dict[str, int] = {}
     for inv_id, runtimes in inv_id_runtimes.items():
         test_qualified_name = (
             inv_id.test_class_name + "." + inv_id.test_function_name  # type: ignore[operator]
             if inv_id.test_class_name
             else inv_id.test_function_name
         )
-        abs_path = str(Path(inv_id.test_module_path.replace(".", os.sep)).with_suffix(".py").resolve().with_suffix(""))
-        if "__unit_test_" not in abs_path:
+        abs_path = tests_project_rootdir / Path(inv_id.test_module_path.replace(".", os.sep)).with_suffix(".py")
+        abs_path_str = str(abs_path.resolve().with_suffix(""))
+        if "__unit_test_" not in abs_path_str or not test_qualified_name:
             continue
-        key = test_qualified_name + "#" + abs_path  # type: ignore[operator]
+        key = test_qualified_name + "#" + abs_path_str
         parts = inv_id.iteration_id.split("_").__len__()  # type: ignore[union-attr]
         cur_invid = inv_id.iteration_id.split("_")[0] if parts < 3 else "_".join(inv_id.iteration_id.split("_")[:-1])  # type: ignore[union-attr]
         match_key = key + "#" + cur_invid
@@ -174,10 +175,11 @@ def add_runtime_comments_to_generated_tests(
     generated_tests: GeneratedTestsList,
     original_runtimes: dict[InvocationId, list[int]],
     optimized_runtimes: dict[InvocationId, list[int]],
+    tests_project_rootdir: Optional[Path] = None,
 ) -> GeneratedTestsList:
     """Add runtime performance comments to function calls in generated tests."""
-    original_runtimes_dict = unique_inv_id(original_runtimes)
-    optimized_runtimes_dict = unique_inv_id(optimized_runtimes)
+    original_runtimes_dict = unique_inv_id(original_runtimes, tests_project_rootdir or Path())
+    optimized_runtimes_dict = unique_inv_id(optimized_runtimes, tests_project_rootdir or Path())
     # Process each generated test
     modified_tests = []
     for test in generated_tests.generated_tests:

codeflash/code_utils/formatter.py

@@ -76,12 +76,9 @@ def apply_formatter_cmds(
                 logger.error(f"Failed to format code with {' '.join(formatter_cmd_list)}")
         except FileNotFoundError as e:
             from rich.panel import Panel
-            from rich.text import Text
 
-            panel = Panel(
-                Text.from_markup(f"⚠️  Formatter command not found: {' '.join(formatter_cmd_list)}", style="bold red"),
-                expand=False,
-            )
+            command_str = " ".join(str(part) for part in formatter_cmd_list)
+            panel = Panel(f"⚠️  Formatter command not found: {command_str}", expand=False, border_style="yellow")
             console.print(panel)
             if exit_on_failure:
                 raise e from None

codeflash/code_utils/git_worktree_utils.py

@@ -3,34 +3,18 @@
 import subprocess
 import tempfile
 import time
-from functools import lru_cache
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional
+from typing import Optional
 
 import git
 
 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 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)
@@ -96,12 +80,6 @@ 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)
-
-
 def create_diff_patch_from_worktree(
     worktree_dir: Path, files: list[str], fto_name: Optional[str] = None
 ) -> Optional[Path]:
@@ -115,10 +93,8 @@ def create_diff_patch_from_worktree(
     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)
-
-    patch_path = project_patches_dir / f"{worktree_dir.name}.{fto_name}.patch"
+    patches_dir.mkdir(parents=True, exist_ok=True)
+    patch_path = Path(patches_dir / f"{worktree_dir.name}.{fto_name}.patch")
     with patch_path.open("w", encoding="utf8") as f:
         f.write(uni_diff_text)
 

codeflash/lsp/beta.py

@@ -263,6 +263,15 @@ def init_project(server: CodeflashLanguageServer, params: ValidateProjectParams)
 def _initialize_optimizer_if_api_key_is_valid(
     server: CodeflashLanguageServer, api_key: Optional[str] = None
 ) -> dict[str, str]:
+    key_check_result = _check_api_key_validity(api_key)
+    if key_check_result.get("status") != "success":
+        return key_check_result
+
+    _initialize_optimizer(server)
+    return key_check_result
+
+
+def _check_api_key_validity(api_key: Optional[str]) -> dict[str, str]:
     user_id = get_user_id(api_key=api_key)
     if user_id is None:
         return {"status": "error", "message": "api key not found or invalid"}
@@ -271,11 +280,15 @@ def _initialize_optimizer_if_api_key_is_valid(
         error_msg = user_id[7:]
         return {"status": "error", "message": error_msg}
 
+    return {"status": "success", "user_id": user_id}
+
+
+def _initialize_optimizer(server: CodeflashLanguageServer) -> None:
     from codeflash.optimization.optimizer import Optimizer
 
     new_args = process_args(server)
-    server.optimizer = Optimizer(new_args)
-    return {"status": "success", "user_id": user_id}
+    if not server.optimizer:
+        server.optimizer = Optimizer(new_args)
 
 
 def process_args(server: CodeflashLanguageServer) -> Namespace:
@@ -302,16 +315,16 @@ def provide_api_key(server: CodeflashLanguageServer, params: ProvideApiKeyParams
         if not api_key.startswith("cf-"):
             return {"status": "error", "message": "Api key is not valid"}
 
-        # clear cache to ensure the new api key is used
+        # # clear cache to ensure the new api key is used
         get_codeflash_api_key.cache_clear()
         get_user_id.cache_clear()
-
-        init_result = _initialize_optimizer_if_api_key_is_valid(server, api_key)
-        if init_result["status"] == "error":
-            return {"status": "error", "message": "Api key is not valid"}
-
-        user_id = init_result["user_id"]
+        key_check_result = _check_api_key_validity(api_key)
+        if key_check_result.get("status") != "success":
+            return key_check_result
+        user_id = key_check_result["user_id"]
         result = save_api_key_to_rc(api_key)
+        # initialize optimizer with the new api key
+        _initialize_optimizer(server)
         if not is_successful(result):
             return {"status": "error", "message": result.failure()}
         return {"status": "success", "message": "Api key saved successfully", "user_id": user_id}  # noqa: TRY300
@@ -325,21 +338,19 @@ def initialize_function_optimization(
 ) -> dict[str, str]:
     document_uri = params.textDocument.uri
     document = server.workspace.get_text_document(document_uri)
+    file_path = Path(document.path)
 
     server.show_message_log(f"Initializing optimization for function: {params.functionName} in {document_uri}", "Info")
 
     if server.optimizer is None:
         _initialize_optimizer_if_api_key_is_valid(server)
 
-    server.optimizer.worktree_mode()
-
-    original_args, _ = server.optimizer.original_args_and_test_cfg
-
+    server.optimizer.args.file = file_path
     server.optimizer.args.function = params.functionName
-    original_relative_file_path = Path(document.path).relative_to(original_args.project_root)
-    server.optimizer.args.file = server.optimizer.current_worktree / original_relative_file_path
     server.optimizer.args.previous_checkpoint_functions = False
 
+    server.optimizer.worktree_mode()
+
     server.show_message_log(
         f"Args set - function: {server.optimizer.args.function}, file: {server.optimizer.args.file}", "Info"
     )

codeflash/main.py

@@ -9,6 +9,7 @@
 from codeflash.cli_cmds.cli import parse_args, process_pyproject_config
 from codeflash.cli_cmds.cmd_init import CODEFLASH_LOGO, ask_run_end_to_end_test
 from codeflash.cli_cmds.console import paneled_text
+from codeflash.code_utils import env_utils
 from codeflash.code_utils.checkpoint import ask_should_use_checkpoint_get_functions
 from codeflash.code_utils.config_parser import parse_config_file
 from codeflash.code_utils.version_check import check_for_newer_minor_version
@@ -39,6 +40,8 @@ def main() -> None:
         ask_run_end_to_end_test(args)
     else:
         args = process_pyproject_config(args)
+        if not env_utils.check_formatter_installed(args.formatter_cmds):
+            return
         args.previous_checkpoint_functions = ask_should_use_checkpoint_get_functions(args)
         init_sentry(not args.disable_telemetry, exclude_errors=True)
         posthog_cf.initialize_posthog(not args.disable_telemetry)

codeflash/optimization/function_optimizer.py

@@ -1429,7 +1429,7 @@ def process_review(
         )
 
         generated_tests = add_runtime_comments_to_generated_tests(
-            generated_tests, original_runtime_by_test, optimized_runtime_by_test
+            generated_tests, original_runtime_by_test, optimized_runtime_by_test, self.test_cfg.tests_project_rootdir
         )
 
         generated_tests_str = "\n#------------------------------------------------\n".join(

codeflash/optimization/optimizer.py

@@ -261,8 +261,6 @@ def run(self) -> None:
         console.rule()
         if not env_utils.ensure_codeflash_api_key():
             return
-        if not env_utils.check_formatter_installed(self.args.formatter_cmds):
-            return
         if self.args.no_draft and is_pr_draft():
             logger.warning("PR is in draft mode, skipping optimization")
             return

docs/crisp.js

@@ -9,8 +9,8 @@
   },
   "favicon": "/favicon.ico",
   "integrations": {
-    "intercom": {
-      "appId": "ljxo1nzr"
+    "posthog": {
+        "apiKey": "phc_aUO790jHd7z1SXwsYCz8dRApxueplZlZWeDSpKc5hol"
     }
   },
   "navigation": {