fix: align multi-language discovery with zero-config Java and add monorepo subdirectory scanning

Adapt find_all_config_files() after rebasing on java-config-redesign (PR #1880):
- Java detected via pom.xml/build.gradle instead of codeflash.toml
- Add subdirectory scan for monorepo language subprojects (java/, js/ etc.)
- Extract _check_dir_for_configs() to eliminate duplicated detection logic
- Fix --all flag in multi-language mode (module_root wasn't available during resolution)
- Add Java project_root directory override in apply_language_config()
- Update all tests to use build-tool detection mocks and directory-based Java paths
- Add 5 new monorepo discovery tests (subdir Java, subdir JS, all-three, skip-hidden, root-wins)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: mohamedashrraf222

codeflash/cli_cmds/cli.py

@@ -328,6 +328,11 @@ def apply_language_config(args: Namespace, lang_config: LanguageConfig) -> Names
         args.benchmarks_root = Path(args.benchmarks_root).resolve()
     args.test_project_root = project_root_from_module_root(args.tests_root, config_path)
 
+    if is_java and config_path.is_dir():
+        # For Java projects, config_path IS the project root directory (from build-tool detection).
+        args.project_root = config_path.resolve()
+        args.test_project_root = config_path.resolve()
+
     return args
 
 

codeflash/code_utils/config_parser.py

@@ -157,51 +157,92 @@ def normalize_toml_config(config: dict[str, Any], config_file_path: Path) -> dic
     return config
 
 
+def _parse_java_config_for_dir(dir_path: Path) -> dict[str, Any] | None:
+    from codeflash.languages.java.build_tools import parse_java_project_config
+
+    return parse_java_project_config(dir_path)
+
+
+_SUBDIR_SKIP = frozenset({
+    ".git", ".hg", ".svn", "node_modules", ".venv", "venv", "__pycache__",
+    "target", "build", "dist", ".tox", ".mypy_cache", ".ruff_cache", ".pytest_cache",
+})
+
+
+def _check_dir_for_configs(
+    dir_path: Path,
+    configs: list[LanguageConfig],
+    seen_languages: set[Language],
+) -> None:
+    """Check a single directory for language config files and append any found to *configs*."""
+    if Language.PYTHON not in seen_languages:
+        pyproject = dir_path / "pyproject.toml"
+        if pyproject.exists():
+            try:
+                with pyproject.open("rb") as f:
+                    data = tomlkit.parse(f.read())
+                tool = data.get("tool", {})
+                if isinstance(tool, dict) and "codeflash" in tool:
+                    raw_config = dict(tool["codeflash"])
+                    normalized = normalize_toml_config(raw_config, pyproject)
+                    seen_languages.add(Language.PYTHON)
+                    configs.append(LanguageConfig(config=normalized, config_path=pyproject, language=Language.PYTHON))
+            except Exception:
+                pass
+
+    if Language.JAVASCRIPT not in seen_languages:
+        package_json = dir_path / "package.json"
+        if package_json.exists():
+            try:
+                result = parse_package_json_config(package_json)
+                if result is not None:
+                    config, path = result
+                    seen_languages.add(Language.JAVASCRIPT)
+                    configs.append(LanguageConfig(config=config, config_path=path, language=Language.JAVASCRIPT))
+            except Exception:
+                pass
+
+    if Language.JAVA not in seen_languages:
+        if (
+            (dir_path / "pom.xml").exists()
+            or (dir_path / "build.gradle").exists()
+            or (dir_path / "build.gradle.kts").exists()
+        ):
+            try:
+                java_config = _parse_java_config_for_dir(dir_path)
+                if java_config is not None:
+                    seen_languages.add(Language.JAVA)
+                    configs.append(LanguageConfig(config=java_config, config_path=dir_path, language=Language.JAVA))
+            except Exception:
+                pass
+
+
 def find_all_config_files(start_dir: Path | None = None) -> list[LanguageConfig]:
     if start_dir is None:
         start_dir = Path.cwd()
 
     configs: list[LanguageConfig] = []
     seen_languages: set[Language] = set()
 
-    toml_configs = {"pyproject.toml": Language.PYTHON, "codeflash.toml": Language.JAVA}
-
+    # Walk upward from start_dir to filesystem root (closest config wins per language)
     dir_path = start_dir.resolve()
     while True:
-        for config_name, language in toml_configs.items():
-            if language in seen_languages:
-                continue
-            config_file = dir_path / config_name
-            if config_file.exists():
-                try:
-                    with config_file.open("rb") as f:
-                        data = tomlkit.parse(f.read())
-                    tool = data.get("tool", {})
-                    if isinstance(tool, dict) and "codeflash" in tool:
-                        raw_config = dict(tool["codeflash"])
-                        normalized = normalize_toml_config(raw_config, config_file)
-                        seen_languages.add(language)
-                        configs.append(LanguageConfig(config=normalized, config_path=config_file, language=language))
-                except Exception:
-                    continue
-
-        if Language.JAVASCRIPT not in seen_languages:
-            package_json = dir_path / "package.json"
-            if package_json.exists():
-                try:
-                    result = parse_package_json_config(package_json)
-                    if result is not None:
-                        config, path = result
-                        seen_languages.add(Language.JAVASCRIPT)
-                        configs.append(LanguageConfig(config=config, config_path=path, language=Language.JAVASCRIPT))
-                except Exception:
-                    pass
+        _check_dir_for_configs(dir_path, configs, seen_languages)
 
         parent = dir_path.parent
         if parent == dir_path:
             break
         dir_path = parent
 
+    # Scan immediate subdirectories for monorepo language subprojects
+    resolved_start = start_dir.resolve()
+    try:
+        subdirs = sorted(p for p in resolved_start.iterdir() if p.is_dir() and p.name not in _SUBDIR_SKIP)
+    except OSError:
+        subdirs = []
+    for subdir in subdirs:
+        _check_dir_for_configs(subdir, configs, seen_languages)
+
     return configs
 
 

codeflash/main.py

@@ -131,6 +131,11 @@ def main() -> None:
             except UnsupportedLanguageError:
                 pass  # Unknown extension, let all configs run
 
+        # Track whether --all was originally requested (before handle_optimize_all_arg_parsing
+        # resolves it — in multi-language mode, module_root isn't available yet so the resolution
+        # produces None; we re-resolve per language inside the loop)
+        optimize_all_requested = hasattr(args, "all") and args.all is not None
+
         # Multi-language path: run git/GitHub checks ONCE before the loop
         args = handle_optimize_all_arg_parsing(args)
 
@@ -141,7 +146,7 @@ def main() -> None:
                 pass_args = copy.deepcopy(args)
                 pass_args = apply_language_config(pass_args, lang_config)
 
-                if hasattr(pass_args, "all") and pass_args.all is not None:
+                if optimize_all_requested:
                     pass_args.all = pass_args.module_root
 
                 if not env_utils.check_formatter_installed(pass_args.formatter_cmds):

tests/test_multi_config_discovery.py

@@ -2,10 +2,11 @@
 
 import json
 from pathlib import Path
+from unittest.mock import patch
 
 import tomlkit
 
-from codeflash.code_utils.config_parser import LanguageConfig, find_all_config_files
+from codeflash.code_utils.config_parser import find_all_config_files
 from codeflash.languages.language_enum import Language
 
 
@@ -22,19 +23,29 @@ def test_finds_pyproject_toml_with_codeflash_section(self, tmp_path: Path, monke
         assert result[0].language == Language.PYTHON
         assert result[0].config_path == tmp_path / "pyproject.toml"
 
-    def test_finds_codeflash_toml(self, tmp_path: Path, monkeypatch) -> None:
-        write_toml(tmp_path / "codeflash.toml", {"tool": {"codeflash": {"module-root": "src/main/java"}}})
+    def test_finds_java_via_build_tool_detection(self, tmp_path: Path, monkeypatch) -> None:
+        java_config = {"language": "java", "module_root": str(tmp_path / "src/main/java")}
+        (tmp_path / "pom.xml").write_text("<project/>", encoding="utf-8")
         monkeypatch.chdir(tmp_path)
-        result = find_all_config_files()
+        with patch(
+            "codeflash.code_utils.config_parser._parse_java_config_for_dir",
+            return_value=java_config,
+        ):
+            result = find_all_config_files()
         assert len(result) == 1
         assert result[0].language == Language.JAVA
-        assert result[0].config_path == tmp_path / "codeflash.toml"
+        assert result[0].config_path == tmp_path
 
-    def test_finds_multiple_configs(self, tmp_path: Path, monkeypatch) -> None:
+    def test_finds_multiple_configs_python_and_java(self, tmp_path: Path, monkeypatch) -> None:
         write_toml(tmp_path / "pyproject.toml", {"tool": {"codeflash": {"module-root": "src"}}})
-        write_toml(tmp_path / "codeflash.toml", {"tool": {"codeflash": {"module-root": "src/main/java"}}})
+        java_config = {"language": "java", "module_root": str(tmp_path / "src/main/java")}
+        (tmp_path / "pom.xml").write_text("<project/>", encoding="utf-8")
         monkeypatch.chdir(tmp_path)
-        result = find_all_config_files()
+        with patch(
+            "codeflash.code_utils.config_parser._parse_java_config_for_dir",
+            return_value=java_config,
+        ):
+            result = find_all_config_files()
         assert len(result) == 2
         languages = {r.language for r in result}
         assert languages == {Language.PYTHON, Language.JAVA}
@@ -49,9 +60,14 @@ def test_finds_config_in_parent_directory(self, tmp_path: Path, monkeypatch) ->
         write_toml(tmp_path / "pyproject.toml", {"tool": {"codeflash": {"module-root": "src"}}})
         subdir = tmp_path / "subproject"
         subdir.mkdir()
-        write_toml(subdir / "codeflash.toml", {"tool": {"codeflash": {"module-root": "src/main/java"}}})
+        java_config = {"language": "java", "module_root": str(subdir / "src/main/java")}
+        (subdir / "pom.xml").write_text("<project/>", encoding="utf-8")
         monkeypatch.chdir(subdir)
-        result = find_all_config_files()
+        with patch(
+            "codeflash.code_utils.config_parser._parse_java_config_for_dir",
+            return_value=java_config,
+        ):
+            result = find_all_config_files()
         assert len(result) == 2
         languages = {r.language for r in result}
         assert languages == {Language.PYTHON, Language.JAVA}
@@ -78,27 +94,111 @@ def test_finds_package_json_with_codeflash_section(self, tmp_path: Path, monkeyp
 
     def test_finds_all_three_config_types(self, tmp_path: Path, monkeypatch) -> None:
         write_toml(tmp_path / "pyproject.toml", {"tool": {"codeflash": {"module-root": "src"}}})
-        write_toml(tmp_path / "codeflash.toml", {"tool": {"codeflash": {"module-root": "src/main/java"}}})
         pkg = {"codeflash": {"moduleRoot": "src"}}
         (tmp_path / "package.json").write_text(json.dumps(pkg), encoding="utf-8")
+        java_config = {"language": "java", "module_root": str(tmp_path / "src/main/java")}
+        (tmp_path / "pom.xml").write_text("<project/>", encoding="utf-8")
         monkeypatch.chdir(tmp_path)
-        result = find_all_config_files()
+        with patch(
+            "codeflash.code_utils.config_parser._parse_java_config_for_dir",
+            return_value=java_config,
+        ):
+            result = find_all_config_files()
         assert len(result) == 3
         languages = {r.language for r in result}
         assert languages == {Language.PYTHON, Language.JAVA, Language.JAVASCRIPT}
 
-    def test_malformed_toml_skipped(self, tmp_path: Path, monkeypatch) -> None:
-        (tmp_path / "codeflash.toml").write_text("not valid [toml", encoding="utf-8")
+    def test_no_java_when_no_build_file_exists(self, tmp_path: Path, monkeypatch) -> None:
         monkeypatch.chdir(tmp_path)
         result = find_all_config_files()
         assert len(result) == 0
 
     def test_missing_codeflash_section_skipped(self, tmp_path: Path, monkeypatch) -> None:
-        write_toml(tmp_path / "codeflash.toml", {"tool": {"other": {"key": "value"}}})
+        write_toml(tmp_path / "pyproject.toml", {"tool": {"other": {"key": "value"}}})
+        monkeypatch.chdir(tmp_path)
+        result = find_all_config_files()
+        assert len(result) == 0
+
+    def test_finds_java_in_subdirectory(self, tmp_path: Path, monkeypatch) -> None:
+        """Monorepo: Java project in a subdirectory is discovered from the repo root."""
+        write_toml(tmp_path / "pyproject.toml", {"tool": {"codeflash": {"module-root": "src"}}})
+        java_dir = tmp_path / "java"
+        java_dir.mkdir()
+        (java_dir / "pom.xml").write_text("<project/>", encoding="utf-8")
+        java_config = {"language": "java", "module_root": str(java_dir / "src/main/java")}
+        monkeypatch.chdir(tmp_path)
+        with patch(
+            "codeflash.code_utils.config_parser._parse_java_config_for_dir",
+            return_value=java_config,
+        ):
+            result = find_all_config_files()
+        assert len(result) == 2
+        languages = {r.language for r in result}
+        assert languages == {Language.PYTHON, Language.JAVA}
+        java_result = next(r for r in result if r.language == Language.JAVA)
+        assert java_result.config_path == java_dir
+
+    def test_finds_js_in_subdirectory(self, tmp_path: Path, monkeypatch) -> None:
+        """Monorepo: JS project in a subdirectory is discovered from the repo root."""
+        write_toml(tmp_path / "pyproject.toml", {"tool": {"codeflash": {"module-root": "src"}}})
+        js_dir = tmp_path / "js"
+        js_dir.mkdir()
+        pkg = {"codeflash": {"moduleRoot": "src"}}
+        (js_dir / "package.json").write_text(json.dumps(pkg), encoding="utf-8")
+        monkeypatch.chdir(tmp_path)
+        result = find_all_config_files()
+        assert len(result) == 2
+        languages = {r.language for r in result}
+        assert languages == {Language.PYTHON, Language.JAVASCRIPT}
+
+    def test_finds_all_three_in_monorepo_subdirs(self, tmp_path: Path, monkeypatch) -> None:
+        """Monorepo: Python at root, Java and JS in subdirectories."""
+        write_toml(tmp_path / "pyproject.toml", {"tool": {"codeflash": {"module-root": "src"}}})
+        java_dir = tmp_path / "java"
+        java_dir.mkdir()
+        (java_dir / "pom.xml").write_text("<project/>", encoding="utf-8")
+        java_config = {"language": "java", "module_root": str(java_dir / "src/main/java")}
+        js_dir = tmp_path / "js"
+        js_dir.mkdir()
+        pkg = {"codeflash": {"moduleRoot": "src"}}
+        (js_dir / "package.json").write_text(json.dumps(pkg), encoding="utf-8")
+        monkeypatch.chdir(tmp_path)
+        with patch(
+            "codeflash.code_utils.config_parser._parse_java_config_for_dir",
+            return_value=java_config,
+        ):
+            result = find_all_config_files()
+        assert len(result) == 3
+        languages = {r.language for r in result}
+        assert languages == {Language.PYTHON, Language.JAVA, Language.JAVASCRIPT}
+
+    def test_skips_hidden_and_build_subdirs(self, tmp_path: Path, monkeypatch) -> None:
+        """Subdirectory scan skips .git, node_modules, target, etc."""
+        for name in [".git", "node_modules", "target", "build", "__pycache__"]:
+            d = tmp_path / name
+            d.mkdir()
+            write_toml(d / "pyproject.toml", {"tool": {"codeflash": {"module-root": "."}}})
         monkeypatch.chdir(tmp_path)
         result = find_all_config_files()
         assert len(result) == 0
 
+    def test_root_config_wins_over_subdir(self, tmp_path: Path, monkeypatch) -> None:
+        """Config at CWD (found during upward walk) takes precedence over subdirectory."""
+        (tmp_path / "pom.xml").write_text("<project/>", encoding="utf-8")
+        java_dir = tmp_path / "java"
+        java_dir.mkdir()
+        (java_dir / "pom.xml").write_text("<project/>", encoding="utf-8")
+        java_config = {"language": "java", "module_root": str(tmp_path / "src/main/java")}
+        monkeypatch.chdir(tmp_path)
+        with patch(
+            "codeflash.code_utils.config_parser._parse_java_config_for_dir",
+            return_value=java_config,
+        ):
+            result = find_all_config_files()
+        java_results = [r for r in result if r.language == Language.JAVA]
+        assert len(java_results) == 1
+        assert java_results[0].config_path == tmp_path
+
 
 def test_find_all_functions_uses_registry_not_singleton() -> None:
     """DISC-04: Verify find_all_functions_in_file uses per-file registry lookup."""