@codeyam/codeyam-cli 0.1.0-staging.8e7b1bd → 0.1.0-staging.b8a55ba

package/analyzer-template/project/TESTING.md

@@ -0,0 +1,83 @@
+# Testing writeScenarioComponents
+
+This document describes how to test changes to `writeScenarioComponents.ts`.
+
+## 1. Run the specific test
+
+```bash
+npx jest background/src/lib/virtualized/project/__tests__/writeScenarioComponents.test.ts -t "test name here" --no-coverage
+```
+
+## 2. Run all tests in the file
+
+```bash
+npx jest background/src/lib/virtualized/project/__tests__/writeScenarioComponents.test.ts --no-coverage -w 2
+```
+
+## 3. Rebuild and reinstall the CLI
+
+The globally installed CLI must be reinstalled to pick up changes:
+
+```bash
+# Remove the globally installed CLI and rebuild
+rm -rf /Users/jaredcosulich/.nvm/versions/node/v20.16.0/lib/node_modules/@codeyam/codeyam-cli && pnpm cli
+```
+
+## 4. Restart the server in the client project
+
+After rebuilding the CLI, restart the codeyam server in the client project:
+
+```bash
+cd /Users/jaredcosulich/workspace/codeyam/formbricks && codeyam stop & codeyam
+```
+
+## 5. Force analyzer update and run debug
+
+The analyzer is cached in `/tmp/codeyam/local-dev/{project-slug}/codeyam/analyzer`.
+To force it to use the new code:
+
+```bash
+# Remove cached analyzer
+rm -rf /tmp/codeyam/local-dev/formbricks-formbricks/codeyam/analyzer
+
+# Run debug (from the project directory)
+cd /Users/jaredcosulich/workspace/codeyam/formbricks && codeyam debug <analysis-id>
+```
+
+## 6. Verify the fix
+
+```bash
+# Check version in logs (should match version in writeScenarioComponents.ts)
+grep "CodeYam \[v" /tmp/codeyam/local-dev/formbricks-formbricks/codeyam/log.txt | tail -3
+
+# Check generated files
+head -30 /tmp/codeyam/local-dev/formbricks-formbricks/project/path/to/generated/file.tsx
+
+# List data scenario files
+ls -la /tmp/codeyam/local-dev/formbricks-formbricks/project/apps/web/lib/*_data_Default_Scenario*
+```
+
+## 7. Start dev server and test in browser
+
+```bash
+cd /tmp/codeyam/local-dev/formbricks-formbricks/project/apps/web && pnpm next dev --turbopack -p 3112
+```
+
+Test the actual simulation page (not just codeyam-sample):
+
+```bash
+# Format: /static/{project-slug}/{analysis-id}/{entity-name}/{scenario-name}/default
+curl http://localhost:3112/static/formbricks-formbricks/7925cfe4-7789-470d-bddc-2a85e48ef356/SurveysPage/Default_Scenario/default
+```
+
+Visit in browser: http://localhost:3112/static/formbricks-formbricks/7925cfe4-7789-470d-bddc-2a85e48ef356/SurveysPage/Default_Scenario/default
+
+## Version Tracking
+
+The version is defined in `writeScenarioComponents.ts`:
+
+```typescript
+const WRITE_SCENARIO_COMPONENTS_VERSION = '2.5.13-strip-use-server-directive';
+```
+
+Increment this when making changes to help track which version is running.

package/analyzer-template/project/constructMockCode.ts

@@ -206,6 +206,8 @@ export default function constructMockCode(
   mockName: string,
   dependencySchemas: DeepReadonly<DataStructure['dependencySchemas']>,
   entityType?: EntityType,
+  canonicalKey?: string,
+  options?: { keepOriginalFunctionName?: boolean },
 ) {
   // Check for variable-qualified mock name (e.g., "entityDiffFetcher <- useFetcher")
   // Format: "variableName <- functionName" which reads naturally as "variableName receives from functionName"
@@ -412,11 +414,15 @@ export default function constructMockCode(
       // so "useLoaderData<typeof loader>()" becomes "useLoaderData()"
       name = cleanOutTypes(name);
 
-      // For variable-qualified mocks at root level, use the "variableName <- functionName" format
-      // This matches the format generated by gatherDataForMocks and is more intuitive for LLMs
-      // e.g., "useFetcher()" becomes "entityDiffFetcher <- useFetcher"
+      // For root data access, use the canonical key if provided
+      // Canonical keys use format: EntityName::hookName::index (e.g., "Dashboard::useLoaderData::0")
+      if (isRootAccess && canonicalKey) {
+        return `?.["${canonicalKey}"]`;
+      }
+
+      // Fallback for variable-qualified mocks when no canonical key provided
+      // Format: "variableName <- functionName" (legacy format)
       if (isRootAccess && variableQualifier) {
-        // Remove trailing () from the function name to match gatherDataForMocks key format
         const baseName = name.replace(/\(\)$/, '');
         name = `${variableQualifier} <- ${baseName}`;
       }
@@ -662,10 +668,19 @@ export default function constructMockCode(
           // When GENERIC array (using []) has nested content (like functions that need wrapping),
           // use .map() to transform ALL elements instead of just creating [0]
           // For DIFFERENTIATED arrays (using [0], [1], etc.), keep the static array structure
+          //
+          // IMPORTANT: If the nested content contains differentiated indices like [0], [1],
+          // we MUST use static array pattern, not .map(). The presence of differentiated
+          // indices means the array elements have different types/structures, so .map()
+          // would generate invalid code trying to treat them uniformly.
+          const hasDifferentiatedIndices =
+            nested &&
+            nested.some((n) => n.name.match(/^\[\d+\]$/) && n.name !== '[0]');
           if (
             isGenericArray &&
             nestedContent.length > 0 &&
-            dataPaths.length > 0
+            dataPaths.length > 0 &&
+            !hasDifferentiatedIndices
           ) {
             // Get the array base path (without the [0])
             const arrayBasePath = dataPaths[0].replace(/\?\.\[0\]$/, '');
@@ -698,6 +713,13 @@ export default function constructMockCode(
       if (args && args.length > 0) {
         if (!isValidKey(name)) return;
 
+        // Skip array index patterns like [], [0], [1] when they have args
+        // These represent function calls on array elements, not property keys
+        // e.g., customSizes[].(args) means each array element is callable, not a property named "[]"
+        if (name.match(/^\[\d*\]$/)) {
+          return;
+        }
+
         const mostArgs = args.sort(
           (a: string[], b: string[]) => b.length - a.length,
         )[0];
@@ -757,8 +779,18 @@ export default function constructMockCode(
             // Use all paths for fallback (existing behavior)
             fallbackContent = `return ${returnValueContents}`;
           } else {
-            // Use all paths as fallback for unknown arguments
-            fallbackContent = `return ${returnValueContents}`;
+            // No explicit fallback paths - return the first literal's value as default
+            // Returning spread of all values is dangerous because if values are primitives (strings),
+            // spreading them creates objects with numeric keys like {0:'a', 1:'b', ...}
+            // which causes "Objects are not valid as React child" errors
+            const firstLiteralValue = literalKeys[0];
+            const firstGroupPaths = argGroups.get(firstLiteralValue);
+            if (firstGroupPaths && firstGroupPaths.length === 1) {
+              fallbackContent = `return ${firstGroupPaths[0]}`;
+            } else {
+              // Multiple paths for first literal - return undefined as safe fallback
+              fallbackContent = `return undefined`;
+            }
           }
 
           const funcContents =
@@ -888,6 +920,39 @@ export default function constructMockCode(
         'jsx-component';
     if (isJsxComponent) continue;
 
+    // Skip paths that bypass .functionCallReturnValue when there's a corresponding path with it.
+    // Example: If we have both:
+    //   - trpc.customer.useQuery(...).data (incorrect - no .functionCallReturnValue)
+    //   - trpc.customer.useQuery(...).functionCallReturnValue.data (correct)
+    // We should skip the first path because the second one properly captures the return value.
+    // This can happen when the analyzer sees both the raw property access and the return value structure.
+    if (!hasFunctionCallReturnValue) {
+      // This path has no .functionCallReturnValue. Check if any function call in this path
+      // has a corresponding .functionCallReturnValue path in the schema.
+      let shouldSkipKey = false;
+      for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (part.endsWith(')') && !isFunctionCallReturnValue(parts[i + 1])) {
+          // This part is a function call, and the next part is NOT .functionCallReturnValue
+          // Check if there's any path with .functionCallReturnValue for this function call
+          const functionCallPath = joinParenthesesAndArrays(
+            parts.slice(0, i + 1),
+          );
+          const hasProperFunctionCallPath = Object.keys(
+            relevantReturnValueSchema,
+          ).some((k) =>
+            k.startsWith(functionCallPath + '.functionCallReturnValue'),
+          );
+          if (hasProperFunctionCallPath) {
+            // Skip this path - the .functionCallReturnValue path will handle it correctly
+            shouldSkipKey = true;
+            break;
+          }
+        }
+      }
+      if (shouldSkipKey) continue;
+    }
+
     const isFunctionPath =
       ['function', 'async-function'].includes(value) &&
       parts[parts.length - 1].endsWith(')') &&
@@ -1197,17 +1262,22 @@ export default function constructMockCode(
         ) {
           returnValueSection.nested.push(relevantPart);
         }
-      } else if (
-        relevantPart.args &&
-        funcArgs(part).join(',') !== funcArgs(relevantPart.name).join(',')
-      ) {
-        const existingArgs = relevantPart.args.find(
-          (args) => args.join(',') === funcArgs(part).join(','),
-        );
+      } else {
+        // Add args to existing entry if current part has function arguments
+        // This handles the case where bare `t` is processed first (creating {name: 't', args: undefined})
+        // and then `t("common.close")` is processed - we need to add its args to the existing entry
+        const currentArgs = funcArgs(part);
+        const hasNewArgs = currentArgs.length > 0 || part.includes('(');
+
+        if (hasNewArgs) {
+          const existingArgs = relevantPart.args?.find(
+            (args) => args.join(',') === currentArgs.join(','),
+          );
 
-        if (!existingArgs) {
-          relevantPart.args ||= [];
-          relevantPart.args.push(funcArgs(part));
+          if (!existingArgs) {
+            relevantPart.args ||= [];
+            relevantPart.args.push(currentArgs);
+          }
         }
       }
 
@@ -1289,12 +1359,14 @@ export default function constructMockCode(
     let enhancedContents = contents;
     if (needsIteratorMethods && contents.trim().startsWith('{')) {
       // Add iterator methods that operate on the scenario data
+      // Use canonical key if provided, otherwise fall back to legacy format
+      const dataKey = canonicalKey || `${mockName}()`;
       const iteratorMethods = `,
-  entries: () => Object.entries(scenarios().data()?.["${mockName}()"] || {}),
-  keys: () => Object.keys(scenarios().data()?.["${mockName}()"] || {}),
-  values: () => Object.values(scenarios().data()?.["${mockName}()"] || {}),
-  forEach: (fn) => Object.entries(scenarios().data()?.["${mockName}()"] || {}).forEach(([k, v]) => fn(v, k)),
-  has: (key) => Object.prototype.hasOwnProperty.call(scenarios().data()?.["${mockName}()"] || {}, key)`;
+  entries: () => Object.entries(scenarios().data()?.["${dataKey}"] || {}),
+  keys: () => Object.keys(scenarios().data()?.["${dataKey}"] || {}),
+  values: () => Object.values(scenarios().data()?.["${dataKey}"] || {}),
+  forEach: (fn) => Object.entries(scenarios().data()?.["${dataKey}"] || {}).forEach(([k, v]) => fn(v, k)),
+  has: (key) => Object.prototype.hasOwnProperty.call(scenarios().data()?.["${dataKey}"] || {}, key)`;
       // Insert before the closing brace (handle trailing whitespace)
       enhancedContents = contents.replace(/\}\s*$/, iteratorMethods + '\n}');
     }
@@ -1311,12 +1383,14 @@ export default function constructMockCode(
       const nameAssignment = isErrorSubclass
         ? `this.name = '${mockName}';`
         : '';
+      // Use canonical key if provided, otherwise fall back to legacy format
+      const dataKey = canonicalKey || `${mockName}()`;
 
       return `class ${mockName}${isErrorSubclass ? ' extends Error' : ''} {
   constructor(message) {
     ${superCall}
     ${nameAssignment}
-    Object.assign(this, scenarios().data()?.["${mockName}()"] || {});
+    Object.assign(this, scenarios().data()?.["${dataKey}"] || {});
   }
 }`;
     }
@@ -1324,17 +1398,64 @@ export default function constructMockCode(
     // For variable-qualified mocks, use underscore separator in the function name
     // e.g., "entityDiffFetcher <- useFetcher" becomes "useFetcher_entityDiffFetcher"
     // For indexed qualifiers like "data[1]", convert to safe identifier: "useFetcher_data_1"
-    const safeFunctionName = variableQualifier
-      ? `${baseMockName}_${safeVariableQualifier(variableQualifier)}`
-      : mockName;
+    // EXCEPTION: When keepOriginalFunctionName is true (for single-call cases), use the base name
+    const safeFunctionName =
+      variableQualifier && !options?.keepOriginalFunctionName
+        ? `${baseMockName}_${safeVariableQualifier(variableQualifier)}`
+        : baseMockName;
+
+    // Check if this function returns a function (detected by double-call pattern: mockName(args)())
+    // This happens when the schema has keys like "wrapThrows(() => JSON.parse(savedFilters))()"
+    // where the function call is immediately followed by another call.
+    // Example usage: const result = wrapThrows(() => JSON.parse(x))(); // double call
+    const isHigherOrderFunction = Object.keys(
+      relevantReturnValueSchema ?? {},
+    ).some((key) => {
+      if (!key.startsWith(baseMockName)) return false;
+
+      // Find the first ( after baseMockName (the start of the function call)
+      const firstOpenParen = key.indexOf('(', baseMockName.length);
+      if (firstOpenParen === -1) return false;
+
+      // Skip if the ( is not immediately after the mock name
+      // (there might be type params like func<T>() - handle by checking for < or ()
+      const between = key.slice(baseMockName.length, firstOpenParen);
+      if (between.length > 0 && !between.startsWith('<')) return false;
+
+      // Find the matching ) for the first ( using depth counting
+      let depth = 1;
+      let i = firstOpenParen + 1;
+      while (i < key.length && depth > 0) {
+        if (key[i] === '(') depth++;
+        if (key[i] === ')') depth--;
+        i++;
+      }
+
+      if (depth !== 0) return false; // Unbalanced parentheses
+
+      // Now i points just after the matching )
+      // Check if there's another ( immediately (indicating double call)
+      const remaining = key.slice(i);
+      if (remaining.startsWith('(')) return true;
+
+      return false;
+    });
+
+    // For higher-order functions, wrap the return in an arrow function
+    // so that mockFunc(arg)() works correctly (outer call returns a function, inner call gets the data)
+    const returnValue = isHigherOrderFunction
+      ? `() => ${safeFunctionName}ReturnValue`
+      : `${safeFunctionName}ReturnValue`;
 
-    return `const ${safeFunctionName}ReturnValue = ${enhancedContents};\n\n${isRootAsyncFunction ? 'async ' : ''}function ${safeFunctionName}() {\n${indent(`return ${safeFunctionName}ReturnValue;`)}\n}`;
+    return `const ${safeFunctionName}ReturnValue = ${enhancedContents};\n\n${isRootAsyncFunction ? 'async ' : ''}function ${safeFunctionName}() {\n${indent(`return ${returnValue};`)}\n}`;
   } else {
     // For variable-qualified mocks, use underscore separator in the const name
     // For indexed qualifiers like "data[1]", convert to safe identifier: "useFetcher_data_1"
-    const safeName = variableQualifier
-      ? `${baseMockName}_${safeVariableQualifier(variableQualifier)}`
-      : mockName;
+    // EXCEPTION: When keepOriginalFunctionName is true (for single-call cases), use the base name
+    const safeName =
+      variableQualifier && !options?.keepOriginalFunctionName
+        ? `${baseMockName}_${safeVariableQualifier(variableQualifier)}`
+        : baseMockName;
 
     // Get any jsx-component properties that need to be preserved from the original
     const jsxProperties = getJsxComponentProperties(

package/analyzer-template/project/loadReadyToBeCaptured.ts

@@ -88,7 +88,23 @@ async function gatherAllReferencedEntities(
         if (!entities) return [];
 
         // Filter to only the entities we need (loadEntities returns all for the file)
-        return entities.filter((e) => names.includes(e.name));
+        // Special handling: if we requested 'default' and got a default export entity,
+        // include it even though the name doesn't match (entities are stored by actual name, not 'default')
+        return entities.filter((e) => {
+          if (names.includes(e.name)) {
+            return true;
+          }
+          // If we requested 'default' and this is a default export, include it
+          if (
+            names.includes('default') &&
+            e.metadata &&
+            !e.metadata.notExported &&
+            !e.metadata.namedExport
+          ) {
+            return true;
+          }
+          return false;
+        });
       },
     );
 

package/analyzer-template/project/orchestrateCapture/KyselyAnalysisLoader.ts

@@ -46,10 +46,13 @@ export default class KyselyAnalysisLoader implements AnalysisLoader {
             'status',
           ])
           // Base condition: readyToBeCaptured = true
-          .where(
-            sql<string>` ${sql.ref('status')} -> 'readyToBeCaptured'`,
-            '=',
-            'true',
+          // Use json_extract for SQLite (returns 1 for boolean true)
+          .where((eb) =>
+            eb(
+              sql`json_extract(${sql.ref('status')}, '$.readyToBeCaptured')`,
+              '=',
+              sql`1`,
+            ),
           )
           // Project filter (always required)
           .where('project_id', '=', this.config.project.id);
@@ -94,11 +97,11 @@ export default class KyselyAnalysisLoader implements AnalysisLoader {
             return false;
           }
 
-          // Check: has incomplete scenarios
+          // Check: has scenarios needing capture
           // Include if:
           // - No scenarios field
           // - Empty scenarios array
-          // - At least one scenario without finishedAt or error
+          // - At least one scenario that needs capture (no finishedAt OR has error)
           const scenarios = status?.scenarios;
           if (!scenarios || !Array.isArray(scenarios)) {
             return true; // No scenarios field
@@ -107,12 +110,16 @@ export default class KyselyAnalysisLoader implements AnalysisLoader {
             return true; // Empty array
           }
 
-          // Check if at least one scenario is incomplete
-          const hasIncompleteScenario = scenarios.some(
+          // Check if at least one scenario needs capture
+          // A scenario needs capture if it has no finishedAt AND no error
+          // (i.e., it hasn't been attempted yet)
+          // Scenarios with finishedAt are complete (successful)
+          // Scenarios with error are complete (failed, not retried automatically)
+          const needsCapture = scenarios.some(
             (scenario: any) => !scenario.finishedAt && !scenario.error,
           );
 
-          return hasIncompleteScenario;
+          return needsCapture;
         });
 
         // Map to ReadyAnalysisData, excluding the status field

package/analyzer-template/project/orchestrateCapture/SequentialCaptureTaskRunner.ts

@@ -91,47 +91,59 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
 
     // Derive paths
     const parentDir = parentOfCodeyam;
-    const capturerPath = path.normalize(path.join(parentDir, 'capturer-1'));
 
-    console.log(`CodeYam: Sequential runner using capturer at ${capturerPath}`);
-
-    // Create capturer base directory
-    if (!fs.existsSync(capturerPath)) {
-      fs.mkdirSync(capturerPath, { recursive: true });
-    }
+    // In CAPTURE_ONLY mode, run directly from the main project folder (skip rsync)
+    // This preserves any manual edits made to generated files
+    const captureOnly = process.env.CAPTURE_ONLY === 'true';
+    const capturerPath = captureOnly
+      ? parentDir
+      : path.normalize(path.join(parentDir, 'capturer-1'));
 
-    // Copy both codeyam/ and project/ into capturer-1/
-    // start.ts waits for repo checkout to complete before creating this runner
-    console.log('CodeYam: Copying codeyam/ and project/ to capturer-1/...');
-    await rsyncCopy({
-      sourcePath: parentDir,
-      destinationPath: capturerPath,
-      excludes: ['codeyam/log.txt', 'capturer-*'],
-      silent: false,
-    });
+    console.log(`CodeYam: Sequential runner using capturer at ${capturerPath}`);
 
-    // Sanitize env files in capturer project (replaces real values with mock placeholders)
-    const capturerProjectPath = path.join(capturerPath, 'project');
-    console.log('CodeYam: Sanitizing env files in capturer project...');
-    const sanitizeResult = sanitizeEnvFiles({
-      projectPath: capturerProjectPath,
-      log: (msg) => console.log(`CodeYam Sanitize: ${msg}`),
-    });
-    if (sanitizeResult.sanitizedFiles.length > 0) {
+    if (captureOnly) {
       console.log(
-        `CodeYam: Env files sanitized: ${sanitizeResult.sanitizedFiles.join(', ')}`,
+        'CodeYam: CAPTURE_ONLY mode - running from main project folder, skipping rsync',
       );
-    }
+    } else {
+      // Create capturer base directory
+      if (!fs.existsSync(capturerPath)) {
+        fs.mkdirSync(capturerPath, { recursive: true });
+      }
 
-    // Apply universal mocks to capturer project
-    if (context.universalMocks && context.universalMocks.length > 0) {
-      console.log(
-        `CodeYam: Applying ${context.universalMocks.length} universal mock(s) to capturer project...`,
-      );
-      await applyUniversalMocks({
-        mocks: context.universalMocks,
+      // Copy both codeyam/ and project/ into capturer-1/
+      // start.ts waits for repo checkout to complete before creating this runner
+      console.log('CodeYam: Copying codeyam/ and project/ to capturer-1/...');
+      await rsyncCopy({
+        sourcePath: parentDir,
+        destinationPath: capturerPath,
+        excludes: ['codeyam/log.txt', 'capturer-*'],
+        silent: false,
+      });
+
+      // Sanitize env files in capturer project (replaces real values with mock placeholders)
+      const capturerProjectPath = path.join(capturerPath, 'project');
+      console.log('CodeYam: Sanitizing env files in capturer project...');
+      const sanitizeResult = sanitizeEnvFiles({
         projectPath: capturerProjectPath,
+        log: (msg) => console.log(`CodeYam Sanitize: ${msg}`),
       });
+      if (sanitizeResult.sanitizedFiles.length > 0) {
+        console.log(
+          `CodeYam: Env files sanitized: ${sanitizeResult.sanitizedFiles.join(', ')}`,
+        );
+      }
+
+      // Apply universal mocks to capturer project
+      if (context.universalMocks && context.universalMocks.length > 0) {
+        console.log(
+          `CodeYam: Applying ${context.universalMocks.length} universal mock(s) to capturer project...`,
+        );
+        await applyUniversalMocks({
+          mocks: context.universalMocks,
+          projectPath: capturerProjectPath,
+        });
+      }
     }
 
     const runner = new SequentialCaptureTaskRunner(
@@ -247,6 +259,10 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
         READY_TO_BE_CAPTURED: 'true',
         PROJECT_SLUG: this.config.projectSlug,
         CODEYAM_LOG_PATH: capturerLogPath,
+        // Pass CAPTURE_ONLY through from parent process to skip file regeneration
+        ...(process.env.CAPTURE_ONLY && {
+          CAPTURE_ONLY: process.env.CAPTURE_ONLY,
+        }),
       },
       workingDir: capturerCodeyamPath,
       processName: 'project',
@@ -280,14 +296,38 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
       }, timeoutMs);
     });
 
+    // Track which process exits first and when
+    const batchStartTime = Date.now();
+    let startExitCode: number | null = null;
+    let captureExitCode: number | null = null;
+    let firstToExit: 'start' | 'capture' | 'timeout' | null = null;
+
+    const startPromiseWithLogging = startResult.promise.then((code) => {
+      startExitCode = code;
+      if (!firstToExit) {
+        firstToExit = 'start';
+      }
+      return code;
+    });
+
+    const capturePromiseWithLogging = captureResult.promise.then((code) => {
+      captureExitCode = code;
+      if (!firstToExit) {
+        firstToExit = 'capture';
+      }
+      return code;
+    });
+
     try {
-      // Race: whichever finishes first (capture exits when done, or timeout)
+      // Wait for EITHER process to complete (or timeout)
+      // If start.js exits, we should investigate why - it shouldn't exit before capture is done
       await Promise.race([
-        captureResult.promise,
-        startResult.promise,
+        capturePromiseWithLogging,
+        startPromiseWithLogging,
         timeoutPromise,
       ]);
-      console.log('CodeYam: Batch processing completed successfully');
+      const elapsed = ((Date.now() - batchStartTime) / 1000).toFixed(1);
+      console.log(`CodeYam: Batch processing completed after ${elapsed}s`);
     } finally {
       // Clean up timeout handle
       if (timeoutHandle) {