@codeyam/codeyam-cli 0.1.0-staging.da5baf5 → 0.1.0-staging.dd216e0

package/analyzer-template/packages/utils/src/lib/frameworks/sanitizeNextRouteSegments.ts

@@ -1,15 +1,25 @@
 /**
- * Sanitize Next.js route path segments to remove special syntax.
+ * Sanitize Next.js route path segments for use in URLs or folder paths.
+ *
+ * Behavior depends on whether routeParams is provided:
+ *
+ * WITH routeParams (for URL generation):
+ * - Route groups (folder) become folder (strip parens, keep name)
+ * - Dynamic segments [param] are substituted with actual values from routeParams
+ * - Catch-all [...slug] values (arrays) are joined with '/'
+ * - Missing params fall back to preserving the bracket syntax
+ *
+ * WITHOUT routeParams (for folder creation):
  * - Route groups (folder) become folder (strip parens, keep name)
- * - Dynamic segments [param] become param0 (suffix avoids Next.js private folder convention)
- * - Catch-all [...slug] becomes slug0
- * - Optional catch-all [[...slug]] becomes slug0
+ * - Dynamic segments [param], [...slug], [[...slug]] are preserved as-is
+ *   so Next.js recognizes them as dynamic routes and populates params
  *
- * Note: We use suffix "0" instead of prefix "_" because Next.js treats folders
- * starting with underscore as private segments that are excluded from routing.
+ * @param segments - Array of path segments (e.g., ['app', '[environmentId]', 'page.tsx'])
+ * @param routeParams - Optional map of param names to values for URL substitution
  */
 export default function sanitizeNextRouteSegments(
   segments: string[],
+  routeParams?: Record<string, string | string[]>,
 ): string[] {
   return segments.map((segment) => {
     // Handle route groups (folder) - strip parens, keep name
@@ -18,15 +28,39 @@ export default function sanitizeNextRouteSegments(
 
     // Handle optional catch-all [[...param]]
     const optionalCatchAll = segment.match(/^\[\[\.\.\.([\w]+)\]\]$/);
-    if (optionalCatchAll) return `${optionalCatchAll[1]}0`;
+    if (optionalCatchAll) {
+      const paramName = optionalCatchAll[1];
+      if (routeParams && paramName in routeParams) {
+        const value = routeParams[paramName];
+        return Array.isArray(value) ? value.join('/') : String(value);
+      }
+      // Preserve bracket syntax for folder creation (no routeParams)
+      return segment;
+    }
 
     // Handle catch-all [...param]
     const catchAll = segment.match(/^\[\.\.\.([\w]+)\]$/);
-    if (catchAll) return `${catchAll[1]}0`;
+    if (catchAll) {
+      const paramName = catchAll[1];
+      if (routeParams && paramName in routeParams) {
+        const value = routeParams[paramName];
+        return Array.isArray(value) ? value.join('/') : String(value);
+      }
+      // Preserve bracket syntax for folder creation (no routeParams)
+      return segment;
+    }
 
     // Handle dynamic [param]
     const dynamic = segment.match(/^\[([\w]+)\]$/);
-    if (dynamic) return `${dynamic[1]}0`;
+    if (dynamic) {
+      const paramName = dynamic[1];
+      if (routeParams && paramName in routeParams) {
+        const value = routeParams[paramName];
+        return Array.isArray(value) ? value.join('/') : String(value);
+      }
+      // Preserve bracket syntax for folder creation (no routeParams)
+      return segment;
+    }
 
     return segment;
   });

package/analyzer-template/packages/utils/src/lib/lightweightEntityExtractor.ts

@@ -121,6 +121,22 @@ export function extractEntitiesFromContent(
           entityType: 'unknown',
           isDefault: true,
         });
+      } else if (ts.isExportDeclaration(node) && node.exportClause) {
+        // Handle re-exports: export { foo, bar } from './module'
+        // and named exports: export { foo, bar }
+        if (ts.isNamedExports(node.exportClause)) {
+          const code = node.getText(sourceFile);
+          for (const element of node.exportClause.elements) {
+            const exportedName = element.name.text;
+            entities.push({
+              name: exportedName,
+              code,
+              sha: generateSha(filePath, exportedName, code),
+              entityType: 'unknown',
+              isDefault: false,
+            });
+          }
+        }
       }
 
       ts.forEachChild(node, visit);
@@ -249,6 +265,33 @@ export function findEntityInContent(
             }
           }
         }
+      } else if (
+        ts.isFunctionDeclaration(node) &&
+        !hasExportModifier(node) &&
+        node.name?.text === entityName
+      ) {
+        // Non-exported function declaration
+        result = {
+          code: node.getText(sourceFile),
+          start: node.getStart(sourceFile),
+          end: node.getEnd(),
+        };
+        return;
+      } else if (ts.isVariableStatement(node) && !hasExportModifier(node)) {
+        // Non-exported variable statement
+        for (const declaration of node.declarationList.declarations) {
+          if (
+            ts.isIdentifier(declaration.name) &&
+            declaration.name.text === entityName
+          ) {
+            result = {
+              code: node.getText(sourceFile),
+              start: node.getStart(sourceFile),
+              end: node.getEnd(),
+            };
+            return;
+          }
+        }
       }
 
       ts.forEachChild(node, visit);

package/analyzer-template/packages/utils/src/lib/safeFileName.ts

@@ -1,6 +1,9 @@
 export default function safeFileName(name: string) {
   // Replace unsafe characters with underscores, preserving original casing
-  const safeSlug = name.replace(/[^a-zA-Z0-9_]+/g, '_');
+  // Then trim leading/trailing underscores to avoid malformed route segments
+  const safeSlug = name.replace(/[^a-zA-Z0-9_]+/g, '_').replace(/^_+|_+$/g, '');
+
+  if (!safeSlug) return '';
 
   // Ensure it starts with a capital letter (for consistency with Remix routes)
   return safeSlug.slice(0, 1).toUpperCase() + safeSlug.slice(1);

package/analyzer-template/packages/utils/src/lib/startCommand/buildStartCommand.ts

@@ -0,0 +1,63 @@
+import { WebApp, EnvironmentVariable } from '~codeyam/types';
+
+export interface BuildStartCommandOptions {
+  webapp: WebApp | undefined;
+  port: number;
+  environmentVariables: EnvironmentVariable[];
+  packageManager: string;
+}
+
+/**
+ * Builds a shell-ready start command string for a webapp.
+ *
+ * This function handles:
+ * - $PORT substitution in args and env vars
+ * - Environment variable formatting with proper escaping
+ * - sh -c command quoting
+ * - Fallback when no startCommand is configured
+ */
+export default function buildStartCommand(
+  options: BuildStartCommandOptions,
+): string {
+  const { webapp, port, environmentVariables, packageManager } = options;
+  const startCmd = webapp?.startCommand;
+
+  // Fallback when no startCommand configured
+  if (!startCmd) {
+    return `${packageManager} ${packageManager === 'npm' ? 'run ' : ''}dev`;
+  }
+
+  // Substitute $PORT in args
+  const args =
+    startCmd.args?.map((arg: string) => arg.replace(/\$PORT/g, String(port))) ??
+    [];
+
+  // Build environment variables string from config
+  const envVars: string[] = [];
+  for (const envVar of environmentVariables) {
+    if (envVar.key && envVar.value !== undefined) {
+      // Escape single quotes in values
+      const escapedValue = String(envVar.value).replace(/'/g, "'\\''");
+      envVars.push(`${envVar.key}='${escapedValue}'`);
+    }
+  }
+
+  // Add any env vars from startCommand.env
+  if (startCmd.env) {
+    for (const [key, value] of Object.entries(startCmd.env)) {
+      const substitutedValue = String(value).replace(/\$PORT/g, String(port));
+      const escapedValue = substitutedValue.replace(/'/g, "'\\''");
+      envVars.push(`${key}='${escapedValue}'`);
+    }
+  }
+
+  const envPrefix = envVars.length > 0 ? envVars.join(' ') + ' ' : '';
+
+  // If command is 'sh' with '-c' arg, properly quote the shell command
+  if (startCmd.command === 'sh' && args[0] === '-c' && args[1]) {
+    return `${envPrefix}sh -c "${args[1]}"`;
+  }
+
+  // Default: just join command and args
+  return `${envPrefix}${startCmd.command} ${args.join(' ')}`;
+}

package/analyzer-template/packages/utils/src/lib/startCommand/getWebappInfo.ts

@@ -0,0 +1,108 @@
+import { WebApp, EnvironmentVariable, ProjectFramework } from '~codeyam/types';
+import buildStartCommand from './buildStartCommand';
+import * as path from 'path';
+
+export interface GetWebappInfoOptions {
+  filePath: string;
+  webapps: WebApp[];
+  environmentVariables: EnvironmentVariable[];
+  port: number;
+  packageManager: string;
+}
+
+export interface WebappInfo {
+  webapp: WebApp;
+  webappPath: string;
+  framework: ProjectFramework;
+  packageManager: string;
+  startCommand: string;
+  url: string;
+}
+
+/**
+ * Find which webapp a component belongs to based on its file path.
+ * Returns the webapp with the most specific (longest) path match.
+ */
+function findWebAppForComponent(
+  componentPath: string,
+  webapps: WebApp[],
+): WebApp | undefined {
+  if (!webapps || webapps.length === 0) {
+    return undefined;
+  }
+
+  if (webapps.length === 1) {
+    return webapps[0];
+  }
+
+  // Normalize the component path
+  const normalizedComponentPath = path.normalize(componentPath);
+
+  // Sort webapps by path length (descending) to match most specific path first
+  const sortedWebapps = [...webapps].sort(
+    (a, b) => (b.path?.length ?? 0) - (a.path?.length ?? 0),
+  );
+
+  // Find the webapp whose path is a prefix of the component path
+  for (const webapp of sortedWebapps) {
+    const webappPath = path.normalize(webapp.path ?? '.');
+
+    // Check if component is within this webapp
+    if (webappPath === '.') {
+      // Root webapp - matches everything (but we check others first due to sorting)
+      return webapp;
+    }
+
+    // Check if component path starts with webapp path
+    if (
+      normalizedComponentPath.startsWith(webappPath + path.sep) ||
+      normalizedComponentPath === webappPath
+    ) {
+      return webapp;
+    }
+  }
+
+  // Fallback to first webapp
+  return webapps[0];
+}
+
+/**
+ * Gets comprehensive webapp information for a given file path.
+ *
+ * This function:
+ * - Finds the correct webapp for the file path
+ * - Builds the complete start command with environment variables
+ * - Returns all relevant webapp metadata
+ */
+export default function getWebappInfo(
+  options: GetWebappInfoOptions,
+): WebappInfo {
+  const { filePath, webapps, environmentVariables, port, packageManager } =
+    options;
+
+  if (!webapps || webapps.length === 0) {
+    throw new Error('No webapps configured. Please run CodeYam init again.');
+  }
+
+  const webapp = findWebAppForComponent(filePath, webapps);
+
+  if (!webapp) {
+    throw new Error('Could not find webapp for file path: ' + filePath);
+  }
+
+  const startCommand = buildStartCommand({
+    webapp,
+    port,
+    environmentVariables,
+    packageManager,
+  });
+
+  return {
+    webapp,
+    webappPath: webapp.path ?? '.',
+    framework: webapp.framework,
+    packageManager: webapp.packageManager ?? packageManager,
+    startCommand,
+    url: `http://localhost:${port}/static/codeyam-sample`,
+  };
+}

package/analyzer-template/packages/utils/src/lib/startCommand/index.ts

@@ -0,0 +1,10 @@
+export {
+  default as buildStartCommand,
+  type BuildStartCommandOptions,
+} from './buildStartCommand';
+
+export {
+  default as getWebappInfo,
+  type GetWebappInfoOptions,
+  type WebappInfo,
+} from './getWebappInfo';

package/analyzer-template/playwright/capture.ts

@@ -6,7 +6,7 @@ import {
   loadScenario,
   updateFreshAnalysisStatus,
   updateFreshAnalysisStatusWithScenarios,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import { default as checkURL, URLStatus } from './checkURL';
 import { Analysis, AnalysisStatus, Scenario } from '~codeyam/types';
 import getCodeYamInfo, { CodeYamInfo } from './getCodeYamInfo';
@@ -64,6 +64,46 @@ async function readControllerPortFromLog(
   return null;
 }
 
+/**
+ * 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)
+ */
+function extractRouteParamsFromScenario(
+  scenario: Scenario,
+): Record<string, string | string[]> | undefined {
+  // Check both possible locations for argumentsData
+  const argumentsData =
+    scenario.data?.argumentsData ??
+    (scenario.metadata?.data as { argumentsData?: unknown[] } | undefined)
+      ?.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;
+  }
+
+  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;
+}
+
 // Set process title for Activity Monitor visibility
 if (process.env.CODEYAM_PROCESS_NAME) {
   process.title = process.env.CODEYAM_PROCESS_NAME;
@@ -450,12 +490,15 @@ export default async function capture({
         let selector;
         if (isFrameworkRoute(file, analysis.entity, framework)) {
           awsLog('CodeYam: Route file', file.name);
+          // Extract route params from scenario mock data for URL generation
+          const routeParams = extractRouteParamsFromScenario(scenario);
           relativePath = frameworkRouteFileNameToRoute(
             projectSlug,
             file,
             analysis,
             framework,
             scenario.name,
+            routeParams,
           );
         } else {
           selector = '#component';
@@ -799,36 +842,12 @@ export default async function capture({
 
             // Check if all scenarios are now complete
             // dbScenarios comes from the scenarios table and gives us the accurate expected count
-            const expectedScenarioCount = dbScenarios.length;
-            awsLog('CodeYam DEBUG: Checking if all scenarios complete', {
-              analysisId: inAnalysis.id,
-              expectedScenarioCount,
-              actualStatusCount: freshStatus.scenarios.length,
-              dbScenarioNames: dbScenarios.map((s) => s.name),
-              statusScenarioNames: freshStatus.scenarios.map((s) => s.name),
-            });
-
-            const allScenariosAvailable =
-              freshStatus.scenarios.length >= expectedScenarioCount;
-            awsLog('CodeYam DEBUG: Scenario completion check', {
-              analysisId: inAnalysis.id,
-              expectedScenarioCount,
-              actualScenarioCount: freshStatus.scenarios.length,
-              allScenariosAvailable,
-              allHaveFinishedAt: freshStatus.scenarios.every(
-                (s) => !!s.finishedAt,
-              ),
-            });
             if (
-              allScenariosAvailable &&
+              freshStatus.scenarios.length >= dbScenarios.length &&
               freshStatus.scenarios.every((s) => !!s.finishedAt)
             ) {
               freshStatus.finishedAt = new Date().toISOString();
               freshStatus.readyToBeCaptured = false;
-              awsLog('CodeYam DEBUG: All scenarios complete result', {
-                analysisId: inAnalysis.id,
-                finishedAt: freshStatus.finishedAt,
-              });
             }
           },
         );
@@ -837,21 +856,6 @@ export default async function capture({
           1,
           `Capture process complete for ${analysis.entityName}: ${scenarioName}`,
         );
-        awsLog(
-          'CodeYam CAPTURE DEBUG: Capture Complete - about to call taskComplete',
-          {
-            fileId: file?.id,
-            analysisId: analysis?.id,
-            filePath: file?.path,
-            entityName:
-              analysis?.entity?.metadata?.exportAlias ?? analysis?.entityName,
-            scenarioName: scenario?.name,
-            scenarioId: scenario?.id,
-            entityType: analysis?.entity?.entityType,
-            isDefaultScenario: scenario.name === DEFAULT_SCENARIO_NAME,
-            controllerUrl,
-          },
-        );
 
         await taskComplete(controllerUrl, scenario.id);
 
@@ -861,17 +865,6 @@ export default async function capture({
           includeScenarios: true,
         });
 
-        awsLog('CodeYam DEBUG: Checking if all scenarios complete', {
-          analysisId: analysis.id,
-          scenarioCount: freshAnalysis.scenarios.length,
-          scenarios: freshAnalysis.scenarios.map((s) => s.name),
-          statusScenarios: freshAnalysis.status?.scenarios?.map((ss) => ({
-            name: ss.name,
-            hasFinishedAt: !!ss.finishedAt,
-            hasError: !!ss.error,
-          })),
-        });
-
         const allScenariosComplete = freshAnalysis.scenarios.every((s) => {
           const scenarioStatus = freshAnalysis.status?.scenarios?.find(
             (ss) => ss.name === s.name,
@@ -879,21 +872,7 @@ export default async function capture({
           // A scenario is only complete if it has finishedAt
           // An error alone is not enough - that might just be the protective error
           // set before the server starts
-          const isComplete = !!scenarioStatus?.finishedAt;
-
-          awsLog('CodeYam DEBUG: Scenario completion check', {
-            scenarioName: s.name,
-            hasStatus: !!scenarioStatus,
-            hasFinishedAt: !!scenarioStatus?.finishedAt,
-            hasError: !!scenarioStatus?.error,
-            isComplete,
-          });
-
-          return isComplete;
-        });
-
-        awsLog('CodeYam DEBUG: All scenarios complete result', {
-          allScenariosComplete,
+          return !!scenarioStatus?.finishedAt;
         });
 
         if (allScenariosComplete) {

package/analyzer-template/playwright/captureFromUrl.ts

@@ -8,7 +8,7 @@ import {
   loadProject,
   loadScenario,
   upsertScenarios,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { loadEnv } from '~codeyam/utils/server';
@@ -33,7 +33,13 @@ async function main() {
   }
 
   const config: CaptureArgs = JSON.parse(args[0]);
-  const { url, scenarioId, projectId, projectRoot, viewportWidth = 1440 } = config;
+  const {
+    url,
+    scenarioId,
+    projectId,
+    projectRoot,
+    viewportWidth = 1440,
+  } = config;
 
   // KEY DEBUG INFO: What URL are we capturing?
   console.log(`[Capture] Received URL: ${url}`);
@@ -42,35 +48,49 @@ async function main() {
   // Load the scenario from database
   const scenario = await loadScenario({ id: scenarioId, projectId });
   if (!scenario) {
-    console.error(`[Capture] ERROR: Scenario ${scenarioId} not found in database`);
+    console.error(
+      `[Capture] ERROR: Scenario ${scenarioId} not found in database`,
+    );
     process.exit(1);
   }
 
   // KEY DEBUG INFO: What data does this scenario have?
-  console.log(`[Capture] Loaded scenario from DB: "${scenario.name}" (id: ${scenario.id})`);
+  console.log(
+    `[Capture] Loaded scenario from DB: "${scenario.name}" (id: ${scenario.id})`,
+  );
   console.log(`[Capture] Scenario analysisId: ${scenario.analysisId}`);
 
   const argData = scenario.metadata?.data?.argumentsData;
   if (Array.isArray(argData) && argData.length > 0) {
-    console.log(`[Capture] Scenario data preview: ${JSON.stringify(argData[0]).substring(0, 200)}...`);
+    console.log(
+      `[Capture] Scenario data preview: ${JSON.stringify(argData[0]).substring(0, 200)}...`,
+    );
   } else {
     console.log(`[Capture] Scenario has no argumentsData`);
   }
 
   // Load analysis to get fileId (required for correct screenshot path convention)
   // Also load scenarios so we can regenerate MockData.tsx
-  const analysis = await loadAnalysis({ id: scenario.analysisId, includeFile: true, includeScenarios: true });
+  const analysis = await loadAnalysis({
+    id: scenario.analysisId,
+    includeFile: true,
+    includeScenarios: true,
+  });
   if (!analysis) {
     console.error(`[Capture] ERROR: Analysis ${scenario.analysisId} not found`);
     process.exit(1);
   }
   if (!analysis.file?.id) {
-    console.error(`[Capture] ERROR: Analysis ${scenario.analysisId} has no associated file`);
+    console.error(
+      `[Capture] ERROR: Analysis ${scenario.analysisId} has no associated file`,
+    );
     process.exit(1);
   }
   const fileId = analysis.file.id;
   console.log(`[Capture] Analysis fileId: ${fileId}`);
-  console.log(`[Capture] Analysis scenarios count: ${analysis.scenarios?.length || 0}`);
+  console.log(
+    `[Capture] Analysis scenarios count: ${analysis.scenarios?.length || 0}`,
+  );
 
   // Load project to get slug for screenshot path
   const project = await loadProject({ id: projectId });
@@ -82,7 +102,9 @@ async function main() {
 
   // Regenerate MockData.tsx to ensure dev server has the latest scenario data
   // This is critical for recapture to show updated data
-  console.log(`[Capture] Regenerating MockData.tsx for scenario: ${scenario.name}`);
+  console.log(
+    `[Capture] Regenerating MockData.tsx for scenario: ${scenario.name}`,
+  );
 
   try {
     // Load config to find which webapp this analysis belongs to
@@ -94,7 +116,9 @@ async function main() {
     console.log(`[Capture] Analysis file path: ${filePath}`);
 
     // Find which webapp this file belongs to
-    const webapp = projectConfig.webapps?.find((w: { path: string }) => filePath.startsWith(w.path));
+    const webapp = projectConfig.webapps?.find((w: { path: string }) =>
+      filePath.startsWith(w.path),
+    );
 
     if (webapp) {
       console.log(`[Capture] Found webapp: ${webapp.path}`);
@@ -105,7 +129,7 @@ async function main() {
         localDevProjectPath,
         webapp.path,
         webapp.appDirectory || 'app',
-        '__codeyamMocks__'
+        '__codeyamMocks__',
       );
 
       console.log(`[Capture] MockData.tsx directory: ${mocksDir}`);
@@ -117,7 +141,7 @@ async function main() {
       };
 
       // If the current scenario isn't in the scenarios array, add it
-      if (!analysisWithScenarios.scenarios.find(s => s.id === scenario.id)) {
+      if (!analysisWithScenarios.scenarios.find((s) => s.id === scenario.id)) {
         analysisWithScenarios.scenarios.push(scenario);
       }
 
@@ -126,19 +150,26 @@ async function main() {
 
       // Give the dev server time to hot-reload the updated MockData.tsx
       console.log(`[Capture] Waiting for dev server to reload...`);
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      await new Promise((resolve) => setTimeout(resolve, 2000));
       console.log(`[Capture] Proceeding with screenshot capture`);
     } else {
-      console.log(`[Capture] WARNING: Could not find webapp for file ${filePath}, skipping MockData.tsx regeneration`);
+      console.log(
+        `[Capture] WARNING: Could not find webapp for file ${filePath}, skipping MockData.tsx regeneration`,
+      );
     }
   } catch (mockError) {
-    console.error(`[Capture] WARNING: Failed to regenerate MockData.tsx:`, mockError);
+    console.error(
+      `[Capture] WARNING: Failed to regenerate MockData.tsx:`,
+      mockError,
+    );
     // Continue with screenshot capture even if MockData regeneration fails
   }
 
   // Screenshot path convention: {slug}/{fileId}/{analysisId}/{scenarioName}.png
   // This matches the original capture system in capture.ts
-  const sanitizedName = scenario.name.replace(/\s+/g, '_').replace(/[^a-zA-Z0-9_-]/g, '');
+  const sanitizedName = scenario.name
+    .replace(/\s+/g, '_')
+    .replace(/[^a-zA-Z0-9_-]/g, '');
   const screenshotFileName = `${sanitizedName}.png`;
   const capturesDir = path.join(
     projectRoot,
@@ -147,7 +178,7 @@ async function main() {
     'screenshots',
     projectSlug,
     fileId,
-    scenario.analysisId
+    scenario.analysisId,
   );
   const screenshotPath = path.join(capturesDir, screenshotFileName);
 

package/analyzer-template/playwright/captureStatic.ts

@@ -4,7 +4,7 @@ import {
   updateCommitMetadata,
   updateFreshAnalysisStatus,
   updateFreshAnalysisStatusWithScenarios,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import { uploadAssetDirectory } from './uploadAssets';
 import invalidateCloudFrontPath from './invalidateCloudFrontPath';
 import { awsLogDebugLevel, pushAnalysisError } from '~codeyam/utils';