fix: extract shared config helper and fix 4 review bugs

Extract resolve_config_onto_args() from duplicated logic between
process_pyproject_config and apply_language_config (~100 lines deduped).
This fixes:
- Missing benchmark validation in apply_language_config (HIGH)
- Missing LSP guard in apply_language_config (MEDIUM)
- --all /specific/path silently overridden in orchestration loop (MEDIUM)
- Silent except Exception: pass in config discovery (MEDIUM)

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

Author: mashraf-222

codeflash/cli_cmds/cli.py

@@ -1,21 +1,29 @@
+from __future__ import annotations
+
 import logging
 import os
 import sys
-from argparse import SUPPRESS, ArgumentParser, Namespace
+from argparse import SUPPRESS, ArgumentParser
 from functools import lru_cache
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from codeflash.cli_cmds import logging_config
 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 LanguageConfig, parse_config_file
+from codeflash.code_utils.config_parser import 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
 
+if TYPE_CHECKING:
+    from argparse import Namespace
+
+    from codeflash.code_utils.config_parser import LanguageConfig
+
 
 def parse_args() -> Namespace:
     parser = _build_parser()
@@ -91,6 +99,21 @@ def process_pyproject_config(args: Namespace) -> Namespace:
         pyproject_config, pyproject_file_path = parse_config_file(args.config_file)
     except ValueError as e:
         exit_with_message(f"Error parsing config file: {e}", error_on_exit=True)
+
+    language = None
+    lang_str = pyproject_config.get("language")
+    if lang_str:
+        language = Language(lang_str)
+
+    args = resolve_config_onto_args(args, pyproject_config, pyproject_file_path, language)
+
+    if is_LSP_enabled():
+        args.all = None
+        return args
+    return handle_optimize_all_arg_parsing(args)
+
+
+def resolve_config_onto_args(args: Namespace, config: dict, config_path: Path, language: Language | None) -> Namespace:
     supported_keys = [
         "module_root",
         "tests_root",
@@ -104,29 +127,26 @@ def process_pyproject_config(args: Namespace) -> Namespace:
         "override_fixtures",
     ]
     for key in supported_keys:
-        if key in pyproject_config and (
-            (hasattr(args, key.replace("-", "_")) and getattr(args, key.replace("-", "_")) is None)
-            or not hasattr(args, key.replace("-", "_"))
+        attr_key = key.replace("-", "_")
+        if key in config and (
+            (hasattr(args, attr_key) and getattr(args, attr_key) is None) or not hasattr(args, attr_key)
         ):
-            setattr(args, key.replace("-", "_"), pyproject_config[key])
+            setattr(args, attr_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"
 
-    is_js_ts_project = pyproject_config.get("language") in ("javascript", "typescript")
-    is_java_project = pyproject_config.get("language") == "java"
+    is_js_ts = language in (Language.JAVASCRIPT, Language.TYPESCRIPT)
+    is_java = language == 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"])
+    if language is not None:
+        set_current_language(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"])
+    if is_js_ts and config.get("test_framework"):
+        set_current_test_framework(config["test_framework"])
 
     if args.tests_root is None:
-        if is_java_project:
-            # Try standard Maven/Gradle test directories
+        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():
@@ -136,29 +156,26 @@ def process_pyproject_config(args: Namespace) -> Namespace:
                     break
             if args.tests_root is None:
                 args.tests_root = str(Path.cwd() / "src" / "test" / "java")
-        elif is_js_ts_project:
-            # Try common JS test directories at project root first
+        elif is_js_ts:
             for test_dir in ["test", "tests", "__tests__"]:
                 if Path(test_dir).is_dir():
                     args.tests_root = test_dir
                     break
-            # If not found at project root, try inside module_root (e.g., src/test, src/__tests__)
             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
-            # Final fallback: default to module_root
-            # Note: This may cause issues if tests are colocated with source files
-            # In such cases, the user should explicitly configure testsRoot in package.json
             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"
-    if args.benchmark:
+
+    if getattr(args, "benchmark", False):
         assert args.benchmarks_root is not None, "--benchmarks-root must be specified when running with --benchmark"
         assert Path(args.benchmarks_root).is_dir(), (
             f"--benchmarks-root {args.benchmarks_root} must be a valid directory"
@@ -184,29 +201,20 @@ def process_pyproject_config(args: Namespace) -> Namespace:
 
             require_github_app_or_exit(owner, repo_name)
 
-    # Project root path is one level above the specified directory, because that's where the module can be imported from
     args.module_root = Path(args.module_root).resolve()
     if hasattr(args, "ignore_paths") and args.ignore_paths is not None:
-        # Normalize ignore paths, supporting both literal paths and glob patterns
-        # Use module_root as base path for resolving relative paths and patterns
         args.ignore_paths = normalize_ignore_paths(args.ignore_paths, base_path=args.module_root)
-    # If module-root is "." then all imports are relatives to it.
-    # in this case, the ".." becomes outside project scope, causing issues with un-importable paths
-    args.project_root = project_root_from_module_root(Path(args.module_root), pyproject_file_path)
+    args.project_root = project_root_from_module_root(Path(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, pyproject_file_path)
+    args.test_project_root = project_root_from_module_root(args.tests_root, config_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
-    return handle_optimize_all_arg_parsing(args)
+    if is_java and config_path.is_dir():
+        args.project_root = config_path.resolve()
+        args.test_project_root = config_path.resolve()
+
+    return args
 
 
 def project_root_from_module_root(module_root: Path, pyproject_file_path: Path) -> Path:
@@ -227,80 +235,7 @@ def project_root_from_module_root(module_root: Path, pyproject_file_path: Path)
 
 
 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
+    return resolve_config_onto_args(args, lang_config.config, lang_config.config_path, lang_config.language)
 
 
 def handle_optimize_all_arg_parsing(args: Namespace) -> Namespace:

codeflash/code_utils/config_parser.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
@@ -10,6 +11,8 @@
 from codeflash.languages.language_enum import Language
 from codeflash.lsp.helpers import is_LSP_enabled
 
+logger = logging.getLogger("codeflash")
+
 PYPROJECT_TOML_CACHE: dict[Path, Path] = {}
 ALL_CONFIG_FILES: dict[Path, dict[str, Path]] = {}
 
@@ -197,7 +200,7 @@ def _check_dir_for_configs(dir_path: Path, configs: list[LanguageConfig], seen_l
                     seen_languages.add(Language.PYTHON)
                     configs.append(LanguageConfig(config=normalized, config_path=pyproject, language=Language.PYTHON))
             except Exception:
-                pass
+                logger.debug("Failed to parse Python config in %s", dir_path, exc_info=True)
 
     if Language.JAVASCRIPT not in seen_languages and Language.TYPESCRIPT not in seen_languages:
         package_json = dir_path / "package.json"
@@ -210,7 +213,7 @@ def _check_dir_for_configs(dir_path: Path, configs: list[LanguageConfig], seen_l
                     seen_languages.add(lang)
                     configs.append(LanguageConfig(config=config, config_path=path, language=lang))
             except Exception:
-                pass
+                logger.debug("Failed to parse JS/TS config in %s", dir_path, exc_info=True)
 
     if Language.JAVA not in seen_languages:
         if (
@@ -224,7 +227,7 @@ def _check_dir_for_configs(dir_path: Path, configs: list[LanguageConfig], seen_l
                     seen_languages.add(Language.JAVA)
                     configs.append(LanguageConfig(config=java_config, config_path=dir_path, language=Language.JAVA))
             except Exception:
-                pass
+                logger.debug("Failed to parse Java config in %s", dir_path, exc_info=True)
 
 
 def find_all_config_files(start_dir: Path | None = None) -> list[LanguageConfig]:

codeflash/main.py

@@ -129,10 +129,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
+        # Save the raw --all value before handle_optimize_all_arg_parsing mutates it.
+        # In multi-language mode, module_root is None at this point so the resolution
+        # produces None for the default case; we re-resolve per language inside the loop.
+        original_all = getattr(args, "all", None) if hasattr(args, "all") else None
+        optimize_all_requested = hasattr(args, "all") and original_all is not None
 
         # Multi-language path: run git/GitHub checks ONCE before the loop
         args = handle_optimize_all_arg_parsing(args)
@@ -145,7 +146,12 @@ def main() -> None:
                 pass_args = apply_language_config(pass_args, lang_config)
 
                 if optimize_all_requested:
-                    pass_args.all = pass_args.module_root
+                    if original_all == "":
+                        # --all with no path: use this language's module_root
+                        pass_args.all = pass_args.module_root
+                    else:
+                        # --all /specific/path: preserve the user's path
+                        pass_args.all = Path(original_all).resolve()
 
                 if not env_utils.check_formatter_installed(pass_args.formatter_cmds):
                     logger.info("Skipping %s: formatter not installed", lang_name)