validating python and git environment with the lsp

Author: mohammedahmed18

codeflash/cli_cmds/cli.py

@@ -10,6 +10,7 @@
 from codeflash.code_utils import env_utils
 from codeflash.code_utils.code_utils import exit_with_message
 from codeflash.code_utils.config_parser import parse_config_file
+from codeflash.lsp.helpers import is_LSP_enabled
 from codeflash.version import __version__ as version
 
 
@@ -211,6 +212,9 @@ def process_pyproject_config(args: Namespace) -> Namespace:
     if args.benchmarks_root:
         args.benchmarks_root = Path(args.benchmarks_root).resolve()
     args.test_project_root = project_root_from_module_root(args.tests_root, pyproject_file_path)
+    if is_LSP_enabled():
+        args.all = None
+        return args
     return handle_optimize_all_arg_parsing(args)
 
 

codeflash/cli_cmds/cmd_init.py

@@ -155,6 +155,22 @@ def ask_run_end_to_end_test(args: Namespace) -> None:
         run_end_to_end_test(args, bubble_sort_path, bubble_sort_test_path)
 
 
+def is_valid_pyproject_toml(pyproject_toml_path: Path) -> dict[str, Any] | None:
+    if not pyproject_toml_path.exists():
+        return None
+    try:
+        config, _ = parse_config_file(pyproject_toml_path)
+    except Exception:
+        return None
+
+    if "module_root" not in config or config["module_root"] is None or not Path(config["module_root"]).is_dir():
+        return None
+    if "tests_root" not in config or config["tests_root"] is None or not Path(config["tests_root"]).is_dir():
+        return None
+
+    return config
+
+
 def should_modify_pyproject_toml() -> tuple[bool, dict[str, Any] | None]:
     """Check if the current directory contains a valid pyproject.toml file with codeflash config.
 
@@ -163,16 +179,9 @@ def should_modify_pyproject_toml() -> tuple[bool, dict[str, Any] | None]:
     from rich.prompt import Confirm
 
     pyproject_toml_path = Path.cwd() / "pyproject.toml"
-    if not pyproject_toml_path.exists():
-        return True, None
-    try:
-        config, config_file_path = parse_config_file(pyproject_toml_path)
-    except Exception:
-        return True, None
 
-    if "module_root" not in config or config["module_root"] is None or not Path(config["module_root"]).is_dir():
-        return True, None
-    if "tests_root" not in config or config["tests_root"] is None or not Path(config["tests_root"]).is_dir():
+    config = is_valid_pyproject_toml(pyproject_toml_path)
+    if config is None:
         return True, None
 
     return Confirm.ask(
@@ -442,7 +451,7 @@ def collect_setup_info() -> SetupInfo:
         apologize_and_exit()
     formatter = formatter_answers["formatter"]
 
-    git_remote = ""
+    git_remote = "origin"
     try:
         repo = Repo(str(module_root), search_parent_directories=True)
         git_remotes = get_git_remotes(repo)
@@ -968,6 +977,11 @@ def install_github_app(git_remote: str) -> None:
     except git.InvalidGitRepositoryError:
         click.echo("Skipping GitHub app installation because you're not in a git repository.")
         return
+
+    if git_remote not in get_git_remotes(git_repo):
+        click.echo(f"Skipping GitHub app installation, remote ({git_remote}) does not exist in this repository.")
+        return
+
     owner, repo = get_repo_owner_and_name(git_repo, git_remote)
 
     if is_github_app_installed_on_repo(owner, repo, suppress_errors=True):

codeflash/code_utils/git_utils.py

@@ -201,7 +201,8 @@ def get_last_commit_author_if_pr_exists(repo: Repo | None = None) -> str | None:
 
 def create_worktree_snapshot_commit(worktree_dir: Path, commit_message: str) -> None:
     repository = git.Repo(worktree_dir, search_parent_directories=True)
-    repository.git.commit("-am", commit_message, "--no-verify")
+    repository.git.add(".")
+    repository.git.commit("-m", commit_message, "--no-verify")
 
 
 def create_detached_worktree(module_root: Path) -> Optional[Path]:
@@ -234,7 +235,7 @@ def create_detached_worktree(module_root: Path) -> Optional[Path]:
         # Apply the patch inside the worktree
         try:
             subprocess.run(
-                ["git", "apply", "--ignore-space-change", "--ignore-whitespace", patch_path],
+                ["git", "apply", "--ignore-space-change", "--ignore-whitespace", "--whitespace=nowarn", patch_path],
                 cwd=worktree_dir,
                 check=True,
             )

codeflash/discovery/functions_to_optimize.py

@@ -27,6 +27,7 @@
 from codeflash.code_utils.git_utils import get_git_diff, get_repo_owner_and_name
 from codeflash.code_utils.time_utils import humanize_runtime
 from codeflash.discovery.discover_unit_tests import discover_unit_tests
+from codeflash.lsp.helpers import is_LSP_enabled
 from codeflash.models.models import FunctionParent
 from codeflash.telemetry.posthog_cf import ph
 
@@ -470,6 +471,9 @@ def was_function_previously_optimized(
         Tuple of (filtered_functions_dict, remaining_count)
 
     """
+    if is_LSP_enabled:
+        return False
+
     # Check optimization status if repository info is provided
     # already_optimized_count = 0
     try:

codeflash/lsp/beta.py

@@ -6,6 +6,7 @@
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+import git
 from pygls import uris
 
 from codeflash.api.cfapi import get_codeflash_api_key, get_user_id
@@ -88,9 +89,14 @@ def initialize_function_optimization(
 ) -> dict[str, str]:
     file_path = Path(uris.to_fs_path(params.textDocument.uri))
     server.show_message_log(f"Initializing optimization for function: {params.functionName} in {file_path}", "Info")
+
     if server.optimizer is None:
-        _initialize_optimizer_if_valid(server)
+        _initialize_optimizer_if_api_key_is_valid(server)
+
     server.optimizer.worktree_mode()
+    # make sure the tests dir is created in the worktree, this can happen if the original tests dir is empty
+    Path(server.optimizer.args.tests_root).mkdir(parents=True, exist_ok=True)
+
     original_args, _ = server.optimizer.original_args_and_test_cfg
 
     server.optimizer.args.function = params.functionName
@@ -132,7 +138,36 @@ def discover_function_tests(server: CodeflashLanguageServer, params: FunctionOpt
     return {"functionName": params.functionName, "status": "success", "discovered_tests": num_discovered_tests}
 
 
-def _initialize_optimizer_if_valid(server: CodeflashLanguageServer) -> dict[str, str]:
+@server.feature("validateProject")
+def validate_project(server: CodeflashLanguageServer, _params: FunctionOptimizationParams) -> dict[str, str]:
+    from codeflash.cli_cmds.cli import process_pyproject_config
+    from codeflash.cli_cmds.cmd_init import is_valid_pyproject_toml
+
+    server.show_message_log("Validating project...", "Info")
+    config = is_valid_pyproject_toml(server.args.config_file)
+    if config is None:
+        server.show_message_log("pyproject.toml is not valid", "Error")
+        return {
+            "status": "error",
+            "message": "pyproject.toml is not valid",
+        }  # keep the error message the same, the extension is matching "pyproject.toml" in the error message to show the codeflash init instructions
+
+    new_args = process_pyproject_config(server.args)
+    server.args = new_args
+
+    repo = git.Repo(new_args.module_root, search_parent_directories=True)
+    if repo.bare:
+        return {"status": "error", "message": "Repository is in bare state"}
+
+    try:
+        _ = repo.head.commit
+    except Exception:
+        return {"status": "error", "message": "Repository has no commits (unborn HEAD)"}
+
+    return {"status": "success"}
+
+
+def _initialize_optimizer_if_api_key_is_valid(server: CodeflashLanguageServer) -> dict[str, str]:
     user_id = get_user_id()
     if user_id is None:
         return {"status": "error", "message": "api key not found or invalid"}
@@ -150,7 +185,7 @@ def _initialize_optimizer_if_valid(server: CodeflashLanguageServer) -> dict[str,
 @server.feature("apiKeyExistsAndValid")
 def check_api_key(server: CodeflashLanguageServer, _params: any) -> dict[str, str]:
     try:
-        return _initialize_optimizer_if_valid(server)
+        return _initialize_optimizer_if_api_key_is_valid(server)
     except Exception:
         return {"status": "error", "message": "something went wrong while validating the api key"}
 
@@ -170,7 +205,7 @@ def provide_api_key(server: CodeflashLanguageServer, params: ProvideApiKeyParams
         get_codeflash_api_key.cache_clear()
         get_user_id.cache_clear()
 
-        init_result = _initialize_optimizer_if_valid(server)
+        init_result = _initialize_optimizer_if_api_key_is_valid(server)
         if init_result["status"] == "error":
             return {"status": "error", "message": "Api key is not valid"}
 

codeflash/lsp/server.py

@@ -49,13 +49,12 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:  # noqa: ANN401
         self.args = None
 
     def prepare_optimizer_arguments(self, config_file: Path) -> None:
-        from codeflash.cli_cmds.cli import parse_args, process_pyproject_config
+        from codeflash.cli_cmds.cli import parse_args
 
         args = parse_args()
         args.config_file = config_file
         args.no_pr = True  # LSP server should not create PRs
         args.worktree = True
-        args = process_pyproject_config(args)
         self.args = args
         # avoid initializing the optimizer during initialization, because it can cause an error if the api key is invalid