refactor: remove zero-config logic from java-config-redesign branch

Zero-config Java support (auto-detection from build files, codeflash.toml
elimination) is handled separately in cf-java-zero-config-strategy. This
commit strips those changes, keeping only bug fixes:
- JFR parser, ReplayHelper, instrumentation, replay tests
- Multi-module test root resolution
- JUnit 4/5 test framework detection
- add_help=False for optimize subparser

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Ubuntu

code_to_optimize/java-gradle/codeflash.toml

@@ -0,0 +1,4 @@
+[tool.codeflash]
+module-root = "src/main/java"
+tests-root = "src/test/java"
+formatter-cmds = []

code_to_optimize/java/codeflash.toml

@@ -0,0 +1,6 @@
+# Codeflash configuration for Java project
+
+[tool.codeflash]
+module-root = "src/main/java"
+tests-root = "src/test/java"
+formatter-cmds = []

codeflash/cli_cmds/cli.py

@@ -190,12 +190,6 @@ def process_pyproject_config(args: Namespace) -> Namespace:
     if args.benchmarks_root:
         args.benchmarks_root = Path(args.benchmarks_root).resolve()
     args.test_project_root = project_root_from_module_root(args.tests_root, pyproject_file_path)
-
-    if is_java_project and pyproject_file_path.is_dir():
-        # For Java projects, pyproject_file_path IS the project root directory (not a file).
-        # Override project_root which may have resolved to a sub-module.
-        args.project_root = pyproject_file_path.resolve()
-        args.test_project_root = pyproject_file_path.resolve()
     if is_LSP_enabled():
         args.all = None
         return args
@@ -214,6 +208,8 @@ def project_root_from_module_root(module_root: Path, pyproject_file_path: Path)
             return current.resolve()
         if (current / "build.gradle").exists() or (current / "build.gradle.kts").exists():
             return current.resolve()
+        if (current / "codeflash.toml").exists():
+            return current.resolve()
         current = current.parent
 
     return module_root.parent.resolve()

codeflash/code_utils/config_parser.py

@@ -12,29 +12,8 @@
 ALL_CONFIG_FILES: dict[Path, dict[str, Path]] = {}
 
 
-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.
-
-    Returns (config_dict, project_root) if a Java project is found, None otherwise.
-    """
-    dir_path = Path.cwd()
-    while dir_path != dir_path.parent:
-        if (
-            (dir_path / "pom.xml").exists()
-            or (dir_path / "build.gradle").exists()
-            or (dir_path / "build.gradle.kts").exists()
-        ):
-            from codeflash.languages.java.build_tools import parse_java_project_config
-
-            config = parse_java_project_config(dir_path)
-            if config is not None:
-                return config, dir_path
-        dir_path = dir_path.parent
-    return None
-
-
 def find_pyproject_toml(config_file: Path | None = None) -> Path:
-    # Find the pyproject.toml file on the root of the project
+    # Find the pyproject.toml or codeflash.toml file on the root of the project
 
     if config_file is not None:
         config_file = Path(config_file)
@@ -50,13 +29,21 @@ def find_pyproject_toml(config_file: Path | None = None) -> Path:
     # see if it was encountered before in search
     if cur_path in PYPROJECT_TOML_CACHE:
         return PYPROJECT_TOML_CACHE[cur_path]
+    # map current path to closest file - check both pyproject.toml and codeflash.toml
     while dir_path != dir_path.parent:
+        # First check pyproject.toml (Python projects)
         config_file = dir_path / "pyproject.toml"
         if config_file.exists():
             PYPROJECT_TOML_CACHE[cur_path] = config_file
             return config_file
+        # Then check codeflash.toml (Java/other projects)
+        config_file = dir_path / "codeflash.toml"
+        if config_file.exists():
+            PYPROJECT_TOML_CACHE[cur_path] = config_file
+            return config_file
+        # Search in parent directories
         dir_path = dir_path.parent
-    msg = f"Could not find pyproject.toml in the current directory {Path.cwd()} or any of the parent directories. Please create it by running `codeflash init`, or pass the path to the config file with the --config-file argument."
+    msg = f"Could not find pyproject.toml or codeflash.toml in the current directory {Path.cwd()} or any of the parent directories. Please create it by running `codeflash init`, or pass the path to the config file with the --config-file argument."
 
     raise ValueError(msg) from None
 
@@ -103,34 +90,33 @@ def find_conftest_files(test_paths: list[Path]) -> list[Path]:
     return list(list_of_conftest_files)
 
 
+# TODO for claude: There should be different functions to parse it per language, which should be chosen during runtime
 def parse_config_file(
     config_file_path: Path | None = None, override_formatter_check: bool = False
 ) -> tuple[dict[str, Any], Path]:
-    # Detect all config sources — Java, package.json, pyproject.toml
-    java_result = _try_parse_java_build_config() if config_file_path is None else None
     package_json_path = find_package_json(config_file_path)
     pyproject_toml_path = find_closest_config_file("pyproject.toml") if config_file_path is None else None
+    codeflash_toml_path = find_closest_config_file("codeflash.toml") if config_file_path is None else None
 
-    # Use Java config only if no closer JS/Python config exists (monorepo support).
-    # In a monorepo with a parent pom.xml and a child package.json, the closer config wins.
-    if java_result is not None:
-        java_depth = len(java_result[1].parts)
-        has_closer = (package_json_path is not None and len(package_json_path.parent.parts) >= java_depth) or (
-            pyproject_toml_path is not None and len(pyproject_toml_path.parent.parts) >= java_depth
-        )
-        if not has_closer:
-            return java_result
+    # Pick the closest toml config (pyproject.toml or codeflash.toml).
+    # Java projects use codeflash.toml; Python projects use pyproject.toml.
+    closest_toml_path = None
+    if pyproject_toml_path and codeflash_toml_path:
+        closest_toml_path = max(pyproject_toml_path, codeflash_toml_path, key=lambda p: len(p.parent.parts))
+    else:
+        closest_toml_path = pyproject_toml_path or codeflash_toml_path
 
     # When both config files exist, prefer the one closer to CWD.
     # This prevents a parent-directory package.json (e.g., monorepo root)
-    # from overriding a closer pyproject.toml.
+    # from overriding a closer pyproject.toml or codeflash.toml.
     use_package_json = False
     if package_json_path:
-        if pyproject_toml_path is None:
+        if closest_toml_path is None:
             use_package_json = True
         else:
+            # Compare depth: more path parts = closer to CWD = more specific
             package_json_depth = len(package_json_path.parent.parts)
-            toml_depth = len(pyproject_toml_path.parent.parts)
+            toml_depth = len(closest_toml_path.parent.parts)
             use_package_json = package_json_depth >= toml_depth
 
     if use_package_json:
@@ -174,7 +160,7 @@ def parse_config_file(
     if config == {} and lsp_mode:
         return {}, config_file_path
 
-    # Preserve language field if present (important for JS/TS projects)
+    # Preserve language field if present (important for Java/JS projects using codeflash.toml)
     # default values:
     path_keys = ["module-root", "tests-root", "benchmarks-root"]
     path_list_keys = ["ignore-paths"]

codeflash/languages/java/build_tools.py

@@ -10,8 +10,7 @@
 import xml.etree.ElementTree as ET
 from dataclasses import dataclass
 from enum import Enum
-from pathlib import Path
-from typing import Any
+from pathlib import Path  # noqa: TC003 — used at runtime
 
 logger = logging.getLogger(__name__)
 
@@ -344,218 +343,6 @@ def _parse_surefire_reports(surefire_dir: Path) -> tuple[int, int, int, int]:
     return tests_run, failures, errors, skipped
 
 
-def parse_java_project_config(project_root: Path) -> dict[str, Any] | None:
-    """Parse codeflash config from Maven/Gradle build files.
-
-    Reads codeflash.* properties from pom.xml <properties> or gradle.properties,
-    then fills in defaults from auto-detected build tool conventions.
-
-    Returns None if no Java build tool is detected.
-    """
-    build_tool = detect_build_tool(project_root)
-    if build_tool == BuildTool.UNKNOWN:
-        return None
-
-    # Read explicit codeflash properties from build files
-    user_config: dict[str, str] = {}
-    if build_tool == BuildTool.MAVEN:
-        user_config = _read_maven_codeflash_properties(project_root)
-    elif build_tool == BuildTool.GRADLE:
-        user_config = _read_gradle_codeflash_properties(project_root)
-
-    # Auto-detect defaults — for multi-module Maven projects, scan module pom.xml files
-    source_root = find_source_root(project_root)
-    test_root = find_test_root(project_root)
-
-    if build_tool == BuildTool.MAVEN:
-        source_from_modules, test_from_modules = _detect_roots_from_maven_modules(project_root)
-        # Module-level pom.xml declarations are more precise than directory-name heuristics
-        if source_from_modules is not None:
-            source_root = source_from_modules
-        if test_from_modules is not None:
-            test_root = test_from_modules
-
-    # Build the config dict matching the format expected by the rest of codeflash
-    config: dict[str, Any] = {
-        "language": "java",
-        "module_root": str(
-            (project_root / user_config["moduleRoot"]).resolve()
-            if "moduleRoot" in user_config
-            else (source_root or project_root / "src" / "main" / "java")
-        ),
-        "tests_root": str(
-            (project_root / user_config["testsRoot"]).resolve()
-            if "testsRoot" in user_config
-            else (test_root or project_root / "src" / "test" / "java")
-        ),
-        "pytest_cmd": "pytest",
-        "git_remote": user_config.get("gitRemote", "origin"),
-        "disable_telemetry": user_config.get("disableTelemetry", "false").lower() == "true",
-        "disable_imports_sorting": False,
-        "override_fixtures": False,
-        "benchmark": False,
-        "formatter_cmds": [],
-        "ignore_paths": [],
-    }
-
-    if "ignorePaths" in user_config:
-        config["ignore_paths"] = [
-            str((project_root / p.strip()).resolve()) for p in user_config["ignorePaths"].split(",") if p.strip()
-        ]
-
-    if "formatterCmds" in user_config:
-        config["formatter_cmds"] = [cmd.strip() for cmd in user_config["formatterCmds"].split(",") if cmd.strip()]
-
-    return config
-
-
-def _read_maven_codeflash_properties(project_root: Path) -> dict[str, str]:
-    """Read codeflash.* properties from pom.xml <properties> section."""
-    pom_path = project_root / "pom.xml"
-    if not pom_path.exists():
-        return {}
-
-    try:
-        tree = _safe_parse_xml(pom_path)
-        root = tree.getroot()
-        ns = {"m": "http://maven.apache.org/POM/4.0.0"}
-
-        result: dict[str, str] = {}
-        for props in [root.find("m:properties", ns), root.find("properties")]:
-            if props is None:
-                continue
-            for child in props:
-                tag = child.tag
-                # Strip Maven namespace prefix
-                if "}" in tag:
-                    tag = tag.split("}", 1)[1]
-                if tag.startswith("codeflash.") and child.text:
-                    key = tag[len("codeflash.") :]
-                    result[key] = child.text.strip()
-        return result
-    except Exception:
-        logger.debug("Failed to read codeflash properties from pom.xml", exc_info=True)
-        return {}
-
-
-def _read_gradle_codeflash_properties(project_root: Path) -> dict[str, str]:
-    """Read codeflash.* properties from gradle.properties."""
-    props_path = project_root / "gradle.properties"
-    if not props_path.exists():
-        return {}
-
-    result: dict[str, str] = {}
-    try:
-        with props_path.open("r", encoding="utf-8") as f:
-            for line in f:
-                stripped = line.strip()
-                if stripped.startswith("#") or "=" not in stripped:
-                    continue
-                key, value = stripped.split("=", 1)
-                key = key.strip()
-                if key.startswith("codeflash."):
-                    result[key[len("codeflash.") :]] = value.strip()
-        return result
-    except Exception:
-        logger.debug("Failed to read codeflash properties from gradle.properties", exc_info=True)
-        return {}
-
-
-def _detect_roots_from_maven_modules(project_root: Path) -> tuple[Path | None, Path | None]:
-    """Scan Maven module pom.xml files for custom sourceDirectory/testSourceDirectory.
-
-    For multi-module projects like aerospike (client/, test/, benchmarks/),
-    finds the main source module and test module by parsing each module's build config.
-    """
-    pom_path = project_root / "pom.xml"
-    if not pom_path.exists():
-        return None, None
-
-    try:
-        tree = _safe_parse_xml(pom_path)
-        root = tree.getroot()
-        ns = {"m": "http://maven.apache.org/POM/4.0.0"}
-
-        # Find <modules> to get module names
-        modules: list[str] = []
-        for modules_elem in [root.find("m:modules", ns), root.find("modules")]:
-            if modules_elem is not None:
-                for mod in modules_elem:
-                    if mod.text:
-                        modules.append(mod.text.strip())
-
-        if not modules:
-            return None, None
-
-        # Collect candidate source and test roots with Java file counts
-        source_candidates: list[tuple[Path, int]] = []
-        test_root: Path | None = None
-
-        skip_modules = {"example", "examples", "benchmark", "benchmarks", "demo", "sample", "samples"}
-
-        for module_name in modules:
-            module_pom = project_root / module_name / "pom.xml"
-            if not module_pom.exists():
-                continue
-
-            # Modules named "test" are test modules, not source modules
-            is_test_module = "test" in module_name.lower()
-
-            try:
-                mod_tree = _safe_parse_xml(module_pom)
-                mod_root = mod_tree.getroot()
-
-                for build in [mod_root.find("m:build", ns), mod_root.find("build")]:
-                    if build is None:
-                        continue
-
-                    for src_elem in [build.find("m:sourceDirectory", ns), build.find("sourceDirectory")]:
-                        if src_elem is not None and src_elem.text:
-                            src_text = src_elem.text.replace("${project.basedir}", str(project_root / module_name))
-                            src_path = Path(src_text)
-                            if not src_path.is_absolute():
-                                src_path = project_root / module_name / src_path
-                            if src_path.exists():
-                                if is_test_module and test_root is None:
-                                    test_root = src_path
-                                elif module_name.lower() not in skip_modules:
-                                    java_count = sum(1 for _ in src_path.rglob("*.java"))
-                                    if java_count > 0:
-                                        source_candidates.append((src_path, java_count))
-
-                    for test_elem in [build.find("m:testSourceDirectory", ns), build.find("testSourceDirectory")]:
-                        if test_elem is not None and test_elem.text:
-                            test_text = test_elem.text.replace("${project.basedir}", str(project_root / module_name))
-                            test_path = Path(test_text)
-                            if not test_path.is_absolute():
-                                test_path = project_root / module_name / test_path
-                            if test_path.exists() and test_root is None:
-                                test_root = test_path
-
-                # Also check standard module layouts
-                if module_name.lower() not in skip_modules and not is_test_module:
-                    std_src = project_root / module_name / "src" / "main" / "java"
-                    if std_src.exists():
-                        java_count = sum(1 for _ in std_src.rglob("*.java"))
-                        if java_count > 0:
-                            source_candidates.append((std_src, java_count))
-
-                if test_root is None:
-                    std_test = project_root / module_name / "src" / "test" / "java"
-                    if std_test.exists() and any(std_test.rglob("*.java")):
-                        test_root = std_test
-
-            except Exception:
-                continue
-
-        # Pick the source root with the most Java files (likely the main library)
-        source_root = max(source_candidates, key=lambda x: x[1])[0] if source_candidates else None
-        return source_root, test_root
-
-    except Exception:
-        return None, None
-
-
 def find_test_root(project_root: Path) -> Path | None:
     """Find the test root directory for a Java project.