@codeyam/codeyam-cli 0.1.0-staging.bbe4da9 → 0.1.0-staging.e38f7bd

package/analyzer-template/packages/ai/src/lib/transformMockDataToMatchSchema.ts

@@ -0,0 +1,156 @@
+/**
+ * Transforms mock data values to match expected schema types.
+ *
+ * LLMs sometimes generate values in the wrong format. For example, when analyzing
+ * code like `const segments = splat.split('/').filter(Boolean)`, the LLM might
+ * output an array like `["scenarios", "abc123"]` even though `splat` is typed as
+ * a string and should be `"scenarios/abc123"`.
+ *
+ * This function walks the mock data and schema in parallel, transforming values
+ * that don't match their expected types.
+ */
+
+type SchemaValue = string | Record<string, unknown> | unknown[];
+
+/**
+ * Gets the base type from a schema type string like "string | undefined" -> "string"
+ */
+function getBaseType(schemaType: string): string {
+  // Remove "| undefined", "| null", etc. and get the primary type
+  const parts = schemaType.split('|').map((s) => s.trim());
+  const primaryType = parts.find(
+    (p) => p !== 'undefined' && p !== 'null' && p !== 'never',
+  );
+  return primaryType || parts[0];
+}
+
+/**
+ * Transforms a single value to match the expected schema type
+ */
+function transformValue(value: unknown, schemaType: string): unknown {
+  if (value === null || value === undefined) {
+    return value;
+  }
+
+  const baseType = getBaseType(schemaType);
+
+  // Array -> String: join with '/' (common for route params like `params['*']`)
+  if (Array.isArray(value) && baseType === 'string') {
+    return value.join('/');
+  }
+
+  // String -> Number
+  if (typeof value === 'string' && baseType === 'number') {
+    const num = Number(value);
+    if (!isNaN(num)) {
+      return num;
+    }
+  }
+
+  // Number -> String
+  if (typeof value === 'number' && baseType === 'string') {
+    return String(value);
+  }
+
+  // Boolean -> String
+  if (typeof value === 'boolean' && baseType === 'string') {
+    return String(value);
+  }
+
+  // String -> Boolean
+  if (typeof value === 'string' && baseType === 'boolean') {
+    return value === 'true';
+  }
+
+  return value;
+}
+
+/**
+ * Recursively transforms mock data to match the schema types
+ */
+function transformObject(
+  mockData: Record<string, unknown>,
+  schema: Record<string, SchemaValue>,
+  path: string = '',
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+
+  for (const key of Object.keys(mockData)) {
+    const value = mockData[key];
+    const schemaValue = schema[key];
+    const currentPath = path ? `${path}.${key}` : key;
+
+    if (schemaValue === undefined) {
+      // No schema for this key, keep as-is
+      result[key] = value;
+      continue;
+    }
+
+    if (typeof schemaValue === 'string') {
+      // Schema is a type string like "string" or "string | undefined"
+      result[key] = transformValue(value, schemaValue);
+    } else if (
+      typeof schemaValue === 'object' &&
+      schemaValue !== null &&
+      !Array.isArray(schemaValue)
+    ) {
+      // Schema is a nested object
+      if (
+        typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value)
+      ) {
+        result[key] = transformObject(
+          value as Record<string, unknown>,
+          schemaValue as Record<string, SchemaValue>,
+          currentPath,
+        );
+      } else {
+        result[key] = value;
+      }
+    } else if (Array.isArray(schemaValue)) {
+      // Schema is an array - transform each item if value is also an array
+      if (Array.isArray(value) && schemaValue.length > 0) {
+        const itemSchema = schemaValue[0];
+        if (typeof itemSchema === 'object' && itemSchema !== null) {
+          result[key] = value.map((item, i) => {
+            if (typeof item === 'object' && item !== null) {
+              return transformObject(
+                item as Record<string, unknown>,
+                itemSchema as Record<string, SchemaValue>,
+                `${currentPath}[${i}]`,
+              );
+            }
+            return item;
+          });
+        } else {
+          result[key] = value;
+        }
+      } else {
+        result[key] = value;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Transforms scenario mock data to match expected schema types.
+ *
+ * @param mockData - The generated mock data from the LLM
+ * @param dataForMocks - The schema defining expected types
+ * @returns The transformed mock data with values matching expected types
+ */
+export default function transformMockDataToMatchSchema(
+  mockData: Record<string, unknown> | undefined,
+  dataForMocks: Record<string, unknown> | undefined,
+): Record<string, unknown> | undefined {
+  if (!mockData || !dataForMocks) {
+    return mockData;
+  }
+
+  return transformObject(mockData, dataForMocks as Record<string, SchemaValue>);
+}

package/analyzer-template/packages/ai/src/lib/worker/SerializableDataStructure.ts

@@ -24,6 +24,10 @@ export interface SerializableFunctionCallInfo {
   equivalencies?: Record<string, SerializableScopeVariable[]>;
   /** All call signatures merged into this entry (e.g., logger.info, logger.debug) */
   allCallSignatures?: string[];
+  /** Variable names that receive the return value of each call */
+  receivingVariableNames?: string[];
+  /** Maps each call signature to the variable that receives its return value */
+  callSignatureToVariable?: Record<string, string>;
 }
 
 export interface SerializableFunctionResult {

package/analyzer-template/packages/analyze/src/lib/FileAnalyzer.ts

@@ -177,6 +177,93 @@ export class FileAnalyzer {
     return lib.asts.sourceFiles.getAllExports(this.sourceFile);
   }
 
+  /**
+   * Find an export by following star export chains.
+   * When a file has `export * from './path'`, this method will recursively
+   * resolve the path and search for the export in the target module.
+   *
+   * @param exportName The name of the export to find
+   * @param visited Set of already visited file paths to prevent infinite loops
+   * @returns The export info with resolved path if found, undefined otherwise
+   */
+  findExportThroughStarExports(
+    exportName: string,
+    visited: Set<string> = new Set(),
+  ): { export: ExportedFunction; resolvedPath: string } | undefined {
+    if (!this.file?.path || visited.has(this.file.path)) {
+      return undefined;
+    }
+    visited.add(this.file.path);
+
+    const exports = this.getAllExports();
+
+    // First, check if the export exists directly
+    const directExport = exports[exportName];
+    if (directExport) {
+      return { export: directExport, resolvedPath: this.file.path };
+    }
+
+    // If not found directly, look for star exports and follow them
+    const starExports = Object.entries(exports).filter(
+      ([_, exp]) => exp.isStarExport,
+    );
+
+    for (const [_, starExport] of starExports) {
+      if (!starExport.directImportPath) continue;
+
+      // Resolve the star export path
+      const resolvedModule = this.getResolvedModule(
+        starExport.directImportPath,
+      );
+      if (!resolvedModule) continue;
+
+      const resolvedPath = this.projectAnalyzer.getRelativePath(
+        resolvedModule.resolvedFileName,
+      );
+
+      // Handle dist -> src mapping for workspace packages
+      let targetPath = resolvedPath;
+      let targetFile = this.projectAnalyzer.project.files.find(
+        (f) => f.path === targetPath,
+      );
+
+      if (!targetFile && targetPath.includes('/dist/')) {
+        const srcPath = targetPath.replace('/dist/', '/src/');
+        targetFile = this.projectAnalyzer.project.files.find(
+          (f) => f.path === srcPath,
+        );
+        if (targetFile) {
+          targetPath = srcPath;
+        }
+
+        // Try with different extensions if still not found
+        if (!targetFile) {
+          const basePath = srcPath.replace(/\.d\.ts$/, '').replace(/\.js$/, '');
+          targetFile = this.projectAnalyzer.project.files.find(
+            (f) => f.path === basePath + '.ts' || f.path === basePath + '.tsx',
+          );
+          if (targetFile) {
+            targetPath = targetFile.path;
+          }
+        }
+      }
+
+      if (!targetFile) continue;
+
+      // Recursively search in the target file
+      const targetAnalyzer = this.projectAnalyzer.getFileAnalyzer(targetFile);
+      const result = targetAnalyzer.findExportThroughStarExports(
+        exportName,
+        visited,
+      );
+      if (result) {
+        return result;
+      }
+    }
+
+    return undefined;
+  }
+
   getImportsAnalysis() {
     if (!this.sourceFile) return {};
     return lib.asts.sourceFiles.getImportsAnalysis(this.sourceFile);
@@ -410,10 +497,39 @@ export class FileAnalyzer {
               );
             }
 
-            const importedExport = importedExports[exportInfo.exportName];
-            const directImportPath = importedExport?.directImportPath;
+            let importedExport = importedExports[exportInfo.exportName];
+            let directImportPath = importedExport?.directImportPath;
+            let foundThroughStarExports = false;
+
+            // If export not found directly, try following star export chains
+            // This handles cases like `export * from './client'` where the actual
+            // export is defined in a re-exported module
+            if (
+              !importedExport &&
+              typeof importedFileAnalyer.findExportThroughStarExports ===
+                'function'
+            ) {
+              const starExportResult =
+                importedFileAnalyer.findExportThroughStarExports(
+                  exportInfo.exportName,
+                );
+              if (starExportResult) {
+                // Found the export through star exports - update the resolved path
+                // The directImportPath is effectively the resolved path where we found it
+                directImportPath = starExportResult.export.directImportPath;
+                // Update exportInfo with the resolved location
+                if (!exportInfo.resolvedPath) {
+                  exportInfo.resolvedPath = starExportResult.resolvedPath;
+                }
+                importedExport = starExportResult.export;
+                foundThroughStarExports = true;
+              }
+            }
 
-            if (directImportPath) {
+            // Skip recursive processing if we found the export through star exports,
+            // since we already have the resolved path and the recursive call would
+            // use the wrong file analyzer (the original file, not where we found the export)
+            if (directImportPath && !foundThroughStarExports) {
               const directImportResolvedImports =
                 importedFileAnalyer.getResolvedImportsRelevantToFunctionName(
                   exportInfo.exportName,
@@ -733,8 +849,9 @@ export class FileAnalyzer {
   getEntityStartAndEnd(entityName: string): { start: number; end: number } {
     if (!this.sourceFile) return { start: 0, end: 0 };
     const node = this.getAllEntityNodes()[entityName];
+    if (!node) return { start: 0, end: 0 };
     const start = this.sourceFile.getLineAndCharacterOfPosition(
-      node.getStart(),
+      node.getStart(this.sourceFile),
     ).line;
     const end = this.sourceFile.getLineAndCharacterOfPosition(
       node.getEnd(),

package/analyzer-template/packages/analyze/src/lib/asts/sourceFiles/getAllExports.ts

@@ -5,6 +5,7 @@ export interface ExportedFunction {
   code: string;
   isDefaultExport: boolean;
   isNamespaceExport: boolean;
+  isStarExport?: boolean;
   directImportPath?: string;
   directImportName?: string;
 }
@@ -202,12 +203,38 @@ export function getAllExports(
       }
     } else if (ts.isExportAssignment(node) && !node.isExportEquals) {
       processExportAssignment(node);
-    } else if (ts.isExportDeclaration(node) && node.exportClause) {
-      if (ts.isNamedExports(node.exportClause)) {
-        processNamedExports(node.exportClause);
-      } else if (ts.isNamespaceExport(node.exportClause)) {
-        const name = node.exportClause.name.text;
-        addExport(name, node, false);
+    } else if (ts.isExportDeclaration(node)) {
+      if (node.exportClause) {
+        if (ts.isNamedExports(node.exportClause)) {
+          processNamedExports(node.exportClause);
+        } else if (ts.isNamespaceExport(node.exportClause)) {
+          const name = node.exportClause.name.text;
+          addExport(name, node, false);
+        }
+      } else if (node.moduleSpecifier) {
+        // Handle star exports: export * from './path'
+        // The exportClause is undefined for star exports
+        const moduleSpecifier = node.moduleSpecifier.getText(sourceFile);
+        const directImportPath = moduleSpecifier.replace(/['"]/g, '');
+
+        // Use a synthetic name based on the path to track this star export
+        // The * symbol indicates this is a star export that needs to be followed
+        const starExportName = `*:${directImportPath}`;
+
+        let code: string;
+        try {
+          code = node.getFullText(sourceFile).trim();
+        } catch (error) {
+          code = `export * from '${directImportPath}'`;
+        }
+
+        exportsCodeMap[starExportName] = {
+          code,
+          isDefaultExport: false,
+          isNamespaceExport: false,
+          isStarExport: true,
+          directImportPath,
+        };
       }
     }
   });

package/analyzer-template/packages/analyze/src/lib/files/analyze/analyzeEntities/prepareDataStructures.ts

@@ -68,7 +68,8 @@ export default async function prepareEntityDataStructures(
           return;
         }
 
-        const { isolatedDataStructure, functionCalls } = dataStructureInfo;
+        const { isolatedDataStructure, functionCalls, callVariableNames } =
+          dataStructureInfo;
 
         // Store data structure in entity metadata
         entity.metadata ||= {};
@@ -125,6 +126,10 @@ export default async function prepareEntityDataStructures(
           if (relevantCalls) {
             importedExport.calls = relevantCalls;
           }
+          const relevantVariableNames = callVariableNames[importedExport.name];
+          if (relevantVariableNames) {
+            importedExport.callVariableNames = relevantVariableNames;
+          }
         }
 
         // Annotate node module imports with function call information
@@ -136,6 +141,10 @@ export default async function prepareEntityDataStructures(
             if (relevantCalls) {
               info.calls = relevantCalls;
             }
+            const relevantVariableNames = callVariableNames[info.name];
+            if (relevantVariableNames) {
+              info.callVariableNames = relevantVariableNames;
+            }
           }
         }
 
@@ -143,6 +152,12 @@ export default async function prepareEntityDataStructures(
         const mockedDependencies = determineMockedDependencies(entity);
         for (const importedExport of importedExports) {
           if (importedExport.isMocked === undefined) {
+            // Never mock visual components - they render UI and should use real implementation
+            if (importedExport.entityType === 'visual') {
+              importedExport.isMocked = false;
+              continue;
+            }
+
             importedExport.isMocked = mockedDependencies.some(
               (dep) =>
                 dep.filePath === importedExport.filePath &&
@@ -298,17 +313,92 @@ async function getEntityDataStructureAndFunctionCalls({
   };
 
   const functionCalls: Record<string, string[]> = {};
+  const callVariableNames: Record<string, string[]> = {};
 
   // Note: externalFunctionCalls is needed for callSignature info, which isn't exposed through helpers
   for (const filePath in dependencySchemas) {
     for (const entityName in dependencySchemas[filePath]) {
-      functionCalls[entityName] = dataStructure.externalFunctionCalls
-        .filter((efc) => efc.callSignature.startsWith(entityName))
-        .map((efc) => efc.callSignature);
+      const matchingCalls = dataStructure.externalFunctionCalls.filter((efc) =>
+        efc.callSignature.startsWith(entityName),
+      );
+
+      // DEBUG: Log external function calls info for useFetcher
+      if (entityName === 'useFetcher' || entityName.includes('Fetcher')) {
+        console.log(
+          'CodeYam DEBUG prepareDataStructures:',
+          JSON.stringify(
+            {
+              entityName,
+              filePath,
+              totalExternalFunctionCalls:
+                dataStructure.externalFunctionCalls.length,
+              matchingCallsCount: matchingCalls.length,
+              matchingCalls: matchingCalls.map((efc) => ({
+                name: efc.name,
+                callSignature: efc.callSignature,
+                allCallSignatures: efc.allCallSignatures,
+                receivingVariableNames: efc.receivingVariableNames,
+                callSignatureToVariable: efc.callSignatureToVariable,
+              })),
+            },
+            null,
+            2,
+          ),
+        );
+      }
+
+      // Collect all call signatures from all matching efc entries
+      // Each efc may have just one callSignature, or allCallSignatures if merged
+      const allSignatures: string[] = [];
+      for (const efc of matchingCalls) {
+        if (efc.allCallSignatures) {
+          allSignatures.push(...efc.allCallSignatures);
+        } else {
+          allSignatures.push(efc.callSignature);
+        }
+      }
+      functionCalls[entityName] = allSignatures;
+
+      // Aggregate callSignatureToVariable maps across all matching calls
+      // This handles the case where tracking data ends up on just one efc entry
+      const aggregatedCallSignatureToVariable: Record<string, string> = {};
+      const aggregatedReceivingVariableNames: string[] = [];
+      for (const efc of matchingCalls) {
+        if (efc.callSignatureToVariable) {
+          Object.assign(
+            aggregatedCallSignatureToVariable,
+            efc.callSignatureToVariable,
+          );
+        }
+        if (efc.receivingVariableNames) {
+          aggregatedReceivingVariableNames.push(...efc.receivingVariableNames);
+        }
+      }
+
+      // Extract variable names for each call signature using the aggregated map
+      const variableNames: string[] = [];
+      for (const signature of allSignatures) {
+        const variableName = aggregatedCallSignatureToVariable[signature];
+        if (variableName) {
+          variableNames.push(variableName);
+        }
+      }
+
+      // If no variables found via aggregated map, fall back to aggregated receivingVariableNames
+      // This handles cases where receivingVariableNames is set but callSignatureToVariable is not
+      if (
+        variableNames.length === 0 &&
+        aggregatedReceivingVariableNames.length > 0
+      ) {
+        variableNames.push(...aggregatedReceivingVariableNames);
+      }
+      if (variableNames.length > 0) {
+        callVariableNames[entityName] = variableNames;
+      }
     }
   }
 
-  return { isolatedDataStructure, functionCalls };
+  return { isolatedDataStructure, functionCalls, callVariableNames };
 }
 
 /**
@@ -326,6 +416,47 @@ function schemaContainsFunctions(schema: Record<string, string>): boolean {
   return false;
 }
 
+/**
+ * Helper: Check if ALL function paths in the schema are jsx-components
+ *
+ * A function path is considered a jsx-component if:
+ * - The value is 'jsx-component', OR
+ * - The functionCallReturnValue for that path is 'jsx-component'
+ *
+ * Returns true if ALL function paths are jsx-components (entity should NOT be mocked)
+ * Returns false if there are any real functions (entity may need mocking)
+ */
+function allFunctionsAreJsxComponents(schema: Record<string, string>): boolean {
+  // Get all function paths (paths ending with () that aren't functionCallReturnValue)
+  const functionPaths = Object.entries(schema ?? {}).filter(([path, value]) => {
+    // Only consider paths that are function calls
+    if (!path.includes('(')) return false;
+    // Skip functionCallReturnValue entries - we check those separately
+    if (path.includes('functionCallReturnValue')) return false;
+    // This is a function call path
+    return value === 'function' || value === 'jsx-component';
+  });
+
+  // If no function paths at all, return false (no functions to check)
+  if (functionPaths.length === 0) return false;
+
+  // Check if ALL function paths are jsx-components
+  for (const [path, value] of functionPaths) {
+    // If the value itself is jsx-component, skip it
+    if (value === 'jsx-component') continue;
+
+    // Check if the functionCallReturnValue for this path is jsx-component
+    const returnValuePath = path + '.functionCallReturnValue';
+    if (schema[returnValuePath] === 'jsx-component') continue;
+
+    // This is a real function that's NOT a jsx-component
+    return false;
+  }
+
+  // All function paths are jsx-components
+  return true;
+}
+
 /**
  * Helper: Check if a return value schema has actual return value data (not just function type markers)
  *
@@ -349,12 +480,80 @@ function hasActualReturnValueData(schema: Record<string, string>): boolean {
   return false;
 }
 
+/**
+ * Helper: Check if a return value schema contains chained method calls (not just simple function calls)
+ *
+ * A chained method call has a pattern like:
+ * - `z.string()` - method call on object z
+ * - `z.string().cuid2()` - chained method calls
+ * - `client.schema().action()` - chained method calls
+ *
+ * A simple function call is just:
+ * - `FileProvider()` - standalone function call (no dot before parens)
+ *
+ * We detect chained calls by looking for patterns where there's a `.` followed by an identifier
+ * and then `()`. The pattern `.identifier()` indicates a method call, not a standalone function.
+ *
+ * EXCEPTION: React Context's .Provider and .Consumer are built-in components that
+ * look like method calls but aren't. When a component uses <SomeContext.Provider>,
+ * the AST creates paths like "SomeContext.Provider()" which should NOT trigger
+ * the chained method call detection.
+ */
+function hasChainedMethodCalls(schema: Record<string, string>): boolean {
+  // Pattern: look for ".identifier(" which indicates a method call
+  // This distinguishes "z.string()" (chained) from "FileProvider()" (simple)
+  const chainedMethodPattern = /\.\w+\(/;
+
+  for (const [path, value] of Object.entries(schema ?? {})) {
+    // Skip JSX components - they look like chained method calls (e.g., Context.Provider())
+    // but they're actually React components used in JSX, not method chains to bypass
+    if (value === 'jsx-component') {
+      continue;
+    }
+
+    // Only look at paths that contain function calls
+    if (path.includes('(') || value === 'function') {
+      if (chainedMethodPattern.test(path)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Validation function name prefixes that should always be mocked.
+ * These functions validate data using schemas (e.g., Zod) that we can't easily
+ * generate data for. Instead of trying to generate data that passes validation,
+ * we mock the validation function itself to return its input unchanged.
+ */
+const VALIDATION_FUNCTION_PREFIXES = ['validate', 'check', 'verify', 'assert'];
+
+/**
+ * Check if a function name indicates it's a validation function that should be mocked.
+ * Validation functions are identified by their name starting with common validation prefixes.
+ */
+export function isValidationFunction(name: string): boolean {
+  const lowerName = name.toLowerCase();
+  return VALIDATION_FUNCTION_PREFIXES.some((prefix) =>
+    lowerName.startsWith(prefix),
+  );
+}
+
 /**
  * Helper: Determine which dependencies should be mocked based on whether they contain functions
  *
  * Only entities that are functions or contain functions in their return values need to be mocked.
  * Data constants (like arrays, objects, strings) don't need mocking because they don't have
  * behavior that needs to be replaced.
+ *
+ * Additionally, validation functions (names starting with validate, check, verify, assert)
+ * are always mocked because they use validation schemas we can't easily generate data for.
+ *
+ * Functions/chains with no return value are also mocked because:
+ * - If a function takes parameters but returns nothing, it's doing side effects (validation, logging)
+ * - If a chain like z.string().cuid2() has no functionCallReturnValue, the chain is doing
+ *   operations (like schema building/validation) whose return is meaningless to us
  */
 export function determineMockedDependencies(entity: Entity) {
   const mockedEntities: { filePath: string; entityName: string }[] = [];
@@ -366,6 +565,7 @@ export function determineMockedDependencies(entity: Entity) {
       const entitySignatureSchema = dataStructure.signatureSchema ?? {};
 
       const emptySignature = Object.keys(entitySignatureSchema).length === 0;
+      const hasSignature = !emptySignature;
       const complexSignature = Object.values(entitySignatureSchema).some(
         (value) => value === 'object' || value === 'array',
       );
@@ -393,11 +593,32 @@ export function determineMockedDependencies(entity: Entity) {
         entityReturnValueSchema ?? {},
       ).some((value) => value === 'object' || value === 'array');
 
+      // Check if this is a validation function that should always be mocked
+      const isValidationFn = isValidationFunction(entityName);
+
+      // Check if entity has chained method calls but no return value
+      // e.g., z.string().cuid2() or authenticatedActionClient.schema().action()
+      // These chains are doing operations (validation, schema building) we want to bypass
+      // NOTE: Simple function calls like FileProvider() are NOT chained - only method calls
+      // with a pattern like .method() count as chained
+      const hasChainedCallsWithNoReturn =
+        hasChainedMethodCalls(entityReturnValueSchema) && !hasReturnValue;
+
+      // Check if ALL functions in the return value schema are jsx-components
+      // If so, we should NOT mock this entity - jsx-components like React Context's
+      // Provider/Consumer should use the original, not be mocked
+      const onlyHasJsxComponents = allFunctionsAreJsxComponents(
+        entityReturnValueSchema,
+      );
+
       const entityShouldBeMocked =
-        (signatureHasFunctions || returnValueHasFunctions) &&
-        hasReturnValue &&
-        ((emptySignature && hasReturnValue) ||
-          (!complexSignature && complexReturnValue));
+        !onlyHasJsxComponents &&
+        (isValidationFn ||
+          hasChainedCallsWithNoReturn ||
+          ((signatureHasFunctions || returnValueHasFunctions) &&
+            hasReturnValue &&
+            ((emptySignature && hasReturnValue) ||
+              (!complexSignature && complexReturnValue))));
 
       if (entityShouldBeMocked) {
         mockedEntities.push({

package/analyzer-template/packages/analyze/src/lib/files/analyze/analyzeEntities.ts

@@ -16,7 +16,7 @@ import {
   updateFreshAnalysisStatus,
   upsertAnalyses,
   upsertEntities,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import { getCandidatesReadyForCapture as getAnalysesReadyForCapture } from './dependencyResolver';
 import { awsLog, awsLogDebugLevel, Semaphore } from '~codeyam/utils';