@codeyam/codeyam-cli 0.1.0-staging.28f73cf → 0.1.0-staging.596f0eb

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,