@codeyam/codeyam-cli 0.1.0-staging.596f0eb → 0.1.0-staging.62d4615

package/analyzer-template/project/controller/startController.ts

@@ -13,8 +13,8 @@ export enum ControllerPhase {
   Startup = 'STARTUP',
   RepoCheckout = 'REPO_CHECKOUT',
   Analysis = 'ANALYSIS',
+  AnalysisProducing = 'ANALYSIS_PRODUCING',
   Serving = 'SERVING',
-  Orchestrating = 'ORCHESTRATING',
   Complete = 'COMPLETE',
 }
 
@@ -30,6 +30,7 @@ type ControllerContext =
   | { phase: ControllerPhase.Startup; info: null }
   | { phase: ControllerPhase.RepoCheckout; info: null }
   | { phase: ControllerPhase.Analysis; info: null }
+  | { phase: ControllerPhase.AnalysisProducing; info: null }
   | { phase: ControllerPhase.Serving; info: ServingCodeYamInfo }
   | { phase: ControllerPhase.Complete; info: null };
 
@@ -100,6 +101,11 @@ export class Controller extends EventEmitter {
     this.setPhase({ phase: ControllerPhase.Analysis, info: null });
   }
 
+  setAnalysisProducingPhase(): void {
+    this.setPhase({ phase: ControllerPhase.AnalysisProducing, info: null });
+    this.emit('analysisProducing');
+  }
+
   setServingPhase(info: ServingCodeYamInfo): void {
     this.setPhase({ phase: ControllerPhase.Serving, info });
   }
@@ -116,6 +122,15 @@ export class Controller extends EventEmitter {
     );
   }
 
+  hasStartedProducing(): boolean {
+    // Analysis is producing once we've moved past the Analysis phase
+    return (
+      this.context.phase === ControllerPhase.AnalysisProducing ||
+      this.context.phase === ControllerPhase.Serving ||
+      this.context.phase === ControllerPhase.Complete
+    );
+  }
+
   async close(): Promise<void> {
     if (!this.server) return;
 

package/analyzer-template/project/createEntitiesAndSortFiles.ts

@@ -28,6 +28,14 @@ export interface SortedEntitiesAndMap {
   entityMap: { [key: string]: { [key: string]: EntityWithImportCount } };
 }
 
+// Timing stats for debugging
+let findOrCreateEntityTime = 0;
+let gatherEntityMapTime = 0;
+let recursiveCallTime = 0;
+let findOrCreateEntityCalls = 0;
+let gatherEntityMapCalls = 0;
+let recursiveCalls = 0;
+
 async function findAndGatherEntity({
   project,
   branch,
@@ -37,6 +45,7 @@ async function findAndGatherEntity({
   projectAnalyzer,
   context,
   fileStore,
+  depth = 0,
 }: {
   project: Project;
   branch: Branch;
@@ -46,6 +55,7 @@ async function findAndGatherEntity({
   projectAnalyzer: ProjectAnalyzer;
   context: AnalysisContext;
   fileStore?: LazyFileStore;
+  depth?: number;
 }) {
   let entityWithImportCount: EntityWithImportCount = context.getEntity(
     file.path,
@@ -53,6 +63,7 @@ async function findAndGatherEntity({
   ) as EntityWithImportCount;
   if (entityWithImportCount?.importCount === undefined) {
     try {
+      const t0 = performance.now();
       entityWithImportCount = await findOrCreateEntity({
         file,
         branchId: branch?.id,
@@ -61,6 +72,8 @@ async function findAndGatherEntity({
         projectAnalyzer,
         context,
       });
+      findOrCreateEntityTime += performance.now() - t0;
+      findOrCreateEntityCalls++;
     } catch (e) {
       console.log(
         'CodeYam Warning: Entity not found in create and sort entities',
@@ -72,12 +85,15 @@ async function findAndGatherEntity({
     // Add entity to context
     context.addEntity(entityWithImportCount);
 
+    const t1 = performance.now();
     await gatherEntityMap({
       entity: entityWithImportCount,
       branchId: branch?.id,
       context,
       projectAnalyzer,
     });
+    gatherEntityMapTime += performance.now() - t1;
+    gatherEntityMapCalls++;
 
     entityWithImportCount.importCount = 0;
     for (const importedEntity of entityWithImportCount.metadata
@@ -105,6 +121,8 @@ async function findAndGatherEntity({
         continue;
       }
 
+      const t2 = performance.now();
+      recursiveCalls++;
       const info = await findAndGatherEntity({
         project,
         branch,
@@ -114,7 +132,11 @@ async function findAndGatherEntity({
         projectAnalyzer,
         context,
         fileStore,
+        depth: depth + 1,
       });
+      if (depth === 0) {
+        recursiveCallTime += performance.now() - t2;
+      }
       entityWithImportCount.importCount +=
         info.entityWithImportCount.importCount;
     }
@@ -147,6 +169,14 @@ export default async function createEntitiesAndSortFiles({
   branchCommit, // just for progress updates
   fileStore,
 }: EntitiesAndSortFiles): Promise<SortedEntitiesAndMap> {
+  // Reset timing stats
+  findOrCreateEntityTime = 0;
+  gatherEntityMapTime = 0;
+  recursiveCallTime = 0;
+  findOrCreateEntityCalls = 0;
+  gatherEntityMapCalls = 0;
+  recursiveCalls = 0;
+
   const sortedEntities: Entity[] = [];
 
   // We slightly abuse the AnalysisContext here, initializing and later throwing it away
@@ -161,6 +191,16 @@ export default async function createEntitiesAndSortFiles({
   // Enable baseline mode to skip DB reads during entity creation
   context.setBaselineMode(true);
   let ii = 0;
+  let updateCommitMetadataTime = 0;
+  let getFileAnalyzerTime = 0;
+  let getAllEntityNodesTime = 0;
+  const loopStart = performance.now();
+  let lastLogTime = loopStart;
+
+  console.log(
+    `CodeYam: createEntitiesAndSortFiles starting, ${filePaths.length} files to process`,
+  );
+
   for (const currentFilePath of filePaths) {
     if (filePath && currentFilePath !== filePath) {
       ii++;
@@ -179,16 +219,23 @@ export default async function createEntitiesAndSortFiles({
     }
 
     if (branchCommit) {
+      const t0 = performance.now();
       branchCommit.metadata = await updateCommitMetadata({
         commitId: branchCommit.id,
         runStatusUpdate: {
           filesCompleted: ii + 1,
         },
       });
+      updateCommitMetadataTime += performance.now() - t0;
     }
 
+    const t1 = performance.now();
     const fileAnalyzer = projectAnalyzer.getFileAnalyzer(file);
+    getFileAnalyzerTime += performance.now() - t1;
+
+    const t2 = performance.now();
     const allEntityNodes = fileAnalyzer.getAllEntityNodesOnlyAliases();
+    getAllEntityNodesTime += performance.now() - t2;
 
     for (const entityName of Object.keys(allEntityNodes)) {
       const { entityWithImportCount: entity } = await findAndGatherEntity({
@@ -206,8 +253,44 @@ export default async function createEntitiesAndSortFiles({
     }
 
     ii++;
+
+    // Log timing stats every 5 seconds
+    const now = performance.now();
+    if (now - lastLogTime > 5000) {
+      lastLogTime = now;
+      const elapsed = ((now - loopStart) / 1000).toFixed(1);
+      console.log(`CodeYam: createEntitiesAndSortFiles progress`, {
+        filesProcessed: ii,
+        totalFiles: filePaths.length,
+        elapsedSec: elapsed,
+        timings: {
+          updateCommitMetadata: `${(updateCommitMetadataTime / 1000).toFixed(1)}s`,
+          getFileAnalyzer: `${(getFileAnalyzerTime / 1000).toFixed(1)}s`,
+          getAllEntityNodes: `${(getAllEntityNodesTime / 1000).toFixed(1)}s`,
+          findOrCreateEntity: `${(findOrCreateEntityTime / 1000).toFixed(1)}s (${findOrCreateEntityCalls} calls)`,
+          gatherEntityMap: `${(gatherEntityMapTime / 1000).toFixed(1)}s (${gatherEntityMapCalls} calls)`,
+          recursiveCalls: `${(recursiveCallTime / 1000).toFixed(1)}s (${recursiveCalls} calls)`,
+        },
+      });
+    }
   }
 
+  // Final timing log
+  const totalElapsed = ((performance.now() - loopStart) / 1000).toFixed(1);
+  console.log(`CodeYam: createEntitiesAndSortFiles loop complete`, {
+    filesProcessed: ii,
+    totalFiles: filePaths.length,
+    elapsedSec: totalElapsed,
+    timings: {
+      updateCommitMetadata: `${(updateCommitMetadataTime / 1000).toFixed(1)}s`,
+      getFileAnalyzer: `${(getFileAnalyzerTime / 1000).toFixed(1)}s`,
+      getAllEntityNodes: `${(getAllEntityNodesTime / 1000).toFixed(1)}s`,
+      findOrCreateEntity: `${(findOrCreateEntityTime / 1000).toFixed(1)}s (${findOrCreateEntityCalls} calls)`,
+      gatherEntityMap: `${(gatherEntityMapTime / 1000).toFixed(1)}s (${gatherEntityMapCalls} calls)`,
+      recursiveCalls: `${(recursiveCallTime / 1000).toFixed(1)}s (${recursiveCalls} calls)`,
+    },
+  });
+
   await setImportedExports({
     entities: Object.values(sortedEntities).flat(),
     context,

package/analyzer-template/project/executeLibraryFunctionDirect.ts

@@ -33,11 +33,15 @@ export default async function executeLibraryFunctionDirect(
   // Generate the execution script
   const script = directExecutionScript(file, entity, analysis, scenario);
 
+  // Use .ts extension for TypeScript source files so tsx can resolve TS imports
+  const isTypeScript = file.path.endsWith('.ts') || file.path.endsWith('.tsx');
+  const scriptExtension = isTypeScript ? '.ts' : '.mjs';
+
   // Write the script to a temporary file
   const scriptPath = path.join(
     PROJECT_RELATIVE_PATH,
     '.codeyam-execution',
-    `${entity.sha}_${scenario.id}.mjs`,
+    `${entity.sha}_${scenario.id}${scriptExtension}`,
   );
 
   await writeFile(scriptPath, script);
@@ -54,10 +58,10 @@ export default async function executeLibraryFunctionDirect(
       command: 'npx',
       args: ['tsx', scriptPath],
       workingDir: PROJECT_RELATIVE_PATH,
-      onData: async (data) => {
+      onData: (data) => {
         stdout += data;
       },
-      onError: async (data) => {
+      onError: (data) => {
         stderr += data;
       },
       processName: 'library-function-execution',

package/analyzer-template/project/loadReadyToBeCaptured.ts

@@ -7,6 +7,28 @@ import {
 import { Analysis, Project } from '~codeyam/types';
 import { LazyFileStore } from './LazyFileStore';
 
+const DB_CONCURRENCY = 1;
+
+async function mapWithConcurrency<T, R>(
+  items: T[],
+  fn: (item: T) => Promise<R>,
+  concurrency: number,
+): Promise<R[]> {
+  const results: R[] = new Array(items.length);
+  let index = 0;
+  const workers = Array.from(
+    { length: Math.min(concurrency, items.length) },
+    async () => {
+      while (index < items.length) {
+        const i = index++;
+        results[i] = await fn(items[i]);
+      }
+    },
+  );
+  await Promise.all(workers);
+  return results;
+}
+
 interface LoadReadyToBeCapturedArgs {
   project: Project;
   branchCommitSha?: string;
@@ -77,8 +99,9 @@ async function gatherAllReferencedEntities(
       byFilePath.get(filePath)!.push(name);
     }
 
-    // Batch load entities by file path
-    const loadPromises = Array.from(byFilePath.entries()).map(
+    // Batch load entities by file path (concurrency-limited to avoid exhausting DB connections)
+    const results = await mapWithConcurrency(
+      Array.from(byFilePath.entries()),
       async ([filePath, names]) => {
         const entities = await loadEntities({
           projectId: project.id,
@@ -106,9 +129,8 @@ async function gatherAllReferencedEntities(
           return false;
         });
       },
+      DB_CONCURRENCY,
     );
-
-    const results = await Promise.all(loadPromises);
     const loadedEntities = results.flat();
 
     // Add loaded entities to context
@@ -198,48 +220,50 @@ export default async function loadReadyToBeCaptured({
     foundNewDependencies = false;
     const currentBatch = Array.from(stillNeeded);
 
-    // Load analyses for current batch
-    const loadPromises = currentBatch.map(async (keyString) => {
-      const [filePath, entityName] = keyString.split(':');
-
-      // Find the file ID for this file path - use fileStore for O(1) lookup when available
-      const file = fileStore
-        ? fileStore.getByPath(filePath)
-        : project.files.find((f) => f.path === filePath);
-      if (!file) {
-        console.log(
-          `CodeYam Warning: File not found in project: ${filePath} for key ${keyString}`,
-        );
-        return null;
-      }
-
-      try {
-        const analysis = await loadAnalysis({
-          projectId: project.id,
-          fileId: file.id,
-          entityName,
-          includeScenarios: isFirstBatch, // Only include scenarios for the root analyses
-        });
-
-        if (analysis) {
-          console.log(`CodeYam: Loaded analysis ${filePath}:${entityName}`);
-          return { key: keyString, analysis };
-        } else {
+    // Load analyses for current batch (concurrency-limited to avoid exhausting DB connections)
+    const results = await mapWithConcurrency(
+      currentBatch,
+      async (keyString) => {
+        const [filePath, entityName] = keyString.split(':');
+
+        // Find the file ID for this file path - use fileStore for O(1) lookup when available
+        const file = fileStore
+          ? fileStore.getByPath(filePath)
+          : project.files.find((f) => f.path === filePath);
+        if (!file) {
           console.log(
-            `CodeYam Warning: Analysis not found: ${filePath}:${entityName}`,
+            `CodeYam Warning: File not found in project: ${filePath} for key ${keyString}`,
           );
           return null;
         }
-      } catch (error) {
-        console.log(
-          `CodeYam Error loading analysis ${filePath}:${entityName}:`,
-          error,
-        );
-        return null;
-      }
-    });
 
-    const results = await Promise.all(loadPromises);
+        try {
+          const analysis = await loadAnalysis({
+            projectId: project.id,
+            fileId: file.id,
+            entityName,
+            includeScenarios: isFirstBatch, // Only include scenarios for the root analyses
+          });
+
+          if (analysis) {
+            console.log(`CodeYam: Loaded analysis ${filePath}:${entityName}`);
+            return { key: keyString, analysis };
+          } else {
+            console.log(
+              `CodeYam Warning: Analysis not found: ${filePath}:${entityName}`,
+            );
+            return null;
+          }
+        } catch (error) {
+          console.log(
+            `CodeYam Error loading analysis ${filePath}:${entityName}:`,
+            error,
+          );
+          return null;
+        }
+      },
+      DB_CONCURRENCY,
+    );
 
     // Process loaded analyses and find new dependencies
     for (const result of results) {

package/analyzer-template/project/mocks/analyzeFileMock.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/require-await */
 import {
   Analysis,
   AnalysisMap,
@@ -47,7 +48,7 @@ const standaloneComponentAnalysis = {
         'The counter is initialized at 0, with the ability to increment and decrement the count.',
       metadata: {
         dataMapping: {},
-        keyAttributeInstructions: {},
+        coveredFlows: [],
         data: {
           argumentsData: [],
           mockData: {},
@@ -221,7 +222,7 @@ async function analyzeReturnsSimplePropsFile(): Promise<{
                 'A user who is under 18 years old and is currently active.',
               metadata: {
                 dataMapping: {},
-                keyAttributeInstructions: {},
+                coveredFlows: [],
                 data: {
                   argumentsData: [
                     {
@@ -242,7 +243,7 @@ async function analyzeReturnsSimplePropsFile(): Promise<{
                 'A user who is between 18 and 39 years old and is currently active.',
               metadata: {
                 dataMapping: {},
-                keyAttributeInstructions: {},
+                coveredFlows: [],
                 data: {
                   argumentsData: [
                     {
@@ -263,7 +264,7 @@ async function analyzeReturnsSimplePropsFile(): Promise<{
                 'A user who is 40 years or older and is currently active.',
               metadata: {
                 dataMapping: {},
-                keyAttributeInstructions: {},
+                coveredFlows: [],
                 data: {
                   argumentsData: [
                     {
@@ -284,7 +285,7 @@ async function analyzeReturnsSimplePropsFile(): Promise<{
                 'A user who is under 18 years old and is currently inactive.',
               metadata: {
                 dataMapping: {},
-                keyAttributeInstructions: {},
+                coveredFlows: [],
                 data: {
                   argumentsData: [
                     {
@@ -305,7 +306,7 @@ async function analyzeReturnsSimplePropsFile(): Promise<{
                 'A user who is between 18 and 39 years old and is currently inactive.',
               metadata: {
                 dataMapping: {},
-                keyAttributeInstructions: {},
+                coveredFlows: [],
                 data: {
                   argumentsData: [
                     {
@@ -378,7 +379,7 @@ async function analyzeReturnsImportedComponentsFile(): Promise<{
               description: 'Default scenario description',
               metadata: {
                 dataMapping: {},
-                keyAttributeInstructions: {},
+                coveredFlows: [],
                 data: {
                   argumentsData: [],
                   mockData: {},

package/analyzer-template/project/orchestrateCapture/AwsCaptureTaskRunner.ts

@@ -35,7 +35,10 @@ export default class AwsCaptureTaskRunner implements CaptureTaskRunner {
   private sqs: SQSClient;
   private queueInfo: QueueInfo;
   private taskArns: string[];
-  private batchCompletedCallback?: (analysisIds: string[]) => void;
+  private batchCompletedCallback?: (
+    analysisIds: string[],
+    success: boolean,
+  ) => void;
   private controlPollingInterval?: NodeJS.Timeout;
   private lastTaskHealthCheck = Date.now();
   private isCleanedUp = false;
@@ -213,7 +216,9 @@ export default class AwsCaptureTaskRunner implements CaptureTaskRunner {
     }
   }
 
-  onBatchCompleted(callback: (analysisIds: string[]) => void): void {
+  onBatchCompleted(
+    callback: (analysisIds: string[], success: boolean) => void,
+  ): void {
     this.batchCompletedCallback = callback;
   }
 
@@ -255,9 +260,12 @@ export default class AwsCaptureTaskRunner implements CaptureTaskRunner {
               body.analysisIds &&
               Array.isArray(body.analysisIds)
             ) {
-              // Notify callback
+              // Notify callback with success status (default false for backwards compatibility)
               if (this.batchCompletedCallback) {
-                this.batchCompletedCallback(body.analysisIds);
+                this.batchCompletedCallback(
+                  body.analysisIds,
+                  body.success ?? false,
+                );
               }
             }
 

package/analyzer-template/project/orchestrateCapture/KyselyAnalysisLoader.ts

@@ -46,13 +46,10 @@ export default class KyselyAnalysisLoader implements AnalysisLoader {
             'status',
           ])
           // Base condition: readyToBeCaptured = true
-          // Use json_extract for SQLite (returns 1 for boolean true)
+          // Use -> operator which works in both PostgreSQL and SQLite
+          // Both return a value that compares equal to string 'true'
           .where((eb) =>
-            eb(
-              sql`json_extract(${sql.ref('status')}, '$.readyToBeCaptured')`,
-              '=',
-              sql`1`,
-            ),
+            eb(sql`${sql.ref('status')} -> 'readyToBeCaptured'`, '=', 'true'),
           )
           // Project filter (always required)
           .where('project_id', '=', this.config.project.id);