Merge branch 'main' into fix/js-jest30-loop-runner

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/languages/javascript/module_system.py

@@ -222,6 +222,7 @@ def _convert_destructuring_to_imports(names_str: str) -> str:
 
     Returns:
         Import names string with aliases using 'as' syntax
+
     """
     # Split by commas and process each name
     parts = []

codeflash/languages/javascript/test_runner.py

@@ -296,6 +296,33 @@ def _find_node_project_root(file_path: Path) -> Path | None:
     return None
 
 
+def _find_monorepo_root(start_path: Path) -> Path | None:
+    """Find the monorepo workspace root by looking for workspace markers.
+
+    Traverses up from the given path to find a directory containing
+    monorepo workspace markers like yarn.lock, pnpm-workspace.yaml, etc.
+
+    Args:
+        start_path: A path within the monorepo.
+
+    Returns:
+        The monorepo root directory, or None if not found.
+
+    """
+    monorepo_markers = ["yarn.lock", "pnpm-workspace.yaml", "lerna.json", "package-lock.json"]
+    current = start_path if start_path.is_dir() else start_path.parent
+
+    while current != current.parent:
+        # Check for monorepo markers
+        if any((current / marker).exists() for marker in monorepo_markers):
+            # Verify it has node_modules (it's the workspace root)
+            if (current / "node_modules").exists():
+                return current
+        current = current.parent
+
+    return None
+
+
 def _find_jest_config(project_root: Path) -> Path | None:
     """Find Jest configuration file in the project.
 
@@ -797,6 +824,12 @@ def run_jest_benchmarking_tests(
     jest_env["JEST_JUNIT_SUITE_NAME"] = "{filepath}"
     jest_env["JEST_JUNIT_ADD_FILE_ATTRIBUTE"] = "true"
     jest_env["JEST_JUNIT_INCLUDE_CONSOLE_OUTPUT"] = "true"
+
+    # Pass monorepo root to loop-runner for jest-runner resolution
+    monorepo_root = _find_monorepo_root(effective_cwd)
+    if monorepo_root:
+        jest_env["CODEFLASH_MONOREPO_ROOT"] = str(monorepo_root)
+        logger.debug(f"Detected monorepo root: {monorepo_root}")
     codeflash_sqlite_file = get_run_tmp_file(Path("test_return_values_0.sqlite"))
     jest_env["CODEFLASH_OUTPUT_FILE"] = str(codeflash_sqlite_file)
     jest_env["CODEFLASH_TEST_ITERATION"] = "0"

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):

codeflash/verification/parse_test_output.py

@@ -150,19 +150,31 @@ def resolve_test_file_from_class_path(test_class_path: str, base_dir: Path) -> P
     # Handle file paths (contain slashes and extensions like .js/.ts)
     if "/" in test_class_path or "\\" in test_class_path:
         # This is a file path, not a Python module path
+        # Try the path as-is if it's absolute
+        potential_path = Path(test_class_path)
+        if potential_path.is_absolute() and potential_path.exists():
+            return potential_path
+
         # Try to resolve relative to base_dir's parent (project root)
         project_root = base_dir.parent
         potential_path = project_root / test_class_path
-        if potential_path.exists():
-            return potential_path
+        # Normalize to resolve .. and . components
+        try:
+            potential_path = potential_path.resolve()
+            if potential_path.exists():
+                return potential_path
+        except (OSError, RuntimeError):
+            pass
+
         # Also try relative to base_dir itself
         potential_path = base_dir / test_class_path
-        if potential_path.exists():
-            return potential_path
-        # Try the path as-is if it's absolute
-        potential_path = Path(test_class_path)
-        if potential_path.exists():
-            return potential_path
+        try:
+            potential_path = potential_path.resolve()
+            if potential_path.exists():
+                return potential_path
+        except (OSError, RuntimeError):
+            pass
+
         return None
 
     # First try the full path (Python module path)
@@ -731,16 +743,25 @@ def parse_jest_test_xml(
                         if not test_file_path.exists():
                             test_file_path = base_dir / test_file_name
 
-            if test_file_path is None or not test_file_path.exists():
+            # For Jest tests in monorepos, test files may not exist after cleanup
+            # but we can still parse results and infer test type from the path
+            if test_file_path is None:
                 logger.warning(f"Could not resolve test file for Jest test: {test_class_path}")
                 continue
 
             # Get test type if not already set from lookup
-            if test_type is None:
+            if test_type is None and test_file_path.exists():
                 test_type = test_files.get_test_type_by_instrumented_file_path(test_file_path)
             if test_type is None:
-                # Default to GENERATED_REGRESSION for Jest tests
-                test_type = TestType.GENERATED_REGRESSION
+                # Infer test type from filename pattern
+                filename = test_file_path.name
+                if "__perf_test_" in filename or "_perf_test_" in filename:
+                    test_type = TestType.GENERATED_PERFORMANCE
+                elif "__unit_test_" in filename or "_unit_test_" in filename:
+                    test_type = TestType.GENERATED_REGRESSION
+                else:
+                    # Default to GENERATED_REGRESSION for Jest tests
+                    test_type = TestType.GENERATED_REGRESSION
 
             # For Jest tests, keep the relative file path with extension intact
             # (Python uses module_name_from_file_path which strips extensions)