make sure js support is working fine

Author: mohammedahmed18

code_to_optimize/js/code_to_optimize_js/bubble_sort.js

@@ -31,26 +31,5 @@ function bubbleSort(arr) {
     return result;
 }
 
-/**
- * Sort an array in descending order.
- * @param {number[]} arr - The array to sort
- * @returns {number[]} - The sorted array in descending order
- */
-function bubbleSortDescending(arr) {
-    const n = arr.length;
-    const result = [...arr];
-
-    for (let i = 0; i < n - 1; i++) {
-        for (let j = 0; j < n - i - 1; j++) {
-            if (result[j] < result[j + 1]) {
-                const temp = result[j];
-                result[j] = result[j + 1];
-                result[j + 1] = temp;
-            }
-        }
-    }
-
-    return result;
-}
 
-module.exports = { bubbleSort, bubbleSortDescending };
+module.exports = { bubbleSort };

code_to_optimize/js/code_to_optimize_js/tests/bubble_sort.test.js

@@ -1,4 +1,4 @@
-const { bubbleSort, bubbleSortDescending } = require('../bubble_sort');
+const { bubbleSort } = require('../bubble_sort');
 
 describe('bubbleSort', () => {
     test('sorts an empty array', () => {
@@ -54,17 +54,3 @@ describe('bubbleSort', () => {
         expect(result[result.length - 1]).toBe(96);
     });
 });
-
-describe('bubbleSortDescending', () => {
-    test('sorts in descending order', () => {
-        expect(bubbleSortDescending([1, 3, 2, 5, 4])).toEqual([5, 4, 3, 2, 1]);
-    });
-
-    test('handles empty array', () => {
-        expect(bubbleSortDescending([])).toEqual([]);
-    });
-
-    test('handles single element', () => {
-        expect(bubbleSortDescending([42])).toEqual([42]);
-    });
-});

codeflash/languages/base.py

@@ -956,6 +956,7 @@ def run_behavioral_tests(
         project_root: Path | None = None,
         enable_coverage: bool = False,
         candidate_index: int = 0,
+        test_framework: str | None = None,
     ) -> tuple[Path, Any, Path | None, Path | None]:
         """Run behavioral tests for this language.
 
@@ -967,6 +968,7 @@ def run_behavioral_tests(
             project_root: Project root directory.
             enable_coverage: Whether to collect coverage information.
             candidate_index: Index of the candidate being tested.
+            test_framework: Test framework to use
 
         Returns:
             Tuple of (result_file_path, subprocess_result, coverage_path, config_path).

codeflash/languages/javascript/test_runner.py

@@ -796,6 +796,7 @@ def run_jest_behavioral_tests(
     # Build Jest command
     jest_cmd = [
         "npx",
+        "-y",
         "jest",
         "--reporters=default",
         f"--reporters={CODEFLASH_JEST_REPORTER}",
@@ -1050,6 +1051,7 @@ def run_jest_benchmarking_tests(
     # Build Jest command for performance tests
     jest_cmd = [
         "npx",
+        "-y",
         "jest",
         "--reporters=default",
         f"--reporters={CODEFLASH_JEST_REPORTER}",
@@ -1220,6 +1222,7 @@ def run_jest_line_profile_tests(
     # Build Jest command for line profiling - simple run without benchmarking loops
     jest_cmd = [
         "npx",
+        "-y",
         "jest",
         "--reporters=default",
         f"--reporters={CODEFLASH_JEST_REPORTER}",

mcp_server/db.py

@@ -38,7 +38,7 @@ def _create_tables(conn: sqlite3.Connection) -> None:
             created_at TEXT NOT NULL,
             project_root TEXT NOT NULL,
             test_files TEXT NOT NULL,
-            total_runtime_ns INTEGER,
+            best_summed_runtime_ns INTEGER,
             total_tests INTEGER,
             passed INTEGER,
             failed INTEGER,
@@ -79,23 +79,23 @@ def store_run(
     raw_stdout: str = "",
     raw_stderr: str = "",
 ) -> None:
-    total_runtime_ns = test_results.total_passed_runtime() if test_results else 0
+    best_summed_runtime_ns = test_results.total_passed_runtime() if test_results else 0
     total_tests = len(test_results)
     passed = sum(1 for r in test_results if r.did_pass)
     failed = total_tests - passed
     loops_executed = test_results.effective_loop_count() if test_results else 0
 
     conn.execute(
         "INSERT INTO runs (run_id, run_type, created_at, project_root, test_files, "
-        "total_runtime_ns, total_tests, passed, failed, loops_executed, raw_stdout, raw_stderr) "
+        "best_summed_runtime_ns, total_tests, passed, failed, loops_executed, raw_stdout, raw_stderr) "
         "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
         (
             run_id,
             run_type,
             datetime.now(timezone.utc).isoformat(),
             project_root,
             json.dumps(test_files),
-            total_runtime_ns,
+            best_summed_runtime_ns,
             total_tests,
             passed,
             failed,
@@ -200,7 +200,7 @@ def load_test_results(conn: sqlite3.Connection, run_id: str) -> TestResults:
 
 def load_run_metadata(conn: sqlite3.Connection, run_id: str) -> dict[str, Any] | None:
     row = conn.execute(
-        "SELECT run_type, created_at, project_root, test_files, total_runtime_ns, "
+        "SELECT run_type, created_at, project_root, test_files, best_summed_runtime_ns, "
         "total_tests, passed, failed, loops_executed FROM runs WHERE run_id = ?",
         (run_id,),
     ).fetchone()
@@ -211,7 +211,7 @@ def load_run_metadata(conn: sqlite3.Connection, run_id: str) -> dict[str, Any] |
         "created_at": row[1],
         "project_root": row[2],
         "test_files": json.loads(row[3]),
-        "total_runtime_ns": row[4],
+        "best_summed_runtime_ns": row[4],
         "total_tests": row[5],
         "passed": row[6],
         "failed": row[7],

mcp_server/models.py

@@ -23,7 +23,7 @@ class BehavioralRunResult:
     total_tests: int
     passed: int
     failed: int
-    total_runtime_ns: int
+    best_summed_runtime_ns: int
     test_results: list[TestInvocationResult]
     errors: list[str] = field(default_factory=list)
 
@@ -58,7 +58,7 @@ class SpeedupInfo:
 @dataclass
 class BenchmarkRunResult:
     run_id: str
-    total_runtime_ns: int
+    best_summed_runtime_ns: int
     loops_executed: int
     test_results: list[TestInvocationResult]
     speedup: SpeedupInfo | None = None

mcp_server/runner.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import inspect
 from enum import Enum
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -53,12 +54,63 @@ def _build_test_config(project_root: Path, tests_dir: Path | None = None) -> Tes
     return TestConfig(tests_root=effective_tests_dir, project_root_path=project_root, tests_project_rootdir=effective_tests_dir)
 
 
-def _find_call_positions(test_path: Path, function_name: str) -> list:
-    """Scan a test file's AST to find all call sites of the target function."""
+def _build_fallback_function_to_optimize(module_path: Path, function_name: str, language: str):
+    from codeflash.models.function_types import FunctionParent, FunctionToOptimize
+
+    qualified_name_parts = function_name.split(".")
+    simple_name = qualified_name_parts[-1]
+    parents = [FunctionParent(name=part, type="ClassDef") for part in qualified_name_parts[:-1]]
+    return FunctionToOptimize(
+        function_name=simple_name,
+        file_path=module_path,
+        parents=parents,
+        is_method=bool(parents),
+        language=language,
+    )
+
+
+def _resolve_function_to_optimize(lang_support: object, module_path: str, function_name: str, language: str):
+    from codeflash.languages.base import FunctionFilterCriteria
+
+    source_path = Path(module_path).resolve()
+    fallback = _build_fallback_function_to_optimize(source_path, function_name, language)
+
+    try:
+        source = source_path.read_text(encoding="utf-8")
+    except OSError:
+        return fallback
+
+    criteria = FunctionFilterCriteria(require_return=False, require_export=False)
+    discovered_functions = lang_support.discover_functions(source, source_path, criteria)
+    if not discovered_functions:
+        return fallback
+
+    requested_name = function_name.rsplit(".", 1)[-1]
+
+    qualified_matches = [func for func in discovered_functions if func.qualified_name == function_name]
+    if len(qualified_matches) == 1:
+        return qualified_matches[0]
+
+    top_level_matches = [func for func in discovered_functions if func.qualified_name == requested_name]
+    if len(top_level_matches) == 1:
+        return top_level_matches[0]
+
+    simple_matches = [func for func in discovered_functions if func.function_name == requested_name]
+    if len(simple_matches) == 1:
+        return simple_matches[0]
+
+    return fallback
+
+
+def _find_call_positions(test_path: Path, function_name: str, language: str) -> list:
+    """Scan a Python test file's AST to find all call sites of the target function."""
     import ast
 
     from codeflash.models.models import CodePosition
 
+    if language != "python":
+        return []
+
     try:
         source = test_path.read_text(encoding="utf-8")
         tree = ast.parse(source)
@@ -77,6 +129,15 @@ def _find_call_positions(test_path: Path, function_name: str) -> list:
     return positions
 
 
+def _invoke_with_optional_test_framework(run_callable: object, *, test_framework: str | None = None, **kwargs: object):
+    try:
+        if test_framework is not None and "test_framework" in inspect.signature(run_callable).parameters:
+            kwargs["test_framework"] = test_framework
+    except (TypeError, ValueError):
+        pass
+    return run_callable(**kwargs)
+
+
 class _InstrumentedFiles:
     """Context manager that instruments test files in-place and restores originals on exit."""
 
@@ -100,16 +161,15 @@ def __init__(
     def __enter__(self) -> list[str]:
         from codeflash.languages.current import set_current_language
         from codeflash.languages.registry import get_language_support
-        from codeflash.models.function_types import FunctionToOptimize
 
         set_current_language(self.language)
         lang_support = get_language_support(self.language)
 
-        func_to_optimize = FunctionToOptimize(
+        func_to_optimize = _resolve_function_to_optimize(
+            lang_support=lang_support,
+            module_path=self.module_path,
             function_name=self.function_name,
-            file_path=Path(self.module_path),
-            parents=(),
-            qualified_name=self.function_name,
+            language=self.language,
         )
 
         instrument_mode = "behavior" if self.mode == TestingMode.BEHAVIORAL else "performance"
@@ -118,8 +178,8 @@ def __enter__(self) -> list[str]:
         for test_file in self.test_file_paths:
             test_path = Path(test_file).resolve()
 
-            call_positions = _find_call_positions(test_path, self.function_name)
-            if not call_positions:
+            call_positions = _find_call_positions(test_path, func_to_optimize.function_name, self.language)
+            if self.language == "python" and not call_positions:
                 instrumented_paths.append(test_file)
                 continue
 
@@ -157,6 +217,7 @@ def run_and_parse(
     target_duration_seconds: float = 0.5,
     function_name: str | None = None,
     module_path: str | None = None,
+    test_framework: str | None = None,
 ) -> tuple[TestResults, subprocess.CompletedProcess[str]]:
     from codeflash.languages.current import set_current_language
     from codeflash.languages.registry import get_language_support
@@ -172,11 +233,19 @@ def _execute(effective_files: list[str]) -> tuple[TestResults, subprocess.Comple
         test_files_obj = _build_test_files(effective_files, mode)
 
         if mode == TestingMode.BEHAVIORAL:
-            result_file_path, run_result, _, _ = lang_support.run_behavioral_tests(
-                test_paths=test_files_obj, test_env=test_env, cwd=project_root, timeout=timeout, project_root=project_root
+            result_file_path, run_result, _, _ = _invoke_with_optional_test_framework(
+                lang_support.run_behavioral_tests,
+                test_framework=test_framework,
+                test_paths=test_files_obj,
+                test_env=test_env,
+                cwd=project_root,
+                timeout=timeout,
+                project_root=project_root,
             )
         else:
-            result_file_path, run_result = lang_support.run_benchmarking_tests(
+            result_file_path, run_result = _invoke_with_optional_test_framework(
+                lang_support.run_benchmarking_tests,
+                test_framework=test_framework,
                 test_paths=test_files_obj,
                 test_env=test_env,
                 cwd=project_root,

mcp_server/server.py

@@ -19,6 +19,7 @@ def run_behavioral_tests(
     run_id: str | None = None,
     function_name: str | None = None,
     module_path: str | None = None,
+    test_framework: str | None = None,
 ) -> dict[str, Any]:
     """Run tests and capture function return values + timing for each test invocation.
 
@@ -39,9 +40,10 @@ def run_behavioral_tests(
         run_id: Identifier for this run. Use descriptive IDs like "baseline-exp-1". Auto-generated UUID if omitted.
         function_name: Name of the function being optimized. When provided with module_path, enables automatic instrumentation of test files to capture return values and precise timing.
         module_path: Absolute path to the source file containing the function being optimized. Required together with function_name for instrumentation.
+        test_framework: Optional test framework override. If omitted, codeflash will try to detect the framework automatically. For Python, the supported value is `pytest`. For JavaScript/TypeScript, supported values are `jest`, `vitest`, and `mocha`. For Java and Go, leave this unset because it is not used.
 
     Returns:
-        run_id, total_tests, passed, failed, total_runtime_ns, test_results (per-test detail), errors.
+        run_id, total_tests, passed, failed, best_summed_runtime_ns, test_results (per-test detail), errors.
 
     """
     from mcp_server.tools.behavioral import run_behavioral_tests as impl
@@ -54,6 +56,7 @@ def run_behavioral_tests(
         run_id=run_id,
         function_name=function_name,
         module_path=module_path,
+        test_framework=test_framework,
     )
 
 
@@ -98,6 +101,7 @@ def run_benchmarking_tests(
     baseline_run_id: str | None = None,
     function_name: str | None = None,
     module_path: str | None = None,
+    test_framework: str | None = None,
 ) -> dict[str, Any]:
     """Run tests in multi-loop mode for stable timing, then compute speedup against a baseline.
 
@@ -132,9 +136,10 @@ def run_benchmarking_tests(
         baseline_run_id: Run ID of a previous benchmark to compare against. Omit for baseline capture.
         function_name: Name of the function being benchmarked. When provided with module_path, enables automatic instrumentation with performance-mode timing capture.
         module_path: Absolute path to the source file containing the function. Required together with function_name.
+        test_framework: Optional test framework override. If omitted, codeflash will try to detect the framework automatically. For Python, the supported value is `pytest`. For JavaScript/TypeScript, supported values are `jest`, `vitest`, and `mocha`. For Java and Go, leave this unset because it is not used.
 
     Returns:
-        run_id, total_runtime_ns, loops_executed, test_results, speedup (null if no baseline_run_id).
+        run_id, best_summed_runtime_ns, loops_executed, test_results, speedup (null if no baseline_run_id).
 
     """
     from mcp_server.tools.benchmarking import run_benchmarking_tests as impl
@@ -151,6 +156,7 @@ def run_benchmarking_tests(
         baseline_run_id=baseline_run_id,
         function_name=function_name,
         module_path=module_path,
+        test_framework=test_framework,
     )