@codeyam/codeyam-cli 0.1.0-staging.ad31e3e → 0.1.0-staging.b8a55ba

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';
 
@@ -499,7 +499,23 @@ export default async function analyzeEntities({
 
     const successfullyUpdated: Analysis[] = [];
 
+    console.log('CodeYam DEBUG: updateReadyAnalyses - newlyReady analyses:', {
+      count: newlyReady.length,
+      analyses: newlyReady.map((a) => ({
+        id: a.id,
+        filePath: a.filePath,
+        entityName: a.entityName,
+        scenarioCount: a.scenarios?.length ?? 0,
+      })),
+    });
+
     for (const analysis of newlyReady) {
+      console.log('CodeYam DEBUG: Setting readyToBeCaptured=true for:', {
+        id: analysis.id,
+        filePath: analysis.filePath,
+        entityName: analysis.entityName,
+      });
+
       const updatedStatus = await updateFreshAnalysisStatus(
         analysis.id!,
         (status) => {
@@ -511,6 +527,10 @@ export default async function analyzeEntities({
       if (updatedStatus) {
         analysis.status = updatedStatus;
         successfullyUpdated.push(analysis);
+        console.log('CodeYam DEBUG: Successfully marked readyToBeCaptured:', {
+          id: analysis.id,
+          entityName: analysis.entityName,
+        });
       } else {
         console.warn(
           `CodeYam: updateReadyAnalyses: Failed to update status for analysis ${analysis.id}`,

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(
@@ -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(

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,
@@ -63,19 +63,116 @@ export default function getImportedExports(
           imports[filePath].resolvedPath ??
           filePath;
 
-        const importedExportFile = project.files.find(
+        let importedExportFile = project.files.find(
           (f) => f.path === searchPath,
         );
 
-        if (!importedExportFile) {
-          console.log(
-            'CodeYam Error: File not found for imported export',
-            file.path,
-            filePath,
-            importedExportInfo,
-            imports[filePath],
+        // Track the actual path we found (may differ from searchPath after dist->src mapping)
+        let actualResolvedPath = imports[filePath].resolvedPath;
+
+        // 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/')) {
+          // 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\/(.+)$/,
           );
-          return;
+          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$/, '')
+              .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/')),
+            );
+            if (importedExportFile) {
+              actualResolvedPath = importedExportFile.path;
+              console.log(
+                `CodeYam: Mapped dist->src path (extension): ${searchPath} -> ${importedExportFile.path}`,
+              );
+            }
+          }
+        }
+
+        if (!importedExportFile) {
+          // 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: Tracking unresolved import (mocking decision deferred): ${filePath} -> ${name}`,
+            );
+            return {
+              filePath,
+              name,
+              isDefault: importedExportInfo.isImportDefault,
+              // isMocked intentionally undefined - will be determined later by prepareDataStructures
+              // based on mockedDependencies analysis
+              entityType: 'library' as const,
+            };
+          }
         }
 
         try {
@@ -91,19 +188,39 @@ 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;
 
+          // When a default export is re-exported as named (e.g., `export { default as X }`),
+          // isExportDefault will be false (it's exported as named from the barrel),
+          // but resolvedName will be 'default'. In this case, we need resolvedIsDefault
+          // to be true so that writeScenarioComponents adds the named re-export.
+          const resolvedIsDefault =
+            importedExportInfo.isExportDefault || resolvedName === 'default';
+
           return {
             fileId: importedExportFile.id,
-            filePath: imports[filePath].resolvedPath,
+            filePath: actualResolvedPath,
             isDefault: importedExportInfo.isImportDefault,
             resolvedFilePath:
-              resolvedFilePath === imports[filePath].resolvedPath
+              resolvedFilePath === actualResolvedPath
                 ? undefined
                 : resolvedFilePath,
             resolvedName: resolvedName === name ? undefined : resolvedName,
-            resolvedIsDefault: importedExportInfo.isExportDefault,
+            resolvedIsDefault,
             entityType,
             name,
             code,

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

@@ -0,0 +1,158 @@
+import { DataStructure } from '~codeyam/types';
+
+/**
+ * Enriches mocked dependency array types with fields from child component signatures.
+ *
+ * When a mocked dependency (e.g., getSurveysAction) returns an array, and elements
+ * from that array are passed to child components (e.g., SurveyCard), the child's
+ * signatureSchema specifies required fields (e.g., survey.updatedAt). This function
+ * enriches the mocked dependency's returnValueSchema so the LLM knows what fields
+ * to generate for array elements.
+ *
+ * Example:
+ * - getSurveysAction returns { data: array }
+ * - SurveyCard expects signature[0].survey.updatedAt: date
+ * - After enrichment: getSurveysAction().data[]: object, data[].updatedAt: date
+ */
+export default function enrichArrayTypesFromChildSignatures(
+  importedExports: {
+    filePath?: string;
+    name: string;
+    isMocked?: boolean;
+  }[],
+  dependencySchemas: DataStructure['dependencySchemas'],
+): void {
+  // Find all mocked dependencies with array return types
+  const mockedArrayPaths: {
+    filePath: string;
+    entityName: string;
+    arrayPath: string; // e.g., "getSurveysAction().functionCallReturnValue.data"
+  }[] = [];
+
+  for (const importedExport of importedExports) {
+    if (!importedExport.isMocked || !importedExport.filePath) continue;
+
+    const schema =
+      dependencySchemas?.[importedExport.filePath]?.[importedExport.name]
+        ?.returnValueSchema;
+    if (!schema) continue;
+
+    // Find paths that are top-level data arrays (not deeply nested, not direct returns)
+    // We only want to enrich arrays that likely contain objects passed to children
+    // e.g., getSurveysAction().data but NOT:
+    //   - wrapThrows().data.createdBy (deeply nested)
+    //   - getStatusOptions().functionCallReturnValue (direct array return - usually options/primitives)
+    for (const [path, type] of Object.entries(schema)) {
+      if (type !== 'array') continue;
+
+      // Skip paths with computed property patterns like [key], [i], [0], etc.
+      // These represent dynamic access patterns, not simple data arrays
+      // We only match brackets with content (not empty [] which indicates array element type)
+      if (/\[[^\]]+\]/.test(path)) {
+        continue;
+      }
+
+      // Skip direct array returns (e.g., getStatusOptions().functionCallReturnValue)
+      // These are typically specialized arrays like [{label, value}], not entity arrays
+      if (path.endsWith('.functionCallReturnValue')) {
+        continue;
+      }
+
+      // Check if this is a top-level array (at most one property after functionCallReturnValue)
+      // e.g., "foo().functionCallReturnValue.data" is top-level
+      // e.g., "foo().functionCallReturnValue.data.createdBy" is nested (skip)
+      const returnValueMatch = path.match(/\.functionCallReturnValue\.(.+)$/);
+      if (returnValueMatch) {
+        const afterReturnValue = returnValueMatch[1];
+        // If there's more than one property access, it's nested
+        const propertyCount = afterReturnValue.split('.').length;
+        if (propertyCount > 1) {
+          continue; // Skip deeply nested arrays
+        }
+      }
+
+      mockedArrayPaths.push({
+        filePath: importedExport.filePath,
+        entityName: importedExport.name,
+        arrayPath: path,
+      });
+    }
+  }
+
+  if (mockedArrayPaths.length === 0) return;
+
+  // Find all non-mocked child components and extract their signature fields
+  const childSignatureFields: {
+    filePath: string;
+    entityName: string;
+    // Map of prop paths to types, e.g., { "survey.id": "string", "survey.updatedAt": "date" }
+    propFields: Record<string, string>;
+  }[] = [];
+
+  for (const importedExport of importedExports) {
+    // Skip mocked dependencies - we want child components
+    if (importedExport.isMocked || !importedExport.filePath) continue;
+
+    const schema =
+      dependencySchemas?.[importedExport.filePath]?.[importedExport.name]
+        ?.signatureSchema;
+    if (!schema) continue;
+
+    // Extract signature[0].* fields (first prop of child component)
+    const propFields: Record<string, string> = {};
+    for (const [path, type] of Object.entries(schema)) {
+      // Match signature[0].propName.field patterns
+      const match = path.match(/^signature\[0\]\.(\w+)\.(.+)$/);
+      if (match) {
+        const [, propName, fieldPath] = match;
+        // Store as "fieldPath" without the prop name prefix
+        // e.g., signature[0].survey.updatedAt -> updatedAt
+        propFields[fieldPath] = type;
+      }
+    }
+
+    if (Object.keys(propFields).length > 0) {
+      childSignatureFields.push({
+        filePath: importedExport.filePath,
+        entityName: importedExport.name,
+        propFields,
+      });
+    }
+  }
+
+  if (childSignatureFields.length === 0) return;
+
+  // Enrich mocked dependency arrays with child signature fields
+  // Only enrich arrays that don't already have element types defined
+  // A more sophisticated approach would trace the data flow to match specific arrays to specific children
+  for (const { filePath, entityName, arrayPath } of mockedArrayPaths) {
+    const schema = dependencySchemas[filePath][entityName].returnValueSchema;
+
+    // Check if this array already has element type definitions
+    // If so, skip it - it's likely a specialized array like [null] for refs
+    const elementPathPrefix = `${arrayPath}[`;
+    const hasExistingElementType = Object.keys(schema).some((path) =>
+      path.startsWith(elementPathPrefix),
+    );
+
+    if (hasExistingElementType) {
+      // Array already has element type info (e.g., useAutoAnimate()[0]: null)
+      // Don't override it with child signature fields
+      continue;
+    }
+
+    // Add array element type
+    const elementPath = `${arrayPath}[]`;
+    schema[elementPath] = 'object';
+
+    // Add fields from all child signatures to the array element
+    for (const { propFields } of childSignatureFields) {
+      for (const [fieldPath, type] of Object.entries(propFields)) {
+        const fullPath = `${elementPath}.${fieldPath}`;
+        if (!schema[fullPath]) {
+          schema[fullPath] = type;
+        }
+      }
+    }
+  }
+}