error handling and node path in comparator

Saga4 · Saga4 · commit 99587353a64d · 2026-01-21T21:49:05.000+05:30
diff --git a/code_to_optimize_js/codeflash-compare-results.js b/code_to_optimize_js/codeflash-compare-results.js
@@ -37,12 +37,14 @@ let Database;
 try {
     Database = require('better-sqlite3');
 } catch (e) {
-    console.error(JSON.stringify({
+    // Use console.log (stdout) for JSON output, not console.error (stderr)
+    // Exit code 2 indicates a setup error (distinct from 1 = "not equivalent")
+    console.log(JSON.stringify({
         equivalent: false,
         diffs: [],
-        error: 'better-sqlite3 not installed'
+        error: 'better-sqlite3 not installed. Run: npm install better-sqlite3'
     }));
-    process.exit(1);
+    process.exit(2);
 }
 
 /**
diff --git a/code_to_optimize_js/package.json b/code_to_optimize_js/package.json
@@ -7,6 +7,12 @@
     "test": "jest",
     "test:coverage": "jest --coverage"
   },
+  "codeflash": {
+    "moduleRoot": ".",
+    "testsRoot": "tests",
+    "language": "javascript",
+    "formatterCmds": ["npx prettier --write $file"]
+  },
   "keywords": [
     "codeflash",
     "optimization",
diff --git a/codeflash/languages/base.py b/codeflash/languages/base.py
@@ -505,12 +505,18 @@ def remove_test_functions(self, test_source: str, functions_to_remove: list[str]
 
     # === Test Result Comparison ===
 
-    def compare_test_results(self, original_results_path: Path, candidate_results_path: Path) -> tuple[bool, list]:
+    def compare_test_results(
+        self,
+        original_results_path: Path,
+        candidate_results_path: Path,
+        project_root: Path | None = None,
+    ) -> tuple[bool, list]:
         """Compare test results between original and candidate code.
 
         Args:
             original_results_path: Path to original test results (e.g., SQLite DB).
             candidate_results_path: Path to candidate test results.
+            project_root: Project root directory (for finding node_modules, etc.).
 
         Returns:
             Tuple of (are_equivalent, list of TestDiff objects).
diff --git a/codeflash/languages/javascript/comparator.py b/codeflash/languages/javascript/comparator.py
@@ -7,6 +7,7 @@
 from __future__ import annotations
 
 import json
+import os
 import subprocess
 from pathlib import Path
 
@@ -19,6 +20,7 @@ def compare_test_results(
     original_sqlite_path: Path,
     candidate_sqlite_path: Path,
     comparator_script: Path | None = None,
+    project_root: Path | None = None,
 ) -> tuple[bool, list[TestDiff]]:
     """Compare JavaScript test results using the Node.js comparator.
 
@@ -32,6 +34,7 @@ def compare_test_results(
         original_sqlite_path: Path to SQLite database with original code results.
         candidate_sqlite_path: Path to SQLite database with candidate code results.
         comparator_script: Optional path to the comparison script.
+        project_root: Project root directory where node_modules is installed.
 
     Returns:
         Tuple of (all_equivalent, list of TestDiff objects).
@@ -50,29 +53,61 @@ def compare_test_results(
         logger.error(f"Candidate SQLite database not found: {candidate_sqlite_path}")
         return False, []
 
+    # Determine working directory - should be where node_modules is installed
+    # The script needs better-sqlite3 which is installed in the project's node_modules
+    cwd = project_root or Path.cwd()
+
+    # Set NODE_PATH to include the project's node_modules
+    # This is needed because the script runs from the codeflash package directory,
+    # but needs to resolve modules from the project's node_modules
+    env = os.environ.copy()
+    node_modules_path = cwd / "node_modules"
+    if node_modules_path.exists():
+        existing_node_path = env.get("NODE_PATH", "")
+        if existing_node_path:
+            env["NODE_PATH"] = f"{node_modules_path}:{existing_node_path}"
+        else:
+            env["NODE_PATH"] = str(node_modules_path)
+
     try:
         result = subprocess.run(
             ["node", str(script_path), str(original_sqlite_path), str(candidate_sqlite_path)],
             check=False,
             capture_output=True,
             text=True,
             timeout=60,
+            cwd=str(cwd),
+            env=env,
         )
 
-        # Parse the JSON output
+        # Parse the JSON output first - errors are reported in JSON too
         try:
+            if not result.stdout or not result.stdout.strip():
+                logger.error("JavaScript comparator returned empty output")
+                if result.stderr:
+                    logger.error(f"stderr: {result.stderr}")
+                return False, []
             comparison = json.loads(result.stdout)
         except json.JSONDecodeError as e:
             logger.error(f"Failed to parse JavaScript comparator output: {e}")
-            logger.debug(f"stdout: {result.stdout}")
-            logger.debug(f"stderr: {result.stderr}")
+            logger.error(f"stdout: {result.stdout[:500] if result.stdout else '(empty)'}")
+            if result.stderr:
+                logger.error(f"stderr: {result.stderr[:500]}")
             return False, []
 
-        # Check for errors
+        # Check for errors in the JSON response
+        # Exit code 0 = equivalent, 1 = not equivalent, 2 = setup error
         if comparison.get("error"):
             logger.error(f"JavaScript comparator error: {comparison['error']}")
             return False, []
 
+        # Check for unexpected exit codes (not 0 or 1)
+        if result.returncode != 0 and result.returncode != 1:
+            logger.error(f"JavaScript comparator failed with exit code {result.returncode}")
+            if result.stderr:
+                logger.error(f"stderr: {result.stderr}")
+            return False, []
+
         # Convert diffs to TestDiff objects
         test_diffs: list[TestDiff] = []
         for diff in comparison.get("diffs", []):
diff --git a/codeflash/languages/javascript/runtime/codeflash-compare-results.js b/codeflash/languages/javascript/runtime/codeflash-compare-results.js
@@ -37,12 +37,14 @@ let Database;
 try {
     Database = require('better-sqlite3');
 } catch (e) {
-    console.error(JSON.stringify({
+    // Use console.log (stdout) for JSON output, not console.error (stderr)
+    // Exit code 2 indicates a setup error (distinct from 1 = "not equivalent")
+    console.log(JSON.stringify({
         equivalent: false,
         diffs: [],
-        error: 'better-sqlite3 not installed'
+        error: 'better-sqlite3 not installed. Run: npm install better-sqlite3'
     }));
-    process.exit(1);
+    process.exit(2);
 }
 
 /**
diff --git a/codeflash/languages/javascript/support.py b/codeflash/languages/javascript/support.py
@@ -902,20 +902,26 @@ def remove_test_functions(self, test_source: str, functions_to_remove: list[str]
 
     # === Test Result Comparison ===
 
-    def compare_test_results(self, original_results_path: Path, candidate_results_path: Path) -> tuple[bool, list]:
+    def compare_test_results(
+        self,
+        original_results_path: Path,
+        candidate_results_path: Path,
+        project_root: Path | None = None,
+    ) -> tuple[bool, list]:
         """Compare test results between original and candidate code.
 
         Args:
             original_results_path: Path to original test results SQLite DB.
             candidate_results_path: Path to candidate test results SQLite DB.
+            project_root: Project root directory where node_modules is installed.
 
         Returns:
             Tuple of (are_equivalent, list of TestDiff objects).
 
         """
         from codeflash.languages.javascript.comparator import compare_test_results
 
-        return compare_test_results(original_results_path, candidate_results_path)
+        return compare_test_results(original_results_path, candidate_results_path, project_root=project_root)
 
     # === Configuration ===
 
diff --git a/codeflash/lsp/features/perform_optimization.py b/codeflash/lsp/features/perform_optimization.py
@@ -35,6 +35,7 @@ def sync_perform_optimization(server: CodeflashLanguageServer, cancel_event: thr
         code_context.read_writable_code.flat,
         file_name=current_function.file_path,
         function_name=current_function.function_name,
+        language=current_function.language,
     )
     abort_if_cancelled(cancel_event)
 
diff --git a/codeflash/optimization/function_optimizer.py b/codeflash/optimization/function_optimizer.py
@@ -2536,7 +2536,9 @@ def run_optimized_candidate(
 
                 if original_sqlite.exists() and candidate_sqlite.exists():
                     # Full comparison using captured return values via language support
-                    match, diffs = self.language_support.compare_test_results(original_sqlite, candidate_sqlite)
+                    match, diffs = self.language_support.compare_test_results(
+                        original_sqlite, candidate_sqlite, project_root=self.args.project_root
+                    )
                     # Cleanup SQLite files after comparison
                     candidate_sqlite.unlink(missing_ok=True)
                 else:

Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,7 @@ def sync_perform_optimization(server: CodeflashLanguageServer, cancel_event: thr`
`35`	`35`	`code_context.read_writable_code.flat,`
`36`	`36`	`file_name=current_function.file_path,`
`37`	`37`	`function_name=current_function.function_name,`
	`38`	`+ language=current_function.language,`
`38`	`39`	`)`
`39`	`40`	`abort_if_cancelled(cancel_event)`
`40`	`41`