@codeyam/codeyam-cli 0.1.0-staging.28f73cf → 0.1.0-staging.842873f

package/analyzer-template/packages/ai/src/lib/promptGenerators/generateEntityScenariosGenerator.ts

@@ -25,6 +25,9 @@ export default function generateEntityScenariosGenerator({
       localVariable: ka.internalPath,
       description: ka.description,
       validValueOptions: ka.validValueOptions,
+      // Include new fields when present
+      ...(ka.valueType && { valueType: ka.valueType }),
+      ...(ka.dependencies && { dependencies: ka.dependencies }),
     })),
     null,
     2,
@@ -44,6 +47,9 @@ ${JSON.stringify(
     forDependency: ka.dependentEntityName,
     description: ka.description,
     validValueOptions: ka.validValueOptions,
+    // Include new fields when present
+    ...(ka.valueType && { valueType: ka.valueType }),
+    ...(ka.dependencies && { dependencies: ka.dependencies }),
   })),
   null,
   2,

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

@@ -22,6 +22,12 @@ export interface SerializableFunctionCallInfo {
   callScope: string;
   schema?: Record<string, string>;
   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);
@@ -348,14 +435,41 @@ export class FileAnalyzer {
           }
 
           const relativePath = this.projectAnalyzer.getRelativePath(importPath);
-          const projectPath = this.projectAnalyzer.getRelativePath(
+          let projectPath = this.projectAnalyzer.getRelativePath(
             resolvedImport.resolvedFileName,
           );
 
-          const importedFile = this.projectAnalyzer.project.files.find(
+          let importedFile = this.projectAnalyzer.project.files.find(
             (f) => f.path === projectPath,
           );
 
+          // Workspace packages often resolve to dist/ paths (from package.json "types" or "main"),
+          // but our project.files contains source files in src/. Try mapping dist -> src.
+          if (!importedFile && projectPath.includes('/dist/')) {
+            const srcPath = projectPath.replace('/dist/', '/src/');
+            // Try exact match first (e.g., dist/index.d.ts -> src/index.ts)
+            importedFile = this.projectAnalyzer.project.files.find(
+              (f) => f.path === srcPath,
+            );
+            if (importedFile) {
+              projectPath = srcPath;
+            }
+
+            // If not found, try with different extensions
+            if (!importedFile) {
+              const basePath = srcPath
+                .replace(/\.d\.ts$/, '')
+                .replace(/\.js$/, '');
+              importedFile = this.projectAnalyzer.project.files.find(
+                (f) =>
+                  f.path === basePath + '.ts' || f.path === basePath + '.tsx',
+              );
+              if (importedFile) {
+                projectPath = importedFile.path;
+              }
+            }
+          }
+
           if (!importedFile) {
             // File not found in project.files, but still preserve resolvedPath
             return [
@@ -383,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,
@@ -706,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/nodes/getNodeType.ts

@@ -17,7 +17,7 @@ export function getNodeType(node: ts.Node, sourceFile: ts.SourceFile) {
       nodeType = 'function';
       break;
     case 'ClassDeclaration':
-      nodeType = 'function';
+      nodeType = 'class';
       break;
     case 'ExportDeclaration':
     case 'ExportAssignment':

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

@@ -54,13 +54,15 @@ export function getAllExportedNodes(
   }
 
   function processNamedExports(node: ts.NamedExports) {
+    const parent = node.parent as ts.ExportDeclaration | undefined;
+
     node.elements.forEach((element) => {
       const name = element.name.text;
       const propertyName = element.propertyName
         ? element.propertyName.text
         : name;
-      const importedSource = node.parent.moduleSpecifier
-        ? node.parent.moduleSpecifier.getText(sourceFile)
+      const importedSource = parent?.moduleSpecifier
+        ? parent.moduleSpecifier.getText(sourceFile)
         : undefined;
 
       if (importedSource) {

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;
 }
@@ -103,19 +104,21 @@ export function getAllExports(
   }
 
   function processNamedExports(node: ts.NamedExports) {
+    const parent = node.parent as ts.ExportDeclaration | undefined;
+
     node.elements.forEach((element) => {
       const name = element.name.text;
       const propertyName = element.propertyName
         ? element.propertyName.text
         : name;
-      const importedSource = node.parent.moduleSpecifier
-        ? node.parent.moduleSpecifier.getText(sourceFile)
+      const importedSource = parent?.moduleSpecifier
+        ? parent.moduleSpecifier.getText(sourceFile)
         : undefined;
 
       if (importedSource) {
         const directImportPath = importedSource?.replace(/['"]/g, '');
         const directImport = (
-          node.parent.exportClause as ts.NamedExports
+          parent?.exportClause as ts.NamedExports | undefined
         )?.elements?.find(
           (e) => (e.propertyName || e.name).text === propertyName,
         );
@@ -200,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';
 

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

@@ -8,7 +8,7 @@ import {
   updateEntityBranch,
   upsertEntities,
   upsertEntityBranches,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import getImportedExports from '../getImportedExports';
 import getNodeModuleImports from '../getNodeModuleImports';
 import { AnalysisContext } from '../../analysisContext';

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

@@ -1,4 +1,4 @@
-import { loadMostRecentPreviousAnalysis } from '~codeyam/supabase';
+import { loadMostRecentPreviousAnalysis } from '~codeyam/database';
 import { Commit, Entity, File, Project } from '~codeyam/types';
 
 export interface FindValidExistingAnalysisArgs {

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

@@ -1,4 +1,4 @@
-import { loadAnalysis } from '~codeyam/supabase';
+import { loadAnalysis } from '~codeyam/database';
 import { Analysis, Project } from '~codeyam/types';
 
 export interface FindValidExistingAnalysisArgs {