Merge branch 'main' into fix/cf_setup

Author: Saga4

CLAUDE.md

@@ -57,19 +57,11 @@ codeflash/
 └── result/                 # Result types and handling
 ```
 
-### Key Patterns
-
-**Either/Result pattern for errors:**
-```python
-from codeflash.either import is_successful, Success, Failure
-result = some_operation()
-if is_successful(result):
-    value = result.unwrap()
-else:
-    error = result.failure()
-```
+### Key Rules to follow
 
-**Use libcst, not ast** - Always use `libcst` for code parsing/modification to preserve formatting.
+- Use libcst, not ast - For Python, always use `libcst` for code parsing/modification to preserve formatting.
+- Code context extraction and replacement tests must always assert for full string equality, no substring matching.
+- Any new feature or bug fix that can be tested automatically must have test cases.
 
 ## Code Style
 

codeflash/benchmarking/plugin/plugin.py

@@ -200,7 +200,7 @@ def get_benchmark_timings(trace_path: Path) -> dict[BenchmarkKey, int]:
 
     # Pytest hooks
     @pytest.hookimpl
-    def pytest_sessionfinish(self, session, exitstatus) -> None:  # noqa: ANN001
+    def pytest_sessionfinish(self, session, exitstatus) -> None:
         """Execute after whole test run is completed."""
         # Write any remaining benchmark timings to the database
         codeflash_trace.close()
@@ -236,20 +236,20 @@ class Benchmark:  # noqa: D106
         def __init__(self, request: pytest.FixtureRequest) -> None:
             self.request = request
 
-        def __call__(self, func, *args, **kwargs):  # noqa: ANN001, ANN002, ANN003, ANN204
+        def __call__(self, func, *args, **kwargs):  # noqa: ANN002, ANN003, ANN204
             """Handle both direct function calls and decorator usage."""
             if args or kwargs:
                 # Used as benchmark(func, *args, **kwargs)
                 return self._run_benchmark(func, *args, **kwargs)
 
             # Used as @benchmark decorator
-            def wrapped_func(*args, **kwargs):  # noqa: ANN002, ANN003, ANN202
+            def wrapped_func(*args, **kwargs):  # noqa: ANN002, ANN003
                 return func(*args, **kwargs)
 
             self._run_benchmark(func)
             return wrapped_func
 
-        def _run_benchmark(self, func, *args, **kwargs):  # noqa: ANN002, ANN003, ANN202
+        def _run_benchmark(self, func, *args, **kwargs):  # noqa: ANN002, ANN003
             """Actual benchmark implementation."""
             node_path = getattr(self.request.node, "path", None) or getattr(self.request.node, "fspath", None)
             if node_path is None:

codeflash/cli_cmds/cli.py

@@ -231,11 +231,22 @@ def process_pyproject_config(args: Namespace) -> Namespace:
     is_js_ts_project = pyproject_config.get("language") in ("javascript", "typescript")
     if args.tests_root is None:
         if is_js_ts_project:
-            # Try common JS test directories, or default to module_root
+            # Try common JS test directories at project root first
             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:

codeflash/cli_cmds/console.py

@@ -129,6 +129,9 @@ def code_print(
 
 spinners = cycle(SPINNER_TYPES)
 
+# Track whether a progress bar is already active to prevent nested Live displays
+_progress_bar_active = False
+
 
 @contextmanager
 def progress_bar(
@@ -138,28 +141,38 @@ def progress_bar(
 
     If revert_to_print is True, falls back to printing a single logger.info message
     instead of showing a progress bar.
+
+    If a progress bar is already active, yields a dummy task ID to avoid Rich's
+    LiveError from nested Live displays.
     """
+    global _progress_bar_active
+
     if is_LSP_enabled():
         lsp_log(LspTextMessage(text=message, takes_time=True))
         yield
         return
 
-    if revert_to_print:
-        logger.info(message)
+    if revert_to_print or _progress_bar_active:
+        if revert_to_print:
+            logger.info(message)
 
         # Create a fake task ID since we still need to yield something
         yield DummyTask().id
     else:
-        progress = Progress(
-            SpinnerColumn(next(spinners)),
-            *Progress.get_default_columns(),
-            TimeElapsedColumn(),
-            console=console,
-            transient=transient,
-        )
-        task = progress.add_task(message, total=None)
-        with progress:
-            yield task
+        _progress_bar_active = True
+        try:
+            progress = Progress(
+                SpinnerColumn(next(spinners)),
+                *Progress.get_default_columns(),
+                TimeElapsedColumn(),
+                console=console,
+                transient=transient,
+            )
+            task = progress.add_task(message, total=None)
+            with progress:
+                yield task
+        finally:
+            _progress_bar_active = False
 
 
 @contextmanager

codeflash/code_utils/code_utils.py

@@ -436,7 +436,7 @@ def extract_unique_errors(pytest_output: str) -> set[str]:
     pattern = r"^E\s+(.*)$"
 
     for error_message in re.findall(pattern, pytest_output, re.MULTILINE):
-        error_message = error_message.strip()  # noqa: PLW2901
+        error_message = error_message.strip()
         if error_message:
             unique_errors.add(error_message)
 

codeflash/code_utils/config_js.py

@@ -105,7 +105,7 @@ def detect_module_root(project_root: Path, package_data: dict[str, Any]) -> str:
     return "."
 
 
-def detect_test_runner(project_root: Path, package_data: dict[str, Any]) -> str:  # noqa: ARG001
+def detect_test_runner(project_root: Path, package_data: dict[str, Any]) -> str:
     """Detect test runner from devDependencies or scripts.test.
 
     Detection order:
@@ -144,7 +144,7 @@ def detect_test_runner(project_root: Path, package_data: dict[str, Any]) -> str:
     return "jest"
 
 
-def detect_formatter(project_root: Path, package_data: dict[str, Any]) -> list[str] | None:  # noqa: ARG001
+def detect_formatter(project_root: Path, package_data: dict[str, Any]) -> list[str] | None:
     """Detect formatter from devDependencies.
 
     Detection order:

codeflash/code_utils/deduplicate_code.py

@@ -14,10 +14,7 @@
 
 
 def normalize_code(
-    code: str,
-    remove_docstrings: bool = True,
-    return_ast_dump: bool = False,
-    language: str | None = None,
+    code: str, remove_docstrings: bool = True, return_ast_dump: bool = False, language: str | None = None
 ) -> str:
     """Normalize code by parsing, cleaning, and normalizing variable names.
 

codeflash/code_utils/instrument_existing_tests.py

@@ -89,7 +89,7 @@ def find_and_update_line_node(
         # it's much more efficient to visit nodes manually. We'll only descend into expressions/statements.
 
         # Helper for manual walk
-        def iter_ast_calls(node):  # noqa: ANN202
+        def iter_ast_calls(node):
             # Generator to yield each ast.Call in test_node, preserves node identity
             stack = [node]
             while stack:
@@ -102,7 +102,7 @@ def iter_ast_calls(node):  # noqa: ANN202
                     if isinstance(value, list):
                         for item in reversed(value):
                             if isinstance(item, ast.AST):
-                                stack.append(item)  # noqa: PERF401
+                                stack.append(item)
                     elif isinstance(value, ast.AST):
                         stack.append(value)
 

codeflash/context/code_context_extractor.py

@@ -46,8 +46,8 @@ def build_testgen_context(
     helpers_of_fto_dict: dict[Path, set[FunctionSource]],
     helpers_of_helpers_dict: dict[Path, set[FunctionSource]],
     project_root_path: Path,
-    remove_docstrings: bool,  # noqa: FBT001
-    include_imported_classes: bool,  # noqa: FBT001
+    remove_docstrings: bool,
+    include_imported_classes: bool,
 ) -> CodeStringsMarkdown:
     """Build testgen context with optional imported class definitions and external base inits."""
     testgen_context = extract_code_markdown_context_from_files(

codeflash/discovery/functions_to_optimize.py

@@ -216,6 +216,32 @@ def get_files_for_language(
     return files
 
 
+def _is_js_ts_function_exported(file_path: Path, function_name: str) -> tuple[bool, str | None]:
+    """Check if a JavaScript/TypeScript function is exported from its module.
+
+    For JS/TS, functions that are not exported cannot be imported by tests,
+    making them impossible to optimize.
+
+    Args:
+        file_path: Path to the source file.
+        function_name: Name of the function to check.
+
+    Returns:
+        Tuple of (is_exported, export_name). export_name may be 'default' for default exports.
+
+    """
+    from codeflash.languages.treesitter_utils import get_analyzer_for_file
+
+    try:
+        source = file_path.read_text(encoding="utf-8")
+        analyzer = get_analyzer_for_file(file_path)
+        return analyzer.is_function_exported(source, function_name)
+    except Exception as e:
+        logger.debug(f"Failed to check export status for {function_name}: {e}")
+        # Return True to avoid blocking in case of errors
+        return True, None
+
+
 def _find_all_functions_in_python_file(file_path: Path) -> dict[Path, list[FunctionToOptimize]]:
     """Find all optimizable functions in a Python file using AST parsing.
 
@@ -338,6 +364,36 @@ def get_functions_to_optimize(
                     exit_with_message(
                         f"Function {only_get_this_function} not found in file {file}\nor the function does not have a 'return' statement or is a property"
                     )
+
+                # For JavaScript/TypeScript, verify that the function (or its parent class) is exported
+                # Non-exported functions cannot be imported by tests
+                if found_function.language in ("javascript", "typescript"):
+                    # For class methods, check if the parent class is exported
+                    # For standalone functions, check if the function itself is exported
+                    if found_function.parents:
+                        # It's a class method - check if the class is exported
+                        name_to_check = found_function.top_level_parent_name
+                    else:
+                        # It's a standalone function - check if the function is exported
+                        name_to_check = found_function.function_name
+
+                    is_exported, export_name = _is_js_ts_function_exported(file, name_to_check)
+                    if not is_exported:
+                        if found_function.parents:
+                            logger.debug(
+                                f"Class '{name_to_check}' containing method '{found_function.function_name}' "
+                                f"is not exported from {file}. "
+                                f"In JavaScript/TypeScript, only exported classes/functions can be optimized "
+                                f"because tests need to import them."
+                            )
+                        else:
+                            logger.debug(
+                                f"Function '{found_function.function_name}' is not exported from {file}. "
+                                f"In JavaScript/TypeScript, only exported functions can be optimized because "
+                                f"tests need to import them."
+                            )
+                        return {}, 0, None
+
                 functions[file] = [found_function]
         else:
             logger.info("Finding all functions modified in the current git diff ...")