Merge branch 'main' into java-config-redesign

Author: HeshamHM28

codeflash/languages/base.py

@@ -50,6 +50,12 @@ class IndexResult:
     error: bool
 
 
+@dataclass(frozen=True)
+class SetupError:
+    message: str
+    should_abort: bool
+
+
 @dataclass
 class HelperFunction:
     """A helper function that is a dependency of the target function.
@@ -725,8 +731,12 @@ def prepare_module(
         """Parse/validate a module before optimization."""
         ...
 
-    def setup_test_config(self, test_cfg: TestConfig, file_path: Path, current_worktree: Path | None = None) -> None:
-        """One-time project setup after language detection. Default: no-op."""
+    def setup_test_config(self, test_cfg: TestConfig, file_path: Path, current_worktree: Path | None = None) -> bool:
+        """One-time project setup after language detection. Default: no-op.
+
+        Returns True if the project is valid for optimization, False otherwise.
+        """
+        return True
 
     def adjust_test_config_for_discovery(self, test_cfg: TestConfig) -> None:
         """Adjust test config before test discovery. Default: no-op."""

codeflash/languages/java/build_tool_strategy.py

@@ -9,6 +9,7 @@
 
 import logging
 import os
+import shutil
 from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
@@ -73,6 +74,18 @@ def find_runtime_jar(self) -> Path | None:
 
         return None
 
+    def find_wrapper_executable(
+        self, build_root: Path, wrapper_names: tuple[str, ...], system_command: str
+    ) -> str | None:
+        search = build_root.resolve()
+        while search != search.parent:
+            for name in wrapper_names:
+                candidate = search / name
+                if candidate.exists():
+                    return str(candidate)
+            search = search.parent
+        return shutil.which(system_command)
+
     @abstractmethod
     def find_executable(self, build_root: Path) -> str | None:
         """Find the build tool executable, searching up parent directories if needed."""

codeflash/languages/java/gradle_strategy.py

@@ -417,22 +417,7 @@ def get_project_info(self, project_root: Path) -> JavaProjectInfo | None:
         )
 
     def find_executable(self, build_root: Path) -> str | None:
-        # Walk up from build_root to find gradlew — for multi-module projects
-        # the wrapper lives at the repo root, which may be a parent of build_root.
-        current = build_root.resolve()
-        while True:
-            gradlew_path = current / "gradlew"
-            if gradlew_path.exists():
-                return str(gradlew_path)
-            gradlew_bat_path = current / "gradlew.bat"
-            if gradlew_bat_path.exists():
-                return str(gradlew_bat_path)
-            parent = current.parent
-            if parent == current:
-                break
-            current = parent
-        # Fall back to system Gradle
-        return shutil.which("gradle")
+        return self.find_wrapper_executable(build_root, ("gradlew", "gradlew.bat"), "gradle")
 
     def ensure_runtime(self, build_root: Path, test_module: str | None) -> bool:
         runtime_jar = self.find_runtime_jar()

codeflash/languages/java/maven_strategy.py

@@ -647,21 +647,7 @@ def get_text(xpath: str, default: str | None = None) -> str | None:
             return None
 
     def find_executable(self, build_root: Path) -> str | None:
-        # Walk up parent directories to find mvnw (multi-module projects keep it in the root)
-        search = build_root.resolve()
-        while search != search.parent:
-            mvnw_path = search / "mvnw"
-            if mvnw_path.exists():
-                return str(mvnw_path)
-            mvnw_cmd_path = search / "mvnw.cmd"
-            if mvnw_cmd_path.exists():
-                return str(mvnw_cmd_path)
-            search = search.parent
-        if Path("mvnw").exists():
-            return "./mvnw"
-        if Path("mvnw.cmd").exists():
-            return "mvnw.cmd"
-        return shutil.which("mvn")
+        return self.find_wrapper_executable(build_root, ("mvnw", "mvnw.cmd"), "mvn")
 
     def find_runtime_jar(self) -> Path | None:
         if self._M2_JAR.exists():

codeflash/languages/java/support.py

@@ -403,11 +403,12 @@ def load_coverage(
     ) -> None:
         return None
 
-    def setup_test_config(self, test_cfg: Any, file_path: Path, current_worktree: Path | None = None) -> None:
+    def setup_test_config(self, test_cfg: Any, file_path: Path, current_worktree: Path | None = None) -> bool:
         """Detect test framework from project build config (pom.xml / build.gradle)."""
         config = detect_java_project(test_cfg.project_root_path)
         if config is not None:
             self._test_framework = config.test_framework
+        return True
 
     def adjust_test_config_for_discovery(self, test_cfg: Any) -> None:
         """Adjust test config before test discovery for Java.

codeflash/languages/javascript/optimizer.py

@@ -3,6 +3,7 @@
 from typing import TYPE_CHECKING
 
 from codeflash.cli_cmds.console import logger
+from codeflash.languages.base import SetupError
 from codeflash.models.models import ValidCode
 
 if TYPE_CHECKING:
@@ -25,19 +26,21 @@ def prepare_javascript_module(
     return validated_original_code, None
 
 
-def verify_js_requirements(test_cfg: TestConfig) -> None:
+def verify_js_requirements(test_cfg: TestConfig) -> list[SetupError]:
     """Verify JavaScript/TypeScript requirements before optimization.
 
     Checks that Node.js, npm, and the test framework are available.
     Logs warnings if requirements are not met but does not abort.
+
+    Returns: List of setup errors if requirements are not met, empty list otherwise.
     """
     from codeflash.languages import get_language_support
     from codeflash.languages.base import Language
     from codeflash.languages.test_framework import get_js_test_framework_or_default
 
     js_project_root = test_cfg.js_project_root
     if not js_project_root:
-        return
+        return [SetupError("JavaScript project root not found", should_abort=True)]
 
     try:
         js_support = get_language_support(Language.JAVASCRIPT)
@@ -47,6 +50,9 @@ def verify_js_requirements(test_cfg: TestConfig) -> None:
         if not success:
             logger.warning("JavaScript requirements check found issues:")
             for error in errors:
-                logger.warning(f"  - {error}")
+                logger.warning(f"  - {error.message}")
+            return errors
+        return []
     except Exception as e:
         logger.debug(f"Failed to verify JS requirements: {e}")
+        return [SetupError(str(e), should_abort=True)]

codeflash/languages/javascript/support.py

@@ -14,7 +14,15 @@
 
 from codeflash.code_utils.git_utils import git_root_dir, mirror_path
 from codeflash.discovery.functions_to_optimize import FunctionToOptimize
-from codeflash.languages.base import CodeContext, FunctionFilterCriteria, HelperFunction, Language, TestInfo, TestResult
+from codeflash.languages.base import (
+    CodeContext,
+    FunctionFilterCriteria,
+    HelperFunction,
+    Language,
+    SetupError,
+    TestInfo,
+    TestResult,
+)
 from codeflash.languages.javascript.treesitter import TreeSitterAnalyzer, TreeSitterLanguage, get_analyzer_for_file
 from codeflash.languages.registry import register_language
 from codeflash.models.models import FunctionParent
@@ -1950,11 +1958,13 @@ def prepare_module(
 
         return prepare_javascript_module(module_code, module_path)
 
-    def setup_test_config(self, test_cfg: TestConfig, file_path: Path, current_worktree: Path | None) -> None:
+    def setup_test_config(self, test_cfg: TestConfig, file_path: Path, current_worktree: Path | None) -> bool:
         from codeflash.languages.javascript.optimizer import verify_js_requirements
         from codeflash.languages.javascript.test_runner import find_node_project_root
 
         test_cfg.js_project_root = find_node_project_root(file_path)
+        if test_cfg.js_project_root is None:
+            return False
         if current_worktree is not None:
             original_js_root = git_root_dir()
             worktree_node_modules = test_cfg.js_project_root / "node_modules"
@@ -1970,7 +1980,11 @@ def setup_test_config(self, test_cfg: TestConfig, file_path: Path, current_workt
                 original_root_node_modules = original_js_root / "node_modules"
                 if original_root_node_modules.exists() and not worktree_root_node_modules.exists():
                     worktree_root_node_modules.symlink_to(original_root_node_modules)
-        verify_js_requirements(test_cfg)
+        setup_errors = verify_js_requirements(test_cfg)
+        if any(e.should_abort for e in setup_errors):
+            return False
+
+        return True
 
     def adjust_test_config_for_discovery(self, test_cfg: TestConfig) -> None:
         test_cfg.tests_project_rootdir = test_cfg.tests_root
@@ -2164,8 +2178,9 @@ def find_test_root(self, project_root: Path) -> Path | None:
     def get_module_path(self, source_file: Path, project_root: Path, tests_root: Path | None = None) -> str:
         """Get the module path for importing a JavaScript source file from tests.
 
-        For JavaScript, this returns a relative path from the tests directory to the source file
-        (e.g., '../fibonacci' for source at /project/fibonacci.js and tests at /project/tests/).
+        For JavaScript/TypeScript, this returns a relative path from the tests directory to
+        the source file. For ESM projects or TypeScript, the path includes a .js extension
+        (TypeScript convention). For CommonJS, no extension is added.
 
         Args:
             source_file: Path to the source file.
@@ -2179,13 +2194,15 @@ def get_module_path(self, source_file: Path, project_root: Path, tests_root: Pat
         import os
 
         from codeflash.cli_cmds.console import logger
+        from codeflash.languages.javascript.module_system import ModuleSystem, detect_module_system
 
         if tests_root is None:
             tests_root = self.find_test_root(project_root) or project_root
 
         try:
             # Resolve both paths to absolute to ensure consistent relative path calculation
-            source_file_abs = source_file.resolve().with_suffix("")
+            # Note: Don't remove extension yet - we'll decide based on module system
+            source_file_abs = source_file.resolve()
             tests_root_abs = tests_root.resolve()
 
             # Find the project root using language support
@@ -2205,18 +2222,42 @@ def get_module_path(self, source_file: Path, project_root: Path, tests_root: Pat
                     if not tests_root_abs.exists():
                         tests_root_abs = project_root_from_lang
 
+            # Detect module system to determine if we need to add .js extension
+            module_system = detect_module_system(project_root, source_file)
+
+            # Remove source file extension first
+            source_without_ext = source_file_abs.with_suffix("")
+
             # Use os.path.relpath to compute relative path from tests_root to source file
-            rel_path = os.path.relpath(str(source_file_abs), str(tests_root_abs))
-            logger.debug(
-                f"!lsp|Module path: source={source_file_abs}, tests_root={tests_root_abs}, rel_path={rel_path}"
-            )
+            rel_path = os.path.relpath(str(source_without_ext), str(tests_root_abs))
+
+            # For ESM, add .js extension (TypeScript convention)
+            # TypeScript requires imports to reference the OUTPUT file extension (.js),
+            # even when the source file is .ts. This is required for Node.js ESM resolution.
+            if module_system == ModuleSystem.ES_MODULE:
+                rel_path = rel_path + ".js"
+                logger.debug(
+                    f"!lsp|Module path (ESM): source={source_file_abs}, tests_root={tests_root_abs}, "
+                    f"rel_path={rel_path} (added .js for ESM)"
+                )
+            else:
+                logger.debug(
+                    f"!lsp|Module path (CommonJS): source={source_file_abs}, tests_root={tests_root_abs}, "
+                    f"rel_path={rel_path}"
+                )
+
             return rel_path
         except ValueError:
             # Fallback if paths are on different drives (Windows)
             rel_path = source_file.relative_to(project_root)
-            return "../" + rel_path.with_suffix("").as_posix()
-
-    def verify_requirements(self, project_root: Path, test_framework: str = "jest") -> tuple[bool, list[str]]:
+            # For fallback, also check module system
+            module_system = detect_module_system(project_root, source_file)
+            path_without_ext = "../" + rel_path.with_suffix("").as_posix()
+            if module_system == ModuleSystem.ES_MODULE:
+                return path_without_ext + ".js"
+            return path_without_ext
+
+    def verify_requirements(self, project_root: Path, test_framework: str = "jest") -> tuple[bool, list[SetupError]]:
         """Verify that all JavaScript requirements are met.
 
         Checks for:
@@ -2236,27 +2277,40 @@ def verify_requirements(self, project_root: Path, test_framework: str = "jest")
             Tuple of (success, list of error messages).
 
         """
-        errors: list[str] = []
+        errors: list[SetupError] = []
 
         # Check Node.js
         try:
             result = subprocess.run(["node", "--version"], check=False, capture_output=True, text=True, timeout=10)
             if result.returncode != 0:
-                errors.append("Node.js is not installed. Please install Node.js 18+ from https://nodejs.org/")
+                errors.append(
+                    SetupError(
+                        "Node.js is not installed. Please install Node.js 18+ from https://nodejs.org/",
+                        should_abort=True,
+                    )
+                )
         except FileNotFoundError:
-            errors.append("Node.js is not installed. Please install Node.js 18+ from https://nodejs.org/")
+            errors.append(
+                SetupError(
+                    "Node.js is not installed. Please install Node.js 18+ from https://nodejs.org/", should_abort=True
+                )
+            )
         except Exception as e:
-            errors.append(f"Failed to check Node.js: {e}")
+            errors.append(SetupError(f"Failed to check Node.js: {e}", should_abort=True))
 
         # Check npm
         try:
             result = subprocess.run(["npm", "--version"], check=False, capture_output=True, text=True, timeout=10)
             if result.returncode != 0:
-                errors.append("npm is not available. Please ensure npm is installed with Node.js.")
+                errors.append(
+                    SetupError("npm is not available. Please ensure npm is installed with Node.js.", should_abort=True)
+                )
         except FileNotFoundError:
-            errors.append("npm is not available. Please ensure npm is installed with Node.js.")
+            errors.append(
+                SetupError("npm is not available. Please ensure npm is installed with Node.js.", should_abort=True)
+            )
         except Exception as e:
-            errors.append(f"Failed to check npm: {e}")
+            errors.append(SetupError(f"Failed to check npm: {e}", should_abort=True))
 
         # Check test framework is installed (with monorepo support)
         # Uses find_node_modules_with_package which searches up the directory tree
@@ -2270,12 +2324,17 @@ def verify_requirements(self, project_root: Path, test_framework: str = "jest")
             local_node_modules = project_root / "node_modules"
             if not local_node_modules.exists():
                 errors.append(
-                    f"node_modules not found in {project_root}. Please run 'npm install' to install dependencies."
+                    SetupError(
+                        f"node_modules not found in {project_root}. Please run 'npm install' to install dependencies.",
+                        should_abort=True,
+                    )
                 )
             else:
                 errors.append(
-                    f"{test_framework} is not installed. "
-                    f"Please run 'npm install --save-dev {test_framework}' to install it."
+                    SetupError(
+                        f"{test_framework} is not installed. Please run 'npm install --save-dev {test_framework}' to install it.",
+                        should_abort=True,
+                    )
                 )
 
         return len(errors) == 0, errors

codeflash/languages/javascript/treesitter.py

@@ -290,6 +290,18 @@ def _walk_tree_for_functions(
                 if func_info.is_method and node.parent and node.parent.type == "object":
                     should_include = False
 
+                # Skip property getters/setters (e.g., get: function foo() {})
+                # These are defined inside Object.defineProperty or object literals
+                # and cannot be called directly - they're accessed via property names.
+                # Tests would fail trying to call obj.getterFuncName() instead of obj.propertyName
+                if node.type == "function_expression" and node.parent and node.parent.type == "pair":
+                    # Check if this is a getter or setter by looking at the property name
+                    property_name_node = node.parent.child_by_field_name("key")
+                    if property_name_node:
+                        property_name = self.get_node_text(property_name_node, source_bytes)
+                        if property_name in ("get", "set"):
+                            should_include = False
+
                 if should_include:
                     functions.append(func_info)
 

codeflash/languages/python/support.py

@@ -1044,8 +1044,9 @@ def prepare_module(
 
     pytest_cmd: str = "pytest"
 
-    def setup_test_config(self, test_cfg: TestConfig, file_path: Path, current_worktree: Path | None = None) -> None:
+    def setup_test_config(self, test_cfg: TestConfig, file_path: Path, current_worktree: Path | None = None) -> bool:
         self.pytest_cmd = test_cfg.pytest_cmd or "pytest"
+        return True
 
     def pytest_cmd_tokens(self, is_posix: bool) -> list[str]:
         import shlex

codeflash/optimization/optimizer.py

@@ -527,7 +527,11 @@ def run(self) -> None:
                 if funcs and funcs[0].language:
                     set_current_language(funcs[0].language)
                     self.test_cfg.set_language(funcs[0].language)
-                    current_language_support().setup_test_config(self.test_cfg, file_path, self.current_worktree)
+                    if not current_language_support().setup_test_config(
+                        self.test_cfg, file_path, self.current_worktree
+                    ):
+                        logger.error("Project setup failed — aborting optimization. Check warnings above for details.")
+                        return
                     break
 
         if self.args.all: