Merge monorepo fixes and Jest 30 support

Merged:
- fix/jest-xml-path-resolution-monorepo (path resolution, monorepo detection)
- fix/js-jest30-loop-runner (Jest 30 support with TestRunner class)

Using Jest 30 PR's loop-runner.js which is cleaner and more maintainable.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: mohammedahmed18

code_to_optimize/js/code_to_optimize_ts/package-lock.json

@@ -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/cli_cmds/cli.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/code_utils/config_js.py

@@ -58,9 +58,6 @@ def set_current_language(language: Language | str) -> None:
 
     """
     global _current_language
-
-    if _current_language is not None:
-        return
     _current_language = Language(language) if isinstance(language, str) else language
 
 

codeflash/languages/current.py

@@ -11,6 +11,8 @@
 import re
 from typing import TYPE_CHECKING
 
+from codeflash.languages.current import is_typescript
+
 if TYPE_CHECKING:
     from pathlib import Path
 
@@ -44,9 +46,10 @@ def detect_module_system(project_root: Path, file_path: Path | None = None) -> s
     """Detect the module system used by a JavaScript/TypeScript project.
 
     Detection strategy:
-    1. Check package.json for "type" field
-    2. If file_path provided, check file extension (.mjs = ESM, .cjs = CommonJS)
-    3. Analyze import statements in the file
+    1. Check file extension for explicit module type (.mjs, .cjs, .ts, .tsx, .mts)
+       - TypeScript files always use ESM syntax regardless of package.json
+    2. Check package.json for explicit "type" field (only if explicitly set)
+    3. Analyze import/export statements in the file content
     4. Default to CommonJS if uncertain
 
     Args:
@@ -57,58 +60,65 @@ def detect_module_system(project_root: Path, file_path: Path | None = None) -> s
         ModuleSystem constant (COMMONJS, ES_MODULE, or UNKNOWN).
 
     """
-    # Strategy 1: Check package.json
+    # Strategy 1: Check file extension first for explicit module type indicators
+    # TypeScript files always use ESM syntax (import/export)
+    if file_path:
+        suffix = file_path.suffix.lower()
+        if suffix == ".mjs":
+            logger.debug("Detected ES Module from .mjs extension")
+            return ModuleSystem.ES_MODULE
+        if suffix == ".cjs":
+            logger.debug("Detected CommonJS from .cjs extension")
+            return ModuleSystem.COMMONJS
+        if suffix in (".ts", ".tsx", ".mts"):
+            # TypeScript always uses ESM syntax (import/export)
+            # even if package.json doesn't have "type": "module"
+            logger.debug("Detected ES Module from TypeScript file extension")
+            return ModuleSystem.ES_MODULE
+
+    # Strategy 2: Check package.json for explicit type field
     package_json = project_root / "package.json"
     if package_json.exists():
         try:
             with package_json.open("r") as f:
                 pkg = json.load(f)
-                pkg_type = pkg.get("type", "commonjs")
+                pkg_type = pkg.get("type")  # Don't default - only use if explicitly set
 
                 if pkg_type == "module":
                     logger.debug("Detected ES Module from package.json type field")
                     return ModuleSystem.ES_MODULE
                 if pkg_type == "commonjs":
                     logger.debug("Detected CommonJS from package.json type field")
                     return ModuleSystem.COMMONJS
+                # If type is not explicitly set, continue to file content analysis
 
         except Exception as e:
             logger.warning("Failed to parse package.json: %s", e)
 
-    # Strategy 2: Check file extension
-    if file_path:
-        suffix = file_path.suffix
-        if suffix == ".mjs":
-            logger.debug("Detected ES Module from .mjs extension")
-            return ModuleSystem.ES_MODULE
-        if suffix == ".cjs":
-            logger.debug("Detected CommonJS from .cjs extension")
-            return ModuleSystem.COMMONJS
-
-        # Strategy 3: Analyze file content
-        if file_path.exists():
-            try:
-                content = file_path.read_text()
+    # Strategy 3: Analyze file content for import/export patterns
+    if file_path and file_path.exists():
+        try:
+            content = file_path.read_text()
 
-                # Look for ES module syntax
-                has_import = "import " in content and "from " in content
-                has_export = "export " in content or "export default" in content or "export {" in content
+            # Look for ES module syntax
+            has_import = "import " in content and "from " in content
+            has_export = "export " in content or "export default" in content or "export {" in content
 
-                # Look for CommonJS syntax
-                has_require = "require(" in content
-                has_module_exports = "module.exports" in content or "exports." in content
+            # Look for CommonJS syntax
+            has_require = "require(" in content
+            has_module_exports = "module.exports" in content or "exports." in content
 
-                # Determine based on what we found
-                if (has_import or has_export) and not (has_require or has_module_exports):
-                    logger.debug("Detected ES Module from import/export statements")
-                    return ModuleSystem.ES_MODULE
+            # Determine based on what we found
+            if (has_import or has_export) and not (has_require or has_module_exports):
+                logger.debug("Detected ES Module from import/export statements")
+                return ModuleSystem.ES_MODULE
 
-                if (has_require or has_module_exports) and not (has_import or has_export):
-                    logger.debug("Detected CommonJS from require/module.exports")
-                    return ModuleSystem.COMMONJS
+            if (has_require or has_module_exports) and not (has_import or has_export):
+                logger.debug("Detected CommonJS from require/module.exports")
+                return ModuleSystem.COMMONJS
 
-            except Exception as e:
-                logger.warning("Failed to analyze file %s: %s", file_path, e)
+        except Exception as e:
+            logger.warning("Failed to analyze file %s: %s", file_path, e)
 
     # Default to CommonJS (more common and backward compatible)
     logger.debug("Defaulting to CommonJS")
@@ -212,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 = []
@@ -331,36 +342,89 @@ def replace_default(match) -> str:
     return default_import.sub(replace_default, code)
 
 
-def ensure_module_system_compatibility(code: str, target_module_system: str) -> str:
+def uses_ts_jest(project_root: Path) -> bool:
+    """Check if the project uses ts-jest for TypeScript transformation.
+
+    ts-jest handles module interoperability internally, allowing mixed
+    CommonJS/ESM imports without explicit conversion.
+
+    Args:
+        project_root: The project root directory.
+
+    Returns:
+        True if ts-jest is being used, False otherwise.
+
+    """
+    # Check for ts-jest in devDependencies or dependencies
+    package_json = project_root / "package.json"
+    if package_json.exists():
+        try:
+            with package_json.open("r") as f:
+                pkg = json.load(f)
+                dev_deps = pkg.get("devDependencies", {})
+                deps = pkg.get("dependencies", {})
+                if "ts-jest" in dev_deps or "ts-jest" in deps:
+                    return True
+        except Exception as e:
+            logger.debug(f"Failed to read package.json for ts-jest detection: {e}")  # noqa: G004
+
+    # Also check for jest.config with ts-jest preset
+    for config_file in ["jest.config.js", "jest.config.cjs", "jest.config.ts", "jest.config.mjs"]:
+        config_path = project_root / config_file
+        if config_path.exists():
+            try:
+                content = config_path.read_text()
+                if "ts-jest" in content:
+                    return True
+            except Exception as e:
+                logger.debug(f"Failed to read {config_file}: {e}")  # noqa: G004
+
+    return False
+
+
+def ensure_module_system_compatibility(code: str, target_module_system: str, project_root: Path | None = None) -> str:
     """Ensure code uses the correct module system syntax.
 
-    Detects the current module system in the code and converts if needed.
-    Handles mixed-style code (e.g., ESM imports with CommonJS require for npm packages).
+    If the project uses ts-jest, no conversion is performed because ts-jest
+    handles module interoperability internally. Otherwise, converts between
+    CommonJS and ES Modules as needed.
 
     Args:
         code: JavaScript code to check and potentially convert.
         target_module_system: Target ModuleSystem (COMMONJS or ES_MODULE).
+        project_root: Project root directory for ts-jest detection.
 
     Returns:
-        Code with correct module system syntax.
+        Converted code, or unchanged if ts-jest handles interop.
 
     """
+    # If ts-jest is installed, skip conversion - it handles interop natively
+    if is_typescript() and project_root and uses_ts_jest(project_root):
+        logger.debug(
+            f"Skipping module system conversion (target was {target_module_system}). "  # noqa: G004
+            "ts-jest handles interop natively."
+        )
+        return code
+
     # Detect current module system in code
     has_require = "require(" in code
+    has_module_exports = "module.exports" in code or "exports." in code
     has_import = "import " in code and "from " in code
+    has_export = "export " in code
+
+    is_commonjs = has_require or has_module_exports
+    is_esm = has_import or has_export
 
-    if target_module_system == ModuleSystem.ES_MODULE:
-        # Convert any require() statements to imports for ESM projects
-        # This handles mixed code (ESM imports + CommonJS requires for npm packages)
-        if has_require:
-            logger.debug("Converting CommonJS requires to ESM imports")
-            return convert_commonjs_to_esm(code)
-    elif target_module_system == ModuleSystem.COMMONJS:
-        # Convert any import statements to requires for CommonJS projects
-        if has_import:
-            logger.debug("Converting ESM imports to CommonJS requires")
-            return convert_esm_to_commonjs(code)
+    # Convert if needed
+    if target_module_system == ModuleSystem.ES_MODULE and is_commonjs and not is_esm:
+        logger.debug("Converting CommonJS to ES Module syntax")
+        return convert_commonjs_to_esm(code)
 
+    if target_module_system == ModuleSystem.COMMONJS and is_esm and not is_commonjs:
+        logger.debug("Converting ES Module to CommonJS syntax")
+        return convert_esm_to_commonjs(code)
+
+    logger.debug("No module system conversion needed")
     return code
 
 
@@ -387,12 +451,8 @@ def ensure_vitest_imports(code: str, test_framework: str) -> str:
 
     # Check if the code uses test functions that need to be imported
     test_globals = ["describe", "test", "it", "expect", "vi", "beforeEach", "afterEach", "beforeAll", "afterAll"]
-    needs_import = any(f"{global_name}(" in code or f"{global_name} (" in code for global_name in test_globals)
-
-    if not needs_import:
-        return code
 
-    # Determine which globals are actually used in the code
+    # Combine detection and collection into a single pass
     used_globals = [g for g in test_globals if f"{g}(" in code or f"{g} (" in code]
     if not used_globals:
         return code
@@ -405,9 +465,14 @@ def ensure_vitest_imports(code: str, test_framework: str) -> str:
     insert_index = 0
     for i, line in enumerate(lines):
         stripped = line.strip()
-        if stripped and not stripped.startswith("//") and not stripped.startswith("/*") and not stripped.startswith("*"):
+        if (
+            stripped
+            and not stripped.startswith("//")
+            and not stripped.startswith("/*")
+            and not stripped.startswith("*")
+        ):
             # Check if this line is an import/require - insert after imports
-            if stripped.startswith("import ") or stripped.startswith("const ") or stripped.startswith("let "):
+            if stripped.startswith(("import ", "const ", "let ")):
                 continue
             insert_index = i
             break