@codeyam/codeyam-cli 0.1.0-staging.1 → 0.1.0-staging.596f0eb

package/analyzer-template/project/createEntitiesAndSortFiles.ts

@@ -11,9 +11,12 @@ import {
   updateCommitMetadata,
   upsertEntities,
   upsertEntityBranches,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import { LazyFileStore } from './LazyFileStore';
 
+// Track files we've already warned about to avoid duplicate warnings
+const warnedMissingFiles = new Set<string>();
+
 export interface EntityWithImportCount extends Entity {
   importCount?: number;
   started?: string;
@@ -89,12 +92,17 @@ async function findAndGatherEntity({
         ? fileStore.getByPath(importedEntityFilePath)
         : project.files.find((f) => f.path === importedEntityFilePath);
       if (!entityFile) {
-        console.log(
-          'CodeYam Error: Entity file not found for create and sort entities',
-          importedEntityName,
-          importedEntityFilePath,
-        );
-        throw new Error('Entity file not found for create and sort entities');
+        // File not in project - likely a mocked dependency or external library
+        // Skip this import rather than throwing, similar to gatherEntityMap.ts
+        if (!warnedMissingFiles.has(importedEntityFilePath)) {
+          warnedMissingFiles.add(importedEntityFilePath);
+          console.log(
+            'CodeYam Warning: Skipping dependency in create and sort - file not in project.files:',
+            importedEntityName,
+            importedEntityFilePath,
+          );
+        }
+        continue;
       }
 
       const info = await findAndGatherEntity({

package/analyzer-template/project/getFilesWithEntitiesFromRepo.ts

@@ -3,7 +3,7 @@ import {
   saveFiles,
   generateSha,
   loadEntities,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import { File, Project } from '~codeyam/types';
 import { ProjectAnalyzer } from '~codeyam/analyze';
 

package/analyzer-template/project/getScenarioUrl.ts

@@ -1,6 +1,17 @@
-import { Analysis, Project, ProjectFramework, Scenario, File } from '~codeyam/types';
+import {
+  Analysis,
+  Project,
+  ProjectFramework,
+  Scenario,
+  File,
+} from '~codeyam/types';
 import getScenarioPagePaths from './getScenarioPagePath';
-import { frameworkRouteFileNameToRoute, isFrameworkRoute, PROJECT_RELATIVE_PATH, getAppDirectoryForFile } from '~codeyam/utils';
+import {
+  frameworkRouteFileNameToRoute,
+  isFrameworkRoute,
+  PROJECT_RELATIVE_PATH,
+  getAppDirectoryForFile,
+} from '~codeyam/utils';
 
 export interface GetScenarioUrlArgs {
   project: Project;
@@ -10,6 +21,48 @@ export interface GetScenarioUrlArgs {
   framework: ProjectFramework;
 }
 
+/**
+ * Extract route params from scenario data for URL generation.
+ * Handles array values (for catch-all routes) by joining them.
+ *
+ * Scenario data can be stored in two locations:
+ * - scenario.data.argumentsData (primary)
+ * - scenario.metadata.data.argumentsData (fallback)
+ *
+ * @param scenario - The scenario containing mock data
+ * @returns A record of param names to string values, or undefined if no params
+ */
+function extractRouteParamsFromScenario(
+  scenario: Scenario,
+): Record<string, string | string[]> | undefined {
+  // Check both possible locations for argumentsData
+  const argumentsData =
+    scenario.data?.argumentsData ?? scenario.metadata?.data?.argumentsData;
+
+  if (!Array.isArray(argumentsData) || argumentsData.length === 0) {
+    return undefined;
+  }
+
+  const params = (argumentsData[0] as Record<string, unknown>)?.params;
+  if (!params || typeof params !== 'object') {
+    return undefined;
+  }
+
+  // Convert all values to strings or string arrays
+  const result: Record<string, string | string[]> = {};
+  for (const [key, value] of Object.entries(
+    params as Record<string, unknown>,
+  )) {
+    if (Array.isArray(value)) {
+      result[key] = value.map(String);
+    } else if (value !== null && value !== undefined) {
+      result[key] = String(value);
+    }
+  }
+
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
 /**
  * Get the URL path for a scenario (the path that goes in the iframe src)
  * This is the same logic used in generateCodeYamPage.ts to determine the iframe src
@@ -40,7 +93,10 @@ export default function getScenarioUrl({
     case ProjectFramework.Next:
       // the routePath looks like: relative/path/app/123/static/c054b7ee-3961-4697-8354-886062a95a9d/default/page.tsx
       // the path should look like: static/123/c054b7ee-3961-4697-8354-886062a95a9d/default/0
-      const appDirectory = getAppDirectoryForFile(file.path, project.metadata?.webapps);
+      const appDirectory = getAppDirectoryForFile(
+        file.path,
+        project.metadata?.webapps,
+      );
       path = routePath
         .replace(PROJECT_RELATIVE_PATH + '/' + appDirectory + '/', '')
         .split('/')
@@ -50,7 +106,10 @@ export default function getScenarioUrl({
     case ProjectFramework.NextPages:
       // the routePath looks like: relative/path/app/123/static/c054b7ee-3961-4697-8354-886062a95a9d/default/page.tsx
       // the path should look like: static/123/c054b7ee-3961-4697-8354-886062a95a9d/default/0
-      const pagesDirectory = getAppDirectoryForFile(file.path, project.metadata?.webapps);
+      const pagesDirectory = getAppDirectoryForFile(
+        file.path,
+        project.metadata?.webapps,
+      );
       path = routePath
         .replace(PROJECT_RELATIVE_PATH + '/' + pagesDirectory + '/', '')
         .split('/')
@@ -62,7 +121,16 @@ export default function getScenarioUrl({
   }
 
   if (isFrameworkRoute(file, analysis.entity, framework)) {
-    path = frameworkRouteFileNameToRoute(project.slug, file, analysis, framework, scenario.name);
+    // Extract route params from scenario mock data for URL generation
+    const routeParams = extractRouteParamsFromScenario(scenario);
+    path = frameworkRouteFileNameToRoute(
+      project.slug,
+      file,
+      analysis,
+      framework,
+      scenario.name,
+      routeParams,
+    );
   }
 
   return `/${path}`;

package/analyzer-template/project/loadReadyToBeCaptured.ts

@@ -1,5 +1,9 @@
 import { AnalysisContext, discoverDirectDependencies } from '~codeyam/analyze';
-import { loadAnalysis, loadReadyToBeCapturedAnalyses } from '~codeyam/supabase';
+import {
+  loadAnalysis,
+  loadEntities,
+  loadReadyToBeCapturedAnalyses,
+} from '~codeyam/database';
 import { Analysis, Project } from '~codeyam/types';
 import { LazyFileStore } from './LazyFileStore';
 
@@ -11,6 +15,132 @@ interface LoadReadyToBeCapturedArgs {
   fileStore?: LazyFileStore;
 }
 
+/**
+ * Recursively gather all entities referenced in importedExports of entities already in context.
+ * This fills the gap where discoverDirectDependencies skips mocked/type/implicit imports,
+ * but writeScenarioComponents still needs those entities in the context.
+ */
+async function gatherAllReferencedEntities(
+  context: AnalysisContext,
+  project: Project,
+): Promise<void> {
+  const processedKeys = new Set<string>();
+  let iterationCount = 0;
+  const MAX_ITERATIONS = 20; // Safety limit to prevent infinite loops
+
+  const getAllEntities = () =>
+    Object.values(context.getMutableEntityMap()).flatMap(Object.values);
+
+  while (iterationCount < MAX_ITERATIONS) {
+    iterationCount++;
+
+    // Collect all (filePath, entityName) pairs from importedExports of entities in context
+    const missingEntities = new Map<
+      string,
+      { filePath: string; name: string }
+    >();
+
+    for (const entity of getAllEntities()) {
+      for (const ie of entity.metadata?.importedExports ?? []) {
+        const filePath = ie.resolvedFilePath ?? ie.filePath;
+        const entityName = ie.resolvedName ?? ie.name;
+        const key = `${filePath}:${entityName}`;
+
+        // Skip if already in context or already processed
+        if (context.getEntity(filePath, entityName) || processedKeys.has(key)) {
+          continue;
+        }
+
+        missingEntities.set(key, { filePath, name: entityName });
+      }
+    }
+
+    if (missingEntities.size === 0) {
+      break; // No more missing entities
+    }
+
+    console.log(
+      `CodeYam: Entity gathering iteration ${iterationCount}: Loading ${missingEntities.size} missing entities`,
+    );
+
+    // Mark all as processed before loading to prevent re-processing
+    for (const key of missingEntities.keys()) {
+      processedKeys.add(key);
+    }
+
+    // Group by file path for batch loading
+    const byFilePath = new Map<string, string[]>();
+    for (const { filePath, name } of missingEntities.values()) {
+      if (!byFilePath.has(filePath)) {
+        byFilePath.set(filePath, []);
+      }
+      byFilePath.get(filePath)!.push(name);
+    }
+
+    // Batch load entities by file path
+    const loadPromises = Array.from(byFilePath.entries()).map(
+      async ([filePath, names]) => {
+        const entities = await loadEntities({
+          projectId: project.id,
+          filePaths: [filePath],
+        });
+
+        if (!entities) return [];
+
+        // Filter to only the entities we need (loadEntities returns all for the file)
+        // 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;
+        });
+      },
+    );
+
+    const results = await Promise.all(loadPromises);
+    const loadedEntities = results.flat();
+
+    // Add loaded entities to context
+    for (const entity of loadedEntities) {
+      context.addEntity(entity);
+
+      // Also register under 'default' alias if it's a default export
+      if (
+        entity.metadata &&
+        !entity.metadata.notExported &&
+        !entity.metadata.namedExport
+      ) {
+        context.addEntity(entity, 'default');
+      }
+    }
+
+    console.log(
+      `CodeYam: Loaded ${loadedEntities.length} entities in iteration ${iterationCount}`,
+    );
+  }
+
+  if (iterationCount >= MAX_ITERATIONS) {
+    console.log(
+      `CodeYam Warning: Entity gathering reached max iterations (${MAX_ITERATIONS}), some entities may be missing`,
+    );
+  }
+
+  console.log(
+    `CodeYam: Entity gathering complete after ${iterationCount} iteration(s), context has ${getAllEntities().length} entities`,
+  );
+}
+
 /**
  * Load the minimal set of analyses required to successfully run scenario capture.
  * This includes the root analyses (with scenarios) plus all recursive mock dependencies.
@@ -145,7 +275,7 @@ export default async function loadReadyToBeCaptured({
     `CodeYam: Loaded ${allRequiredAnalyses.size} total analyses for scenario capture`,
   );
 
-  // Populate the provided analysis context
+  // Populate the provided analysis context with analyses and their direct entities
   for (const analysis of allRequiredAnalyses.values()) {
     // Add the entity if it exists
     if (analysis.entity) {
@@ -156,6 +286,12 @@ export default async function loadReadyToBeCaptured({
     context.addAnalysis(analysis, analysis.filePath, analysis.entityName);
   }
 
+  // Recursively gather ALL entities referenced in importedExports.
+  // This is necessary because discoverDirectDependencies only finds entities that need
+  // ANALYSES loaded (skipping mocked imports, type imports, etc.), but writeScenarioComponents
+  // needs ALL entities in the context for import path rewriting and recursion.
+  await gatherAllReferencedEntities(context, project);
+
   // Extract the root analyses with scenarios from allRequiredAnalyses (they were reloaded with mocks)
   const finalReadyToBeCaptured = readyToBeCapturedAnalyses.map(
     (originalAnalysis) => {

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

@@ -1,5 +1,5 @@
 import type { Commit, Project } from '~codeyam/types';
-import { getDatabase } from '~codeyam/supabase';
+import { getDatabase } from '~codeyam/database';
 import { sql } from 'kysely';
 import type { AnalysisLoader, ReadyAnalysisData } from './taskRunner';
 
@@ -46,21 +46,20 @@ 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);
 
         // Optional: branch commit SHA filter
         if (this.config.commit?.metadata?.baseline) {
-          query = query.where(
-            'branch_commit_sha',
-            '=',
-            this.config.commit.sha,
-          );
+          query = query.where('branch_commit_sha', '=', this.config.commit.sha);
         }
 
         // Optional: commit ID filter
@@ -98,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
@@ -111,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

@@ -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()));
@@ -96,9 +97,6 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
 
     // Create capturer base directory
     if (!fs.existsSync(capturerPath)) {
-      console.log(
-        `CodeYam DEBUG: Creating capturer directory at ${capturerPath}`,
-      );
       fs.mkdirSync(capturerPath, { recursive: true });
     }
 
@@ -111,22 +109,17 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
       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(', ')}`,
+        `CodeYam: Env files sanitized: ${sanitizeResult.sanitizedFiles.join(', ')}`,
       );
     }
 
@@ -139,7 +132,6 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
         mocks: context.universalMocks,
         projectPath: capturerProjectPath,
       });
-      console.log('CodeYam DEBUG: Universal mocks applied');
     }
 
     const runner = new SequentialCaptureTaskRunner(
@@ -150,12 +142,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 +167,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 +193,6 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
         this.isProcessing = false;
       }
     }
-    console.log('CodeYam DEBUG: Processing loop exited');
   }
 
   private async processBatch(analysisIds: string[]): Promise<void> {
@@ -330,9 +312,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,
@@ -331,7 +331,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 +349,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

@@ -46,8 +46,10 @@ 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
  *
  * e.g., "eq('user_id', 'user-12345')" matches "eq('user_id', user.id)"
+ * e.g., "getAll" matches "getAll()"
  */
 function findClosestKey(key: string, expectedKeys: string[]): string | null {
   const keyBase = extractKeyBase(key);
@@ -60,6 +62,17 @@ 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;
+      }
+    }
+  }
+
   return null;
 }
 

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';

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;
@@ -519,7 +515,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,