@codeyam/codeyam-cli 0.1.0-staging.1 → 0.1.0-staging.1669d45

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

@@ -10,6 +10,10 @@ import {
   fuzzyMatchFunctionName,
   findFuzzyMatchingKey,
 } from './fuzzyMatchFunctionName';
+import type {
+  ConditionalEffect,
+  CompoundConditional,
+} from '../astScopes/types';
 
 export interface SerializableScopeVariable {
   scopeNodeName: string;
@@ -22,6 +26,17 @@ export interface SerializableFunctionCallInfo {
   callScope: string;
   schema?: Record<string, string>;
   equivalencies?: Record<string, SerializableScopeVariable[]>;
+  /** All call signatures merged into this entry (e.g., logger.info, logger.debug) */
+  allCallSignatures?: string[];
+  /** Variable names that receive the return value of each call */
+  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 {
@@ -34,6 +49,64 @@ export interface SerializableFunctionResult {
   environmentVariables: string[];
 }
 
+/**
+ * Enriched conditional usage that includes traced source data path.
+ * The sourceDataPath connects a local variable (used in conditionals) back to
+ * the original data attribute from the attributes map.
+ */
+export interface EnrichedConditionalUsage {
+  /** The local variable path (e.g., "activeTab") */
+  path: string;
+  /** The type of condition this attribute is used in */
+  conditionType: 'truthiness' | 'comparison' | 'switch';
+  /** For comparison conditions, the literal values being compared against */
+  comparedValues?: string[];
+  /** Where this conditional usage occurs */
+  location: 'if' | 'ternary' | 'logical-and' | 'switch';
+  /**
+   * 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';
+    /** For comparison operations, the value being compared to */
+    comparedValue?: string;
+  };
+}
+
 export interface SerializableDataStructure {
   // External function calls array
   externalFunctionCalls: SerializableFunctionCallInfo[];
@@ -48,6 +121,39 @@ export interface SerializableDataStructure {
   equivalentSignatureVariables: Record<string, string>;
 
   environmentVariables: string[];
+
+  /**
+   * Conditional usages with source tracing.
+   * Maps local variable path to array of enriched usages that include
+   * 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[]>;
 }
 
 /**
@@ -182,3 +288,44 @@ export function getEquivalentSignatureVariables(
 ): Record<string, string> {
   return dataStructure.equivalentSignatureVariables;
 }
+
+/**
+ * Get enriched conditional usages with source tracing.
+ * Returns the conditional usages map, or empty object if not available.
+ */
+export function getConditionalUsages(
+  dataStructure: SerializableDataStructure,
+): 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 ?? {};
+}

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

@@ -8,7 +8,10 @@
 import { Entity } from '~codeyam/types';
 import { FileAnalyzer, ProjectAnalyzer } from '~codeyam/analyze';
 import { analyzeScopeLocal } from '../analyzeScope';
-import { ScopeInfo } from '../dataStructure/ScopeDataStructure';
+import {
+  ScopeInfo,
+  resetScopeDataStructureMetrics,
+} from '../dataStructure/ScopeDataStructure';
 import { SerializableDataStructure } from './SerializableDataStructure';
 import { AI } from '~codeyam/ai';
 import { setThreadContext } from '~codeyam/utils';
@@ -48,6 +51,10 @@ let fileAnalyzerPath: string | null = null;
 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;
 

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

@@ -84,6 +84,17 @@ export class FileAnalyzer {
     }
   }
 
+  /**
+   * Returns only declared entity nodes (not identifier references).
+   * Use this when you need to find entities that can be replaced/mocked.
+   */
+  getAllDeclaredEntityNodes() {
+    if (!this.sourceFile) return {};
+    return lib.asts.sourceFiles.getAllDeclaredEntityNodes({
+      sourceFile: this.sourceFile,
+    });
+  }
+
   getNodeCode(node: ts.Node, removeComments = false) {
     if (!this.sourceFile) return '';
     if (removeComments) {
@@ -138,11 +149,121 @@ export class FileAnalyzer {
     });
   }
 
+  /**
+   * Get the code for a declared entity (not identifier references).
+   * Use this when you need to find code that can be replaced/mocked.
+   */
+  getDeclaredEntityCode(entityName: string, removeComments = false) {
+    if (!this.sourceFile) return '';
+    const entityNode = lib.asts.sourceFiles.getDeclaredEntityNode({
+      entityName,
+      sourceFile: this.sourceFile,
+    });
+
+    if (removeComments) {
+      const printer = ts.createPrinter({ removeComments: true });
+      return printer.printNode(
+        ts.EmitHint.Unspecified,
+        entityNode,
+        this.sourceFile,
+      );
+    }
+
+    return entityNode.getText(this.sourceFile);
+  }
+
   getAllExports(): Record<string, ExportedFunction> {
     if (!this.sourceFile) return {};
     return lib.asts.sourceFiles.getAllExports(this.sourceFile);
   }
 
+  /**
+   * Find an export by following star export chains.
+   * When a file has `export * from './path'`, this method will recursively
+   * resolve the path and search for the export in the target module.
+   *
+   * @param exportName The name of the export to find
+   * @param visited Set of already visited file paths to prevent infinite loops
+   * @returns The export info with resolved path if found, undefined otherwise
+   */
+  findExportThroughStarExports(
+    exportName: string,
+    visited: Set<string> = new Set(),
+  ): { export: ExportedFunction; resolvedPath: string } | undefined {
+    if (!this.file?.path || visited.has(this.file.path)) {
+      return undefined;
+    }
+    visited.add(this.file.path);
+
+    const exports = this.getAllExports();
+
+    // First, check if the export exists directly
+    const directExport = exports[exportName];
+    if (directExport) {
+      return { export: directExport, resolvedPath: this.file.path };
+    }
+
+    // If not found directly, look for star exports and follow them
+    const starExports = Object.entries(exports).filter(
+      ([_, exp]) => exp.isStarExport,
+    );
+
+    for (const [_, starExport] of starExports) {
+      if (!starExport.directImportPath) continue;
+
+      // Resolve the star export path
+      const resolvedModule = this.getResolvedModule(
+        starExport.directImportPath,
+      );
+      if (!resolvedModule) continue;
+
+      const resolvedPath = this.projectAnalyzer.getRelativePath(
+        resolvedModule.resolvedFileName,
+      );
+
+      // Handle dist -> src mapping for workspace packages
+      let targetPath = resolvedPath;
+      let targetFile = this.projectAnalyzer.project.files.find(
+        (f) => f.path === targetPath,
+      );
+
+      if (!targetFile && targetPath.includes('/dist/')) {
+        const srcPath = targetPath.replace('/dist/', '/src/');
+        targetFile = this.projectAnalyzer.project.files.find(
+          (f) => f.path === srcPath,
+        );
+        if (targetFile) {
+          targetPath = srcPath;
+        }
+
+        // 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',
+          );
+          if (targetFile) {
+            targetPath = targetFile.path;
+          }
+        }
+      }
+
+      if (!targetFile) continue;
+
+      // Recursively search in the target file
+      const targetAnalyzer = this.projectAnalyzer.getFileAnalyzer(targetFile);
+      const result = targetAnalyzer.findExportThroughStarExports(
+        exportName,
+        visited,
+      );
+      if (result) {
+        return result;
+      }
+    }
+
+    return undefined;
+  }
+
   getImportsAnalysis() {
     if (!this.sourceFile) return {};
     return lib.asts.sourceFiles.getImportsAnalysis(this.sourceFile);
@@ -244,11 +365,16 @@ export class FileAnalyzer {
 
         for (let i = 0; i < uniqueRelevantExpressions.length; i++) {
           const relevantExpression = uniqueRelevantExpressions[i];
-          if (
-            relevantExpression.exportName === '*' &&
+          // Resolve namespace imports for local packages (not external libraries).
+          // A module is local if it's not external OR if it resolves to a path outside node_modules
+          // (handles local monorepo packages like @codeyam/ui-components).
+          // If resolvedFileName is undefined, we can't determine location, so treat as external.
+          const isLocalModule =
             resolvedModule &&
-            !resolvedModule.isExternalLibraryImport
-          ) {
+            (!resolvedModule.isExternalLibraryImport ||
+              (resolvedModule.resolvedFileName &&
+                !resolvedModule.resolvedFileName.includes('node_modules')));
+          if (relevantExpression.exportName === '*' && isLocalModule) {
             uniqueRelevantExpressions.splice(i, 1);
             uniqueRelevantExpressions.push(
               ...this.resolveNamespaceImport(
@@ -261,11 +387,18 @@ export class FileAnalyzer {
         }
 
         if (uniqueRelevantExpressions.length > 0) {
-          // Debug logging for ./types imports
+          // A module is external if TypeScript says so AND the resolved path is in node_modules.
+          // This handles local monorepo packages (like @codeyam/ui-components) which TypeScript
+          // marks as isExternalLibraryImport=true because they're symlinked, but actually
+          // resolve to files inside the project (not in node_modules).
+          const isExternalLibrary =
+            (resolvedModule?.isExternalLibraryImport ?? true) &&
+            (resolvedModule?.resolvedFileName?.includes('node_modules') ??
+              true);
           return [
             importedFilePath,
             {
-              externalLibrary: resolvedModule?.isExternalLibraryImport ?? true,
+              externalLibrary: isExternalLibrary,
               resolvedPath: resolvedModule?.resolvedFileName,
               exportInfos: uniqueRelevantExpressions,
             },
@@ -302,14 +435,41 @@ export class FileAnalyzer {
           }
 
           const relativePath = this.projectAnalyzer.getRelativePath(importPath);
-          const projectPath = this.projectAnalyzer.getRelativePath(
+          let projectPath = this.projectAnalyzer.getRelativePath(
             resolvedImport.resolvedFileName,
           );
 
-          const importedFile = this.projectAnalyzer.project.files.find(
+          let importedFile = this.projectAnalyzer.project.files.find(
             (f) => f.path === projectPath,
           );
 
+          // Workspace packages often resolve to dist/ paths (from package.json "types" or "main"),
+          // but our project.files contains source files in src/. Try mapping dist -> src.
+          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,
+            );
+            if (importedFile) {
+              projectPath = srcPath;
+            }
+
+            // If not found, try with different extensions
+            if (!importedFile) {
+              const basePath = srcPath
+                .replace(/\.d\.ts$/, '')
+                .replace(/\.js$/, '');
+              importedFile = this.projectAnalyzer.project.files.find(
+                (f) =>
+                  f.path === basePath + '.ts' || f.path === basePath + '.tsx',
+              );
+              if (importedFile) {
+                projectPath = importedFile.path;
+              }
+            }
+          }
+
           if (!importedFile) {
             // File not found in project.files, but still preserve resolvedPath
             return [
@@ -337,10 +497,39 @@ export class FileAnalyzer {
               );
             }
 
-            const importedExport = importedExports[exportInfo.exportName];
-            const directImportPath = importedExport?.directImportPath;
+            let importedExport = importedExports[exportInfo.exportName];
+            let directImportPath = importedExport?.directImportPath;
+            let foundThroughStarExports = false;
+
+            // If export not found directly, try following star export chains
+            // This handles cases like `export * from './client'` where the actual
+            // export is defined in a re-exported module
+            if (
+              !importedExport &&
+              typeof importedFileAnalyer.findExportThroughStarExports ===
+                'function'
+            ) {
+              const starExportResult =
+                importedFileAnalyer.findExportThroughStarExports(
+                  exportInfo.exportName,
+                );
+              if (starExportResult) {
+                // Found the export through star exports - update the resolved path
+                // The directImportPath is effectively the resolved path where we found it
+                directImportPath = starExportResult.export.directImportPath;
+                // Update exportInfo with the resolved location
+                if (!exportInfo.resolvedPath) {
+                  exportInfo.resolvedPath = starExportResult.resolvedPath;
+                }
+                importedExport = starExportResult.export;
+                foundThroughStarExports = true;
+              }
+            }
 
-            if (directImportPath) {
+            // Skip recursive processing if we found the export through star exports,
+            // since we already have the resolved path and the recursive call would
+            // use the wrong file analyzer (the original file, not where we found the export)
+            if (directImportPath && !foundThroughStarExports) {
               const directImportResolvedImports =
                 importedFileAnalyer.getResolvedImportsRelevantToFunctionName(
                   exportInfo.exportName,
@@ -657,11 +846,26 @@ 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];
+    if (!node) return { start: 0, end: 0 };
     const start = this.sourceFile.getLineAndCharacterOfPosition(
-      node.getStart(),
+      node.getStart(this.sourceFile),
     ).line;
     const end = this.sourceFile.getLineAndCharacterOfPosition(
       node.getEnd(),

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

@@ -17,7 +17,7 @@ export function getNodeType(node: ts.Node, sourceFile: ts.SourceFile) {
       nodeType = 'function';
       break;
     case 'ClassDeclaration':
-      nodeType = 'function';
+      nodeType = 'class';
       break;
     case 'ExportDeclaration':
     case 'ExportAssignment':

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;
@@ -163,7 +164,8 @@ export function isFunction(
     ts.isFunctionDeclaration(node) ||
     ts.isFunctionExpression(node) ||
     ts.isArrowFunction(node) ||
-    ts.isCallExpression(node)
+    ts.isCallExpression(node) ||
+    ts.isClassDeclaration(node)
   );
 }
 

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,
+  );
+}