@codeyam/codeyam-cli 0.1.0-staging.a890816 → 0.1.0-staging.ac9ca58

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

@@ -8,13 +8,11 @@ import {
 import { transformationTracer } from '../scenarios/TransformationTracer';
 import { getFileByPathSafe } from '../../utils/getFileByPath';
 import trackEntityCircularDependencies from './trackEntityCircularDependencies';
-import validateDependencyAnalyses from './validateDependencyAnalyses';
 import extractClassMethods from './analyzeEntities/extractClassMethods';
 import prepareDataStructures from './analyzeEntities/prepareDataStructures';
 import { strategies, asyncComplex } from './analyzeEntities/strategies';
 import {
   updateCommitMetadata,
-  updateFreshAnalysisMetadata,
   updateFreshAnalysisStatus,
   upsertAnalyses,
   upsertEntities,
@@ -263,40 +261,11 @@ export default async function analyzeEntities({
     }
   }
 
-  awsLog(`CodeYam: analyzeEntities: Running patch-up dependency validation`);
-  for (const analysis of analyses) {
-    if (!analysis.entity) {
-      throw new Error(
-        `CodeYam: analyzeEntities: Internal error: Analysis entity is missing for ${analysis.filePath}:${analysis.entityName}.`,
-      );
-    }
-
-    // Validate dependencies, which modifies analysis.metadata.dependentAnalyses
-    validateDependencyAnalyses({ analysis, entity: analysis.entity, context });
-
-    // Carefully update only the metadata field
-    if (analysis.id) {
-      const updatedMetadata = await updateFreshAnalysisMetadata(
-        analysis.id,
-        (metadata) => {
-          metadata.dependentAnalyses =
-            analysis.metadata?.dependentAnalyses || [];
-        },
-      );
-
-      if (updatedMetadata) {
-        analysis.metadata = updatedMetadata;
-      } else {
-        console.warn(
-          `CodeYam: analyzeEntities: Failed to update metadata for analysis ${analysis.id}`,
-        );
-      }
-    } else {
-      console.warn(
-        `CodeYam: analyzeEntities: Analysis ${analysis.filePath}:${analysis.entityName} has no ID, skipping metadata update`,
-      );
-    }
-  }
+  // NOTE: patch-up dependency validation loop was removed here.
+  // analysis.metadata.dependentAnalyses is already populated by validateDependencyAnalyses
+  // inside analyzeEntity() (Call #1) and persisted via upsertAnalysesWithScenarios at the
+  // end of analyzeEntity, then again by upsertAnalyses in analyzeOneEntityKey. Re-validating
+  // every analysis from scratch was redundant work — especially costly for large projects.
 
   const newlyReady = await updateReadyAnalyses();
   if (newlyReady.length > 0) {

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

@@ -94,12 +94,15 @@ export default async function findOrCreateEntity({
   try {
     code = fileAnalyzer.getEntityCode(localEntityName);
   } catch (e) {
-    console.log('CodeYam Error: could not get entity code', {
-      filePath: file.path,
-      localEntityName,
-      entityName,
-      error: e,
-    });
+    console.log(
+      `CodeYam Error: Could not extract code for "${localEntityName}" from ${file.path} — export not found in file, may have been moved or renamed during refactoring`,
+      {
+        filePath: file.path,
+        localEntityName,
+        entityName,
+        error: String(e),
+      },
+    );
     return null;
   }
   const sha = generateSha(file.path, entityName, code);
@@ -108,6 +111,7 @@ export default async function findOrCreateEntity({
     entity = await loadEntity({
       projectId: project.id,
       sha,
+      silent: true, // Entity not existing yet is the normal path — we create it below
     });
   }
 

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

@@ -111,18 +111,15 @@ export default async function gatherEntityMap({
       });
 
       if (!importedEntity) {
-        console.log(
-          `CodeYam Error: Entity not found while gathering entity map: ${importedFile.path}: ${importedExportName}`,
-          {
-            entityName: entity.name,
-            entityFilePath: entity.filePath,
-            importedFilePath: importedFile.path,
-            importedExportName: importedExportName,
-          },
-        );
-        throw new Error(
-          `Entity not found while gathering entity map: ${importedFile.path}: ${importedExport.name}`,
-        );
+        const msg = [
+          `Entity not found: "${importedExportName}" in ${importedFile.path}`,
+          `  While analyzing dependencies of: ${entity.name} (${entity.filePath})`,
+          `  This usually means "${importedExportName}" was moved or renamed but`,
+          `  ${entity.filePath} still has stale import metadata referencing the old location.`,
+          `  Fix: Update or re-analyze ${entity.filePath} so its importedExports reflect current code.`,
+        ].join('\n');
+        console.log(`CodeYam Error: ${msg}`);
+        throw new Error(msg);
       }
 
       // Add newly created entity to context

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

@@ -1,5 +1,6 @@
 import type { Entity } from '~codeyam/types';
 import { AnalysisContext } from '../../analysisContext';
+import { awsLogDebugLevel } from '~codeyam/utils';
 
 /**
  * Optimized version that processes multiple root entities in a single traversal.
@@ -16,6 +17,8 @@ export default function trackEntityCircularDependencies(
   try {
     const allEntities = new Set<Entity>();
     const globalVisited = new Set<string>(); // Track by SHA to avoid duplicate traversals
+    let circularCount = 0;
+    const startTime = Date.now();
 
     // Process each root entity, but skip if already processed
     for (const rootEntity of rootEntities) {
@@ -32,8 +35,26 @@ export default function trackEntityCircularDependencies(
         globalVisited,
         allEntities,
       );
+
+      // Emit periodic progress for large projects
+      if (allEntities.size % 100 === 0 && allEntities.size > 0) {
+        awsLogDebugLevel(
+          1,
+          `Mapping dependencies... (${allEntities.size} entities discovered)`,
+        );
+      }
     }
 
+    const elapsed = Date.now() - startTime;
+    // Count circular deps
+    for (const entity of allEntities) {
+      if (entity.metadata?.hasCircularDependency) circularCount++;
+    }
+    awsLogDebugLevel(
+      1,
+      `Dependency mapping complete: ${allEntities.size} entities, ${circularCount} circular, ${elapsed}ms`,
+    );
+
     return allEntities;
   } catch (e) {
     console.log(

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

@@ -6,6 +6,20 @@ import type {
   ReadonlyEntity,
 } from '~codeyam/types';
 import { ImmutableAnalysisContext } from '../../analysisContext';
+import { awsLogDebugLevel } from '~codeyam/utils';
+
+/**
+ * Tracks statistics across the recursive dependency validation.
+ * Shared by all recursive calls to provide a complete picture.
+ */
+interface ValidationStats {
+  totalVisited: number;
+  skippedDuplicate: number;
+  skippedMissing: number;
+  skippedTrivial: number;
+  maxDepth: number;
+  startTime: number;
+}
 
 export default function validateDependencyAnalyses({
   analysis,
@@ -13,12 +27,18 @@ export default function validateDependencyAnalyses({
   entity,
   context,
   dependentAnalyses,
+  _depth = 0,
+  _stats,
 }: {
   analysis?: Analysis;
   readonlyAnalysis?: ReadonlyAnalysis;
   entity: ReadonlyEntity;
   context: ImmutableAnalysisContext;
   dependentAnalyses?: ReadonlyAnalysisMap;
+  /** Recursion depth (internal, do not set) */
+  _depth?: number;
+  /** Shared stats tracker (internal, do not set) */
+  _stats?: ValidationStats;
 }): { dependentAnalyses: ReadonlyAnalysisMap } {
   if (!readonlyAnalysis) readonlyAnalysis = analysis;
   if (!readonlyAnalysis) {
@@ -32,6 +52,28 @@ export default function validateDependencyAnalyses({
     );
   }
 
+  // Initialize stats on the root call
+  const isRootCall = _depth === 0;
+  if (!_stats) {
+    _stats = {
+      totalVisited: 0,
+      skippedDuplicate: 0,
+      skippedMissing: 0,
+      skippedTrivial: 0,
+      maxDepth: 0,
+      startTime: Date.now(),
+    };
+  }
+  if (_depth > _stats.maxDepth) _stats.maxDepth = _depth;
+
+  const importCount = entity.metadata?.importedExports?.length ?? 0;
+  if (isRootCall && importCount > 0) {
+    awsLogDebugLevel(
+      2,
+      `validateDeps: ${entity.name} has ${importCount} imports to validate`,
+    );
+  }
+
   if (
     dependentAnalyses &&
     dependentAnalyses[readonlyAnalysis.filePath]?.[
@@ -45,6 +87,12 @@ export default function validateDependencyAnalyses({
     })
   ) {
     // already processed this analysis
+    if (isRootCall) {
+      awsLogDebugLevel(
+        2,
+        `validateDeps: ${entity.name} already fully processed (cache hit)`,
+      );
+    }
     return { dependentAnalyses };
   }
 
@@ -69,9 +117,20 @@ export default function validateDependencyAnalyses({
 
     // if the entity has duplicate dependencies, handle gracefully
     if (dependentAnalyses[dependencyFilePath]?.[dependencyName]) {
+      _stats.skippedDuplicate++;
       continue;
     }
 
+    _stats.totalVisited++;
+
+    // Emit periodic progress so the spinner stays alive for large trees
+    if (_stats.totalVisited % 50 === 0) {
+      awsLogDebugLevel(
+        1,
+        `Validating dependencies... (${_stats.totalVisited} resolved, depth ${_depth})`,
+      );
+    }
+
     // Check if dependency analysis exists in context
     const dependentAnalysis = context.getAnalysis(
       dependencyFilePath,
@@ -86,21 +145,20 @@ export default function validateDependencyAnalyses({
       );
 
       if (!dependentEntity) {
-        // console.warn(
-        //   `CodeYam: validateDependencyAnalyses: Missing dependent entity ${dependencyFilePath}:${dependencyName} for ${entity.filePath}:${entity.name}. This is likely a bug.`,
-        // );
+        _stats.skippedMissing++;
         continue;
       }
 
       // ignore trivial missing dependencies
-      if (!['library', 'visual'].includes(dependentEntity.entityType)) continue;
+      if (!['library', 'visual'].includes(dependentEntity.entityType)) {
+        _stats.skippedTrivial++;
+        continue;
+      }
 
       if (!dependentEntity?.metadata?.hasCircularDependency) {
         // TODO: This no longer seems to happen thanks to fixes elsewhere, but leave the warning
-        // console.warn(
-        //   `CodeYam: validateDependencyAnalyses: Missing analysis for dependency ${entity.filePath}:${entity.name} -> ${dependencyFilePath}:${dependencyName}, should be marked as having circular dependencies.`,
-        // );
       }
+      _stats.skippedMissing++;
       continue;
     }
 
@@ -136,9 +194,6 @@ export default function validateDependencyAnalyses({
     if (analysis) {
       // Track dependency relationship in analysis metadata
       if (!analysis.metadata.dependentAnalyses.includes(dependentAnalysis.id)) {
-        // console.log(
-        //   `CodeYam: validateDependencyAnalyses: Establishing dependency ${analysis.filePath}:${analysis.entityName} -> ${dependentAnalysis.filePath}:${dependentAnalysis.entityName}.`,
-        // );
         analysis.metadata.dependentAnalyses.push(dependentAnalysis.id);
       }
     }
@@ -152,9 +207,26 @@ export default function validateDependencyAnalyses({
         entity: dependentEntity,
         context: context,
         dependentAnalyses,
+        _depth: _depth + 1,
+        _stats,
       });
     }
   }
 
+  // Log summary on root call completion
+  if (isRootCall) {
+    const elapsed = Date.now() - _stats.startTime;
+    const totalDeps = Object.values(dependentAnalyses).reduce(
+      (sum, fileMap) => sum + Object.keys(fileMap).length,
+      0,
+    );
+    awsLogDebugLevel(
+      1,
+      `Dependency validation complete for ${entity.name}: ${totalDeps} dependencies resolved, ` +
+        `${_stats.skippedDuplicate} duplicates skipped, ${_stats.skippedMissing} missing, ` +
+        `${_stats.skippedTrivial} trivial, max depth ${_stats.maxDepth}, ${elapsed}ms`,
+    );
+  }
+
   return { dependentAnalyses };
 }

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

@@ -91,6 +91,10 @@ export default async function analyzeChange({
     // Structure phase: CPU-intensive, serialize via semaphore if provided
     if (!steps || steps.includes(Step.Structure)) {
       if (structureSemaphore) {
+        awsLogDebugLevel(
+          1,
+          `Waiting for structure semaphore for ${entity.name}...`,
+        );
         await structureSemaphore.acquire();
       }
       try {

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

@@ -58,6 +58,10 @@ export default async function analyzeInitial({
     // Structure phase: CPU-intensive, serialize via semaphore if provided
     if (!steps || steps.includes(Step.Structure)) {
       if (structureSemaphore) {
+        awsLogDebugLevel(
+          1,
+          `Waiting for structure semaphore for ${entity.name}...`,
+        );
         await structureSemaphore.acquire();
       }
       try {

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

@@ -3,6 +3,8 @@ import { ProjectAnalyzer } from '../ProjectAnalyzer';
 import { generateSha } from '~codeyam/database';
 import { isNextRoute } from '~codeyam/utils';
 
+const warnedLayoutPaths = new Set<string>();
+
 export default function analyzeNextRoute(
   file: File,
   projectAnalyzer: ProjectAnalyzer,
@@ -56,9 +58,12 @@ export default function analyzeNextRoute(
 
           // Ensure entities array exists before trying to use it
           if (!layout.entities) {
-            console.log(
-              `CodeYam Warning: layout.entities not populated for ${layout.path}, skipping implicit dependency`,
-            );
+            if (!warnedLayoutPaths.has(layout.path)) {
+              warnedLayoutPaths.add(layout.path);
+              console.log(
+                `CodeYam Warning: layout.entities not populated for ${layout.path}, skipping implicit dependency`,
+              );
+            }
             return;
           }