Merge branch 'main' into fix/marker-matching-function-name

Author: Saga4

codeflash/cli_cmds/cli.py

@@ -359,11 +359,13 @@ def _handle_show_config() -> None:
     detected = detect_project(project_root)
 
     # Check if config exists or is auto-detected
-    config_exists, _ = has_existing_config(project_root)
+    config_exists, config_file = has_existing_config(project_root)
     status = "Saved config" if config_exists else "Auto-detected (not saved)"
 
     console.print()
     console.print(f"[bold]Codeflash Configuration[/bold] ({status})")
+    if config_exists and config_file:
+        console.print(f"[dim]Config file: {project_root / config_file}[/dim]")
     console.print()
 
     table = Table(show_header=True, header_style="bold cyan")

codeflash/code_utils/config_js.py

@@ -6,6 +6,8 @@
 from pathlib import Path
 from typing import Any
 
+from codeflash.setup.detector import is_build_output_dir
+
 PACKAGE_JSON_CACHE: dict[Path, Path] = {}
 PACKAGE_JSON_DATA_CACHE: dict[Path, dict[str, Any]] = {}
 
@@ -50,12 +52,15 @@ def detect_module_root(project_root: Path, package_data: dict[str, Any]) -> str:
     """Detect module root from package.json fields or directory conventions.
 
     Detection order:
-    1. package.json "exports" field (extract directory from main export)
-    2. package.json "module" field (ESM entry point)
-    3. package.json "main" field (CJS entry point)
-    4. "src/" directory if it exists
+    1. src/, lib/, source/ directories (common source directories)
+    2. package.json "exports" field (if not in build output directory)
+    3. package.json "module" field (ESM, if not in build output directory)
+    4. package.json "main" field (CJS, if not in build output directory)
     5. Fall back to "." (project root)
 
+    Build output directories (build/, dist/, out/) are skipped since they contain
+    compiled code, not source files.
+
     Args:
         project_root: Root directory of the project.
         package_data: Parsed package.json data.
@@ -64,6 +69,11 @@ def detect_module_root(project_root: Path, package_data: dict[str, Any]) -> str:
         Detected module root path (relative to project root).
 
     """
+    # Check for common source directories first - these are always preferred
+    for src_dir in ["src", "lib", "source"]:
+        if (project_root / src_dir).is_dir():
+            return src_dir
+
     # Check exports field (modern Node.js)
     exports = package_data.get("exports")
     if exports:
@@ -80,27 +90,38 @@ def detect_module_root(project_root: Path, package_data: dict[str, Any]) -> str:
 
         if entry_path and isinstance(entry_path, str):
             parent = Path(entry_path).parent
-            if parent != Path() and (project_root / parent).is_dir():
+            if (
+                parent != Path()
+                and parent.as_posix() != "."
+                and (project_root / parent).is_dir()
+                and not is_build_output_dir(parent)
+            ):
                 return parent.as_posix()
 
     # Check module field (ESM)
     module_field = package_data.get("module")
     if module_field and isinstance(module_field, str):
         parent = Path(module_field).parent
-        if parent != Path() and (project_root / parent).is_dir():
+        if (
+            parent != Path()
+            and parent.as_posix() != "."
+            and (project_root / parent).is_dir()
+            and not is_build_output_dir(parent)
+        ):
             return parent.as_posix()
 
     # Check main field (CJS)
     main_field = package_data.get("main")
     if main_field and isinstance(main_field, str):
         parent = Path(main_field).parent
-        if parent != Path() and (project_root / parent).is_dir():
+        if (
+            parent != Path()
+            and parent.as_posix() != "."
+            and (project_root / parent).is_dir()
+            and not is_build_output_dir(parent)
+        ):
             return parent.as_posix()
 
-    # Check for src/ directory convention
-    if (project_root / "src").is_dir():
-        return "src"
-
     # Default to project root
     return "."
 

codeflash/languages/javascript/module_system.py

@@ -222,6 +222,7 @@ def _convert_destructuring_to_imports(names_str: str) -> str:
 
     Returns:
         Import names string with aliases using 'as' syntax
+
     """
     # Split by commas and process each name
     parts = []

codeflash/setup/detector.py

@@ -21,6 +21,8 @@
 
 import tomlkit
 
+_BUILD_DIRS = frozenset({"build", "dist", "out", ".next", ".nuxt"})
+
 
 @dataclass
 class DetectedProject:
@@ -310,14 +312,21 @@ def _detect_js_module_root(project_root: Path) -> tuple[Path, str]:
     """Detect JavaScript/TypeScript module root.
 
     Priority:
-    1. package.json "exports" field
-    2. package.json "module" field (ESM)
-    3. package.json "main" field (CJS)
-    4. src/ directory
-    5. lib/ directory
-    6. Project root
+    1. src/, lib/, source/ directories (common source directories)
+    2. package.json "exports" field (if not in build output directory)
+    3. package.json "module" field (ESM, if not in build output directory)
+    4. package.json "main" field (CJS, if not in build output directory)
+    5. Project root
+
+    Build output directories (build/, dist/, out/) are skipped since they contain
+    compiled code, not source files.
 
     """
+    # Check for common source directories first - these are always preferred
+    for src_dir in ["src", "lib", "source"]:
+        if (project_root / src_dir).is_dir():
+            return project_root / src_dir, f"{src_dir}/ directory"
+
     package_json_path = project_root / "package.json"
     package_data: dict[str, Any] = {}
 
@@ -334,32 +343,52 @@ def _detect_js_module_root(project_root: Path) -> tuple[Path, str]:
         entry_path = _extract_entry_path(exports)
         if entry_path:
             parent = Path(entry_path).parent
-            if parent != Path() and parent.as_posix() != "." and (project_root / parent).is_dir():
+            if (
+                parent != Path()
+                and parent.as_posix() != "."
+                and (project_root / parent).is_dir()
+                and not is_build_output_dir(parent)
+            ):
                 return project_root / parent, f'{parent.as_posix()}/ (from package.json "exports")'
 
     # Check module field (ESM)
     module_field = package_data.get("module")
     if module_field and isinstance(module_field, str):
         parent = Path(module_field).parent
-        if parent != Path() and parent.as_posix() != "." and (project_root / parent).is_dir():
+        if (
+            parent != Path()
+            and parent.as_posix() != "."
+            and (project_root / parent).is_dir()
+            and not is_build_output_dir(parent)
+        ):
             return project_root / parent, f'{parent.as_posix()}/ (from package.json "module")'
 
     # Check main field (CJS)
     main_field = package_data.get("main")
     if main_field and isinstance(main_field, str):
         parent = Path(main_field).parent
-        if parent != Path() and parent.as_posix() != "." and (project_root / parent).is_dir():
+        if (
+            parent != Path()
+            and parent.as_posix() != "."
+            and (project_root / parent).is_dir()
+            and not is_build_output_dir(parent)
+        ):
             return project_root / parent, f'{parent.as_posix()}/ (from package.json "main")'
 
-    # Check for common source directories
-    for src_dir in ["src", "lib", "source"]:
-        if (project_root / src_dir).is_dir():
-            return project_root / src_dir, f"{src_dir}/ directory"
-
     # Default to project root
     return project_root, "project root"
 
 
+def is_build_output_dir(path: Path) -> bool:
+    """Check if a path is within a common build output directory.
+
+    Build output directories contain compiled code and should be skipped
+    in favor of source directories.
+
+    """
+    return not _BUILD_DIRS.isdisjoint(path.parts)
+
+
 def _extract_entry_path(exports: Any) -> str | None:
     """Extract entry path from package.json exports field."""
     if isinstance(exports, str):

packages/codeflash/runtime/__tests__/dynamic-env-vars.test.js

@@ -0,0 +1,73 @@
+/**
+ * Test: Dynamic environment variable reading
+ *
+ * This test verifies that the performance configuration functions read
+ * environment variables at runtime rather than at module load time.
+ *
+ * This is critical for Vitest compatibility, where modules may be cached
+ * and loaded before environment variables are set.
+ *
+ * Run with: node __tests__/dynamic-env-vars.test.js
+ */
+
+const assert = require('assert');
+
+// Clear any existing env vars before loading the module
+delete process.env.CODEFLASH_PERF_LOOP_COUNT;
+delete process.env.CODEFLASH_PERF_MIN_LOOPS;
+delete process.env.CODEFLASH_PERF_TARGET_DURATION_MS;
+delete process.env.CODEFLASH_PERF_BATCH_SIZE;
+delete process.env.CODEFLASH_PERF_STABILITY_CHECK;
+delete process.env.CODEFLASH_PERF_CURRENT_BATCH;
+
+// Now load the module - at this point env vars are not set
+const capture = require('../capture');
+
+console.log('Testing dynamic environment variable reading...\n');
+
+// Test 1: Default values when env vars are not set
+console.log('Test 1: Default values');
+assert.strictEqual(capture.getPerfLoopCount(), 1, 'getPerfLoopCount default should be 1');
+assert.strictEqual(capture.getPerfMinLoops(), 5, 'getPerfMinLoops default should be 5');
+assert.strictEqual(capture.getPerfTargetDurationMs(), 10000, 'getPerfTargetDurationMs default should be 10000');
+assert.strictEqual(capture.getPerfBatchSize(), 10, 'getPerfBatchSize default should be 10');
+assert.strictEqual(capture.getPerfStabilityCheck(), false, 'getPerfStabilityCheck default should be false');
+assert.strictEqual(capture.getPerfCurrentBatch(), 0, 'getPerfCurrentBatch default should be 0');
+console.log('  PASS: All defaults correct\n');
+
+// Test 2: Values change when env vars are set AFTER module load
+// This is the critical test - if these were constants, they would still return defaults
+console.log('Test 2: Dynamic reading after module load');
+process.env.CODEFLASH_PERF_LOOP_COUNT = '100';
+process.env.CODEFLASH_PERF_MIN_LOOPS = '10';
+process.env.CODEFLASH_PERF_TARGET_DURATION_MS = '5000';
+process.env.CODEFLASH_PERF_BATCH_SIZE = '20';
+process.env.CODEFLASH_PERF_STABILITY_CHECK = 'true';
+process.env.CODEFLASH_PERF_CURRENT_BATCH = '5';
+
+assert.strictEqual(capture.getPerfLoopCount(), 100, 'getPerfLoopCount should read 100 from env');
+assert.strictEqual(capture.getPerfMinLoops(), 10, 'getPerfMinLoops should read 10 from env');
+assert.strictEqual(capture.getPerfTargetDurationMs(), 5000, 'getPerfTargetDurationMs should read 5000 from env');
+assert.strictEqual(capture.getPerfBatchSize(), 20, 'getPerfBatchSize should read 20 from env');
+assert.strictEqual(capture.getPerfStabilityCheck(), true, 'getPerfStabilityCheck should read true from env');
+assert.strictEqual(capture.getPerfCurrentBatch(), 5, 'getPerfCurrentBatch should read 5 from env');
+console.log('  PASS: Dynamic reading works correctly\n');
+
+// Test 3: Values change again when env vars are modified
+console.log('Test 3: Values update when env vars change');
+process.env.CODEFLASH_PERF_LOOP_COUNT = '500';
+process.env.CODEFLASH_PERF_BATCH_SIZE = '50';
+
+assert.strictEqual(capture.getPerfLoopCount(), 500, 'getPerfLoopCount should update to 500');
+assert.strictEqual(capture.getPerfBatchSize(), 50, 'getPerfBatchSize should update to 50');
+console.log('  PASS: Values update correctly\n');
+
+// Cleanup
+delete process.env.CODEFLASH_PERF_LOOP_COUNT;
+delete process.env.CODEFLASH_PERF_MIN_LOOPS;
+delete process.env.CODEFLASH_PERF_TARGET_DURATION_MS;
+delete process.env.CODEFLASH_PERF_BATCH_SIZE;
+delete process.env.CODEFLASH_PERF_STABILITY_CHECK;
+delete process.env.CODEFLASH_PERF_CURRENT_BATCH;
+
+console.log('All tests passed!');

packages/codeflash/runtime/capture.js

@@ -47,14 +47,30 @@ const TEST_MODULE = process.env.CODEFLASH_TEST_MODULE;
 //   Batch 1: Test1(5 loops) → Test2(5 loops) → Test3(5 loops)
 //   Batch 2: Test1(5 loops) → Test2(5 loops) → Test3(5 loops)
 //   ...until time budget exhausted
-const PERF_LOOP_COUNT = parseInt(process.env.CODEFLASH_PERF_LOOP_COUNT || '1', 10);
-const PERF_MIN_LOOPS = parseInt(process.env.CODEFLASH_PERF_MIN_LOOPS || '5', 10);
-const PERF_TARGET_DURATION_MS = parseInt(process.env.CODEFLASH_PERF_TARGET_DURATION_MS || '10000', 10);
-const PERF_BATCH_SIZE = parseInt(process.env.CODEFLASH_PERF_BATCH_SIZE || '10', 10);
-const PERF_STABILITY_CHECK = (process.env.CODEFLASH_PERF_STABILITY_CHECK || 'false').toLowerCase() === 'true';
+//
+// IMPORTANT: These are getter functions, NOT constants!
+// Vitest caches modules and may load this file before env vars are set.
+// Using getter functions ensures we read the env vars at runtime when they're actually needed.
+function getPerfLoopCount() {
+    return parseInt(process.env.CODEFLASH_PERF_LOOP_COUNT || '1', 10);
+}
+function getPerfMinLoops() {
+    return parseInt(process.env.CODEFLASH_PERF_MIN_LOOPS || '5', 10);
+}
+function getPerfTargetDurationMs() {
+    return parseInt(process.env.CODEFLASH_PERF_TARGET_DURATION_MS || '10000', 10);
+}
+function getPerfBatchSize() {
+    return parseInt(process.env.CODEFLASH_PERF_BATCH_SIZE || '10', 10);
+}
+function getPerfStabilityCheck() {
+    return (process.env.CODEFLASH_PERF_STABILITY_CHECK || 'false').toLowerCase() === 'true';
+}
 // Current batch number - set by loop-runner before each batch
 // This allows continuous loop indices even when Jest resets module state
-const PERF_CURRENT_BATCH = parseInt(process.env.CODEFLASH_PERF_CURRENT_BATCH || '0', 10);
+function getPerfCurrentBatch() {
+    return parseInt(process.env.CODEFLASH_PERF_CURRENT_BATCH || '0', 10);
+}
 
 // Stability constants (matching Python's config_consts.py)
 const STABILITY_WINDOW_SIZE = 0.35;
@@ -86,7 +102,7 @@ function checkSharedTimeLimit() {
         return false;
     }
     const elapsed = Date.now() - sharedPerfState.startTime;
-    if (elapsed >= PERF_TARGET_DURATION_MS && sharedPerfState.totalLoopsCompleted >= PERF_MIN_LOOPS) {
+    if (elapsed >= getPerfTargetDurationMs() && sharedPerfState.totalLoopsCompleted >= getPerfMinLoops()) {
         sharedPerfState.shouldStop = true;
         return true;
     }
@@ -111,7 +127,7 @@ function getInvocationLoopIndex(invocationKey) {
     // Calculate global loop index using batch number from environment
     // PERF_CURRENT_BATCH is 1-based (set by loop-runner before each batch)
     const currentBatch = parseInt(process.env.CODEFLASH_PERF_CURRENT_BATCH || '1', 10);
-    const globalIndex = (currentBatch - 1) * PERF_BATCH_SIZE + localIndex;
+    const globalIndex = (currentBatch - 1) * getPerfBatchSize() + localIndex;
 
     return globalIndex;
 }
@@ -606,7 +622,7 @@ function capture(funcName, lineId, fn, ...args) {
  */
 function capturePerf(funcName, lineId, fn, ...args) {
     // Check if we should skip looping entirely (shared time budget exceeded)
-    const shouldLoop = PERF_LOOP_COUNT > 1 && !checkSharedTimeLimit();
+    const shouldLoop = getPerfLoopCount() > 1 && !checkSharedTimeLimit();
 
     // Get test context (computed once, reused across batch)
     let testModulePath;
@@ -636,9 +652,9 @@ function capturePerf(funcName, lineId, fn, ...args) {
     // If so, just execute the function once without timing (for test assertions)
     const peekLoopIndex = (sharedPerfState.invocationLoopCounts[invocationKey] || 0);
     const currentBatch = parseInt(process.env.CODEFLASH_PERF_CURRENT_BATCH || '1', 10);
-    const nextGlobalIndex = (currentBatch - 1) * PERF_BATCH_SIZE + peekLoopIndex + 1;
+    const nextGlobalIndex = (currentBatch - 1) * getPerfBatchSize() + peekLoopIndex + 1;
 
-    if (shouldLoop && nextGlobalIndex > PERF_LOOP_COUNT) {
+    if (shouldLoop && nextGlobalIndex > getPerfLoopCount()) {
         // All loops completed, just execute once for test assertion
         return fn(...args);
     }
@@ -654,7 +670,7 @@ function capturePerf(funcName, lineId, fn, ...args) {
     // Batched looping: run BATCH_SIZE loops per capturePerf call when using loop-runner
     // For Vitest (no loop-runner), do all loops internally in a single call
     const batchSize = shouldLoop
-        ? (hasExternalLoopRunner ? PERF_BATCH_SIZE : PERF_LOOP_COUNT)
+        ? (hasExternalLoopRunner ? getPerfBatchSize() : getPerfLoopCount())
         : 1;
 
     for (let batchIndex = 0; batchIndex < batchSize; batchIndex++) {
@@ -667,7 +683,7 @@ function capturePerf(funcName, lineId, fn, ...args) {
         const loopIndex = getInvocationLoopIndex(invocationKey);
 
         // Check if we've exceeded max loops for this invocation
-        if (loopIndex > PERF_LOOP_COUNT) {
+        if (loopIndex > getPerfLoopCount()) {
             break;
         }
 
@@ -872,7 +888,11 @@ module.exports = {
     LOOP_INDEX,
     OUTPUT_FILE,
     TEST_ITERATION,
-    // Batch configuration
-    PERF_BATCH_SIZE,
-    PERF_LOOP_COUNT,
+    // Batch configuration (getter functions for dynamic env var reading)
+    getPerfBatchSize,
+    getPerfLoopCount,
+    getPerfMinLoops,
+    getPerfTargetDurationMs,
+    getPerfStabilityCheck,
+    getPerfCurrentBatch,
 };