@codeyam/codeyam-cli 0.1.0-staging.bbe4da9 → 0.1.0-staging.d0ad4ae

package/analyzer-template/packages/ai/src/lib/promptGenerators/generateChangesEntityScenariosGenerator.ts

@@ -1,4 +1,5 @@
 import {
+  DataStructure,
   Entity,
   Scenario,
   ReadonlyAnalysisMap,
@@ -6,11 +7,18 @@ import {
 } from '~codeyam/types';
 import gatherRelevantDependentKeyAttributes from '../gatherRelevantDependentKeyAttributes';
 
+interface ModifiedKeyAttribute {
+  keyAttribute: Analysis['metadata']['keyAttributes'][0];
+  newSourceLocations: Analysis['metadata']['keyAttributes'][0]['sourceLocations'];
+}
+
 interface GenerateChangesEntityScenariosGeneratorArgs {
   entity: Pick<Entity, 'name' | 'code' | 'metadata'>;
+  mergedDataStructure: Omit<DataStructure, 'equivalentSignatureVariables'>;
   keyAttributes: Analysis['metadata']['keyAttributes'];
   addedKeyAttributes: Analysis['metadata']['keyAttributes'];
   removedKeyAttributes: Analysis['metadata']['keyAttributes'];
+  modifiedKeyAttributes?: ModifiedKeyAttribute[];
   dependentAnalyses: ReadonlyAnalysisMap;
   existingScenarios: Scenario[];
   commitDiff: string;
@@ -20,9 +28,11 @@ interface GenerateChangesEntityScenariosGeneratorArgs {
 
 export default function generateChangesEntityScenariosGenerator({
   entity,
+  mergedDataStructure,
   keyAttributes,
   addedKeyAttributes,
   removedKeyAttributes,
+  modifiedKeyAttributes,
   dependentAnalyses,
   existingScenarios,
   commitDiff,
@@ -30,7 +40,11 @@ export default function generateChangesEntityScenariosGenerator({
   changedDataStructureFields = [],
 }: GenerateChangesEntityScenariosGeneratorArgs) {
   const relevantDependentKeyAttributesFlat =
-    gatherRelevantDependentKeyAttributes(entity, dependentAnalyses);
+    gatherRelevantDependentKeyAttributes(
+      entity,
+      mergedDataStructure,
+      dependentAnalyses,
+    );
 
   // Restructure flat array into nested format: { [filePath]: { [entityName]: KeyAttribute[] } }
   const relevantDependentKeyAttributes: Record<
@@ -57,7 +71,28 @@ export default function generateChangesEntityScenariosGenerator({
       dataStructurePath: ka.dataStructurePath,
       localVariable: ka.internalPath,
       description: ka.description,
-      validValueOptions: ka.validValueOptions,
+      // Include indexed validValueOptions for structured references
+      validValueOptions: ka.validValueOptions.map((value, index) => ({
+        index,
+        value,
+      })),
+      ...(ka.errorValueOptions?.length && {
+        errorValueOptions: ka.errorValueOptions.map((value, index) => ({
+          index,
+          value,
+        })),
+      }),
+      // Include new fields when present
+      ...(ka.valueType && { valueType: ka.valueType }),
+      ...(ka.dependencies && { dependencies: ka.dependencies }),
+      // Include source locations showing where this attribute is used in conditionals
+      ...(ka.sourceLocations?.length && {
+        codeUsages: ka.sourceLocations.map((loc) => ({
+          line: loc.lineNumber,
+          code: loc.codeSnippet,
+          context: loc.description,
+        })),
+      }),
     }));
 
   const addedSection =
@@ -70,6 +105,25 @@ export default function generateChangesEntityScenariosGenerator({
       ? JSON.stringify(removedKeyAttributes, null, 2)
       : 'None';
 
+  // Format modified key attributes to highlight new usages
+  const modifiedSection =
+    modifiedKeyAttributes && modifiedKeyAttributes.length > 0
+      ? JSON.stringify(
+          modifiedKeyAttributes.map((mod) => ({
+            localVariable: mod.keyAttribute.internalPath,
+            dataStructurePath: mod.keyAttribute.dataStructurePath,
+            description: mod.keyAttribute.description,
+            newCodeUsages: mod.newSourceLocations?.map((loc) => ({
+              line: loc.lineNumber,
+              code: loc.codeSnippet,
+              context: loc.description,
+            })),
+          })),
+          null,
+          2,
+        )
+      : 'None';
+
   const changedFieldsSection =
     changedDataStructureFields.length > 0
       ? `
@@ -121,7 +175,32 @@ ${JSON.stringify(
           dataStructurePath: ka.dataStructurePath,
           localVariable: ka.path || ka.internalPath,
           description: ka.description,
-          validValueOptions: ka.validValueOptions,
+          // Include indexed validValueOptions for structured references
+          validValueOptions: (ka.validValueOptions || []).map(
+            (value: string, index: number) => ({
+              index,
+              value,
+            }),
+          ),
+          ...(ka.errorValueOptions?.length && {
+            errorValueOptions: ka.errorValueOptions.map(
+              (value: string, index: number) => ({
+                index,
+                value,
+              }),
+            ),
+          }),
+          // Include new fields when present
+          ...(ka.valueType && { valueType: ka.valueType }),
+          ...(ka.dependencies && { dependencies: ka.dependencies }),
+          // Include source locations showing where this attribute is used in conditionals
+          ...(ka.sourceLocations?.length && {
+            codeUsages: ka.sourceLocations.map((loc: any) => ({
+              line: loc.lineNumber,
+              code: loc.codeSnippet,
+              context: loc.description,
+            })),
+          }),
         }));
         return entityAcc;
       },
@@ -144,6 +223,12 @@ ${addedSection}
 \`\`\`json
 ${removedSection}
 \`\`\`
+
+## Key Attributes with New Usages
+These existing key attributes have NEW code usages that may warrant new or updated scenarios:
+\`\`\`json
+${modifiedSection}
+\`\`\`
 ${changedFieldsSection}
 ## Current Key Attributes
 \`\`\`json

package/analyzer-template/packages/ai/src/lib/promptGenerators/generateEntityScenariosGenerator.ts

@@ -24,7 +24,28 @@ export default function generateEntityScenariosGenerator({
       dataStructurePath: ka.dataStructurePath,
       localVariable: ka.internalPath,
       description: ka.description,
-      validValueOptions: ka.validValueOptions,
+      // Include indexed validValueOptions for structured references
+      validValueOptions: ka.validValueOptions.map((value, index) => ({
+        index,
+        value,
+      })),
+      ...(ka.errorValueOptions?.length && {
+        errorValueOptions: ka.errorValueOptions.map((value, index) => ({
+          index,
+          value,
+        })),
+      }),
+      // Include new fields when present
+      ...(ka.valueType && { valueType: ka.valueType }),
+      ...(ka.dependencies && { dependencies: ka.dependencies }),
+      // Include source locations showing where this attribute is used in conditionals
+      ...(ka.sourceLocations?.length && {
+        codeUsages: ka.sourceLocations.map((loc) => ({
+          line: loc.lineNumber,
+          code: loc.codeSnippet,
+          context: loc.description,
+        })),
+      }),
     })),
     null,
     2,
@@ -43,7 +64,28 @@ ${JSON.stringify(
     localVariable: ka.internalPath,
     forDependency: ka.dependentEntityName,
     description: ka.description,
-    validValueOptions: ka.validValueOptions,
+    // Include indexed validValueOptions for structured references
+    validValueOptions: ka.validValueOptions.map((value, index) => ({
+      index,
+      value,
+    })),
+    ...(ka.errorValueOptions?.length && {
+      errorValueOptions: ka.errorValueOptions.map((value, index) => ({
+        index,
+        value,
+      })),
+    }),
+    // Include new fields when present
+    ...(ka.valueType && { valueType: ka.valueType }),
+    ...(ka.dependencies && { dependencies: ka.dependencies }),
+    // Include source locations showing where this attribute is used in conditionals
+    ...(ka.sourceLocations?.length && {
+      codeUsages: ka.sourceLocations.map((loc) => ({
+        line: loc.lineNumber,
+        code: loc.codeSnippet,
+        context: loc.description,
+      })),
+    }),
   })),
   null,
   2,

package/analyzer-template/packages/ai/src/lib/promptGenerators/guessNewScenarioDataFromDescriptionGenerator.ts

@@ -1,24 +1,50 @@
 import { ScenariosDataStructure, Scenario } from '~codeyam/types';
 
+export interface KeyAttributeSelection {
+  path: string;
+  value: string;
+  valueOptionIndex?: number;
+  isCustom: boolean;
+}
+
 interface GenerateEntityScenariosGeneratorArgs {
   description: string;
   existingScenarios: Scenario[];
   scenariosDataStructure: ScenariosDataStructure;
+  keyAttributeSelections?: KeyAttributeSelection[];
 }
 
 export default function guessNewScenarioDataFromDescriptionGenerator({
   description,
   existingScenarios,
   scenariosDataStructure,
+  keyAttributeSelections,
 }: GenerateEntityScenariosGeneratorArgs) {
+  let keyAttributesSection = '';
+  if (keyAttributeSelections && keyAttributeSelections.length > 0) {
+    keyAttributesSection = `
+  User-selected Key Attributes and Values:
+  The user has specifically requested these key attributes and values be used in the scenario:
+  ${keyAttributeSelections
+    .map(
+      (sel) =>
+        `  - ${sel.path}: ${sel.value}${sel.isCustom ? ' (custom value)' : ''}`,
+    )
+    .join('\n')}
+
+  IMPORTANT: The mockData MUST include these specific values for the specified paths. Generate a scenario name and description that reflects these choices.
+  `;
+  }
+
   return `Mock Scenario Data Structure:
   \`\`\`
   ${JSON.stringify(scenariosDataStructure, null, 2)}
-  \`\`\
+  \`\`\`
   Existing Mock Scenario Data:
   \`\`\`
   ${JSON.stringify(existingScenarios, null, 2)}
   \`\`\`
-  New Scenario user-created prompt: "${description}"
+${keyAttributesSection}
+  New Scenario user-created prompt: "${description || '(No additional description - generate based on selected key attributes)'}"
   `;
 }

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

@@ -24,6 +24,15 @@ export interface SerializableFunctionCallInfo {
   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 {

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

@@ -177,6 +177,93 @@ export class FileAnalyzer {
     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);
@@ -410,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,
@@ -730,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/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,
+  );
+}

package/analyzer-template/packages/analyze/src/lib/asts/sourceFiles/getAllExports.ts

@@ -5,6 +5,7 @@ export interface ExportedFunction {
   code: string;
   isDefaultExport: boolean;
   isNamespaceExport: boolean;
+  isStarExport?: boolean;
   directImportPath?: string;
   directImportName?: string;
 }
@@ -202,12 +203,38 @@ export function getAllExports(
       }
     } else if (ts.isExportAssignment(node) && !node.isExportEquals) {
       processExportAssignment(node);
-    } else if (ts.isExportDeclaration(node) && node.exportClause) {
-      if (ts.isNamedExports(node.exportClause)) {
-        processNamedExports(node.exportClause);
-      } else if (ts.isNamespaceExport(node.exportClause)) {
-        const name = node.exportClause.name.text;
-        addExport(name, node, false);
+    } else if (ts.isExportDeclaration(node)) {
+      if (node.exportClause) {
+        if (ts.isNamedExports(node.exportClause)) {
+          processNamedExports(node.exportClause);
+        } else if (ts.isNamespaceExport(node.exportClause)) {
+          const name = node.exportClause.name.text;
+          addExport(name, node, false);
+        }
+      } else if (node.moduleSpecifier) {
+        // Handle star exports: export * from './path'
+        // The exportClause is undefined for star exports
+        const moduleSpecifier = node.moduleSpecifier.getText(sourceFile);
+        const directImportPath = moduleSpecifier.replace(/['"]/g, '');
+
+        // Use a synthetic name based on the path to track this star export
+        // The * symbol indicates this is a star export that needs to be followed
+        const starExportName = `*:${directImportPath}`;
+
+        let code: string;
+        try {
+          code = node.getFullText(sourceFile).trim();
+        } catch (error) {
+          code = `export * from '${directImportPath}'`;
+        }
+
+        exportsCodeMap[starExportName] = {
+          code,
+          isDefaultExport: false,
+          isNamespaceExport: false,
+          isStarExport: true,
+          directImportPath,
+        };
       }
     }
   });