@codeyam/codeyam-cli 0.1.0-staging.1 → 0.1.0-staging.1669d45

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

@@ -37,7 +37,10 @@ import {
 export interface SequentialCaptureTaskRunnerContext {
   absoluteProjectRootPath: string;
   absoluteTempPath?: string;
-  startArgs: StartArgs;
+  startArgs: Omit<
+    StartArgs,
+    'absoluteProjectRootPath' | 'absoluteTempPath' | 'noServer' | 'fast'
+  >;
   /** Universal mocks to apply to the capturer's project directory */
   universalMocks?: UniversalMock[];
   /** Environment variables to pass to the spawned processes */
@@ -72,8 +75,6 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
     config: TaskRunnerConfig,
     context: SequentialCaptureTaskRunnerContext,
   ): Promise<SequentialCaptureTaskRunner> {
-    console.log('CodeYam DEBUG: Creating SequentialCaptureTaskRunner...');
-
     // Validate that cwd and project path share parent directory
     // Use realpathSync to resolve symlinks (e.g., /tmp -> /private/tmp on macOS)
     const parentOfCodeyam = fs.realpathSync(path.dirname(process.cwd()));
@@ -90,56 +91,59 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
 
     // Derive paths
     const parentDir = parentOfCodeyam;
-    const capturerPath = path.normalize(path.join(parentDir, 'capturer-1'));
+
+    // 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'));
 
     console.log(`CodeYam: Sequential runner using capturer at ${capturerPath}`);
 
-    // Create capturer base directory
-    if (!fs.existsSync(capturerPath)) {
+    if (captureOnly) {
       console.log(
-        `CodeYam DEBUG: Creating capturer directory at ${capturerPath}`,
+        'CodeYam: CAPTURE_ONLY mode - running from main project folder, skipping rsync',
       );
-      fs.mkdirSync(capturerPath, { recursive: true });
-    }
+    } else {
+      // Create capturer base directory
+      if (!fs.existsSync(capturerPath)) {
+        fs.mkdirSync(capturerPath, { recursive: true });
+      }
 
-    // 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 DEBUG: Directory copy completed');
-
-    // 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...');
-    console.log(`CodeYam DEBUG: capturerProjectPath = ${capturerProjectPath}`);
-    const sanitizeResult = sanitizeEnvFiles({
-      projectPath: capturerProjectPath,
-      log: (msg) => console.log(`CodeYam Sanitize: ${msg}`),
-    });
-    console.log(
-      `CodeYam DEBUG: Env files sanitized - created: ${sanitizeResult.createdFiles.length}, sanitized: ${sanitizeResult.sanitizedFiles.length}`,
-    );
-    if (sanitizeResult.sanitizedFiles.length > 0) {
-      console.log(
-        `CodeYam DEBUG: Sanitized files: ${sanitizeResult.sanitizedFiles.join(', ')}`,
-      );
-    }
+      // 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,
+      });
 
-    // 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,
+      // 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}`),
       });
-      console.log('CodeYam DEBUG: Universal mocks applied');
+      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(
@@ -150,12 +154,8 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
 
     // Start background processing loop
     // Each batch will spawn its own paired start+capture processes
-    console.log('CodeYam DEBUG: Starting processing loop...');
     runner.startProcessingLoop();
 
-    console.log(
-      'CodeYam DEBUG: SequentialCaptureTaskRunner created successfully',
-    );
     return runner;
   }
 
@@ -179,23 +179,18 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
   }
 
   private async runProcessingLoop(): Promise<void> {
-    console.log('CodeYam DEBUG: Processing loop started');
     while (!this.isCleanedUp) {
       if (this.queue.length === 0) {
         await new Promise((resolve) => setTimeout(resolve, 1000));
         continue;
       }
 
-      console.log(
-        `CodeYam DEBUG: Processing queue - ${this.queue.length} batches waiting`,
-      );
       this.isProcessing = true;
       const batch = this.queue.shift()!;
 
       try {
         await this.processBatch(batch);
 
-        console.log(`CodeYam DEBUG: Batch completed successfully`);
         // Notify callback of completion
         if (this.batchCompletedCallback) {
           this.batchCompletedCallback(batch);
@@ -210,7 +205,6 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
         this.isProcessing = false;
       }
     }
-    console.log('CodeYam DEBUG: Processing loop exited');
   }
 
   private async processBatch(analysisIds: string[]): Promise<void> {
@@ -265,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',
@@ -298,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) {
@@ -330,9 +352,6 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
   }
 
   enqueueWork(analysisIds: string[]): Promise<void> {
-    console.log(
-      `CodeYam DEBUG: Enqueueing batch of ${analysisIds.length} analyses`,
-    );
     this.queue.push(analysisIds);
     return Promise.resolve();
   }

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

@@ -1,5 +1,5 @@
 import type { Commit, Project } from '~codeyam/types';
-import { getSupabase } from '~codeyam/supabase';
+import { getSupabase } from '~codeyam/database';
 import type { AnalysisLoader, ReadyAnalysisData } from './taskRunner';
 
 interface SupabaseAnalysisLoaderConfig {
@@ -48,7 +48,7 @@ export default class SupabaseAnalysisLoader implements AnalysisLoader {
     let pageOffset = 0;
 
     while (true) {
-      const query = getSupabase()
+      const { data, error } = await getSupabase()
         .rpc('get_ready_to_be_captured_analyses', args)
         .select(
           'id, commit_id, branch_commit_sha, status->processingForCaptureAt',
@@ -56,7 +56,7 @@ export default class SupabaseAnalysisLoader implements AnalysisLoader {
         .range(pageOffset, pageOffset + pageSize - 1)
         .returns<ReadyAnalysisData[]>();
 
-      const { data, error } = await query;
+      const rows = data as ReadyAnalysisData[] | null;
 
       if (error) {
         console.error(
@@ -67,13 +67,13 @@ export default class SupabaseAnalysisLoader implements AnalysisLoader {
         return null;
       }
 
-      if (!data || data.length === 0) {
+      if (!rows || rows.length === 0) {
         break;
       }
 
-      allData.push(...data);
+      allData.push(...rows);
 
-      if (data.length < pageSize) {
+      if (rows.length < pageSize) {
         break;
       }
 

package/analyzer-template/project/orchestrateCapture.ts

@@ -23,7 +23,7 @@
  */
 
 import type { Commit, Project } from '~codeyam/types';
-import { updateCommitMetadata } from '~codeyam/supabase';
+import { updateCommitMetadata } from '~codeyam/database';
 
 import type {
   AnalysisLoader,
@@ -50,6 +50,9 @@ interface OrchestrateCaptureArgs {
   taskRunner: CaptureTaskRunner;
   analysisLoader?: AnalysisLoader;
   pollingInterval?: number;
+  // Optional commit for metadata/progress tracking only (not filtering).
+  // Use when full=true but you still want capture progress updates on a commit.
+  metadataCommit?: Commit | null;
 }
 
 export default async function orchestrateCapture({
@@ -62,6 +65,7 @@ export default async function orchestrateCapture({
   taskRunner,
   analysisLoader,
   pollingInterval = POLLING_INTERVAL,
+  metadataCommit,
 }: OrchestrateCaptureArgs) {
   if (!full && !analysisIds && !commit && !entityShas) {
     throw new Error(
@@ -318,9 +322,12 @@ export default async function orchestrateCapture({
         // console.log(
         //   `Codeyam Debug: All known analyses: ${Array.from(knownAnalyses).join(', ')}`,
         // );
-        if (commit) {
-          commit.metadata = await updateCommitMetadata({
-            commitId: commit.id,
+        // Use metadataCommit if provided, otherwise fall back to commit.
+        // This allows progress tracking even when commit is null (e.g., full=true mode).
+        const trackingCommit = metadataCommit ?? commit;
+        if (trackingCommit) {
+          trackingCommit.metadata = await updateCommitMetadata({
+            commitId: trackingCommit.id,
             runStatusUpdate: {
               readyToBeCaptured: knownAnalyses.size,
               capturesAttempted: capturedAnalysisIds.length + abandoned.length,
@@ -331,7 +338,9 @@ export default async function orchestrateCapture({
       }
 
       // Early exit: if we've processed work and the runner has naturally stopped
-      if (knownAnalyses.size > 0 && enqueuedAnalyses.size > 0) {
+      // IMPORTANT: Only exit early if we're draining (analysis phase complete).
+      // Without isDraining check, we might exit before slow-running analyses finish.
+      if (isDraining && knownAnalyses.size > 0 && enqueuedAnalyses.size > 0) {
         const isStillRunning = await taskRunner.isRunning();
         if (
           !isStillRunning &&
@@ -347,8 +356,10 @@ export default async function orchestrateCapture({
       }
 
       if (isDraining) {
-        // Exit immediately if analysis complete but no entities ready for capture
-        if (knownAnalyses.size === 0) {
+        // Exit if analysis complete but no entities ready for capture
+        // Only check this after at least one poll (not firstLoop) to ensure we've
+        // had a chance to query the database for ready analyses
+        if (knownAnalyses.size === 0 && !firstLoop) {
           console.log(
             'CodeYam Capture: Analysis complete but no entities ready for capture, exiting',
           );

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,10 @@
  * (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)").
+ *
+ * @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 +29,7 @@ export function reconcileMockDataKeys(
       continue;
     }
 
-    // Try to find closest match
+    // Try to find closest match using existing logic
     const closestKey = findClosestKey(key, expectedKeys);
     if (closestKey) {
       result[closestKey] = reconciledValue;
@@ -46,8 +49,16 @@ export function reconcileMockDataKeys(
  * - Extract function name and first argument(s)
  * - 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);
@@ -60,9 +71,111 @@ function findClosestKey(key: string, expectedKeys: string[]): string | null {
     }
   }
 
+  // If no match found and key has no parentheses, try matching with "()" appended
+  // This handles the case where LLM generates "getAll" but expected key is "getAll()"
+  if (!key.includes('(')) {
+    const keyWithParens = key + '()';
+    for (const expected of expectedKeys) {
+      if (expected === keyWithParens) {
+        return expected;
+      }
+    }
+  }
+
+  // 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 name and object arguments.
+  // This handles cases where LLM generates literal values but expected keys have variable references.
+  // e.g., "useQuery({ id: 123 })" matches "useQuery({ id: Number(id) })"
+  // e.g., "trpc.users.getById.useQuery({ userId: 'user-123' })" matches "trpc.users.getById.useQuery({ userId })"
+  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"
+    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) {
+        return expected;
+      }
+    }
+  }
+
+  // If key has a single argument with a literal value (string, number, etc.),
+  // 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)" with a variable reference.
+  // e.g., "useCustomSizes('example-slug')" matches "useCustomSizes(projectSlug)"
+  const singleArgMatch = key.match(
+    /^([a-zA-Z_][a-zA-Z0-9_.]*)\s*\(([^,)]+)\)$/,
+  );
+  if (singleArgMatch) {
+    const funcPath = singleArgMatch[1];
+    const arg = singleArgMatch[2].trim();
+    // Only apply this matching if the argument looks like a literal (quoted string or number)
+    const isLiteralArg = /^['"`].*['"`]$/.test(arg) || /^\d+$/.test(arg);
+    if (isLiteralArg) {
+      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
@@ -330,6 +335,7 @@ export default async function runAnalysis({
         desiredAnalyses,
         force,
         fileStore,
+        onAnalysisProducing: () => controller?.setAnalysisProducingPhase(),
       });
     }
 
@@ -350,6 +356,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(