First e2e working version js optimizer!!

Author: misrasaurabh1

code_to_optimize_js/codeflash.yaml

@@ -0,0 +1,5 @@
+# Codeflash configuration for JavaScript project
+module-root: "."
+tests-root: "tests"
+test-framework: "jest"
+formatter-cmds: []

code_to_optimize_js/string_utils.js

@@ -8,11 +8,13 @@
  * @returns {string} - The reversed string
  */
 function reverseString(str) {
-    let result = '';
-    for (let i = str.length - 1; i >= 0; i--) {
-        result += str[i]; // Inefficient string concatenation
+    // Efficient O(n) implementation using a single allocation and one join
+    const len = str.length;
+    const result = new Array(len);
+    for (let i = 0; i < len; i++) {
+        result[i] = str[len - 1 - i];
     }
-    return result;
+    return result.join('');
 }
 
 /**

codeflash/api/aiservice.py

@@ -101,11 +101,14 @@ def make_ai_service_request(
         return response
 
     def _get_valid_candidates(
-        self, optimizations_json: list[dict[str, Any]], source: OptimizedCandidateSource
+        self,
+        optimizations_json: list[dict[str, Any]],
+        source: OptimizedCandidateSource,
+        language: str = "python",
     ) -> list[OptimizedCandidate]:
         candidates: list[OptimizedCandidate] = []
         for opt in optimizations_json:
-            code = CodeStringsMarkdown.parse_markdown_code(opt["source_code"])
+            code = CodeStringsMarkdown.parse_markdown_code(opt["source_code"], expected_language=language)
             if not code.code_strings:
                 continue
             candidates.append(
@@ -199,7 +202,7 @@ def optimize_code(  # noqa: D417
             logger.debug(f"!lsp|Generating possible optimizations took {end_time - start_time:.2f} seconds.")
             logger.info(f"!lsp|Received {len(optimizations_json)} optimization candidates.")
             console.rule()
-            return self._get_valid_candidates(optimizations_json, OptimizedCandidateSource.OPTIMIZE)
+            return self._get_valid_candidates(optimizations_json, OptimizedCandidateSource.OPTIMIZE, language)
         try:
             error = response.json()["error"]
         except Exception:
@@ -399,6 +402,7 @@ def code_repair(self, request: AIServiceCodeRepairRequest) -> OptimizedCandidate
                 "modified_source_code": request.modified_source_code,
                 "trace_id": request.trace_id,
                 "test_diffs": request.test_diffs,
+                "language": request.language,
             }
             response = self.make_ai_service_request("/code_repair", payload=payload, timeout=self.timeout)
         except (requests.exceptions.RequestException, TypeError) as e:
@@ -410,7 +414,9 @@ def code_repair(self, request: AIServiceCodeRepairRequest) -> OptimizedCandidate
             fixed_optimization = response.json()
             console.rule()
 
-            valid_candidates = self._get_valid_candidates([fixed_optimization], OptimizedCandidateSource.REPAIR)
+            valid_candidates = self._get_valid_candidates(
+                [fixed_optimization], OptimizedCandidateSource.REPAIR, request.language
+            )
             if not valid_candidates:
                 logger.error("Code repair failed to generate a valid candidate.")
                 return None
@@ -721,6 +727,7 @@ def get_optimization_review(
         replay_tests: str,
         concolic_tests: str,  # noqa: ARG002
         calling_fn_details: str,
+        language: str = "python",
     ) -> OptimizationReviewResult:
         """Compute the optimization review of current Pull Request.
 
@@ -762,7 +769,8 @@ def get_optimization_review(
             "original_runtime": humanize_runtime(explanation.original_runtime_ns),
             "codeflash_version": codeflash_version,
             "calling_fn_details": calling_fn_details,
-            "python_version": platform.python_version(),
+            "language": language,
+            "python_version": platform.python_version() if language == "python" else None,
             "call_sequence": self.get_next_sequence(),
         }
         console.rule()

codeflash/code_utils/code_replacer.py

@@ -498,7 +498,7 @@ def replace_function_definitions_for_language(
     from codeflash.languages import get_language_support
     from codeflash.languages.base import FunctionInfo, Language, ParentInfo
 
-    source_code: str = module_abspath.read_text(encoding="utf8")
+    original_source_code: str = module_abspath.read_text(encoding="utf8")
     code_to_apply = get_optimized_code_for_module(module_abspath.relative_to(project_root_path), optimized_code)
 
     if not code_to_apply.strip():
@@ -522,24 +522,24 @@ def replace_function_definitions_for_language(
             is_async=function_to_optimize.is_async,
             language=language,
         )
-        new_code = lang_support.replace_function(source_code, func_info, code_to_apply)
+        new_code = lang_support.replace_function(original_source_code, func_info, code_to_apply)
     else:
         # Fallback: find function in source and replace
         # This is less precise but works when we don't have line info
         functions = lang_support.discover_functions(module_abspath)
+        new_code = original_source_code
         for func in functions:
             qualified_name = func.qualified_name
             if qualified_name in function_names or func.name in function_names:
-                new_code = lang_support.replace_function(source_code, func, code_to_apply)
-                source_code = new_code  # Continue with modified source for multiple replacements
+                new_code = lang_support.replace_function(new_code, func, code_to_apply)
                 break
         else:
             # No matching function found
             logger.warning(f"Could not find function {function_names} in {module_abspath}")
             return False
 
     # Check if there was actually a change
-    if source_code.strip() == new_code.strip():
+    if original_source_code.strip() == new_code.strip():
         return False
 
     module_abspath.write_text(new_code, encoding="utf8")
@@ -550,12 +550,18 @@ def get_optimized_code_for_module(relative_path: Path, optimized_code: CodeStrin
     file_to_code_context = optimized_code.file_to_path()
     module_optimized_code = file_to_code_context.get(str(relative_path))
     if module_optimized_code is None:
-        logger.warning(
-            f"Optimized code not found for {relative_path} In the context\n-------\n{optimized_code}\n-------\n"
-            "re-check your 'markdown code structure'"
-            f"existing files are {file_to_code_context.keys()}"
-        )
-        module_optimized_code = ""
+        # Fallback for JavaScript/TypeScript: if there's only one code block with None file path,
+        # use it regardless of the expected path (the AI server doesn't always include file paths)
+        if "None" in file_to_code_context and len(file_to_code_context) == 1:
+            module_optimized_code = file_to_code_context["None"]
+            logger.debug(f"Using code block with None file_path for {relative_path}")
+        else:
+            logger.warning(
+                f"Optimized code not found for {relative_path} In the context\n-------\n{optimized_code}\n-------\n"
+                "re-check your 'markdown code structure'"
+                f"existing files are {file_to_code_context.keys()}"
+            )
+            module_optimized_code = ""
     return module_optimized_code
 
 

codeflash/code_utils/deduplicate_code.py

@@ -155,21 +155,22 @@ def visit_With(self, node):  # noqa : ANN001, ANN201
 
 
 def normalize_code(code: str, remove_docstrings: bool = True, return_ast_dump: bool = False) -> str:  # noqa : FBT002, FBT001
-    """Normalize Python code by parsing, cleaning, and normalizing only variable names.
+    """Normalize code by parsing, cleaning, and normalizing only variable names.
 
     Function names, class names, and parameters are preserved.
+    For non-Python code (JavaScript, TypeScript), falls back to basic whitespace normalization.
 
     Args:
-        code: Python source code as string
-        remove_docstrings: Whether to remove docstrings
-        return_ast_dump: return_ast_dump
+        code: Source code as string
+        remove_docstrings: Whether to remove docstrings (Python only)
+        return_ast_dump: return_ast_dump (Python only)
 
     Returns:
         Normalized code as string
 
     """
     try:
-        # Parse the code
+        # Parse the code (Python-specific)
         tree = ast.parse(code)
 
         # Remove docstrings if requested
@@ -188,9 +189,10 @@ def normalize_code(code: str, remove_docstrings: bool = True, return_ast_dump: b
 
         # Unparse back to code
         return ast.unparse(normalized_tree)
-    except SyntaxError as e:
-        msg = f"Invalid Python syntax: {e}"
-        raise ValueError(msg) from e
+    except SyntaxError:
+        # Non-Python code (JavaScript, TypeScript, etc.) - use basic whitespace normalization
+        # This still allows duplicate detection to work
+        return " ".join(code.split())
 
 
 def remove_docstrings_from_ast(node):  # noqa : ANN001, ANN201

codeflash/context/unused_definition_remover.py

@@ -722,6 +722,11 @@ def detect_unused_helper_functions(
         List of FunctionSource objects representing unused helper functions
 
     """
+    # Skip this analysis for non-Python languages since we use Python's ast module
+    if function_to_optimize.language in ("javascript", "typescript"):
+        logger.debug("Skipping unused helper function detection for JavaScript/TypeScript")
+        return []
+
     if isinstance(optimized_code, CodeStringsMarkdown) and len(optimized_code.code_strings) > 0:
         return list(
             chain.from_iterable(

codeflash/languages/javascript/runtime/codeflash-jest-helper.js

@@ -65,19 +65,20 @@ let db = null;
 
 /**
  * Get high-resolution time in nanoseconds.
- * Prefers process.hrtime.bigint() for nanosecond precision,
- * falls back to performance.now() * 1e6 for non-Node environments.
+ * Cached at module load time for minimal overhead during timing.
  *
- * @returns {bigint|number} - Time in nanoseconds
+ * @returns {bigint} - Time in nanoseconds
  */
-function getTimeNs() {
+const getTimeNs = (() => {
+    // Determine timing method once at module load, not on every call
     if (typeof process !== 'undefined' && process.hrtime && process.hrtime.bigint) {
-        return process.hrtime.bigint();
+        // Node.js with BigInt hrtime support - fastest, most precise
+        return () => process.hrtime.bigint();
     }
-    // Fallback to performance.now() in milliseconds, converted to nanoseconds
+    // Fallback: pre-import performance module once
     const { performance } = require('perf_hooks');
-    return BigInt(Math.floor(performance.now() * 1_000_000));
-}
+    return () => BigInt(Math.floor(performance.now() * 1_000_000));
+})();
 
 /**
  * Calculate duration in nanoseconds.

codeflash/models/models.py

@@ -93,6 +93,7 @@ class AIServiceCodeRepairRequest:
     modified_source_code: str
     trace_id: str
     test_diffs: list[TestDiff]
+    language: str = "python"
 
 
 class OptimizationReviewResult(NamedTuple):
@@ -226,7 +227,9 @@ def validate_code_syntax(self) -> "CodeString":
         return self
 
 
-def get_code_block_splitter(file_path: Path) -> str:
+def get_code_block_splitter(file_path: Path | None) -> str:
+    if file_path is None:
+        return ""
     return f"# file: {file_path.as_posix()}"
 
 

codeflash/optimization/function_optimizer.py

@@ -848,10 +848,14 @@ def handle_successful_candidate(
 
         Returns the BestOptimization and optional benchmark tree.
         """
-        with progress_bar("Running line-by-line profiling"):
-            line_profile_test_results = self.line_profiler_step(
-                code_context=code_context, original_helper_code=original_helper_code, candidate_index=candidate_index
-            )
+        # Skip line profiling for JavaScript/TypeScript until implementation is ready
+        if self.function_to_optimize.language in ("javascript", "typescript"):
+            line_profile_test_results = {"timings": {}, "unit": 0, "str_out": ""}
+        else:
+            with progress_bar("Running line-by-line profiling"):
+                line_profile_test_results = self.line_profiler_step(
+                    code_context=code_context, original_helper_code=original_helper_code, candidate_index=candidate_index
+                )
 
         eval_ctx.record_line_profiler_result(candidate.optimization_id, line_profile_test_results["str_out"])
 
@@ -1314,13 +1318,15 @@ def repair_optimization(
         optimization_id: str,
         ai_service_client: AiServiceClient,
         executor: concurrent.futures.ThreadPoolExecutor,
+        language: str = "python",
     ) -> concurrent.futures.Future[OptimizedCandidate | None]:
         request = AIServiceCodeRepairRequest(
             optimization_id=optimization_id,
             original_source_code=original_source_code,
             modified_source_code=modified_source_code,
             test_diffs=test_diffs,
             trace_id=trace_id,
+            language=language,
         )
         return executor.submit(ai_service_client.code_repair, request=request)
 
@@ -2016,6 +2022,7 @@ def process_review(
             "coverage_message": coverage_message,
             "replay_tests": replay_tests,
             "concolic_tests": concolic_tests,
+            "language": self.function_to_optimize.language,
         }
 
         raise_pr = not self.args.no_pr
@@ -2058,7 +2065,9 @@ def process_review(
             if "root_dir" not in data:
                 data["root_dir"] = git_root_dir()
             data["git_remote"] = self.args.git_remote
-            check_create_pr(**data)
+            # Remove language from data dict as check_create_pr doesn't accept it
+            pr_data = {k: v for k, v in data.items() if k != "language"}
+            check_create_pr(**pr_data)
         elif staging_review:
             response = create_staging(**data)
             if response.status_code == 200:
@@ -2178,7 +2187,7 @@ def establish_original_code_baseline(
 
         # Skip line profiler for JavaScript/TypeScript (not yet supported)
         if self.function_to_optimize.language in ("javascript", "typescript"):
-            line_profile_results = None
+            line_profile_results = {"timings": {}, "unit": 0, "str_out": ""}
         else:
             with progress_bar("Running line profiler to identify performance bottlenecks..."):
                 line_profile_results = self.line_profiler_step(
@@ -2318,6 +2327,7 @@ def repair_if_possible(
                 ai_service_client=ai_service_client,
                 optimization_id=candidate.optimization_id,
                 executor=self.executor,
+                language=self.function_to_optimize.language,
             )
         )
 
@@ -2386,17 +2396,25 @@ def run_optimized_candidate(
 
             # Use language-appropriate comparison
             if self.function_to_optimize.language in ("javascript", "typescript"):
-                # JavaScript: Compare using Node.js script (handles Map, Set, Date, etc. natively)
-                from codeflash.verification.equivalence import compare_javascript_test_results
-                from codeflash.code_utils.code_utils import get_run_tmp_file
-
+                # JavaScript: Compare using SQLite results if available, otherwise compare test pass/fail
                 original_sqlite = get_run_tmp_file(Path("test_return_values_0.sqlite"))
                 candidate_sqlite = get_run_tmp_file(Path(f"test_return_values_{optimization_candidate_index}.sqlite"))
-                match, diffs = compare_javascript_test_results(original_sqlite, candidate_sqlite)
 
-                # Cleanup SQLite files after comparison (deferred from parse_test_results)
-                candidate_sqlite.unlink(missing_ok=True)
-                # Keep original_sqlite for comparing with other candidates
+                if original_sqlite.exists() and candidate_sqlite.exists():
+                    # Full comparison using captured return values
+                    from codeflash.verification.equivalence import compare_javascript_test_results
+
+                    match, diffs = compare_javascript_test_results(original_sqlite, candidate_sqlite)
+                    # Cleanup SQLite files after comparison
+                    candidate_sqlite.unlink(missing_ok=True)
+                else:
+                    # Fallback: compare test pass/fail status (tests aren't instrumented yet)
+                    # If all tests that passed for original also pass for candidate, consider it a match
+                    if not candidate_sqlite.exists():
+                        logger.error(f"Candidate SQLite database not found: {candidate_sqlite}")
+                    logger.debug("No diffs found, skipping repair")
+                    # Use Python-style comparison on TestResults as fallback
+                    match, diffs = compare_test_results(baseline_results.behavior_test_results, candidate_behavior_results)
             else:
                 # Python: Compare using Python comparator
                 match, diffs = compare_test_results(baseline_results.behavior_test_results, candidate_behavior_results)
@@ -2503,6 +2521,8 @@ def run_and_parse_tests(
                     test_env=test_env,
                     pytest_timeout=INDIVIDUAL_TESTCASE_TIMEOUT,
                     enable_coverage=enable_coverage,
+                    js_project_root=self.test_cfg.js_project_root,
+                    candidate_index=optimization_iteration,
                 )
             elif testing_type == TestingMode.LINE_PROFILE:
                 result_file_path, run_result = run_line_profile_tests(
@@ -2527,6 +2547,7 @@ def run_and_parse_tests(
                     pytest_min_loops=pytest_min_loops,
                     pytest_max_loops=pytest_max_loops,
                     test_framework=self.test_cfg.test_framework,
+                    js_project_root=self.test_cfg.js_project_root,
                 )
             else:
                 msg = f"Unexpected testing type: {testing_type}"