@codeyam/codeyam-cli 0.1.0-staging.1 → 0.1.0-staging.596f0eb

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

@@ -16,9 +16,9 @@ import {
   updateFreshAnalysisStatus,
   upsertAnalyses,
   upsertEntities,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import { getCandidatesReadyForCapture as getAnalysesReadyForCapture } from './dependencyResolver';
-import { awsLog, awsLogDebugLevel } from '~codeyam/utils';
+import { awsLog, awsLogDebugLevel, Semaphore } from '~codeyam/utils';
 
 const MAX_CONCURRENT_ANALYSES = 100; // fairly arbitrary, but more isn't necessarily better
 
@@ -133,6 +133,10 @@ export default async function analyzeEntities({
   const markedReady = new Set<string>(); // Analyses we've attempted to mark ready
   const analyses: Analysis[] = [];
 
+  // Semaphore to serialize CPU-intensive Structure phase while allowing
+  // I/O-bound KeyAttributes LLM calls to run in parallel
+  const structureSemaphore = new Semaphore(1);
+
   const analysesAlreadyCompletedAtStart =
     commit?.metadata?.currentRun?.analysesCompleted ?? 0;
 
@@ -442,6 +446,7 @@ export default async function analyzeEntities({
           analyzeAsDependency: !allRootEntities.some(
             (e) => e.filePath === entity.filePath && e.name === entity.name,
           ),
+          structureSemaphore,
           ...options,
           force,
         }),
@@ -494,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) => {
@@ -506,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;
 }
@@ -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 '..';
@@ -16,7 +16,12 @@ import { AI } from '~codeyam/ai';
 import extractDiffLines from './extractDiffLines';
 import analyzeCodeChange from './analyzeCodeChange';
 import relevantDiffPart from './relevantDiffPart';
-import { awsLog, awsLogDebugLevel, pushAnalysisError } from '~codeyam/utils';
+import {
+  awsLog,
+  awsLogDebugLevel,
+  pushAnalysisError,
+  Semaphore,
+} from '~codeyam/utils';
 
 export interface AnalyzeChangeArgs {
   previousAnalysis: Analysis;
@@ -29,6 +34,8 @@ export interface AnalyzeChangeArgs {
   steps?: string[];
   updateProgress?: (detail: string) => void;
   model: AI.Model;
+  /** Semaphore to serialize CPU-intensive Structure phase */
+  structureSemaphore?: Semaphore;
 }
 
 export default async function analyzeChange({
@@ -42,6 +49,7 @@ export default async function analyzeChange({
   steps,
   updateProgress,
   model,
+  structureSemaphore,
 }: AnalyzeChangeArgs) {
   analysis.entity = entity;
   awsLog('CodeYam: Analyzing change entity', {
@@ -79,24 +87,35 @@ export default async function analyzeChange({
       });
     }
 
+    // Structure phase: CPU-intensive, serialize via semaphore if provided
     if (!steps || steps.includes(Step.Structure)) {
-      awsLogDebugLevel(
-        1,
-        `Merging dependent data structures for ${entity.name}...`,
-      );
+      if (structureSemaphore) {
+        await structureSemaphore.acquire();
+      }
+      try {
+        awsLogDebugLevel(
+          1,
+          `Merging dependent data structures for ${entity.name}...`,
+        );
 
-      const { step: dataStructureStep } = await recordStep(
-        'generateDataStructure',
-        () =>
-          generateDataStructure({
-            entity,
-            dependentAnalyses,
-            analysis,
-          }),
-      );
-      analysis.status.steps.push(dataStructureStep);
+        const { step: dataStructureStep } = await recordStep(
+          'generateDataStructure',
+          () =>
+            generateDataStructure({
+              entity,
+              dependentAnalyses,
+              analysis,
+            }),
+        );
+        analysis.status.steps.push(dataStructureStep);
+      } finally {
+        if (structureSemaphore) {
+          structureSemaphore.release();
+        }
+      }
     }
 
+    // KeyAttributes phase: I/O-bound LLM call, can run in parallel with other entities' Structure
     if (!steps || steps.includes(Step.KeyAttributes)) {
       awsLogDebugLevel(1, `Determining key attributes for ${entity.name}...`);
 

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,
@@ -31,7 +31,12 @@ import relevantDiffPart from './relevantDiffPart';
 import { Step } from './enums/steps';
 import { ImmutableAnalysisContext } from '../analysisContext';
 import generateAnalyzedTreeSha from './analyze/generateAnalyzedTreeSha';
-import { awsLog, awsLogDebugLevel, pushAnalysisError } from '~codeyam/utils';
+import {
+  awsLog,
+  awsLogDebugLevel,
+  pushAnalysisError,
+  Semaphore,
+} from '~codeyam/utils';
 
 export interface AnalyzeEntityArgs {
   project: Project;
@@ -50,6 +55,8 @@ export interface AnalyzeEntityArgs {
   forceAll?: boolean;
   updateProgress?: (detail: string) => void;
   modelString?: string;
+  /** Semaphore to serialize CPU-intensive Structure phase */
+  structureSemaphore?: Semaphore;
 }
 
 /**
@@ -77,6 +84,7 @@ export default async function analyzeEntity({
   forceAll,
   updateProgress,
   modelString,
+  structureSemaphore,
 }: AnalyzeEntityArgs): Promise<{
   analysis: Analysis;
   dependentAnalyses?: ReadonlyAnalysisMap;
@@ -476,6 +484,7 @@ export default async function analyzeEntity({
             steps,
             updateProgress,
             model,
+            structureSemaphore,
           })
         : analyzeInitial({
             analysis,
@@ -485,6 +494,7 @@ export default async function analyzeEntity({
             steps,
             updateProgress,
             model,
+            structureSemaphore,
           }),
     ]);
 
@@ -498,8 +508,12 @@ export default async function analyzeEntity({
     analysis = analysisResult.analysis;
 
     analysis.completedAt = new Date().toISOString();
-    // Don't set analyzedTreeSha when ONLY_DATA_STRUCTURE=true, so full analysis can re-analyze later
-    if (process.env.ONLY_DATA_STRUCTURE !== 'true') {
+    // Don't set analyzedTreeSha when:
+    // 1. ONLY_DATA_STRUCTURE=true - so full analysis can re-analyze later
+    // 2. analyzeAsDependency=true - dependency analyses only generate Structure+KeyAttributes,
+    //    not scenarios. Leaving analyzedTreeSha unset allows partial analysis detection to work
+    //    when the entity is later analyzed directly.
+    if (process.env.ONLY_DATA_STRUCTURE !== 'true' && !analyzeAsDependency) {
       analysis.analyzedTreeSha = generateAnalyzedTreeSha(analysis);
     }
   } catch (error) {

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

@@ -11,8 +11,13 @@ import {
   type Entity,
   type ReadonlyAnalysisMap,
 } from '~codeyam/types';
-import { upsertAnalysesWithScenarios } from '~codeyam/supabase';
-import { awsLog, awsLogDebugLevel, pushAnalysisError } from '~codeyam/utils';
+import { upsertAnalysesWithScenarios } from '~codeyam/database';
+import {
+  awsLog,
+  awsLogDebugLevel,
+  pushAnalysisError,
+  Semaphore,
+} from '~codeyam/utils';
 import generateKeyAttributes from './scenarios/generateKeyAttributes';
 
 export interface AnalyzeInitialArgs {
@@ -23,6 +28,8 @@ export interface AnalyzeInitialArgs {
   steps?: string[];
   updateProgress?: (detail: string) => void;
   model: AI.Model;
+  /** Semaphore to serialize CPU-intensive Structure phase */
+  structureSemaphore?: Semaphore;
 }
 
 export default async function analyzeInitial({
@@ -33,6 +40,7 @@ export default async function analyzeInitial({
   steps,
   updateProgress,
   model,
+  structureSemaphore,
 }: AnalyzeInitialArgs) {
   analysis.entity = entity;
   awsLog('CodeYam: Analyzing initial entity', {
@@ -47,22 +55,32 @@ export default async function analyzeInitial({
   });
 
   try {
+    // Structure phase: CPU-intensive, serialize via semaphore if provided
     if (!steps || steps.includes(Step.Structure)) {
-      awsLogDebugLevel(
-        1,
-        `Merging dependent data structures for ${entity.name}...`,
-      );
-
-      const { step: dataStructureStep } = await recordStep(
-        'generateDataStructure',
-        () =>
-          generateDataStructure({
-            entity,
-            dependentAnalyses,
-            analysis,
-          }),
-      );
-      analysis.status.steps.push(dataStructureStep);
+      if (structureSemaphore) {
+        await structureSemaphore.acquire();
+      }
+      try {
+        awsLogDebugLevel(
+          1,
+          `Merging dependent data structures for ${entity.name}...`,
+        );
+
+        const { step: dataStructureStep } = await recordStep(
+          'generateDataStructure',
+          () =>
+            generateDataStructure({
+              entity,
+              dependentAnalyses,
+              analysis,
+            }),
+        );
+        analysis.status.steps.push(dataStructureStep);
+      } finally {
+        if (structureSemaphore) {
+          structureSemaphore.release();
+        }
+      }
     }
 
     // Short-circuit for test mocking: only generate data structure, skip key attributes and scenarios
@@ -73,6 +91,7 @@ export default async function analyzeInitial({
       return { analysis };
     }
 
+    // KeyAttributes phase: I/O-bound LLM call, can run in parallel with other entities' Structure
     if (!steps || steps.includes(Step.KeyAttributes)) {
       awsLogDebugLevel(1, `Determining key attributes for ${entity.name}...`);
 

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(