Merge branch 'main' into fix/jest-xml-path-resolution-monorepo

Author: mohammedahmed18

codeflash/cli_cmds/cli.py

@@ -359,11 +359,13 @@ def _handle_show_config() -> None:
     detected = detect_project(project_root)
 
     # Check if config exists or is auto-detected
-    config_exists, _ = has_existing_config(project_root)
+    config_exists, config_file = has_existing_config(project_root)
     status = "Saved config" if config_exists else "Auto-detected (not saved)"
 
     console.print()
     console.print(f"[bold]Codeflash Configuration[/bold] ({status})")
+    if config_exists and config_file:
+        console.print(f"[dim]Config file: {project_root / config_file}[/dim]")
     console.print()
 
     table = Table(show_header=True, header_style="bold cyan")

codeflash/code_utils/config_js.py

@@ -6,6 +6,8 @@
 from pathlib import Path
 from typing import Any
 
+from codeflash.setup.detector import is_build_output_dir
+
 PACKAGE_JSON_CACHE: dict[Path, Path] = {}
 PACKAGE_JSON_DATA_CACHE: dict[Path, dict[str, Any]] = {}
 
@@ -50,12 +52,15 @@ def detect_module_root(project_root: Path, package_data: dict[str, Any]) -> str:
     """Detect module root from package.json fields or directory conventions.
 
     Detection order:
-    1. package.json "exports" field (extract directory from main export)
-    2. package.json "module" field (ESM entry point)
-    3. package.json "main" field (CJS entry point)
-    4. "src/" directory if it exists
+    1. src/, lib/, source/ directories (common source directories)
+    2. package.json "exports" field (if not in build output directory)
+    3. package.json "module" field (ESM, if not in build output directory)
+    4. package.json "main" field (CJS, if not in build output directory)
     5. Fall back to "." (project root)
 
+    Build output directories (build/, dist/, out/) are skipped since they contain
+    compiled code, not source files.
+
     Args:
         project_root: Root directory of the project.
         package_data: Parsed package.json data.
@@ -64,6 +69,11 @@ def detect_module_root(project_root: Path, package_data: dict[str, Any]) -> str:
         Detected module root path (relative to project root).
 
     """
+    # Check for common source directories first - these are always preferred
+    for src_dir in ["src", "lib", "source"]:
+        if (project_root / src_dir).is_dir():
+            return src_dir
+
     # Check exports field (modern Node.js)
     exports = package_data.get("exports")
     if exports:
@@ -80,27 +90,38 @@ def detect_module_root(project_root: Path, package_data: dict[str, Any]) -> str:
 
         if entry_path and isinstance(entry_path, str):
             parent = Path(entry_path).parent
-            if parent != Path() and (project_root / parent).is_dir():
+            if (
+                parent != Path()
+                and parent.as_posix() != "."
+                and (project_root / parent).is_dir()
+                and not is_build_output_dir(parent)
+            ):
                 return parent.as_posix()
 
     # Check module field (ESM)
     module_field = package_data.get("module")
     if module_field and isinstance(module_field, str):
         parent = Path(module_field).parent
-        if parent != Path() and (project_root / parent).is_dir():
+        if (
+            parent != Path()
+            and parent.as_posix() != "."
+            and (project_root / parent).is_dir()
+            and not is_build_output_dir(parent)
+        ):
             return parent.as_posix()
 
     # Check main field (CJS)
     main_field = package_data.get("main")
     if main_field and isinstance(main_field, str):
         parent = Path(main_field).parent
-        if parent != Path() and (project_root / parent).is_dir():
+        if (
+            parent != Path()
+            and parent.as_posix() != "."
+            and (project_root / parent).is_dir()
+            and not is_build_output_dir(parent)
+        ):
             return parent.as_posix()
 
-    # Check for src/ directory convention
-    if (project_root / "src").is_dir():
-        return "src"
-
     # Default to project root
     return "."
 

codeflash/setup/detector.py

@@ -21,6 +21,8 @@
 
 import tomlkit
 
+_BUILD_DIRS = frozenset({"build", "dist", "out", ".next", ".nuxt"})
+
 
 @dataclass
 class DetectedProject:
@@ -310,14 +312,21 @@ def _detect_js_module_root(project_root: Path) -> tuple[Path, str]:
     """Detect JavaScript/TypeScript module root.
 
     Priority:
-    1. package.json "exports" field
-    2. package.json "module" field (ESM)
-    3. package.json "main" field (CJS)
-    4. src/ directory
-    5. lib/ directory
-    6. Project root
+    1. src/, lib/, source/ directories (common source directories)
+    2. package.json "exports" field (if not in build output directory)
+    3. package.json "module" field (ESM, if not in build output directory)
+    4. package.json "main" field (CJS, if not in build output directory)
+    5. Project root
+
+    Build output directories (build/, dist/, out/) are skipped since they contain
+    compiled code, not source files.
 
     """
+    # Check for common source directories first - these are always preferred
+    for src_dir in ["src", "lib", "source"]:
+        if (project_root / src_dir).is_dir():
+            return project_root / src_dir, f"{src_dir}/ directory"
+
     package_json_path = project_root / "package.json"
     package_data: dict[str, Any] = {}
 
@@ -334,32 +343,52 @@ def _detect_js_module_root(project_root: Path) -> tuple[Path, str]:
         entry_path = _extract_entry_path(exports)
         if entry_path:
             parent = Path(entry_path).parent
-            if parent != Path() and parent.as_posix() != "." and (project_root / parent).is_dir():
+            if (
+                parent != Path()
+                and parent.as_posix() != "."
+                and (project_root / parent).is_dir()
+                and not is_build_output_dir(parent)
+            ):
                 return project_root / parent, f'{parent.as_posix()}/ (from package.json "exports")'
 
     # Check module field (ESM)
     module_field = package_data.get("module")
     if module_field and isinstance(module_field, str):
         parent = Path(module_field).parent
-        if parent != Path() and parent.as_posix() != "." and (project_root / parent).is_dir():
+        if (
+            parent != Path()
+            and parent.as_posix() != "."
+            and (project_root / parent).is_dir()
+            and not is_build_output_dir(parent)
+        ):
             return project_root / parent, f'{parent.as_posix()}/ (from package.json "module")'
 
     # Check main field (CJS)
     main_field = package_data.get("main")
     if main_field and isinstance(main_field, str):
         parent = Path(main_field).parent
-        if parent != Path() and parent.as_posix() != "." and (project_root / parent).is_dir():
+        if (
+            parent != Path()
+            and parent.as_posix() != "."
+            and (project_root / parent).is_dir()
+            and not is_build_output_dir(parent)
+        ):
             return project_root / parent, f'{parent.as_posix()}/ (from package.json "main")'
 
-    # Check for common source directories
-    for src_dir in ["src", "lib", "source"]:
-        if (project_root / src_dir).is_dir():
-            return project_root / src_dir, f"{src_dir}/ directory"
-
     # Default to project root
     return project_root, "project root"
 
 
+def is_build_output_dir(path: Path) -> bool:
+    """Check if a path is within a common build output directory.
+
+    Build output directories contain compiled code and should be skipped
+    in favor of source directories.
+
+    """
+    return not _BUILD_DIRS.isdisjoint(path.parts)
+
+
 def _extract_entry_path(exports: Any) -> str | None:
     """Extract entry path from package.json exports field."""
     if isinstance(exports, str):

tests/code_utils/test_config_js.py

@@ -127,13 +127,14 @@ def test_detects_from_exports_string(self, tmp_path: Path) -> None:
         assert result == "lib"
 
     def test_detects_from_exports_object_dot(self, tmp_path: Path) -> None:
-        """Should detect module root from exports object with '.' key."""
+        """Should skip build output dirs and return '.' when no src dir exists."""
         (tmp_path / "dist").mkdir()
         package_data = {"exports": {".": "./dist/index.js"}}
 
         result = detect_module_root(tmp_path, package_data)
 
-        assert result == "dist"
+        # dist is a build output directory, so it's skipped
+        assert result == "."
 
     def test_detects_from_exports_object_nested(self, tmp_path: Path) -> None:
         """Should detect module root from nested exports object."""
@@ -227,13 +228,14 @@ def test_ignores_root_level_main(self, tmp_path: Path) -> None:
         assert result == "src"
 
     def test_handles_deeply_nested_exports(self, tmp_path: Path) -> None:
-        """Should handle deeply nested export paths."""
+        """Should handle deeply nested export paths but skip build output dirs."""
         (tmp_path / "packages" / "core" / "dist").mkdir(parents=True)
         package_data = {"exports": {".": {"import": "./packages/core/dist/index.mjs"}}}
 
         result = detect_module_root(tmp_path, package_data)
 
-        assert result == "packages/core/dist"
+        # dist is a build output directory, so it's skipped even when nested
+        assert result == "."
 
     def test_handles_empty_exports(self, tmp_path: Path) -> None:
         """Should handle empty exports gracefully."""
@@ -756,7 +758,7 @@ def test_vite_react_project(self, tmp_path: Path) -> None:
         assert config["formatter_cmds"] == ["npx eslint --fix $file"]
 
     def test_library_with_exports(self, tmp_path: Path) -> None:
-        """Should handle library with modern exports field."""
+        """Should handle library with modern exports field, skipping build output dirs."""
         (tmp_path / "dist").mkdir()
         package_json = tmp_path / "package.json"
         package_json.write_text(
@@ -773,7 +775,8 @@ def test_library_with_exports(self, tmp_path: Path) -> None:
 
         assert result is not None
         config, _ = result
-        assert config["module_root"] == str((tmp_path / "dist").resolve())
+        # dist is a build output directory, so it's skipped and falls back to project root
+        assert config["module_root"] == str(tmp_path.resolve())
 
     def test_monorepo_package(self, tmp_path: Path) -> None:
         """Should handle monorepo package configuration."""

tests/test_languages/test_code_context_extraction.py

@@ -1822,15 +1822,15 @@ def test_with_tricky_helpers(self, ts_support, temp_project):
         target_func = "sendSlackMessage"
 
         functions = ts_support.discover_functions(file_path)
-        func_info = next(f for f in functions if f.name == target_func)
+        func_info = next(f for f in functions if f.function_name == target_func)
         fto = FunctionToOptimize(
             function_name=target_func,
             file_path=file_path,
             parents=func_info.parents,
-            starting_line=func_info.start_line,
-            ending_line=func_info.end_line,
-            starting_col=func_info.start_col,
-            ending_col=func_info.end_col,
+            starting_line=func_info.starting_line,
+            ending_line=func_info.ending_line,
+            starting_col=func_info.starting_col,
+            ending_col=func_info.ending_col,
             is_async=func_info.is_async,
             language="typescript",
         )