@codeyam/codeyam-cli 0.1.0-staging.323686 → 0.1.0-staging.3ef993e

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

@@ -2,21 +2,44 @@ import ts from 'typescript';
 import path from 'path';
 import fs from 'fs';
 
+/**
+ * Cache for nearest tsconfig lookups (keyed by directory).
+ * Speeds up repeated lookups during module resolution.
+ */
+const nearestTsConfigCache = new Map<string, string | undefined>();
+
 /**
  * Find the nearest tsconfig.json by walking up the directory tree from the source file
  */
 function findNearestTsConfig(sourceFileName: string): string | undefined {
   let currentDir = path.dirname(sourceFileName);
   const root = path.parse(currentDir).root;
+  const visited: string[] = [];
 
   while (currentDir !== root) {
+    const cached = nearestTsConfigCache.get(currentDir);
+    if (cached !== undefined || nearestTsConfigCache.has(currentDir)) {
+      for (const dir of visited) {
+        nearestTsConfigCache.set(dir, cached);
+      }
+      return cached;
+    }
+
+    visited.push(currentDir);
     const tsConfigPath = path.join(currentDir, 'tsconfig.json');
     if (fs.existsSync(tsConfigPath)) {
+      for (const dir of visited) {
+        nearestTsConfigCache.set(dir, tsConfigPath);
+      }
       return tsConfigPath;
     }
     currentDir = path.dirname(currentDir);
   }
 
+  for (const dir of visited) {
+    nearestTsConfigCache.set(dir, undefined);
+  }
+
   return undefined;
 }
 
@@ -25,6 +48,14 @@ function findNearestTsConfig(sourceFileName: string): string | undefined {
  */
 const tsConfigCache = new Map<string, ts.CompilerOptions>();
 
+/**
+ * Cache resolved module lookups by program for fast repeat access.
+ */
+const resolvedModuleCacheByProgram = new WeakMap<
+  ts.Program,
+  Map<string, ts.ResolvedModuleFull | null>
+>();
+
 /**
  * Get compiler options from a tsconfig file
  */
@@ -62,6 +93,19 @@ export function getResolvedModule(
   // Try to find the nearest tsconfig for this source file
   const nearestTsConfig = findNearestTsConfig(sourceFile.fileName);
 
+  const cacheForProgram =
+    resolvedModuleCacheByProgram.get(program) ??
+    new Map<string, ts.ResolvedModuleFull | null>();
+  if (!resolvedModuleCacheByProgram.has(program)) {
+    resolvedModuleCacheByProgram.set(program, cacheForProgram);
+  }
+
+  const cacheKey = `${nearestTsConfig ?? ''}|${sourceFile.fileName}|${moduleName}`;
+  if (cacheForProgram.has(cacheKey)) {
+    const cached = cacheForProgram.get(cacheKey);
+    return cached ?? undefined;
+  }
+
   // Start with the program's compiler options
   let compilerOptions = program.getCompilerOptions();
 
@@ -90,6 +134,7 @@ export function getResolvedModule(
 
   // If TypeScript's resolution succeeded, return it
   if (result.resolvedModule) {
+    cacheForProgram.set(cacheKey, result.resolvedModule);
     return result.resolvedModule;
   }
 
@@ -105,14 +150,17 @@ export function getResolvedModule(
     for (const ext of extensions) {
       const testPath = absolutePath + ext;
       if (fs.existsSync(testPath)) {
-        return {
+        const resolved = {
           resolvedFileName: testPath,
           extension: ext.includes('/') ? path.extname(ext) : ext,
           isExternalLibraryImport: false,
         } as ts.ResolvedModuleFull;
+        cacheForProgram.set(cacheKey, resolved);
+        return resolved;
       }
     }
   }
 
+  cacheForProgram.set(cacheKey, null);
   return undefined;
 }

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

@@ -21,5 +21,6 @@ export function getSourceFilesForAllImports(
 
   visit(sourceFile); // Start visiting nodes from the root source file
 
-  return getSourceFilesForImports(moduleNames, sourceFile, program);
+  const uniqueModuleNames = Array.from(new Set(moduleNames));
+  return getSourceFilesForImports(uniqueModuleNames, sourceFile, program);
 }

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

@@ -18,6 +18,7 @@ import {
   getCompoundConditionals,
   getChildBoundaryGatingConditions,
   getJsxRenderingUsages,
+  skipWorkerPool,
 } from '~codeyam/ai';
 import type { AnalysisOptions } from '../analyzeEntities';
 
@@ -271,6 +272,23 @@ export default async function prepareEntityDataStructures(
   };
 
   const entities = Array.from(allEntities);
+
+  // The worker thread creates its own ProjectAnalyzer (ts.Program) on first use,
+  // which takes 50-70s. For small entity counts the overhead far exceeds the actual
+  // processing time (<2s). Skip the worker and run on the main thread instead,
+  // reusing the existing ProjectAnalyzer.
+  const entitiesNeedingGeneration = entities.filter(
+    (e) =>
+      !e.metadata?.isolatedDataStructure || options.force || options.forceAll,
+  ).length;
+  const WORKER_ENTITY_THRESHOLD = 500;
+  if (entitiesNeedingGeneration < WORKER_ENTITY_THRESHOLD) {
+    console.log(
+      `CodeYam: Skipping worker thread for DS prep (${entitiesNeedingGeneration} entities < ${WORKER_ENTITY_THRESHOLD} threshold)`,
+    );
+    skipWorkerPool();
+  }
+
   const sequential =
     DEBUG_SEQUENTIAL_EXECUTION || options.sequentialDataStructurePrep;
 
@@ -336,11 +354,23 @@ async function getEntityDataStructureAndFunctionCalls({
         functionName: importedExport.name,
       });
 
-      // If neither signature nor return value found, this function doesn't exist in the analysis.
-      // We need to check BOTH because hooks like useParams() have no signature (no arguments)
-      // but DO have a return value that needs to be mocked.
+      // If neither signature nor return value found, check if this function has matching
+      // external function calls. External functions (like useLoaderData from react-router)
+      // don't have entries in functionResults, so getReturnValue returns null for them.
+      // But their return values ARE traced in externalFunctionCalls via perVariableSchemas.
+      // We need to check for matching calls before skipping.
       if (!signatureSchema && !returnValueSchema) {
-        return acc;
+        const hasMatchingExternalCall =
+          dataStructure.externalFunctionCalls?.some(
+            (fc) =>
+              fc.name === importedExport.name ||
+              fc.name.startsWith(importedExport.name + '<'),
+          );
+
+        // Only skip if there are no matching external function calls
+        if (!hasMatchingExternalCall) {
+          return acc;
+        }
       }
 
       // Clone schemas before deduplication to avoid mutating shared references
@@ -543,6 +573,42 @@ async function getEntityDataStructureAndFunctionCalls({
     },
   );
 
+  // Add same-file child components to dependencySchemas.
+  // Same-file components (e.g., AgentCard defined in the same file as AgentTranscriptsPage)
+  // appear in externalFunctionCalls and functionResults but NOT in importedExports or
+  // nodeModuleImports. Without this, their signatures are missing from dependencySchemas
+  // and enrichArrayTypesFromChildSignatures can't find child component field accesses.
+  const allDependencyNames = new Set(allDependencies.map((d) => d.name));
+
+  for (const efc of dataStructure.externalFunctionCalls) {
+    // Skip if already covered by importedExports or nodeModuleImports
+    if (allDependencyNames.has(efc.name)) continue;
+
+    const signatureSchema = getFunctionSignature(dataStructure, {
+      functionName: efc.name,
+    });
+
+    const returnValueSchema = getReturnValue(dataStructure, {
+      functionName: efc.name,
+    });
+
+    // Only add if we have signature or return value data
+    if (!signatureSchema && !returnValueSchema) continue;
+
+    const clonedSignatureSchema = { ...(signatureSchema ?? {}) };
+    const clonedReturnValueSchema = { ...(returnValueSchema ?? {}) };
+
+    const entityFilePath = entity.filePath;
+    dependencySchemas[entityFilePath] ||= {};
+    dependencySchemas[entityFilePath][efc.name] = {
+      signatureSchema: deduplicateFunctionSchemas(clonedSignatureSchema),
+      returnValueSchema: deduplicateFunctionSchemas(clonedReturnValueSchema),
+      usageEquivalencies: getUsageEquivalencies(dataStructure, efc.name) ?? {},
+      sourceEquivalencies:
+        getSourceEquivalencies(dataStructure, efc.name) ?? {},
+    };
+  }
+
   const rawReturnValue =
     getReturnValue(dataStructure, { fillInUnknowns: false }) ?? {};
 
@@ -570,11 +636,13 @@ async function getEntityDataStructureAndFunctionCalls({
   // Get JSX rendering usages for array size and text length flow generation
   const jsxRenderingUsages = getJsxRenderingUsages(dataStructure);
 
+  const equivalentSignatureVariables =
+    getEquivalentSignatureVariables(dataStructure);
+
   const isolatedDataStructure = {
     signatureSchema: deduplicateFunctionSchemas(clonedRawSignature),
     returnValueSchema: deduplicateFunctionSchemas(clonedRawReturnValue),
-    equivalentSignatureVariables:
-      getEquivalentSignatureVariables(dataStructure),
+    equivalentSignatureVariables,
     dependencySchemas,
     environmentVariables: dataStructure.environmentVariables,
     conditionalUsages:
@@ -856,9 +924,21 @@ export function determineMockedDependencies(entity: Entity) {
       // A schema with only "EntityName(): function" just indicates the entity is callable,
       // it doesn't mean there's actual return data to mock
       const hasReturnValue = hasActualReturnValueData(entityReturnValueSchema);
-      const complexReturnValue = Object.values(
-        entityReturnValueSchema ?? {},
-      ).some((value) => value === 'object' || value === 'array');
+      // Check for complex return types (object/array), accounting for nullable types
+      // e.g., 'object', 'object | null', 'array | undefined' should all count as complex.
+      // Also detect when functionCallReturnValue has nested child properties — this
+      // proves it's a structured type even if its declared type is still 'unknown'.
+      const returnValueKeys = Object.keys(entityReturnValueSchema ?? {});
+      const complexReturnValue =
+        Object.values(entityReturnValueSchema ?? {}).some((value) => {
+          const baseType = value?.split(' | ')[0];
+          return baseType === 'object' || baseType === 'array';
+        }) ||
+        returnValueKeys.some(
+          (key) =>
+            key.includes('functionCallReturnValue.') ||
+            key.includes('functionCallReturnValue['),
+        );
 
       // Check if this is a validation function that should always be mocked
       const isValidationFn = isValidationFunction(entityName);

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

@@ -5,6 +5,8 @@ import {
   measureAndReportExecutionTime,
   ProjectAnalyzer,
 } from '~codeyam/analyze';
+import { transformationTracer } from '../scenarios/TransformationTracer';
+import { getFileByPathSafe } from '../../utils/getFileByPath';
 import trackEntityCircularDependencies from './trackEntityCircularDependencies';
 import validateDependencyAnalyses from './validateDependencyAnalyses';
 import extractClassMethods from './analyzeEntities/extractClassMethods';
@@ -306,6 +308,18 @@ export default async function analyzeEntities({
   awsLog(
     `CodeYam: analyzeEntities: Analysis completed with ${analyses.length} analyses`,
   );
+
+  // Flush transformation trace if tracing is enabled
+  // Wrapped in try/catch because trace data can exceed V8's max string length
+  // for large projects, and we must not crash the analysis process over tracing.
+  try {
+    transformationTracer.flush();
+  } catch (e) {
+    console.warn(
+      `CodeYam Warning: Failed to flush transformation trace: ${e.message}`,
+    );
+  }
+
   return analyses;
 
   // PHASE 3: Pure graph traversal
@@ -388,10 +402,19 @@ export default async function analyzeEntities({
             // Circular dependency detected in path - skip
             continue;
           }
-          // If already visited via another traversal path, skip to avoid deadlock.
-          // Its subtree has been fully explored; any leaves are already in leafKeys.
-          // Blocking on it would just propagate the block and cause stuck analysis.
+          // If already visited via another traversal path, check if it's a leaf.
+          // If it's a leaf, we should still wait for it to complete.
+          // Only skip if we've already explored it and it's NOT a leaf (meaning it's
+          // blocked on something else - continuing to traverse would cause a deadlock).
           if (visited.has(dependentEntityKey)) {
+            // If the visited entity is a leaf, we should wait for it to complete
+            // before processing this entity. Don't skip it!
+            if (leafKeys.has(dependentEntityKey)) {
+              // It's a leaf that hasn't completed yet - wait for it
+              isLeaf = false;
+              continue;
+            }
+            // If it's not a leaf, it's blocked on something else - skip to avoid deadlock
             continue;
           }
           isLeaf = false;
@@ -426,7 +449,7 @@ export default async function analyzeEntities({
     }
 
     const file =
-      entity.file || project.files.find((f) => f.path === entity.filePath);
+      entity.file || getFileByPathSafe(projectAnalyzer, entity.filePath);
     if (!file) {
       awsLog(
         `CodeYam: analyzeEntities: File not found for entity: ${entityKey}`,

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

@@ -100,12 +100,6 @@ export function getCandidatesReadyForCapture(
       continue;
     }
 
-    // Skip notExported entities - they can't be imported into the simulation
-    // environment and will always fail capture. Don't mark them as ready.
-    if (candidate.entity?.metadata?.notExported) {
-      continue;
-    }
-
     // Get all transitive dependencies
     const candidateKey = `${candidate.filePath}:${candidate.entityName}`;
     const { missingDependencies } = getTransitiveDependencies(

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

@@ -138,6 +138,18 @@ export default async function findOrCreateEntity({
           break;
         }
       }
+
+      // Mark previous versions as superseded
+      const entitiesToSupersede = previousEntities.filter(
+        (e) => !e.metadata?.isSuperseded,
+      );
+      if (entitiesToSupersede.length > 0) {
+        for (const prev of entitiesToSupersede) {
+          prev.metadata = prev.metadata || {};
+          prev.metadata.isSuperseded = true;
+        }
+        await upsertEntities(entitiesToSupersede);
+      }
     }
 
     entity = {

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

@@ -1,6 +1,7 @@
 import { Entity } from '~codeyam/types';
 import findOrCreateEntity from './findOrCreateEntity';
 import { ProjectAnalyzer } from '../../ProjectAnalyzer';
+import { getFileByPathSafe } from '../../utils/getFileByPath';
 import { AnalysisContext } from '../../analysisContext';
 
 // Track files we've already warned about to avoid duplicate warnings
@@ -71,8 +72,9 @@ export default async function gatherEntityMap({
     //   `  → imported export ${importedExportFilePath}:${importedExportName}`,
     // );
 
-    const importedFile = project.files.find(
-      (file) => file.path === importedExportFilePath,
+    const importedFile = getFileByPathSafe(
+      projectAnalyzer,
+      importedExportFilePath,
     );
 
     if (!importedFile) {

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

@@ -69,9 +69,6 @@ export default function validateDependencyAnalyses({
 
     // if the entity has duplicate dependencies, handle gracefully
     if (dependentAnalyses[dependencyFilePath]?.[dependencyName]) {
-      // console.log(
-      //   `CodeYam: validateDependencyAnalyses: Entity ${entity.filePath}:${entity.name} has duplicate dependency ${dependencyFilePath}:${dependencyName}. Skipping...`,
-      // );
       continue;
     }
 

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

@@ -1,5 +1,6 @@
 import { Entity, EntityType, File, ProjectFramework } from '~codeyam/types';
 import { ProjectAnalyzer } from '../ProjectAnalyzer';
+import { getFileByPathSafe } from '../utils/getFileByPath';
 import { generateSha } from '~codeyam/database';
 import { isRemixRoute } from '~codeyam/utils';
 
@@ -88,11 +89,9 @@ export default function analyzeRemixRoute(
   // Find root.tsx for this route's webapp and add as implicit dependency
   // This ensures root.tsx dependencies (like useLoaderData in AppContent) get analyzed for mocking
   const routeAppDir = file.path.split('/routes/')[0];
-  const rootFile = projectAnalyzer.project.files.find(
-    (f) =>
-      f.path === `${routeAppDir}/root.tsx` ||
-      f.path === `${routeAppDir}/root.jsx`,
-  );
+  const rootFile =
+    getFileByPathSafe(projectAnalyzer, `${routeAppDir}/root.tsx`) ??
+    getFileByPathSafe(projectAnalyzer, `${routeAppDir}/root.jsx`);
 
   const rootDependencies: Entity['metadata']['importedExports'] = [];
   if (rootFile) {

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

@@ -1,6 +1,7 @@
 import { Entity, File, Project } from '~codeyam/types';
 import { FileAnalyzer } from '../FileAnalyzer';
 import { ProjectAnalyzer } from '../ProjectAnalyzer';
+import { getFileByPathSafe } from '../utils/getFileByPath';
 import type { FunctionDependenciesMap } from '../asts/sourceFiles/getPseudoFile';
 // import { generateSha } from '~codeyam/database';
 
@@ -63,9 +64,7 @@ export default function getImportedExports(
           imports[filePath].resolvedPath ??
           filePath;
 
-        let importedExportFile = project.files.find(
-          (f) => f.path === searchPath,
-        );
+        let importedExportFile = getFileByPathSafe(projectAnalyzer, searchPath);
 
         // Track the actual path we found (may differ from searchPath after dist->src mapping)
         let actualResolvedPath = imports[filePath].resolvedPath;
@@ -84,7 +83,7 @@ export default function getImportedExports(
             const srcPath = `${packagePath}/src/${relativePath}`
               .replace(/\.d\.ts$/, '.ts')
               .replace(/\.js$/, '.ts');
-            importedExportFile = project.files.find((f) => f.path === srcPath);
+            importedExportFile = getFileByPathSafe(projectAnalyzer, srcPath);
             if (importedExportFile) {
               actualResolvedPath = srcPath;
               console.log(
@@ -97,7 +96,7 @@ export default function getImportedExports(
           if (!importedExportFile) {
             const srcPath = searchPath.replace('/dist/', '/src/');
             // Try exact match first
-            importedExportFile = project.files.find((f) => f.path === srcPath);
+            importedExportFile = getFileByPathSafe(projectAnalyzer, srcPath);
             if (importedExportFile) {
               actualResolvedPath = srcPath;
               console.log(
@@ -114,13 +113,16 @@ export default function getImportedExports(
             const basePath = srcPath
               .replace(/\.d\.ts$/, '')
               .replace(/\.js$/, '');
-            importedExportFile = project.files.find(
-              (f) =>
-                f.path === basePath + '.ts' ||
-                f.path === basePath + '.tsx' ||
-                (f.path.startsWith(basePath.replace('/index', '/')) &&
-                  !f.path.includes('/dist/')),
-            );
+            importedExportFile =
+              getFileByPathSafe(projectAnalyzer, basePath + '.ts') ??
+              getFileByPathSafe(projectAnalyzer, basePath + '.tsx');
+            if (!importedExportFile) {
+              importedExportFile = project.files.find(
+                (f) =>
+                  f.path.startsWith(basePath.replace('/index', '/')) &&
+                  !f.path.includes('/dist/'),
+              );
+            }
             if (importedExportFile) {
               actualResolvedPath = importedExportFile.path;
               console.log(