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

package/analyzer-template/packages/analyze/src/lib/analysisContext.ts

@@ -48,6 +48,12 @@ export class AnalysisContext implements ImmutableAnalysisContext {
   public analysesAdded: Analysis[]; // TODO: Remove this when we switch to immutable maps
   private projectNodeModuleMocks: Mock[];
   private baselineMode: boolean = false;
+  /**
+   * Parent context for delegating lookups when not found locally.
+   * Used by private contexts created via forEntityAnalysis() to see analyses
+   * added to the main context after the fork.
+   */
+  private parentContext?: AnalysisContext;
 
   /**
    * Create a new AnalysisContext with optional initial maps and mocks
@@ -56,16 +62,19 @@ export class AnalysisContext implements ImmutableAnalysisContext {
     primaryEntity,
     initialEntityMap,
     initialAnalysisMap,
+    parentContext,
   }: {
     primaryEntity?: Entity;
     initialEntityMap?: EntityMap;
     initialAnalysisMap?: AnalysisMap;
+    parentContext?: AnalysisContext;
   } = {}) {
     this.primaryEntity = primaryEntity;
     this.entityMap = initialEntityMap || {};
     this.entitiesAdded = []; // TODO: Remove this when we switch to immutable maps
     this.analysisMap = initialAnalysisMap || {};
     this.analysesAdded = []; // TODO: Remove this when we switch to immutable maps
+    this.parentContext = parentContext;
   }
   setPrimaryAnalysis(analysis: Analysis): void {
     if (!this.primaryEntity) {
@@ -102,15 +111,22 @@ export class AnalysisContext implements ImmutableAnalysisContext {
       primaryEntity: entity,
       initialEntityMap: { ...this.entityMap },
       initialAnalysisMap: { ...this.analysisMap },
+      parentContext: this,
     });
   }
 
   /**
-   * Get a read-only view of an entity by file path and entity name
+   * Get a read-only view of an entity by file path and entity name.
+   * Falls back to parent context if not found locally (for private contexts).
    * @returns The entity or undefined if not found
    */
   getEntity(filePath: string, entityName: string): ReadonlyEntity | undefined {
-    return this.entityMap[filePath]?.[entityName];
+    const entity = this.entityMap[filePath]?.[entityName];
+    // Fall back to parent context if not found locally
+    if (!entity && this.parentContext) {
+      return this.parentContext.getEntity(filePath, entityName);
+    }
+    return entity;
   }
 
   /**
@@ -126,7 +142,8 @@ export class AnalysisContext implements ImmutableAnalysisContext {
   }
 
   /**
-   * Get a read-only view of an analysis by file path and entity name
+   * Get a read-only view of an analysis by file path and entity name.
+   * Falls back to parent context if not found locally (for private contexts).
    * @returns The analysis or undefined if not found
    */
   getAnalysis(
@@ -134,7 +151,23 @@ export class AnalysisContext implements ImmutableAnalysisContext {
     entityName: string,
     withEntity = false,
   ): ReadonlyAnalysis | undefined {
-    const analysis = this.analysisMap[filePath]?.[entityName];
+    let analysis = this.analysisMap[filePath]?.[entityName];
+
+    // Fall back to parent context if not found locally
+    // This allows private contexts (created via forEntityAnalysis) to see
+    // analyses added to the main context after the fork
+    if (!analysis && this.parentContext) {
+      analysis = this.parentContext.getAnalysis(
+        filePath,
+        entityName,
+        withEntity,
+      ) as Analysis | undefined;
+      // If found in parent and withEntity was already handled by parent, return directly
+      if (analysis) {
+        return analysis;
+      }
+    }
+
     if (withEntity && analysis) {
       analysis.entity ||= this.getMutableEntity(filePath, entityName);
     }
@@ -183,6 +216,13 @@ export class AnalysisContext implements ImmutableAnalysisContext {
       this.analysisMap[filePath] = {};
     }
     this.analysisMap[filePath][entityName] = analysis;
+
+    // Also add the entity if it's attached to the analysis.
+    // This ensures that when getAnalysis is called with withEntity=true,
+    // the entity will be available in the entity map.
+    if (analysis.entity) {
+      this.addEntity(analysis.entity);
+    }
   }
 
   /**

package/analyzer-template/packages/analyze/src/lib/asts/nodes/index.ts

@@ -7,6 +7,7 @@ export { getCallExpressionNames } from './getCallExpressionNames';
 export { getNodeType } from './getNodeType';
 export { getFunctionNodeType } from './getFunctionNodeType';
 export { isDefaultExport } from './isDefaultExport';
+export { isAsyncFunction } from './isAsyncFunction';
 
 interface ImportInfo {
   packageName: string;

package/analyzer-template/packages/analyze/src/lib/asts/nodes/isAsyncFunction.ts

@@ -0,0 +1,67 @@
+import ts from 'typescript';
+
+/**
+ * Checks if a node represents an async function or component.
+ * This includes:
+ * - Function declarations with async modifier
+ * - Arrow functions with async modifier
+ * - Variable declarations initialized with async functions
+ * - Method declarations with async modifier
+ */
+export function isAsyncFunction(node: ts.Node): boolean {
+  if (!node) return false;
+
+  // Direct function declaration: async function foo() {}
+  if (ts.isFunctionDeclaration(node)) {
+    return hasAsyncModifier(node);
+  }
+
+  // Arrow function: const foo = async () => {}
+  if (ts.isArrowFunction(node)) {
+    return hasAsyncModifier(node);
+  }
+
+  // Function expression: const foo = async function() {}
+  if (ts.isFunctionExpression(node)) {
+    return hasAsyncModifier(node);
+  }
+
+  // Method declaration: async method() {}
+  if (ts.isMethodDeclaration(node)) {
+    return hasAsyncModifier(node);
+  }
+
+  // Variable declaration: const foo = async () => {} or const foo = async function() {}
+  if (ts.isVariableDeclaration(node) && node.initializer) {
+    return isAsyncFunction(node.initializer);
+  }
+
+  // Variable statement: export const foo = async () => {}
+  if (ts.isVariableStatement(node)) {
+    for (const decl of node.declarationList.declarations) {
+      if (decl.initializer && isAsyncFunction(decl.initializer)) {
+        return true;
+      }
+    }
+  }
+
+  // Export assignment: export default async function() {}
+  if (ts.isExportAssignment(node) && node.expression) {
+    return isAsyncFunction(node.expression);
+  }
+
+  return false;
+}
+
+function hasAsyncModifier(
+  node:
+    | ts.FunctionDeclaration
+    | ts.ArrowFunction
+    | ts.FunctionExpression
+    | ts.MethodDeclaration,
+): boolean {
+  if (!node.modifiers) return false;
+  return node.modifiers.some(
+    (modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword,
+  );
+}