@codeyam/codeyam-cli 0.1.0-staging.e38f7bd → 0.1.0-staging.f777668

package/analyzer-template/packages/ai/src/lib/worker/SerializableDataStructure.ts

@@ -10,6 +10,11 @@ import {
   fuzzyMatchFunctionName,
   findFuzzyMatchingKey,
 } from './fuzzyMatchFunctionName';
+import type {
+  ConditionalEffect,
+  CompoundConditional,
+  JsxRenderingUsage,
+} from '../astScopes/types';
 
 export interface SerializableScopeVariable {
   scopeNodeName: string;
@@ -28,6 +33,11 @@ export interface SerializableFunctionCallInfo {
   receivingVariableNames?: string[];
   /** Maps each call signature to the variable that receives its return value */
   callSignatureToVariable?: Record<string, string>;
+  /**
+   * Stores individual return value schemas per receiving variable, BEFORE merging.
+   * Key is the receiving variable name (e.g., "userFetcher", "reportFetcher").
+   */
+  perVariableSchemas?: Record<string, Record<string, string>>;
 }
 
 export interface SerializableFunctionResult {
@@ -53,13 +63,50 @@ export interface EnrichedConditionalUsage {
   /** For comparison conditions, the literal values being compared against */
   comparedValues?: string[];
   /** Where this conditional usage occurs */
-  location: 'if' | 'ternary' | 'logical-and' | 'switch';
+  location: 'if' | 'ternary' | 'logical-and' | 'switch' | 'unconditional';
   /**
    * The traced source data path in the format "scopeName.path"
    * e.g., "useParams().functionCallReturnValue['*']"
    * This connects the local variable to the original data attribute.
    */
   sourceDataPath?: string;
+  /** Whether this condition is negated (e.g., !foo) */
+  isNegated?: boolean;
+  /**
+   * Whether this conditional controls JSX rendering.
+   * True when the conditional appears in a JSX expression like {cond && <Component />}
+   */
+  controlsJsxRendering?: boolean;
+  /** Source location information */
+  sourceLocation?: {
+    lineNumber: number;
+    column: number;
+    codeSnippet: string;
+  };
+  /**
+   * Information about how this variable was derived from other variables.
+   * Used to trace derived boolean variables back to their data sources.
+   */
+  derivedFrom?: {
+    /** For single-source derivations (notNull, equals, etc.) */
+    sourcePath?: string;
+    /** For multi-source derivations (or, and) */
+    sourcePaths?: string[];
+    /** The operation that derived this variable */
+    operation:
+      | 'notNull'
+      | 'isNull'
+      | 'equals'
+      | 'notEquals'
+      | 'or'
+      | 'and'
+      | 'arrayIncludes'
+      | 'arraySome'
+      | 'arrayEvery'
+      | 'arrayLength';
+    /** For comparison operations, the value being compared to */
+    comparedValue?: string;
+  };
 }
 
 export interface SerializableDataStructure {
@@ -73,7 +120,8 @@ export interface SerializableDataStructure {
   functionResults: Record<string, SerializableFunctionResult>;
 
   // Equivalent signature variables for root scope
-  equivalentSignatureVariables: Record<string, string>;
+  // Values can be arrays for OR expressions where a variable maps to multiple sources
+  equivalentSignatureVariables: Record<string, string | string[]>;
 
   environmentVariables: string[];
 
@@ -83,6 +131,41 @@ export interface SerializableDataStructure {
    * the traced source data path.
    */
   conditionalUsages?: Record<string, EnrichedConditionalUsage[]>;
+
+  /**
+   * Conditional effects tracking.
+   * Tracks what setter calls happen inside conditionals (if, switch, ternary).
+   * Used to auto-generate execution flows from static analysis.
+   */
+  conditionalEffects?: ConditionalEffect[];
+
+  /**
+   * Compound conditionals grouped by chain (all conditions must be true together).
+   * Used to generate execution flows that satisfy ALL conditions in compound expressions like:
+   *   (hasNewerVersion || isFromDifferentVersion) && !isAnalyzing && !isQueued
+   */
+  compoundConditionals?: CompoundConditional[];
+
+  /**
+   * Gating conditions for child component boundaries.
+   * Maps child component name to the conditions that must be true for that child to render.
+   *
+   * Example:
+   * {hasAnalysis && <ScenarioViewer />} would produce:
+   * { ScenarioViewer: [{ path: 'hasAnalysis', conditionType: 'truthiness', ... }] }
+   *
+   * This allows us to merge child component execution flows with parent gating conditions.
+   */
+  childBoundaryGatingConditions?: Record<string, EnrichedConditionalUsage[]>;
+
+  /**
+   * JSX rendering usages - tracks arrays rendered via .map() and strings interpolated in JSX.
+   * Used to generate execution flows for array sizes and text lengths without explicit conditionals.
+   *
+   * Example:
+   * {items.map(i => <Item {...i} />)} produces an array-map usage for 'items'
+   */
+  jsxRenderingUsages?: JsxRenderingUsage[];
 }
 
 /**
@@ -214,7 +297,7 @@ export function getSourceEquivalencies(
 
 export function getEquivalentSignatureVariables(
   dataStructure: SerializableDataStructure,
-): Record<string, string> {
+): Record<string, string | string[]> {
   return dataStructure.equivalentSignatureVariables;
 }
 
@@ -227,3 +310,44 @@ export function getConditionalUsages(
 ): Record<string, EnrichedConditionalUsage[]> {
   return dataStructure.conditionalUsages ?? {};
 }
+
+/**
+ * Get conditional effects (setter calls inside conditionals).
+ * Returns the array of conditional effects, or empty array if not available.
+ */
+export function getConditionalEffects(
+  dataStructure: SerializableDataStructure,
+): ConditionalEffect[] {
+  return dataStructure.conditionalEffects ?? [];
+}
+
+/**
+ * Get compound conditionals (grouped conditions that must all be true).
+ * Returns the array of compound conditionals, or empty array if not available.
+ */
+export function getCompoundConditionals(
+  dataStructure: SerializableDataStructure,
+): CompoundConditional[] {
+  return dataStructure.compoundConditionals ?? [];
+}
+
+/**
+ * Get child boundary gating conditions.
+ * Returns the mapping of child component names to their gating conditions,
+ * or empty object if not available.
+ */
+export function getChildBoundaryGatingConditions(
+  dataStructure: SerializableDataStructure,
+): Record<string, EnrichedConditionalUsage[]> {
+  return dataStructure.childBoundaryGatingConditions ?? {};
+}
+
+/**
+ * Get JSX rendering usages (arrays rendered via .map() and strings interpolated in JSX).
+ * Returns the array of JSX rendering usages, or empty array if not available.
+ */
+export function getJsxRenderingUsages(
+  dataStructure: SerializableDataStructure,
+): JsxRenderingUsage[] {
+  return dataStructure.jsxRenderingUsages ?? [];
+}

package/analyzer-template/packages/ai/src/lib/worker/analyzeScopeWorker.ts

@@ -8,11 +8,15 @@
 import { Entity } from '~codeyam/types';
 import { FileAnalyzer, ProjectAnalyzer } from '~codeyam/analyze';
 import { analyzeScopeLocal } from '../analyzeScope';
-import { ScopeInfo } from '../dataStructure/ScopeDataStructure';
+import {
+  resetScopeDataStructureMetrics,
+  ScopeInfo,
+} from '../dataStructure/ScopeDataStructure';
 import { SerializableDataStructure } from './SerializableDataStructure';
 import { AI } from '~codeyam/ai';
 import { setThreadContext } from '~codeyam/utils';
 import { threadId } from 'worker_threads';
+import v8 from 'v8';
 
 // Set thread context for logging
 setThreadContext(`<worker-${threadId}>`);
@@ -42,20 +46,115 @@ let projectAnalyzerKey: string | null = null;
 let fileAnalyzer: FileAnalyzer | null = null;
 let fileAnalyzerPath: string | null = null;
 
+// Memory tracking
+let entitiesProcessed = 0;
+let lastMemoryLogAt = 0;
+const MEMORY_LOG_INTERVAL = 100; // Log every N entities
+const MEMORY_LOG_TIME_INTERVAL = 60_000; // Or every 60 seconds
+
+/**
+ * Get memory stats for logging
+ */
+function getWorkerMemoryStats() {
+  const mem = process.memoryUsage();
+  const heapStats = v8.getHeapStatistics();
+  return {
+    rss: `${Math.round(mem.rss / 1024 / 1024)}MB`,
+    heapUsed: `${Math.round(mem.heapUsed / 1024 / 1024)}MB`,
+    heapTotal: `${Math.round(mem.heapTotal / 1024 / 1024)}MB`,
+    external: `${Math.round(mem.external / 1024 / 1024)}MB`,
+    // V8 heap stats give more detail
+    v8TotalHeapSize: `${Math.round(heapStats.total_heap_size / 1024 / 1024)}MB`,
+    v8UsedHeapSize: `${Math.round(heapStats.used_heap_size / 1024 / 1024)}MB`,
+    v8HeapSizeLimit: `${Math.round(heapStats.heap_size_limit / 1024 / 1024)}MB`,
+    v8MallocedMemory: `${Math.round(heapStats.malloced_memory / 1024 / 1024)}MB`,
+  };
+}
+
+/**
+ * Get ts.Program stats for understanding TypeScript memory usage
+ */
+function getTsProgramStats(pa: ProjectAnalyzer) {
+  const sourceFiles = pa.program.getSourceFiles();
+  const projectSourceFiles = sourceFiles.filter(
+    (sf) => !sf.fileName.includes('node_modules'),
+  );
+  const nodeModulesFiles = sourceFiles.filter((sf) =>
+    sf.fileName.includes('node_modules'),
+  );
+
+  // Estimate AST size by sampling text length (rough proxy)
+  let totalProjectTextLength = 0;
+  for (const sf of projectSourceFiles) {
+    totalProjectTextLength += sf.getFullText().length;
+  }
+
+  return {
+    totalSourceFiles: sourceFiles.length,
+    projectSourceFiles: projectSourceFiles.length,
+    nodeModulesFiles: nodeModulesFiles.length,
+    projectTextSizeMB: `${(totalProjectTextLength / 1024 / 1024).toFixed(1)}MB`,
+    // Note: Actual AST memory is typically 10-20x the source text size
+    estimatedAstSizeMB: `${((totalProjectTextLength * 15) / 1024 / 1024).toFixed(0)}MB`,
+  };
+}
+
+/**
+ * Write a heap snapshot for detailed profiling.
+ * The snapshot can be loaded in Chrome DevTools for analysis.
+ *
+ * TODO: Once we understand memory usage, change this back to env-var controlled
+ */
+const HEAP_SNAPSHOT_MODE: 'off' | 'once' | 'periodic' = 'off';
+
+function maybeWriteHeapSnapshot(label: string) {
+  if (HEAP_SNAPSHOT_MODE === 'off') return;
+
+  try {
+    const filename = v8.writeHeapSnapshot();
+    console.log(
+      `CodeYam Worker: Heap snapshot written (${label}): ${filename}`,
+    );
+  } catch (error) {
+    console.error('CodeYam Worker: Failed to write heap snapshot:', error);
+  }
+}
+
 /**
  * Main worker function called by Piscina
  */
 export default async function runAnalyzeScope(
   input: AnalyzeScopeWorkerInput,
 ): Promise<AnalyzeScopeWorkerOutput> {
+  // Reset metrics counters at the start of each entity analysis to prevent
+  // false "infinite loop" detection when processing multiple entities
+  resetScopeDataStructureMetrics();
+
   try {
     const { entity, project, dirPath, filePath, file, scope, model } = input;
 
     // Create or reuse ProjectAnalyzer
     const paKey = `${dirPath}`;
     if (!projectAnalyzer || projectAnalyzerKey !== paKey) {
-      projectAnalyzer = await ProjectAnalyzer.from({ project, dirPath });
+      const memBefore = process.memoryUsage();
+      console.log('CodeYam Worker: Creating ProjectAnalyzer (ts.Program)...', {
+        memBefore: getWorkerMemoryStats(),
+      });
+
+      projectAnalyzer = ProjectAnalyzer.from({ project, dirPath });
       projectAnalyzerKey = paKey;
+
+      const memAfter = process.memoryUsage();
+      const tsProgramStats = getTsProgramStats(projectAnalyzer);
+      console.log('CodeYam Worker: ProjectAnalyzer created', {
+        memAfter: getWorkerMemoryStats(),
+        rssDelta: `+${Math.round((memAfter.rss - memBefore.rss) / 1024 / 1024)}MB`,
+        heapDelta: `+${Math.round((memAfter.heapUsed - memBefore.heapUsed) / 1024 / 1024)}MB`,
+        tsProgramStats,
+      });
+
+      // Optionally write heap snapshot after ts.Program creation
+      maybeWriteHeapSnapshot('after-ts-program');
     }
 
     // Create or reuse FileAnalyzer
@@ -88,6 +187,26 @@ export default async function runAnalyzeScope(
       );
     }
 
+    // Periodic memory logging
+    entitiesProcessed++;
+    const now = Date.now();
+    const shouldLogMemory =
+      entitiesProcessed % MEMORY_LOG_INTERVAL === 0 ||
+      now - lastMemoryLogAt > MEMORY_LOG_TIME_INTERVAL;
+
+    if (shouldLogMemory) {
+      lastMemoryLogAt = now;
+      console.log('CodeYam Worker: Memory stats', {
+        entitiesProcessed,
+        ...getWorkerMemoryStats(),
+      });
+
+      // Optionally write periodic heap snapshots
+      if (HEAP_SNAPSHOT_MODE === 'periodic' && entitiesProcessed % 500 === 0) {
+        maybeWriteHeapSnapshot(`after-${entitiesProcessed}-entities`);
+      }
+    }
+
     return { dataStructure: dataStructure.toSerializable() };
   } catch (error) {
     console.error(

package/analyzer-template/packages/analyze/index.ts

@@ -41,6 +41,8 @@ export { default as mergeValidatedDataStructures } from './src/lib/files/scenari
 
 export { discoverDirectDependencies } from './src/lib/files/analyze/dependencyResolver';
 
+export { transformationTracer } from './src/lib/files/scenarios/TransformationTracer';
+
 export { default as getAnalysisError } from './src/lib/utils/getAnalysisError';
 export { default as measureAndReportExecutionTime } from './src/lib/utils/measureAndReportExecutionTime';
 

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

@@ -9,6 +9,7 @@ import {
 import { FunctionNode } from './types';
 import getEntityType from './files/getEntityType';
 import getEntityCode from './files/getEntityCode';
+import { getFileByPathSafe } from './utils/getFileByPath';
 
 export class FileAnalyzer {
   public projectAnalyzer: lib.ProjectAnalyzer;
@@ -19,6 +20,7 @@ export class FileAnalyzer {
   // Current per-file caching helps when multiple entities in the same file call getResolvedImportsRelevantToFunctionName,
   // but a project-level cache would also benefit the recursive import chain traversals that cross file boundaries.
   private resolvedImportsCache: Map<string, FunctionDependenciesMap>;
+  private allEntityNodesOnlyAliasesCache?: Record<string, ts.Node>;
 
   constructor({
     projectAnalyzer,
@@ -62,18 +64,23 @@ export class FileAnalyzer {
 
   getAllEntityNodesOnlyAliases() {
     if (!this.sourceFile) return {};
+    if (this.allEntityNodesOnlyAliasesCache) {
+      return this.allEntityNodesOnlyAliasesCache;
+    }
     try {
       const allEntityNodes = lib.asts.sourceFiles.getAllEntityNodes({
         sourceFile: this.sourceFile,
       });
-      if (allEntityNodes.default) {
-        const namedDefault = Object.entries(allEntityNodes).find(
+      const aliasesOnly = { ...allEntityNodes };
+      if (aliasesOnly.default) {
+        const namedDefault = Object.entries(aliasesOnly).find(
           ([otherEntityName, node]) =>
-            otherEntityName !== 'default' && node === allEntityNodes.default,
+            otherEntityName !== 'default' && node === aliasesOnly.default,
         );
-        if (namedDefault) delete allEntityNodes.default;
+        if (namedDefault) delete aliasesOnly.default;
       }
-      return allEntityNodes;
+      this.allEntityNodesOnlyAliasesCache = aliasesOnly;
+      return aliasesOnly;
     } catch (error) {
       console.log('CodeYam ERROR: getAllEntityNodesOnlyAliases failed:', {
         filePath: this.file?.path,
@@ -223,15 +230,11 @@ export class FileAnalyzer {
 
       // Handle dist -> src mapping for workspace packages
       let targetPath = resolvedPath;
-      let targetFile = this.projectAnalyzer.project.files.find(
-        (f) => f.path === targetPath,
-      );
+      let targetFile = getFileByPathSafe(this.projectAnalyzer, targetPath);
 
       if (!targetFile && targetPath.includes('/dist/')) {
         const srcPath = targetPath.replace('/dist/', '/src/');
-        targetFile = this.projectAnalyzer.project.files.find(
-          (f) => f.path === srcPath,
-        );
+        targetFile = getFileByPathSafe(this.projectAnalyzer, srcPath);
         if (targetFile) {
           targetPath = srcPath;
         }
@@ -239,9 +242,9 @@ export class FileAnalyzer {
         // Try with different extensions if still not found
         if (!targetFile) {
           const basePath = srcPath.replace(/\.d\.ts$/, '').replace(/\.js$/, '');
-          targetFile = this.projectAnalyzer.project.files.find(
-            (f) => f.path === basePath + '.ts' || f.path === basePath + '.tsx',
-          );
+          targetFile =
+            getFileByPathSafe(this.projectAnalyzer, basePath + '.ts') ??
+            getFileByPathSafe(this.projectAnalyzer, basePath + '.tsx');
           if (targetFile) {
             targetPath = targetFile.path;
           }
@@ -301,24 +304,25 @@ export class FileAnalyzer {
 
   getLocalEntitiesUsedInFunction(functionName: string) {
     if (!this.sourceFile) return [];
-    const entityNodes = lib.asts.sourceFiles.getAllEntityNodes({
-      sourceFile: this.sourceFile,
-    });
+    const entityNodes = this.getAllEntityNodes();
 
     // Defensive check: ensure the function exists in entityNodes
-    if (!entityNodes[functionName]) {
+    const functionNode = entityNodes[functionName];
+    if (!functionNode) {
       return [];
     }
 
     try {
-      const identifiers = this.getIdentifiersInNode(entityNodes[functionName]);
+      const identifiers = this.getIdentifiersInNode(functionNode);
       return identifiers
-        .filter(
-          (identifier, index, self) =>
-            entityNodes[identifier] !== entityNodes[functionName] &&
-            Object.keys(entityNodes).includes(identifier) &&
-            self.indexOf(identifier) === index,
-        )
+        .filter((identifier) => {
+          const node = entityNodes[identifier];
+          return (
+            !!node &&
+            node !== functionNode &&
+            typeof (node as ts.Node).kind === 'number'
+          );
+        })
         .map((identifier) => ({
           name: identifier,
           node: entityNodes[identifier],
@@ -348,14 +352,13 @@ export class FileAnalyzer {
       sourceFile: this.sourceFile,
     });
     const identifiersInRelevantNode = this.getIdentifiersInNode(relevantNode);
+    const identifiersSet = new Set(identifiersInRelevantNode);
 
     const entries = Object.entries(importsAnalysis)
       .map(([importedFilePath, importedExpressions]) => {
         const relevantExpressions = importedExpressions.filter(
           (importedExpression) => {
-            return identifiersInRelevantNode.includes(
-              importedExpression.importAlias,
-            );
+            return identifiersSet.has(importedExpression.importAlias);
           },
         );
 
@@ -439,8 +442,9 @@ export class FileAnalyzer {
             resolvedImport.resolvedFileName,
           );
 
-          let importedFile = this.projectAnalyzer.project.files.find(
-            (f) => f.path === projectPath,
+          let importedFile = getFileByPathSafe(
+            this.projectAnalyzer,
+            projectPath,
           );
 
           // Workspace packages often resolve to dist/ paths (from package.json "types" or "main"),
@@ -448,9 +452,7 @@ export class FileAnalyzer {
           if (!importedFile && projectPath.includes('/dist/')) {
             const srcPath = projectPath.replace('/dist/', '/src/');
             // Try exact match first (e.g., dist/index.d.ts -> src/index.ts)
-            importedFile = this.projectAnalyzer.project.files.find(
-              (f) => f.path === srcPath,
-            );
+            importedFile = getFileByPathSafe(this.projectAnalyzer, srcPath);
             if (importedFile) {
               projectPath = srcPath;
             }
@@ -460,10 +462,9 @@ export class FileAnalyzer {
               const basePath = srcPath
                 .replace(/\.d\.ts$/, '')
                 .replace(/\.js$/, '');
-              importedFile = this.projectAnalyzer.project.files.find(
-                (f) =>
-                  f.path === basePath + '.ts' || f.path === basePath + '.tsx',
-              );
+              importedFile =
+                getFileByPathSafe(this.projectAnalyzer, basePath + '.ts') ??
+                getFileByPathSafe(this.projectAnalyzer, basePath + '.tsx');
               if (importedFile) {
                 projectPath = importedFile.path;
               }
@@ -591,24 +592,35 @@ export class FileAnalyzer {
 
   getNamespaceIdentifiersInNode(node: ts.Node, namespaceIdentifier: string) {
     const identifiers: string[] = [];
+    const seen = new Set<string>();
 
     const identifierVisitor = (child: ts.Node) => {
       if (ts.isPropertyAccessExpression(child)) {
         if (child.expression.getText() === namespaceIdentifier) {
-          identifiers.push(child.name.getText());
+          const name = child.name.getText();
+          if (!seen.has(name)) {
+            seen.add(name);
+            identifiers.push(name);
+          }
         }
       }
       ts.forEachChild(child, identifierVisitor);
     };
 
     ts.forEachChild(node, identifierVisitor);
-    return identifiers.filter(
-      (identifier, index, self) => self.indexOf(identifier) === index,
-    );
+    return identifiers;
   }
 
   getIdentifiersInNode(node: ts.Node): string[] {
     const identifiers: string[] = [];
+    const seen = new Set<string>();
+
+    const addIdentifier = (text: string, allowDefault = false) => {
+      if (!allowDefault && text === 'default') return;
+      if (seen.has(text)) return;
+      seen.add(text);
+      identifiers.push(text);
+    };
 
     // Helper to safely get text from an identifier or string literal
     const getNodeText = (node: ts.Identifier | ts.StringLiteral): string => {
@@ -637,63 +649,57 @@ export class FileAnalyzer {
     };
 
     if (ts.isIdentifier(node)) {
-      identifiers.push(getNodeText(node));
+      addIdentifier(getNodeText(node));
     }
 
     const identifierVisitor = (child: ts.Node) => {
       if (ts.isIdentifier(child)) {
-        const text = getNodeText(child);
-        if (text === 'default') return;
-        identifiers.push(text);
+        addIdentifier(getNodeText(child));
       } else if (ts.isExportDeclaration(child)) {
         if (child.exportClause && ts.isNamedExports(child.exportClause)) {
           child.exportClause.elements.forEach((element) => {
-            identifiers.push(getNodeText(element.name));
+            addIdentifier(getNodeText(element.name), true);
           });
         } else if (
           child.exportClause &&
           ts.isNamespaceExport(child.exportClause)
         ) {
-          identifiers.push(getNodeText(child.exportClause.name));
+          addIdentifier(getNodeText(child.exportClause.name));
         }
       } else if (ts.isExportAssignment(child)) {
         if (ts.isIdentifier(child.expression)) {
-          identifiers.push(getNodeText(child.expression));
+          addIdentifier(getNodeText(child.expression));
         }
       } else if (ts.isExportSpecifier(child)) {
-        identifiers.push(getNodeText(child.name));
+        addIdentifier(getNodeText(child.name), true);
         return;
       } else if (ts.isFunctionDeclaration(child) && child.name) {
-        identifiers.push(getNodeText(child.name));
+        addIdentifier(getNodeText(child.name));
       } else if (ts.isVariableStatement(child)) {
         child.declarationList.declarations.forEach((declaration) => {
           if (ts.isIdentifier(declaration.name)) {
-            identifiers.push(getNodeText(declaration.name));
+            addIdentifier(getNodeText(declaration.name));
           }
         });
       } else if (ts.isImportDeclaration(child)) {
         if (child.importClause && child.importClause.namedBindings) {
           if (ts.isNamespaceImport(child.importClause.namedBindings)) {
-            identifiers.push(
-              getNodeText(child.importClause.namedBindings.name),
-            );
+            addIdentifier(getNodeText(child.importClause.namedBindings.name));
           } else if (ts.isNamedImports(child.importClause.namedBindings)) {
             child.importClause.namedBindings.elements.forEach((element) => {
-              identifiers.push(getNodeText(element.name));
+              addIdentifier(getNodeText(element.name));
             });
           }
         }
       } else if (ts.isImportSpecifier(child)) {
-        identifiers.push(getNodeText(child.name));
+        addIdentifier(getNodeText(child.name), true);
         return;
       }
       ts.forEachChild(child, identifierVisitor);
     };
 
     ts.forEachChild(node, identifierVisitor);
-    return identifiers.filter(
-      (identifier, index, self) => self.indexOf(identifier) === index,
-    );
+    return identifiers;
   }
 
   resolveNamespaceImport(
@@ -846,6 +852,20 @@ export class FileAnalyzer {
     return getEntityType({ entityName, sourceFile: this.sourceFile });
   }
 
+  /**
+   * Checks if the entity (function/component) is async.
+   * Async functions in Next.js are Server Components that need special handling.
+   */
+  isEntityAsync(entityName: string): boolean {
+    if (!this.sourceFile) return false;
+    const entityNode = lib.asts.sourceFiles.getEntityNode({
+      entityName,
+      sourceFile: this.sourceFile,
+    });
+    if (!entityNode) return false;
+    return lib.asts.nodes.isAsyncFunction(entityNode);
+  }
+
   getEntityStartAndEnd(entityName: string): { start: number; end: number } {
     if (!this.sourceFile) return { start: 0, end: 0 };
     const node = this.getAllEntityNodes()[entityName];