fix: add Jest 30 support and fix time limit in loop-runner

code_to_optimize/js/code_to_optimize_js/bubble_sort.js

@@ -11,14 +11,21 @@ function bubbleSort(arr) {
     const result = arr.slice();
     const n = result.length;
 
-    for (let i = 0; i < n; i++) {
-        for (let j = 0; j < n - 1; j++) {
-            if (result[j] > result[j + 1]) {
-                const temp = result[j];
-                result[j] = result[j + 1];
-                result[j + 1] = temp;
+    if (n <= 1) return result;
+
+    for (let i = 0; i < n - 1; i++) {
+        let swapped = false;
+        const limit = n - i - 1;
+        for (let j = 0; j < limit; j++) {
+            const a = result[j];
+            const b = result[j + 1];
+            if (a > b) {
+                result[j] = b;
+                result[j + 1] = a;
+                swapped = true;
             }
         }
+        if (!swapped) break;
     }
 
     return result;

codeflash/code_utils/code_utils.py

@@ -37,44 +37,32 @@ def is_glob_pattern(path_str: str) -> bool:
 
 
 def normalize_ignore_paths(paths: list[str], base_path: Path | None = None) -> list[Path]:
-    """Normalize ignore paths, expanding glob patterns and resolving paths.
-
-    Accepts a list of path strings that can be either:
-    - Literal paths (relative or absolute): e.g., "node_modules", "/absolute/path"
-    - Glob patterns: e.g., "**/*.test.js", "dist/*", "*.log"
-
-    Args:
-        paths: List of path strings (literal paths or glob patterns).
-        base_path: Base path for resolving relative paths and patterns.
-                   If None, uses current working directory.
-
-    Returns:
-        List of resolved Path objects, deduplicated.
-
-    """
     if base_path is None:
         base_path = Path.cwd()
 
     base_path = base_path.resolve()
     normalized: set[Path] = set()
 
     for path_str in paths:
+        if not path_str:
+            continue
+
+        path_str = str(path_str)
+
         if is_glob_pattern(path_str):
-            # It's a glob pattern - expand it
-            # Use base_path as the root for glob expansion
-            pattern_path = base_path / path_str
-            # glob returns an iterator of matching paths
+            # pathlib requires relative glob patterns
+            path_str = path_str.removeprefix("./")
+            if path_str.startswith("/"):
+                path_str = path_str.lstrip("/")
+
             for matched_path in base_path.glob(path_str):
-                if matched_path.exists():
-                    normalized.add(matched_path.resolve())
+                normalized.add(matched_path.resolve())
         else:
-            # It's a literal path
             path_obj = Path(path_str)
             if not path_obj.is_absolute():
                 path_obj = base_path / path_obj
             if path_obj.exists():
                 normalized.add(path_obj.resolve())
-            # Silently skip non-existent literal paths (e.g., .next, dist before build)
 
     return list(normalized)
 

codeflash/code_utils/time_utils.py

@@ -1,10 +1,5 @@
 from __future__ import annotations
 
-import datetime as dt
-import re
-
-import humanize
-
 
 def humanize_runtime(time_in_ns: int) -> str:
     runtime_human: str = str(time_in_ns)
@@ -14,22 +9,32 @@ def humanize_runtime(time_in_ns: int) -> str:
 
     if time_in_ns / 1000 >= 1:
         time_micro = float(time_in_ns) / 1000
-        runtime_human = humanize.precisedelta(dt.timedelta(microseconds=time_micro), minimum_unit="microseconds")
 
-        units = re.split(r",|\s", runtime_human)[1]
-
-        if units in {"microseconds", "microsecond"}:
+        # Direct unit determination and formatting without external library
+        if time_micro < 1000:
             runtime_human = f"{time_micro:.3g}"
-        elif units in {"milliseconds", "millisecond"}:
-            runtime_human = "%.3g" % (time_micro / 1000)
-        elif units in {"seconds", "second"}:
-            runtime_human = "%.3g" % (time_micro / (1000**2))
-        elif units in {"minutes", "minute"}:
-            runtime_human = "%.3g" % (time_micro / (60 * 1000**2))
-        elif units in {"hour", "hours"}:  # hours
-            runtime_human = "%.3g" % (time_micro / (3600 * 1000**2))
+            units = "microseconds" if time_micro >= 2 else "microsecond"
+        elif time_micro < 1000000:
+            time_milli = time_micro / 1000
+            runtime_human = f"{time_milli:.3g}"
+            units = "milliseconds" if time_milli >= 2 else "millisecond"
+        elif time_micro < 60000000:
+            time_sec = time_micro / 1000000
+            runtime_human = f"{time_sec:.3g}"
+            units = "seconds" if time_sec >= 2 else "second"
+        elif time_micro < 3600000000:
+            time_min = time_micro / 60000000
+            runtime_human = f"{time_min:.3g}"
+            units = "minutes" if time_min >= 2 else "minute"
+        elif time_micro < 86400000000:
+            time_hour = time_micro / 3600000000
+            runtime_human = f"{time_hour:.3g}"
+            units = "hours" if time_hour >= 2 else "hour"
         else:  # days
-            runtime_human = "%.3g" % (time_micro / (24 * 3600 * 1000**2))
+            time_day = time_micro / 86400000000
+            runtime_human = f"{time_day:.3g}"
+            units = "days" if time_day >= 2 else "day"
+
     runtime_human_parts = str(runtime_human).split(".")
     if len(runtime_human_parts[0]) == 1:
         if runtime_human_parts[0] == "1" and len(runtime_human_parts) > 1:

codeflash/github/PrComment.py

@@ -45,8 +45,8 @@ def to_json(self) -> dict[str, Union[str, int, dict[str, dict[str, int]], list[B
         }
 
         if self.original_async_throughput is not None and self.best_async_throughput is not None:
-            result["original_async_throughput"] = str(self.original_async_throughput)
-            result["best_async_throughput"] = str(self.best_async_throughput)
+            result["original_async_throughput"] = self.original_async_throughput
+            result["best_async_throughput"] = self.best_async_throughput
 
         return result