@codeyam/codeyam-cli 0.1.0-staging.28f73cf → 0.1.0-staging.323686

package/analyzer-template/project/prepareRepo.ts

@@ -39,7 +39,7 @@ export default async function prepareRepo(args: PrepareRepoArgs) {
       throw new Error(`Local project path does not exist: ${localProjectPath}`);
     }
 
-    awsLogDebugLevel(1, 'Rsyncing repo...');
+    awsLogDebugLevel(1, 'Syncing repo...');
 
     // Rsync project files respecting .gitignore to avoid copying secrets
     // (.env files, credentials, private keys, etc.) while preserving node_modules

package/analyzer-template/project/reconcileMockDataKeys.ts

@@ -5,7 +5,13 @@
  * (e.g., "eq('user_id', 'user-12345')") when the mock code expects variable
  * references (e.g., "eq('user_id', user.id)").
  *
- * This function remaps mismatched keys to their expected equivalents.
+ * Keys are now original call signatures (e.g., "useFetcher<User>()", "db.select(query)").
+ *
+ * Also handles flat dotted keys (e.g., "trpc.fastener.getAttributeValues.useQuery(...)")
+ * by converting them to nested structure.
+ *
+ * @param mockData The mock data object to reconcile
+ * @param expectedKeys The expected keys from the structure
  */
 export function reconcileMockDataKeys(
   mockData: Record<string, unknown>,
@@ -26,7 +32,27 @@ export function reconcileMockDataKeys(
       continue;
     }
 
-    // Try to find closest match
+    // Check if this is a flat dotted key that should be converted to nested structure
+    // e.g., "trpc.fastener.getAttributeValues.useQuery({ ... })"
+    const flatKeyParts = parseFlatDottedKey(key);
+    if (flatKeyParts && flatKeyParts.length > 1) {
+      // Check if the parts match expected keys (indicating this should be nested)
+      const partsMatchExpected = flatKeyParts.some((part) =>
+        expectedKeys.includes(part),
+      );
+      if (partsMatchExpected) {
+        // Convert flat key to nested structure and merge
+        deepMergeIntoResult(
+          result,
+          flatKeyParts,
+          reconciledValue,
+          expectedKeys,
+        );
+        continue;
+      }
+    }
+
+    // Try to find closest match using existing logic
     const closestKey = findClosestKey(key, expectedKeys);
     if (closestKey) {
       result[closestKey] = reconciledValue;
@@ -39,6 +65,94 @@ export function reconcileMockDataKeys(
   return result;
 }
 
+/**
+ * Parse a flat dotted key into path segments.
+ * Handles keys like "trpc.fastener.getAttributeValues.useQuery({ ... })"
+ * where the last part might contain parentheses with function arguments.
+ *
+ * Returns null if the key doesn't look like a dotted path.
+ */
+function parseFlatDottedKey(key: string): string[] | null {
+  // Don't treat keys that start with a function call as dotted paths
+  // e.g., "useQuery({ id: 123 })" should not be parsed
+  if (key.match(/^[a-zA-Z_][a-zA-Z0-9_]*\s*\(/)) {
+    // Check if there's a dot BEFORE the first parenthesis
+    const parenIndex = key.indexOf('(');
+    const dotBeforeParen = key.slice(0, parenIndex).includes('.');
+    if (!dotBeforeParen) {
+      return null;
+    }
+  }
+
+  // Must contain a dot to be a dotted path
+  if (!key.includes('.')) {
+    return null;
+  }
+
+  const parts: string[] = [];
+  let current = '';
+  let depth = 0;
+
+  for (let i = 0; i < key.length; i++) {
+    const char = key[i];
+
+    if (char === '(' || char === '{' || char === '[') {
+      depth++;
+      current += char;
+    } else if (char === ')' || char === '}' || char === ']') {
+      depth--;
+      current += char;
+    } else if (char === '.' && depth === 0) {
+      if (current) {
+        parts.push(current);
+      }
+      current = '';
+    } else {
+      current += char;
+    }
+  }
+
+  if (current) {
+    parts.push(current);
+  }
+
+  // Need at least 2 parts for it to be a meaningful dotted path
+  return parts.length >= 2 ? parts : null;
+}
+
+/**
+ * Deep merge a value into the result object following the path segments.
+ * Reconciles the leaf key against expected keys.
+ */
+function deepMergeIntoResult(
+  result: Record<string, unknown>,
+  parts: string[],
+  value: unknown,
+  expectedKeys: string[],
+): void {
+  let current = result;
+
+  // Navigate/create path for all but the last part
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!(part in current)) {
+      current[part] = {};
+    }
+    const next = current[part];
+    if (next && typeof next === 'object' && !Array.isArray(next)) {
+      current = next as Record<string, unknown>;
+    } else {
+      // Can't traverse further, structure mismatch
+      return;
+    }
+  }
+
+  // Handle the leaf key
+  const leafKey = parts[parts.length - 1];
+  const closestLeafKey = findClosestKey(leafKey, expectedKeys) || leafKey;
+  current[closestLeafKey] = value;
+}
+
 /**
  * Find the closest matching key from expectedKeys for a given key.
  *
@@ -47,9 +161,15 @@ export function reconcileMockDataKeys(
  * - Ignore the last argument value (could be literal or variable)
  * - Match based on the common prefix
  * - If key has no parentheses, try matching with "()" appended
+ * - If key is "funcName()" (empty args), match expected key "funcName({...})" by function name
+ * - If key has object arguments (like useQuery({...})), match by function name
+ * - If key has single argument with literal value, match by function name
  *
  * e.g., "eq('user_id', 'user-12345')" matches "eq('user_id', user.id)"
  * e.g., "getAll" matches "getAll()"
+ * e.g., "getSurveysAction()" matches "getSurveysAction({ environmentId, ... })"
+ * e.g., "useQuery({ id: 123 })" matches "useQuery({ id: Number(id) })"
+ * e.g., "useCustomSizes('example-slug')" matches "useCustomSizes(projectSlug)"
  */
 function findClosestKey(key: string, expectedKeys: string[]): string | null {
   const keyBase = extractKeyBase(key);
@@ -73,9 +193,132 @@ function findClosestKey(key: string, expectedKeys: string[]): string | null {
     }
   }
 
+  // If key is "funcName()" (empty args), try matching expected key "funcName({...})"
+  // This handles the case where LLM generates "getSurveysAction()" but expected key
+  // is "getSurveysAction({ environmentId, limit, ... })" with an object argument
+  const emptyArgsMatch = key.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\(\)$/);
+  if (emptyArgsMatch) {
+    const funcName = emptyArgsMatch[1];
+    for (const expected of expectedKeys) {
+      // Match if expected key starts with the same function name and has args
+      const expectedMatch = expected.match(
+        new RegExp(`^${escapeRegExp(funcName)}\\([^)]+\\)$`),
+      );
+      if (expectedMatch) {
+        return expected;
+      }
+    }
+  }
+
+  // If key has object literal arguments (like "useQuery({ id: 123, ... })"),
+  // try matching expected keys with the same function path AND first object property.
+  // This handles cases where LLM generates literal values but expected keys have variable references.
+  // e.g., "useQuery({ attributes: ['a', 'b'] })" matches "useQuery({ attributes: items || [] })"
+  // e.g., "trpc.users.getById.useQuery({ userId: 'user-123' })" matches "trpc.users.getById.useQuery({ userId })"
+  // Uses first property matching when multiple candidates exist for disambiguation.
+  const objectArgMatch = key.match(/^([a-zA-Z_][a-zA-Z0-9_.]*)\s*\(\s*\{/);
+  if (objectArgMatch) {
+    const funcPath = objectArgMatch[1]; // Can be "funcName" or "path.to.funcName"
+    // Extract the first property name from the object argument
+    const firstPropMatch = key.match(
+      /\(\s*\{\s*\n?\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*:/,
+    );
+    const firstProp = firstPropMatch ? firstPropMatch[1] : null;
+
+    // Collect all matching candidates
+    const candidates: string[] = [];
+    for (const expected of expectedKeys) {
+      // Match if expected key has the same function path and starts with object argument
+      const expectedObjArgMatch = expected.match(
+        new RegExp(`^${escapeRegExp(funcPath)}\\s*\\(\\s*\\{`),
+      );
+      if (expectedObjArgMatch) {
+        candidates.push(expected);
+      }
+    }
+
+    // If we have a first property, prefer matching by property name
+    if (firstProp && candidates.length > 1) {
+      // Look for a candidate with the same first property
+      const propRegex = new RegExp(
+        `\\(\\s*\\{[\\s\\n]*${escapeRegExp(firstProp)}\\s*:`,
+      );
+      const propMatch = candidates.find((c) => propRegex.test(c));
+      if (propMatch) {
+        return propMatch;
+      }
+    }
+
+    // Fall back to first candidate if no property match found
+    if (candidates.length > 0) {
+      return candidates[0];
+    }
+  }
+
+  // If key has a single argument (literal value OR variable reference),
+  // try matching expected keys with the same function name but different argument.
+  // This handles cases where:
+  // - LLM generates "useCustomSizes('example-slug')" but expected key is "useCustomSizes(projectSlug)"
+  // - LLM generates "useCustomSizes(someProjectSlug)" but expected key is "useCustomSizes(projectSlug)"
+  //
+  // The second case is important because when LLM generates multiple keys with different
+  // variable names (e.g., "useCustomSizes(someProjectSlug)" and "useCustomSizes(projectSlug)"),
+  // without reconciliation, normalizeMockData merges them into "useCustomSizes()" which
+  // doesn't match the expected key "useCustomSizes(projectSlug)", causing undefined data access.
+  const singleArgMatch = key.match(
+    /^([a-zA-Z_][a-zA-Z0-9_.]*)\s*\(([^,)]+)\)$/,
+  );
+  if (singleArgMatch) {
+    const funcPath = singleArgMatch[1];
+    const arg = singleArgMatch[2].trim();
+    // Apply this matching if the argument is a literal OR a simple variable reference
+    const isLiteralArg = /^['"`].*['"`]$/.test(arg) || /^\d+$/.test(arg);
+    const isVariableRef = /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(arg);
+    if (isLiteralArg || isVariableRef) {
+      for (const expected of expectedKeys) {
+        // Match if expected key has the same function path with a single argument
+        const expectedSingleArgMatch = expected.match(
+          new RegExp(`^${escapeRegExp(funcPath)}\\s*\\([^,)]+\\)$`),
+        );
+        if (expectedSingleArgMatch) {
+          return expected;
+        }
+      }
+    }
+  }
+
+  // If key has multiple arguments where one contains a literal value,
+  // try matching expected keys with the same function name and argument count.
+  // This handles cases like "getScenarioDisplayState(scenario, undefined, undefined, 'entitysha123', undefined)"
+  // matching "getScenarioDisplayState(scenario, undefined, undefined, entitySha, undefined)"
+  const multiArgWithLiteralMatch = key.match(
+    /^([a-zA-Z_][a-zA-Z0-9_.]*)\s*\((.+)\)$/,
+  );
+  if (multiArgWithLiteralMatch) {
+    const funcPath = multiArgWithLiteralMatch[1];
+    const argsStr = multiArgWithLiteralMatch[2];
+    // Check if any argument is a string literal
+    const hasLiteralArg = /'[^']*'|"[^"]*"/.test(argsStr);
+    if (hasLiteralArg) {
+      for (const expected of expectedKeys) {
+        // Match if expected key starts with the same function path
+        if (expected.startsWith(funcPath + '(')) {
+          return expected;
+        }
+      }
+    }
+  }
+
   return null;
 }
 
+/**
+ * Escape special regex characters in a string.
+ */
+function escapeRegExp(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 /**
  * Normalize quotes in a string: convert double quotes to single quotes.
  * This handles cases where the LLM generates keys with double quotes

package/analyzer-template/project/runAnalysis.ts

@@ -16,7 +16,7 @@ import {
   loadEntity,
   loadScenario,
   updateCommitMetadata,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import analyzeReadyToBeCaptured from './analyzeReadyToBeCaptured';
 import analyzeBaselineCommit from './analyzeBaselineCommit';
 import analyzeRegularCommit from './analyzeRegularCommit';
@@ -215,6 +215,11 @@ export default async function runAnalysis({
       entityShas,
       branchName: branch?.name,
     });
+
+    // Propagate the fallback branch to branchCommit so downstream code can use it
+    if (branchCommit && branch) {
+      branchCommit.branch = branch;
+    }
   }
 
   // After this block, 'commit' is the union of a regular or baseline commit
@@ -308,6 +313,10 @@ export default async function runAnalysis({
   // Route to appropriate analyzer
   try {
     if (runReadyToBeCapturedPath) {
+      // Signal that analysis can produce captures immediately since analyses are already ready.
+      // This is needed for recapture to work - orchestration waits for the 'analysisProducing' event.
+      controller?.setAnalysisProducingPhase();
+
       return await analyzeReadyToBeCaptured({
         project,
         projectAnalyzer,
@@ -330,6 +339,7 @@ export default async function runAnalysis({
         desiredAnalyses,
         force,
         fileStore,
+        onAnalysisProducing: () => controller?.setAnalysisProducingPhase(),
       });
     }
 
@@ -350,6 +360,7 @@ export default async function runAnalysis({
       backgroundJob,
       desiredAnalyses,
       fileStore,
+      onAnalysisProducing: () => controller?.setAnalysisProducingPhase(),
     });
   } catch (e) {
     awsLog('CodeYam Error: Analysis failed', {

package/analyzer-template/project/runMultiScenarioServer.ts

@@ -11,7 +11,7 @@ import { startServer } from './startServer';
 import { awsLog, safeFileName } from '~codeyam/utils';
 import { recordErrorMessageForScenario } from './utils/errorHandling';
 import { Controller, TaskCompleteType } from './controller/startController';
-import { updateFreshAnalysisStatus, loadAnalysis } from '~codeyam/supabase';
+import { updateFreshAnalysisStatus, loadAnalysis } from '~codeyam/database';
 import getScenarioUrl from './getScenarioUrl';
 import { chromium } from 'playwright';
 import { ScenarioIterator } from './ScenarioIterator';
@@ -184,10 +184,6 @@ export async function runMultiScenarioServer({
     // Start the server (this runs in the background)
     const serverPromise = startServer({
       startCommand,
-      packageManager,
-      exitAfterSuccessfulAppStart,
-      framework,
-
       onStart: async (port: number) => {
         projectPort = port;
         serverStarted = true;
@@ -306,14 +302,14 @@ export async function runMultiScenarioServer({
             message: message.slice(0, 1000),
           });
 
-          // Save error to database
-          await recordErrorMessageForScenario(analysis, currentScenario, {
-            message: messageToSave,
-          } as Error);
-
-          // Only signal scenario failed for RELEVANT crash errors
-          // Non-crash errors (like SSR warnings) should be recorded but not stop capture
+          // Only save error and signal scenario failed for RELEVANT crash errors
+          // Non-crash errors (like SSR warnings) should be logged but not stop capture
+          // or mark the scenario as finished (which would prevent screenshot capture)
           if (relevantError) {
+            // Save crash error to database (sets finishedAt on scenario)
+            await recordErrorMessageForScenario(analysis, currentScenario, {
+              message: messageToSave,
+            } as Error);
             awsLog(
               'CodeYam SERVER DEBUG: Calling handleServerError for crash error',
               {
@@ -324,8 +320,9 @@ export async function runMultiScenarioServer({
             );
             iterator.handleServerError(currentScenario.name);
           } else {
+            // Non-crash errors are logged but don't affect scenario status
             awsLog(
-              'CodeYam SERVER DEBUG: Non-crash error recorded, NOT stopping scenario',
+              'CodeYam SERVER DEBUG: Non-crash error logged, NOT stopping scenario',
               {
                 analysisId: analysis.id,
                 scenarioName: currentScenario.name,
@@ -505,13 +502,13 @@ export async function runMultiScenarioServer({
 
       if (!iterator.hasScenarioFailed(scenario.name)) {
         completedScenarios.push(scenario.name);
-        awsLog('CodeYam SERVER DEBUG: Scenario marked as completed', {
+        awsLog('CodeYam: Scenario marked as completed', {
           analysisId: analysis.id,
           scenarioName: scenario.name,
           scenarioId: scenario.id,
         });
       } else {
-        awsLog('CodeYam SERVER DEBUG: Scenario marked as FAILED', {
+        awsLog('CodeYam: Scenario marked as FAILED', {
           analysisId: analysis.id,
           scenarioName: scenario.name,
           scenarioId: scenario.id,
@@ -519,7 +516,7 @@ export async function runMultiScenarioServer({
       }
 
       // Advance iterator to next scenario
-      awsLog('CodeYam SERVER DEBUG: Advancing to next scenario', {
+      awsLog('CodeYam: Advancing to next scenario', {
         analysisId: analysis.id,
         currentScenarioName: scenario.name,
         nextScenarioIndex: i + 1,

package/analyzer-template/project/runScenarioServer.ts

@@ -11,7 +11,7 @@ import { startServer } from './startServer';
 import { awsLog, safeFileName } from '~codeyam/utils';
 import { recordErrorMessageForScenario } from './utils/errorHandling';
 import { Controller, TaskCompleteType } from './controller/startController';
-import { updateFreshAnalysisStatus, loadAnalysis } from '~codeyam/supabase';
+import { updateFreshAnalysisStatus, loadAnalysis } from '~codeyam/database';
 import getScenarioUrl from './getScenarioUrl';
 
 const closedScenarios: string[] = [];
@@ -119,10 +119,6 @@ export async function runScenarioServer({
   try {
     const code = await startServer({
       startCommand,
-      packageManager,
-      exitAfterSuccessfulAppStart,
-      framework,
-
       onStart: async (port: number) => {
         if (taskCompletion) {
           console.log(