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

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 {

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;
 }
@@ -73,14 +76,19 @@ export default async function gatherEntityMap({
     );
 
     if (!importedFile) {
-      console.log(
-        `CodeYam Error: File not found while gathering entity map: ${importedExportFilePath}`,
-        entity.filePath,
-        entity.name,
-      );
-      throw new Error(
-        `File not found while gathering entity map: ${importedExportFilePath}`,
-      );
+      // Skip dependencies when the file is not found in project.files.
+      // This commonly happens when a universal mock intercepts the import:
+      // 1. TypeScript resolves @formbricks/types/errors to the mock file
+      // 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
+      if (!warnedMissingFiles.has(importedExportFilePath)) {
+        warnedMissingFiles.add(importedExportFilePath);
+        console.log(
+          `CodeYam Warning: Skipping dependency - file not in project.files (likely mocked): ${importedExportFilePath}`,
+        );
+      }
+      continue;
     }
 
     let importedEntity = context.getEntity(

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/analyze/trackEntityCircularDependencies.ts

@@ -99,19 +99,11 @@ function traverseEntity(
     );
 
     if (!dependentEntity) {
-      console.log(
-        'CodeYam Error: trackEntityCircularDependencies: Dependent entity not found',
-        {
-          entityFilePath: entity.filePath,
-          entityName: entity.name,
-          dependencyFilePath,
-          dependencyName,
-          fileEntities: context.getEntityNamesForFile(dependencyFilePath),
-        },
-      );
-      throw new Error(
-        'trackEntityCircularDependencies: Dependent entity not found',
-      );
+      // Skip dependencies when the entity is not found in context.
+      // This commonly happens when a universal mock intercepts the import:
+      // - gatherEntityMap skips adding the entity because the file isn't in project.files
+      // - The mock handles the import at runtime, so we don't need to track it
+      continue;
     }
 
     // Recursively traverse (will skip if already visited)

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(
@@ -48,29 +48,20 @@ export default function analyzeRemixRoute(
           const implicitRouteFileAnalyzer =
             projectAnalyzer.getFileAnalyzer(implicitRoute);
           const exports = implicitRouteFileAnalyzer.getAllExports();
-          const defaultExport = Object.values(exports).find(
-            (e) => e.isDefaultExport,
-          );
-
-          // Ensure entities array exists before trying to use it
-          if (!implicitRoute.entities) {
-            console.log(
-              `CodeYam Warning: implicitRoute.entities not populated for ${implicitRoute.path}, skipping implicit dependency`,
-            );
-            return;
-          }
 
-          const defaultEntity = implicitRoute.entities.find((e) =>
-            implicitRouteFileAnalyzer.isDefaultExport(e.name),
+          // Find the default export entry - the key is the entity name
+          const defaultExportEntry = Object.entries(exports).find(
+            ([, e]) => e.isDefaultExport,
           );
 
-          if (!defaultExport || !defaultEntity) return;
+          if (!defaultExportEntry) return;
 
+          const [entityName, defaultExport] = defaultExportEntry;
           const code = defaultExport.code;
           return {
             code: code,
             // sha: generateSha(implicitRoute.path, 'default', code),
-            name: defaultEntity.name,
+            name: entityName,
             filePath: implicitRoute.path,
             projectId: entity.projectId,
             entityType: 'visual' as EntityType,
@@ -108,26 +99,23 @@ export default function analyzeRemixRoute(
     try {
       const rootFileAnalyzer = projectAnalyzer.getFileAnalyzer(rootFile);
       const exports = rootFileAnalyzer.getAllExports();
-      const defaultExport = Object.values(exports).find(
-        (e) => e.isDefaultExport,
-      );
 
-      if (defaultExport && rootFile.entities) {
-        const defaultEntity = rootFile.entities.find((e) =>
-          rootFileAnalyzer.isDefaultExport(e.name),
-        );
+      // Find the default export entry - the key is the entity name
+      const defaultExportEntry = Object.entries(exports).find(
+        ([, e]) => e.isDefaultExport,
+      );
 
-        if (defaultEntity) {
-          rootDependencies.push({
-            code: defaultExport.code,
-            name: defaultEntity.name,
-            filePath: rootFile.path,
-            entityType: 'visual' as EntityType,
-            isDefault: true,
-            isImplicitDependency: true,
-            isMocked: false,
-          });
-        }
+      if (defaultExportEntry) {
+        const [entityName, defaultExport] = defaultExportEntry;
+        rootDependencies.push({
+          code: defaultExport.code,
+          name: entityName,
+          filePath: rootFile.path,
+          entityType: 'visual' as EntityType,
+          isDefault: true,
+          isImplicitDependency: true,
+          isMocked: false,
+        });
       }
     } catch (e) {
       console.log(