feat: add multi-language orchestration loop with per-language config discovery

Adds the ability for codeflash CLI to discover and optimize multiple
languages in a single run. When configs for Python, Java, and/or JS/TS
are found, the optimizer runs once per language with isolated args.

- Add LanguageConfig dataclass and find_all_config_files() for upward
  walk + monorepo subdirectory scanning (Python/JS/Java)
- Extract normalize_toml_config() from inline parse_config_file logic
- Add apply_language_config() for per-language arg setup in cli.py
- Set language singleton early in process_pyproject_config()
- Add orchestration loop in main.py with --file language filtering,
  per-language error isolation, and summary logging
- Use build_config_strategy.parse_java_project_config() (from #1906)
- Make get_git_diff tests language-agnostic (no singleton dependency)

Intentionally omits auto_configure_language and
detect_unconfigured_languages per Linear CF-1075 review.

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

Author: mashraf-222

codeflash/cli_cmds/cli.py

@@ -9,7 +9,9 @@
 from codeflash.cli_cmds.console import apologize_and_exit, logger
 from codeflash.code_utils import env_utils
 from codeflash.code_utils.code_utils import exit_with_message, normalize_ignore_paths
-from codeflash.code_utils.config_parser import parse_config_file
+from codeflash.code_utils.config_parser import LanguageConfig, parse_config_file
+from codeflash.languages import set_current_language
+from codeflash.languages.language_enum import Language
 from codeflash.languages.test_framework import set_current_test_framework
 from codeflash.lsp.helpers import is_LSP_enabled
 from codeflash.version import __version__ as version
@@ -110,11 +112,14 @@ def process_pyproject_config(args: Namespace) -> Namespace:
     assert args.module_root is not None, "--module-root must be specified"
     assert Path(args.module_root).is_dir(), f"--module-root {args.module_root} must be a valid directory"
 
-    # For JS/TS projects, tests_root is optional (Jest auto-discovers tests)
-    # Default to module_root if not specified
     is_js_ts_project = pyproject_config.get("language") in ("javascript", "typescript")
     is_java_project = pyproject_config.get("language") == "java"
 
+    # Set the language singleton early so downstream code (e.g. get_git_diff)
+    # can use current_language_support() before function discovery.
+    if pyproject_config.get("language"):
+        set_current_language(pyproject_config["language"])
+
     # Set the test framework singleton for JS/TS projects
     if is_js_ts_project and pyproject_config.get("test_framework"):
         set_current_test_framework(pyproject_config["test_framework"])
@@ -221,6 +226,83 @@ def project_root_from_module_root(module_root: Path, pyproject_file_path: Path)
     return module_root.parent.resolve()
 
 
+def apply_language_config(args: Namespace, lang_config: LanguageConfig) -> Namespace:
+    config = lang_config.config
+    config_path = lang_config.config_path
+
+    supported_keys = [
+        "module_root",
+        "tests_root",
+        "benchmarks_root",
+        "ignore_paths",
+        "pytest_cmd",
+        "formatter_cmds",
+        "disable_telemetry",
+        "disable_imports_sorting",
+        "git_remote",
+        "override_fixtures",
+    ]
+    for key in supported_keys:
+        if key in config and ((hasattr(args, key) and getattr(args, key) is None) or not hasattr(args, key)):
+            setattr(args, key, config[key])
+
+    assert args.module_root is not None, "--module-root must be specified"
+    assert Path(args.module_root).is_dir(), f"--module-root {args.module_root} must be a valid directory"
+
+    set_current_language(lang_config.language)
+
+    is_js_ts = lang_config.language in (Language.JAVASCRIPT, Language.TYPESCRIPT)
+    if is_js_ts and config.get("test_framework"):
+        set_current_test_framework(config["test_framework"])
+
+    is_java = lang_config.language == Language.JAVA
+    if args.tests_root is None:
+        if is_java:
+            for test_dir in ["src/test/java", "test", "tests"]:
+                test_path = Path(args.module_root).parent / test_dir if "/" in test_dir else Path(test_dir)
+                if not test_path.is_absolute():
+                    test_path = Path.cwd() / test_path
+                if test_path.is_dir():
+                    args.tests_root = str(test_path)
+                    break
+            if args.tests_root is None:
+                args.tests_root = str(Path.cwd() / "src" / "test" / "java")
+        elif is_js_ts:
+            for test_dir in ["test", "tests", "__tests__"]:
+                if Path(test_dir).is_dir():
+                    args.tests_root = test_dir
+                    break
+            if args.tests_root is None and args.module_root:
+                module_root_path = Path(args.module_root)
+                for test_dir in ["test", "tests", "__tests__"]:
+                    test_path = module_root_path / test_dir
+                    if test_path.is_dir():
+                        args.tests_root = str(test_path)
+                        break
+            if args.tests_root is None:
+                args.tests_root = args.module_root
+        else:
+            raise AssertionError("--tests-root must be specified")
+
+    assert Path(args.tests_root).is_dir(), f"--tests-root {args.tests_root} must be a valid directory"
+
+    args.module_root = Path(args.module_root).resolve()
+    if hasattr(args, "ignore_paths") and args.ignore_paths is not None:
+        args.ignore_paths = normalize_ignore_paths(args.ignore_paths, base_path=args.module_root)
+    args.project_root = project_root_from_module_root(args.module_root, config_path)
+    args.tests_root = Path(args.tests_root).resolve()
+    if args.benchmarks_root:
+        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
+
+
 def handle_optimize_all_arg_parsing(args: Namespace) -> Namespace:
     if hasattr(args, "all") or (hasattr(args, "file") and args.file):
         no_pr = getattr(args, "no_pr", False)
@@ -391,7 +473,7 @@ def _build_parser() -> ArgumentParser:
     compare_parser.add_argument("--timeout", type=int, default=600, help="Benchmark timeout in seconds (default: 600)")
     compare_parser.add_argument("--config-file", type=str, dest="config_file", help="Path to pyproject.toml")
 
-    trace_optimize = subparsers.add_parser("optimize", help="Trace and optimize your project.")
+    trace_optimize = subparsers.add_parser("optimize", help="Trace and optimize your project.", add_help=False)
 
     trace_optimize.add_argument(
         "--max-function-count",

codeflash/code_utils/config_parser.py

@@ -1,17 +1,26 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
 import tomlkit
 
 from codeflash.code_utils.config_js import find_package_json, parse_package_json_config
+from codeflash.languages.language_enum import Language
 from codeflash.lsp.helpers import is_LSP_enabled
 
 PYPROJECT_TOML_CACHE: dict[Path, Path] = {}
 ALL_CONFIG_FILES: dict[Path, dict[str, Path]] = {}
 
 
+@dataclass
+class LanguageConfig:
+    config: dict[str, Any]
+    config_path: Path
+    language: Language
+
+
 def _try_parse_java_build_config() -> tuple[dict[str, Any], Path] | None:
     """Detect Java project from build files and parse config from pom.xml/gradle.properties.
 
@@ -103,6 +112,149 @@ def find_conftest_files(test_paths: list[Path]) -> list[Path]:
     return list(list_of_conftest_files)
 
 
+def normalize_toml_config(config: dict[str, Any], config_file_path: Path) -> dict[str, Any]:
+    path_keys = ["module-root", "tests-root", "benchmarks-root"]
+    path_list_keys = ["ignore-paths"]
+    str_keys = {"pytest-cmd": "pytest", "git-remote": "origin"}
+    bool_keys = {
+        "override-fixtures": False,
+        "disable-telemetry": False,
+        "disable-imports-sorting": False,
+        "benchmark": False,
+    }
+    list_str_keys = {"formatter-cmds": []}
+
+    for key, default_value in str_keys.items():
+        if key in config:
+            config[key] = str(config[key])
+        else:
+            config[key] = default_value
+    for key, default_value in bool_keys.items():
+        if key in config:
+            config[key] = bool(config[key])
+        else:
+            config[key] = default_value
+    for key in path_keys:
+        if key in config:
+            config[key] = str((config_file_path.parent / Path(config[key])).resolve())
+    for key, default_value in list_str_keys.items():
+        if key in config:
+            config[key] = [str(cmd) for cmd in config[key]]
+        else:
+            config[key] = default_value
+    for key in path_list_keys:
+        if key in config:
+            config[key] = [str((config_file_path.parent / path).resolve()) for path in config[key]]
+        else:
+            config[key] = []
+
+    # Convert hyphenated keys to underscored keys
+    for key in list(config.keys()):
+        if "-" in key:
+            config[key.replace("-", "_")] = config[key]
+            del config[key]
+
+    return config
+
+
+def _parse_java_config_for_dir(dir_path: Path) -> dict[str, Any] | None:
+    from codeflash.languages.java.build_config_strategy 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:
+    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()
+
+    # Walk upward from start_dir to filesystem root (closest config wins per language)
+    dir_path = start_dir.resolve()
+    while True:
+        _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
+
+
 def parse_config_file(
     config_file_path: Path | None = None, override_formatter_check: bool = False
 ) -> tuple[dict[str, Any], Path]:
@@ -174,55 +326,13 @@ def parse_config_file(
     if config == {} and lsp_mode:
         return {}, config_file_path
 
-    # Preserve language field if present (important for JS/TS projects)
-    # default values:
-    path_keys = ["module-root", "tests-root", "benchmarks-root"]
-    path_list_keys = ["ignore-paths"]
-    str_keys = {"pytest-cmd": "pytest", "git-remote": "origin"}
-    bool_keys = {
-        "override-fixtures": False,
-        "disable-telemetry": False,
-        "disable-imports-sorting": False,
-        "benchmark": False,
-    }
-    # Note: formatter-cmds defaults to empty list. For Python projects, black is typically
-    # detected by the project detector. For Java projects, no formatter is supported yet.
-    list_str_keys = {"formatter-cmds": []}
-
-    for key, default_value in str_keys.items():
-        if key in config:
-            config[key] = str(config[key])
-        else:
-            config[key] = default_value
-    for key, default_value in bool_keys.items():
-        if key in config:
-            config[key] = bool(config[key])
-        else:
-            config[key] = default_value
-    for key in path_keys:
-        if key in config:
-            config[key] = str((Path(config_file_path).parent / Path(config[key])).resolve())
-    for key, default_value in list_str_keys.items():
-        if key in config:
-            config[key] = [str(cmd) for cmd in config[key]]
-        else:
-            config[key] = default_value
-
-    for key in path_list_keys:
-        if key in config:
-            config[key] = [str((Path(config_file_path).parent / path).resolve()) for path in config[key]]
-        else:
-            config[key] = []
+    config = normalize_toml_config(config, config_file_path)
 
     # see if this is happening during GitHub actions setup
-    if config.get("formatter-cmds") and len(config.get("formatter-cmds")) > 0 and not override_formatter_check:
-        assert config.get("formatter-cmds")[0] != "your-formatter $file", (
+    if config.get("formatter_cmds") and len(config.get("formatter_cmds")) > 0 and not override_formatter_check:
+        assert config.get("formatter_cmds")[0] != "your-formatter $file", (
             "The formatter command is not set correctly in pyproject.toml. Please set the "
             "formatter command in the 'formatter-cmds' key. More info - https://docs.codeflash.ai/configuration"
         )
-    for key in list(config.keys()):
-        if "-" in key:
-            config[key.replace("-", "_")] = config[key]
-            del config[key]
 
     return config, config_file_path