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

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 {

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

@@ -3,6 +3,9 @@ import findOrCreateEntity from './findOrCreateEntity';
 import { ProjectAnalyzer } from '../../ProjectAnalyzer';
 import { AnalysisContext } from '../../analysisContext';
 
+// Track files we've already warned about to avoid duplicate warnings
+const warnedMissingFiles = new Set<string>();
+
 interface EntityWithGatheredDependencies extends Entity {
   dependenciesGathered?: boolean;
 }
@@ -79,9 +82,12 @@ export default async function gatherEntityMap({
       // 2. The original packages/types/errors.ts is never imported
       // 3. So it's not in getSourceFiles() and thus not in project.files
       // 4. Since the mock handles the import, we don't need to analyze the original
-      console.log(
-        `CodeYam Warning: Skipping dependency - file not in project.files (likely mocked): ${importedExportFilePath}`,
-      );
+      if (!warnedMissingFiles.has(importedExportFilePath)) {
+        warnedMissingFiles.add(importedExportFilePath);
+        console.log(
+          `CodeYam Warning: Skipping dependency - file not in project.files (likely mocked): ${importedExportFilePath}`,
+        );
+      }
       continue;
     }
 

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

@@ -2,7 +2,7 @@ import {
   loadAnalysisBranches,
   loadCommitBranches,
   upsertAnalysisBranches,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import { Analysis, AnalysisBranch, Commit, Entity } from '~codeyam/types';
 import { awsLog } from '~codeyam/utils';
 

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

@@ -8,7 +8,7 @@ import generateDataStructure from './scenarios/generateDataStructure';
 import generateChangesScenarioData from './scenarios/generateChangesScenarioData';
 import generateChangesScenarios from './scenarios/generateChangesScenarios';
 import generateKeyAttributes from './scenarios/generateKeyAttributes';
-import { upsertAnalysesWithScenarios } from '~codeyam/supabase';
+import { upsertAnalysesWithScenarios } from '~codeyam/database';
 import { Step } from './enums/steps';
 import recordStep from './recordStep';
 import { FileAnalyzer } from '..';

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

@@ -2,7 +2,7 @@ import {
   deleteScenarios,
   upsertAnalysesWithScenarios,
   upsertEntities,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import {
   AI,
   generateChangesEntityDocumentation,

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

@@ -11,7 +11,7 @@ import {
   type Entity,
   type ReadonlyAnalysisMap,
 } from '~codeyam/types';
-import { upsertAnalysesWithScenarios } from '~codeyam/supabase';
+import { upsertAnalysesWithScenarios } from '~codeyam/database';
 import {
   awsLog,
   awsLogDebugLevel,

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

@@ -1,6 +1,6 @@
 import { Entity, EntityType, File, ProjectFramework } from '~codeyam/types';
 import { ProjectAnalyzer } from '../ProjectAnalyzer';
-import { generateSha } from '~codeyam/supabase';
+import { generateSha } from '~codeyam/database';
 import { isNextRoute } from '~codeyam/utils';
 
 export default function analyzeNextRoute(

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

@@ -1,6 +1,6 @@
 import { Entity, EntityType, File, ProjectFramework } from '~codeyam/types';
 import { ProjectAnalyzer } from '../ProjectAnalyzer';
-import { generateSha } from '~codeyam/supabase';
+import { generateSha } from '~codeyam/database';
 import { isRemixRoute } from '~codeyam/utils';
 
 export default function analyzeRemixRoute(

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

@@ -2,7 +2,7 @@ import { Entity, File, Project } from '~codeyam/types';
 import { FileAnalyzer } from '../FileAnalyzer';
 import { ProjectAnalyzer } from '../ProjectAnalyzer';
 import type { FunctionDependenciesMap } from '../asts/sourceFiles/getPseudoFile';
-// import { generateSha } from '~codeyam/supabase';
+// import { generateSha } from '~codeyam/database';
 
 export default function getImportedExports(
   file: File,
@@ -73,19 +73,43 @@ export default function getImportedExports(
         // 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 (!importedExportFile && searchPath.includes('/dist/')) {
-          const srcPath = searchPath.replace('/dist/', '/src/');
-          // Try exact match first
-          importedExportFile = project.files.find((f) => f.path === srcPath);
-          if (importedExportFile) {
-            actualResolvedPath = srcPath;
-            console.log(
-              `CodeYam: Mapped dist->src path: ${searchPath} -> ${srcPath}`,
-            );
+          // Some build tools create nested structures like dist/packageName/src/file.d.ts
+          // when the source is at packages/packageName/src/file.ts
+          // Pattern: packages/X/dist/X/src/Y -> packages/X/src/Y
+          const nestedDistMatch = searchPath.match(
+            /^(packages\/[^/]+)\/dist\/[^/]+\/src\/(.+)$/,
+          );
+          if (nestedDistMatch) {
+            const [, packagePath, relativePath] = nestedDistMatch;
+            const srcPath = `${packagePath}/src/${relativePath}`
+              .replace(/\.d\.ts$/, '.ts')
+              .replace(/\.js$/, '.ts');
+            importedExportFile = project.files.find((f) => f.path === srcPath);
+            if (importedExportFile) {
+              actualResolvedPath = srcPath;
+              console.log(
+                `CodeYam: Mapped nested dist->src path: ${searchPath} -> ${srcPath}`,
+              );
+            }
+          }
+
+          // Try simple dist -> src replacement if nested pattern didn't match
+          if (!importedExportFile) {
+            const srcPath = searchPath.replace('/dist/', '/src/');
+            // Try exact match first
+            importedExportFile = project.files.find((f) => f.path === srcPath);
+            if (importedExportFile) {
+              actualResolvedPath = srcPath;
+              console.log(
+                `CodeYam: Mapped dist->src path: ${searchPath} -> ${srcPath}`,
+              );
+            }
           }
 
           // If not found, the dist file might be index.d.ts but src might be index.ts
           // or the export might be re-exported from another file
           if (!importedExportFile) {
+            const srcPath = searchPath.replace('/dist/', '/src/');
             // Try removing .d.ts extension and finding any matching src file
             const basePath = srcPath
               .replace(/\.d\.ts$/, '')
@@ -107,40 +131,48 @@ export default function getImportedExports(
         }
 
         if (!importedExportFile) {
-          // Check if this is a workspace package import (scoped npm package like @scope/package)
-          // but NOT a path alias like @/path or @components/...
-          // Scoped packages have format: @scope/package where scope is alphanumeric with hyphens
-          const isScopedPackage =
-            filePath.startsWith('@') &&
-            !filePath.startsWith('@/') && // Not a path alias like @/modules/...
-            !filePath.startsWith('@types/') &&
-            /^@[a-z0-9-]+\/[a-z0-9-]/.test(filePath); // Matches @scope/package pattern
-          if (isScopedPackage) {
-            // Treat unresolved scoped packages like node modules so they get mocked
-            // instead of being silently ignored
+          // Check if this looks like a path alias (starts with @/ or similar patterns)
+          // Path aliases should resolve to project files - if they don't, it's a config issue
+          // Also check for ~packageName/ patterns like ~codeyam/supabase
+          const isPathAlias =
+            filePath.startsWith('@/') ||
+            filePath.startsWith('~/') ||
+            filePath.startsWith('#/') ||
+            /^~[a-zA-Z]/.test(filePath); // ~packageName patterns like ~codeyam/
+
+          const name =
+            importedExportInfo.importName ?? importedExportInfo.importAlias;
+
+          if (isPathAlias) {
+            // Path aliases should resolve - if they don't, it's a configuration issue
+            // Don't treat as node module, just log and skip
+            console.log(
+              'CodeYam Warning: Path alias import not resolved (file may be missing or path alias misconfigured):',
+              file.path,
+              filePath,
+              importedExportInfo,
+            );
+            return;
+          }
+
+          // If still not found, track as unresolved import
+          // Don't set isMocked here - let later processing determine based on mockedDependencies
+          // This ensures the import is tracked (not dropped) while deferring the mocking decision
+          if (!importedExportFile) {
             const name =
               importedExportInfo.importName ?? importedExportInfo.importAlias;
             console.log(
-              `CodeYam: Treating unresolved scoped package as node module: ${filePath} -> ${name}`,
+              `CodeYam: Tracking unresolved import (mocking decision deferred): ${filePath} -> ${name}`,
             );
             return {
               filePath,
               name,
               isDefault: importedExportInfo.isImportDefault,
-              isNodeModule: true, // Mark as node module so it gets mocked
-              entityType: 'library' as const, // Default to library since we can't determine the actual type
-              // No code since we couldn't resolve the source file
+              // isMocked intentionally undefined - will be determined later by prepareDataStructures
+              // based on mockedDependencies analysis
+              entityType: 'library' as const,
             };
-          } else {
-            console.log(
-              'CodeYam Error: File not found for imported export',
-              file.path,
-              filePath,
-              importedExportInfo,
-              imports[filePath],
-            );
           }
-          return;
         }
 
         try {
@@ -156,7 +188,20 @@ export default function getImportedExports(
           const name =
             importedExportInfo.importName ?? importedExportInfo.importAlias;
 
-          const resolvedFilePath = importedExportInfo.resolvedPath;
+          // Map nested dist paths in resolvedPath to src paths
+          // Pattern: packages/X/dist/X/src/Y -> packages/X/src/Y
+          let resolvedFilePath = importedExportInfo.resolvedPath;
+          if (resolvedFilePath) {
+            const nestedDistMatch = resolvedFilePath.match(
+              /^(packages\/[^/]+)\/dist\/[^/]+\/src\/(.+)$/,
+            );
+            if (nestedDistMatch) {
+              const [, packagePath, relativePath] = nestedDistMatch;
+              resolvedFilePath = `${packagePath}/src/${relativePath}`
+                .replace(/\.d\.ts$/, '.ts')
+                .replace(/\.js$/, '.ts');
+            }
+          }
           const resolvedName = importedExportInfo.exportName;
 
           return {

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

@@ -68,154 +68,233 @@ function preprocessSchemaForMocks(
   return result;
 }
 
-export default function gatherDataForMocks(
-  importedExports: {
+/**
+ * Processes a single call (with optional variable name) and returns the mock data entry.
+ * Returns null if no valid schema is found.
+ */
+function processCall(
+  importedExport: {
     filePath?: string;
     name: string;
     isMocked?: boolean;
     calls?: string[];
-  }[],
+    callVariableNames?: string[];
+  },
   dependencySchemas: DataStructure['dependencySchemas'],
-) {
-  return importedExports.reduce(
-    (acc, importedExport) => {
-      if (!importedExport.isMocked) return acc;
+  callIndex: number,
+): { key: string; value: JsonTypeDefinition } | null {
+  const callName = importedExport.calls?.[callIndex] ?? importedExport.name;
+  const variableName = importedExport.callVariableNames?.[callIndex];
 
-      const functionNames: string[] = [];
-
-      const isFunctionNameWithoutFunction = (
-        path: string,
-        functionName: string,
-      ) => {
-        // Check if path starts with functionName but isn't a function call
-        // Must also handle generics: useLoaderData<typeof loader>() should NOT
-        // be filtered when functionName is 'useLoaderData'
-        return (
-          path.startsWith(functionName) &&
-          !path.startsWith(functionName + '(') &&
-          !path.startsWith(functionName + '.(') &&
-          !path.startsWith(functionName + '<') // Handle generics
-        );
-      };
+  // Build the schema lookup key - use variable-qualified key if available
+  const schemaLookupKey = variableName
+    ? `${importedExport.name}::${variableName}`
+    : importedExport.name;
 
-      const rawSchema =
-        dependencySchemas?.[importedExport.filePath]?.[importedExport.name]
-          ?.returnValueSchema ?? {};
-
-      // Preprocess to filter signatures and extract functionCallReturnValue
-      let preprocessedSchema = preprocessSchemaForMocks(rawSchema);
-
-      // Merge non-generic variants into generic variants
-      // e.g., if callName is "useFetcher<T>()", also include paths from "useFetcher()"
-      const callName = importedExport.calls?.[0] ?? importedExport.name;
-      if (callName.includes('<') && callName.includes('(')) {
-        // Extract the base function name without generics
-        const baseFunctionName = cleanFunctionName(callName.split('(')[0]);
-        const nonGenericCall = baseFunctionName + '()';
-        const genericCallPrefix = callName.endsWith(')')
-          ? callName
-          : callName + '()';
-
-        // If we have a generic call, merge paths from non-generic variant
-        const mergedSchema: Record<string, string> = { ...preprocessedSchema };
-        for (const path of Object.keys(preprocessedSchema)) {
-          if (path.startsWith(nonGenericCall)) {
-            // Create corresponding generic path
-            const genericPath =
-              genericCallPrefix + path.slice(nonGenericCall.length);
-            // Only add if the generic path doesn't already exist
-            if (!mergedSchema[genericPath]) {
-              mergedSchema[genericPath] = preprocessedSchema[path];
-            }
-          }
+  const rawSchema =
+    dependencySchemas?.[importedExport.filePath]?.[schemaLookupKey]
+      ?.returnValueSchema ?? {};
+
+  // If no schema found with variable-qualified key, fall back to base name
+  const fallbackSchema =
+    Object.keys(rawSchema).length === 0
+      ? (dependencySchemas?.[importedExport.filePath]?.[importedExport.name]
+          ?.returnValueSchema ?? {})
+      : rawSchema;
+
+  // Preprocess to filter signatures and extract functionCallReturnValue
+  let preprocessedSchema = preprocessSchemaForMocks(fallbackSchema);
+
+  const functionNames: string[] = [];
+
+  const isFunctionNameWithoutFunction = (
+    path: string,
+    functionName: string,
+  ) => {
+    // Check if path starts with functionName but isn't a function call
+    // Must also handle generics: useLoaderData<typeof loader>() should NOT
+    // be filtered when functionName is 'useLoaderData'
+    return (
+      path.startsWith(functionName) &&
+      !path.startsWith(functionName + '(') &&
+      !path.startsWith(functionName + '.(') &&
+      !path.startsWith(functionName + '<') // Handle generics
+    );
+  };
+
+  // For variable-qualified schemas, the paths also include the variable qualifier
+  // e.g., "useFetcher()::entityDiffFetcher.functionCallReturnValue.data"
+  // We need to handle both qualified and non-qualified paths
+
+  // Merge non-generic variants into generic variants
+  // e.g., if callName is "useFetcher<T>()", also include paths from "useFetcher()"
+  if (callName.includes('<') && callName.includes('(')) {
+    // Extract the base function name without generics
+    const baseFunctionName = cleanFunctionName(callName.split('(')[0]);
+    const nonGenericCall = variableName
+      ? `${baseFunctionName}()::${variableName}`
+      : baseFunctionName + '()';
+    const genericCallPrefix = variableName
+      ? `${callName.endsWith(')') ? callName : callName + '()'}::${variableName}`
+      : callName.endsWith(')')
+        ? callName
+        : callName + '()';
+
+    // If we have a generic call, merge paths from non-generic variant
+    const mergedSchema: Record<string, string> = { ...preprocessedSchema };
+    for (const path of Object.keys(preprocessedSchema)) {
+      if (path.startsWith(nonGenericCall)) {
+        // Create corresponding generic path
+        const genericPath =
+          genericCallPrefix + path.slice(nonGenericCall.length);
+        // Only add if the generic path doesn't already exist
+        if (!mergedSchema[genericPath]) {
+          mergedSchema[genericPath] = preprocessedSchema[path];
         }
-        preprocessedSchema = mergedSchema;
       }
+    }
+    preprocessedSchema = mergedSchema;
+  }
 
-      // Merge generic call (e.g., "foo()") data into specific argument calls (e.g., "foo(arg1, arg2)")
-      // This handles the case where the generic schema has richer nested data than the specific call
-      if (callName.includes('(') && !callName.includes('<')) {
-        // Extract the base function name and create generic call
-        const baseFunctionName = callName.split('(')[0];
-        const genericCall = baseFunctionName + '()';
-
-        // Only merge if the callName has arguments (not just empty parens)
-        if (callName !== genericCall) {
-          const mergedSchema: Record<string, string> = {
-            ...preprocessedSchema,
-          };
-          for (const path of Object.keys(preprocessedSchema)) {
-            if (path.startsWith(genericCall)) {
-              // Create corresponding specific path
-              const specificPath = callName + path.slice(genericCall.length);
-              // Only add if the specific path doesn't already exist
-              if (!mergedSchema[specificPath]) {
-                mergedSchema[specificPath] = preprocessedSchema[path];
-              }
-            }
+  // Merge generic call (e.g., "foo()") data into specific argument calls (e.g., "foo(arg1, arg2)")
+  // This handles the case where the generic schema has richer nested data than the specific call
+  if (callName.includes('(') && !callName.includes('<')) {
+    // Extract the base function name and create generic call
+    const baseFunctionName = callName.split('(')[0];
+    const genericCall = variableName
+      ? `${baseFunctionName}()::${variableName}`
+      : baseFunctionName + '()';
+
+    // Build the actual callName with variable qualifier if present
+    const actualCallName = variableName
+      ? `${callName}::${variableName}`
+      : callName;
+
+    // Only merge if the callName has arguments (not just empty parens)
+    if (actualCallName !== genericCall) {
+      const mergedSchema: Record<string, string> = {
+        ...preprocessedSchema,
+      };
+      for (const path of Object.keys(preprocessedSchema)) {
+        if (path.startsWith(genericCall)) {
+          // Create corresponding specific path
+          const specificPath = actualCallName + path.slice(genericCall.length);
+          // Only add if the specific path doesn't already exist
+          if (!mergedSchema[specificPath]) {
+            mergedSchema[specificPath] = preprocessedSchema[path];
           }
-          preprocessedSchema = mergedSchema;
         }
       }
+      preprocessedSchema = mergedSchema;
+    }
+  }
 
-      const relevantMergedDependencySchema = Object.keys(
-        preprocessedSchema,
-      ).reduce(
-        (acc, path) => {
-          if (path.endsWith(')')) {
-            const pathParts = splitOutsideParenthesesAndArrays(path);
-            const functionName = joinParenthesesAndArrays([
-              ...pathParts.slice(0, -1),
-              pathParts[pathParts.length - 1].split('(')[0],
-            ]);
-            functionNames.push(functionName);
-            for (const existingPath in acc) {
-              if (isFunctionNameWithoutFunction(existingPath, functionName)) {
-                delete acc[existingPath];
-              }
-            }
-          }
-
-          if (
-            functionNames.some((fn) => isFunctionNameWithoutFunction(path, fn))
-          ) {
-            return acc;
+  const relevantMergedDependencySchema = Object.keys(preprocessedSchema).reduce(
+    (acc, path) => {
+      if (path.endsWith(')')) {
+        const pathParts = splitOutsideParenthesesAndArrays(path);
+        const functionName = joinParenthesesAndArrays([
+          ...pathParts.slice(0, -1),
+          pathParts[pathParts.length - 1].split('(')[0],
+        ]);
+        functionNames.push(functionName);
+        for (const existingPath in acc) {
+          if (isFunctionNameWithoutFunction(existingPath, functionName)) {
+            delete acc[existingPath];
           }
+        }
+      }
 
-          acc[path] = preprocessedSchema[path];
-          return acc;
-        },
-        {} as Record<string, string>,
-      );
-
-      const schema = convertDotNotation(
-        fillInDirectSchemaGapsAndUnknowns({
-          scopeName: importedExport.name,
-          schema: relevantMergedDependencySchema,
-        }),
-      );
-
-      // Determine if this is an object-style or hook-style dependency:
-      // - Hook-style: calls = ['useAuth()'] - call starts with name + '('
-      // - Object-style: calls = ['supabase.from(...)'] - call starts with name + '.'
-      //
-      // After convertDotNotation:
-      // - Hook-style schema has the callName as top-level key: schema['useAuth()']
-      // - Object-style schema has the import name as top-level key: schema['supabase']
-      // Note: callName is already defined above for generic/non-generic merging
-      const isObjectStyle =
-        callName.startsWith(importedExport.name + '.') ||
-        (!callName.includes('(') && callName === importedExport.name);
-
-      const schemaKey = isObjectStyle ? importedExport.name : callName;
-      const outputKey = isObjectStyle ? importedExport.name : callName;
-      const returnValue = schema[schemaKey] ?? schema['returnValue'];
-
-      if (!returnValue) {
+      if (functionNames.some((fn) => isFunctionNameWithoutFunction(path, fn))) {
         return acc;
       }
 
-      acc[outputKey] = returnValue as JsonTypeDefinition;
+      acc[path] = preprocessedSchema[path];
+      return acc;
+    },
+    {} as Record<string, string>,
+  );
+
+  const schema = convertDotNotation(
+    fillInDirectSchemaGapsAndUnknowns({
+      scopeName: importedExport.name,
+      schema: relevantMergedDependencySchema,
+    }),
+  );
+
+  // Determine if this is an object-style or hook-style dependency:
+  // - Hook-style: calls = ['useAuth()'] - call starts with name + '('
+  // - Object-style: calls = ['supabase.from(...)'] - call starts with name + '.'
+  const isObjectStyle =
+    callName.startsWith(importedExport.name + '.') ||
+    (!callName.includes('(') && callName === importedExport.name);
+
+  // Build schema key with variable qualifier if present
+  const baseSchemaKey = isObjectStyle ? importedExport.name : callName;
+  const schemaKey = variableName
+    ? `${baseSchemaKey}::${variableName}`
+    : baseSchemaKey;
+
+  // Build output key - for variable-qualified, use "variableName <- functionName" format
+  // This reads naturally as "variableName receives from functionName"
+  const outputKey = variableName
+    ? `${variableName} <- ${importedExport.name}`
+    : isObjectStyle
+      ? importedExport.name
+      : callName;
+
+  // Try to find return value - check with variable qualifier first, then without
+  let returnValue = schema[schemaKey];
+  if (!returnValue && variableName) {
+    returnValue = schema[baseSchemaKey];
+  }
+  if (!returnValue) {
+    returnValue = schema['returnValue'];
+  }
+
+  if (!returnValue) {
+    return null;
+  }
+
+  return { key: outputKey, value: returnValue as JsonTypeDefinition };
+}
+
+export default function gatherDataForMocks(
+  importedExports: {
+    filePath?: string;
+    name: string;
+    isMocked?: boolean;
+    calls?: string[];
+    callVariableNames?: string[];
+  }[],
+  dependencySchemas: DataStructure['dependencySchemas'],
+) {
+  return importedExports.reduce(
+    (acc, importedExport) => {
+      if (!importedExport.isMocked) return acc;
+
+      // Check if we have multiple calls with variable names
+      const hasMultipleCalls =
+        importedExport.calls &&
+        importedExport.calls.length > 1 &&
+        importedExport.callVariableNames &&
+        importedExport.callVariableNames.length === importedExport.calls.length;
+
+      if (hasMultipleCalls) {
+        // Process each call separately with its variable name
+        for (let i = 0; i < importedExport.calls!.length; i++) {
+          const result = processCall(importedExport, dependencySchemas, i);
+          if (result) {
+            acc[result.key] = result.value;
+          }
+        }
+      } else {
+        // Original behavior for single calls or calls without variable names
+        const result = processCall(importedExport, dependencySchemas, 0);
+        if (result) {
+          acc[result.key] = result.value;
+        }
+      }
 
       return acc;
     },