style: fix naming, imports, and test conventions in js_project_root fix

- Rename `_get_js_project_root` → `get_js_project_root` (no leading underscores per convention)
- Remove redundant `from pathlib import Path` import inside method (already imported at top)
- Remove unnecessary docstring from new method
- Rewrite tests to use `tmp_path` fixture instead of `tempfile.TemporaryDirectory()`
- Add `.resolve()` calls and `encoding="utf-8"` per project conventions
- Simplify second test file to focus on the actual caching behavior

Co-authored-by: mohammed ahmed <undefined@users.noreply.github.com>

Author: github-actions[bot]

codeflash/languages/function_optimizer.py

@@ -3085,29 +3085,15 @@ def run_optimized_candidate(
                 )
             )
 
-    def _get_js_project_root(self) -> Path | None:
-        """Get the JavaScript project root for the current function being optimized.
-
-        This method calculates the js_project_root for each function instead of
-        caching it in test_cfg. This is important in monorepos where different
-        functions may belong to different packages/extensions with their own
-        package.json files.
-
-        Returns:
-            Path to the JavaScript project root, or None if not a JavaScript project
-            or if the project root cannot be determined.
-        """
+    def get_js_project_root(self) -> Path | None:
         # Only calculate for JavaScript/TypeScript projects
         if self.function_to_optimize.language not in ("javascript", "typescript"):
             return self.test_cfg.js_project_root  # Fall back to cached value for non-JS
 
-        # For JS/TS, calculate fresh for each function
-        from pathlib import Path
-
+        # For JS/TS, calculate fresh for each function to support monorepos
         from codeflash.languages.javascript.test_runner import find_node_project_root
 
-        source_file = Path(self.function_to_optimize.file_path)
-        return find_node_project_root(source_file)
+        return find_node_project_root(Path(self.function_to_optimize.file_path))
 
     def run_and_parse_tests(
         self,
@@ -3129,7 +3115,7 @@ def run_and_parse_tests(
             if testing_type == TestingMode.BEHAVIOR:
                 # Calculate js_project_root for the current function being optimized
                 # instead of using cached value from test_cfg, which may be from a different function
-                js_project_root = self._get_js_project_root()
+                js_project_root = self.get_js_project_root()
 
                 result_file_path, run_result, coverage_database_file, coverage_config_file = (
                     self.language_support.run_behavioral_tests(
@@ -3143,7 +3129,7 @@ def run_and_parse_tests(
                     )
                 )
             elif testing_type == TestingMode.LINE_PROFILE:
-                js_project_root = self._get_js_project_root()
+                js_project_root = self.get_js_project_root()
                 result_file_path, run_result = self.language_support.run_line_profile_tests(
                     test_paths=test_files,
                     test_env=test_env,
@@ -3153,7 +3139,7 @@ def run_and_parse_tests(
                     line_profile_output_file=line_profiler_output_file,
                 )
             elif testing_type == TestingMode.PERFORMANCE:
-                js_project_root = self._get_js_project_root()
+                js_project_root = self.get_js_project_root()
                 result_file_path, run_result = self.language_support.run_benchmarking_tests(
                     test_paths=test_files,
                     test_env=test_env,

tests/test_js_project_root_per_function.py

@@ -1,95 +1,66 @@
 """Test that js_project_root is recalculated per function, not cached."""
 
-import tempfile
 from pathlib import Path
 
-import pytest
-
 from codeflash.languages.javascript.test_runner import find_node_project_root
 
 
-def test_find_node_project_root_returns_different_roots_for_different_files():
+def test_find_node_project_root_returns_different_roots_for_different_files(tmp_path: Path) -> None:
     """Test that find_node_project_root returns the correct root for each file."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        root = Path(tmpdir)
-
-        # Create main project structure
-        main_project = root / "project"
-        main_project.mkdir()
-        (main_project / "package.json").write_text("{}")
-        (main_project / "src").mkdir()
-        main_file = main_project / "src" / "main.ts"
-        main_file.write_text("// main file")
-
-        # Create extension subdirectory with its own package.json
-        extension_dir = main_project / "extensions" / "discord"
-        extension_dir.mkdir(parents=True)
-        (extension_dir / "package.json").write_text("{}")
-        (extension_dir / "src").mkdir()
-        extension_file = extension_dir / "src" / "accounts.ts"
-        extension_file.write_text("// extension file")
-
-        # Test 1: Extension file should return extension directory
-        result1 = find_node_project_root(extension_file)
-        assert result1 == extension_dir, (
-            f"Expected {extension_dir}, got {result1}"
-        )
-
-        # Test 2: Main file should return main project directory
-        result2 = find_node_project_root(main_file)
-        assert result2 == main_project, (
-            f"Expected {main_project}, got {result2}"
-        )
-
-        # Test 3: Calling again with extension file should still return extension dir
-        result3 = find_node_project_root(extension_file)
-        assert result3 == extension_dir, (
-            f"Expected {extension_dir}, got {result3}"
-        )
-
-
-def test_js_project_root_should_be_recalculated_per_function():
-    """
-    Test the actual bug: when optimizing multiple functions from different
-    directories, each should get its own js_project_root, not inherit from
-    the first function.
-
-    This test simulates the scenario where:
-    1. Function #1 is in extensions/discord/src/accounts.ts
-    2. Function #2 is in src/plugins/commands.ts
-    3. Both should get their correct respective project roots
-    """
-    with tempfile.TemporaryDirectory() as tmpdir:
-        root = Path(tmpdir)
-
-        # Create main project
-        main_project = root / "project"
-        main_project.mkdir()
-        (main_project / "package.json").write_text('{"name": "main"}')
-        (main_project / "src").mkdir()
-        (main_project / "test").mkdir()
-
-        # Create extension with its own package.json
-        extension_dir = main_project / "extensions" / "discord"
-        extension_dir.mkdir(parents=True)
-        (extension_dir / "package.json").write_text('{"name": "discord-extension"}')
-        (extension_dir / "src").mkdir()
-
-        # Files to optimize
-        extension_file = extension_dir / "src" / "accounts.ts"
-        extension_file.write_text("export function foo() {}")
-
-        main_file = main_project / "src" / "commands.ts"
-        main_file.write_text("export function bar() {}")
-
-        # Simulate what happens in Codeflash optimizer
-        # Function 1 (extension file) sets js_project_root
-        js_project_root_1 = find_node_project_root(extension_file)
-        assert js_project_root_1 == extension_dir
-
-        # Function 2 (main file) should get its own root, not inherit from function 1
-        js_project_root_2 = find_node_project_root(main_file)
-        assert js_project_root_2 == main_project, (
-            f"Bug reproduced: main file got {js_project_root_2} instead of {main_project}. "
-            f"This happens when test_cfg.js_project_root is not recalculated per function."
-        )
+    # Create main project structure
+    main_project = (tmp_path / "project").resolve()
+    main_project.mkdir()
+    (main_project / "package.json").write_text("{}", encoding="utf-8")
+    (main_project / "src").mkdir()
+    main_file = (main_project / "src" / "main.ts").resolve()
+    main_file.write_text("// main file", encoding="utf-8")
+
+    # Create extension subdirectory with its own package.json
+    extension_dir = (main_project / "extensions" / "discord").resolve()
+    extension_dir.mkdir(parents=True)
+    (extension_dir / "package.json").write_text("{}", encoding="utf-8")
+    (extension_dir / "src").mkdir()
+    extension_file = (extension_dir / "src" / "accounts.ts").resolve()
+    extension_file.write_text("// extension file", encoding="utf-8")
+
+    # Extension file should return extension directory
+    result1 = find_node_project_root(extension_file)
+    assert result1 == extension_dir, f"Expected {extension_dir}, got {result1}"
+
+    # Main file should return main project directory
+    result2 = find_node_project_root(main_file)
+    assert result2 == main_project, f"Expected {main_project}, got {result2}"
+
+    # Calling again with extension file should still return extension dir
+    result3 = find_node_project_root(extension_file)
+    assert result3 == extension_dir, f"Expected {extension_dir}, got {result3}"
+
+
+def test_js_project_root_recalculated_per_function(tmp_path: Path) -> None:
+    """Each function in a monorepo should resolve to its own nearest package.json root."""
+    # Create main project
+    main_project = (tmp_path / "project").resolve()
+    main_project.mkdir()
+    (main_project / "package.json").write_text('{"name": "main"}', encoding="utf-8")
+    (main_project / "src").mkdir()
+
+    # Create extension with its own package.json
+    extension_dir = (main_project / "extensions" / "discord").resolve()
+    extension_dir.mkdir(parents=True)
+    (extension_dir / "package.json").write_text('{"name": "discord-extension"}', encoding="utf-8")
+    (extension_dir / "src").mkdir()
+
+    extension_file = (extension_dir / "src" / "accounts.ts").resolve()
+    extension_file.write_text("export function foo() {}", encoding="utf-8")
+
+    main_file = (main_project / "src" / "commands.ts").resolve()
+    main_file.write_text("export function bar() {}", encoding="utf-8")
+
+    js_project_root_1 = find_node_project_root(extension_file)
+    assert js_project_root_1 == extension_dir
+
+    js_project_root_2 = find_node_project_root(main_file)
+    assert js_project_root_2 == main_project, (
+        f"Expected {main_project}, got {js_project_root_2}. "
+        f"Happens when js_project_root is not recalculated per function."
+    )