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

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

@@ -1,4 +1,5 @@
 import {
+  DataStructure,
   Entity,
   Scenario,
   ReadonlyAnalysisMap,
@@ -8,6 +9,7 @@ import gatherRelevantDependentKeyAttributes from '../gatherRelevantDependentKeyA
 
 interface GenerateChangesEntityScenariosGeneratorArgs {
   entity: Pick<Entity, 'name' | 'code' | 'metadata'>;
+  mergedDataStructure: Omit<DataStructure, 'equivalentSignatureVariables'>;
   keyAttributes: Analysis['metadata']['keyAttributes'];
   addedKeyAttributes: Analysis['metadata']['keyAttributes'];
   removedKeyAttributes: Analysis['metadata']['keyAttributes'];
@@ -20,6 +22,7 @@ interface GenerateChangesEntityScenariosGeneratorArgs {
 
 export default function generateChangesEntityScenariosGenerator({
   entity,
+  mergedDataStructure,
   keyAttributes,
   addedKeyAttributes,
   removedKeyAttributes,
@@ -30,7 +33,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<
@@ -58,6 +65,9 @@ export default function generateChangesEntityScenariosGenerator({
       localVariable: ka.internalPath,
       description: ka.description,
       validValueOptions: ka.validValueOptions,
+      // Include new fields when present
+      ...(ka.valueType && { valueType: ka.valueType }),
+      ...(ka.dependencies && { dependencies: ka.dependencies }),
     }));
 
   const addedSection =
@@ -122,6 +132,9 @@ ${JSON.stringify(
           localVariable: ka.path || ka.internalPath,
           description: ka.description,
           validValueOptions: ka.validValueOptions,
+          // Include new fields when present
+          ...(ka.valueType && { valueType: ka.valueType }),
+          ...(ka.dependencies && { dependencies: ka.dependencies }),
         }));
         return entityAcc;
       },

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

@@ -25,6 +25,9 @@ export default function generateEntityScenariosGenerator({
       localVariable: ka.internalPath,
       description: ka.description,
       validValueOptions: ka.validValueOptions,
+      // Include new fields when present
+      ...(ka.valueType && { valueType: ka.valueType }),
+      ...(ka.dependencies && { dependencies: ka.dependencies }),
     })),
     null,
     2,
@@ -44,6 +47,9 @@ ${JSON.stringify(
     forDependency: ka.dependentEntityName,
     description: ka.description,
     validValueOptions: ka.validValueOptions,
+    // Include new fields when present
+    ...(ka.valueType && { valueType: ka.valueType }),
+    ...(ka.dependencies && { dependencies: ka.dependencies }),
   })),
   null,
   2,

package/analyzer-template/packages/ai/src/lib/transformMockDataToMatchSchema.ts

@@ -0,0 +1,156 @@
+/**
+ * Transforms mock data values to match expected schema types.
+ *
+ * LLMs sometimes generate values in the wrong format. For example, when analyzing
+ * code like `const segments = splat.split('/').filter(Boolean)`, the LLM might
+ * output an array like `["scenarios", "abc123"]` even though `splat` is typed as
+ * a string and should be `"scenarios/abc123"`.
+ *
+ * This function walks the mock data and schema in parallel, transforming values
+ * that don't match their expected types.
+ */
+
+type SchemaValue = string | Record<string, unknown> | unknown[];
+
+/**
+ * Gets the base type from a schema type string like "string | undefined" -> "string"
+ */
+function getBaseType(schemaType: string): string {
+  // Remove "| undefined", "| null", etc. and get the primary type
+  const parts = schemaType.split('|').map((s) => s.trim());
+  const primaryType = parts.find(
+    (p) => p !== 'undefined' && p !== 'null' && p !== 'never',
+  );
+  return primaryType || parts[0];
+}
+
+/**
+ * Transforms a single value to match the expected schema type
+ */
+function transformValue(value: unknown, schemaType: string): unknown {
+  if (value === null || value === undefined) {
+    return value;
+  }
+
+  const baseType = getBaseType(schemaType);
+
+  // Array -> String: join with '/' (common for route params like `params['*']`)
+  if (Array.isArray(value) && baseType === 'string') {
+    return value.join('/');
+  }
+
+  // String -> Number
+  if (typeof value === 'string' && baseType === 'number') {
+    const num = Number(value);
+    if (!isNaN(num)) {
+      return num;
+    }
+  }
+
+  // Number -> String
+  if (typeof value === 'number' && baseType === 'string') {
+    return String(value);
+  }
+
+  // Boolean -> String
+  if (typeof value === 'boolean' && baseType === 'string') {
+    return String(value);
+  }
+
+  // String -> Boolean
+  if (typeof value === 'string' && baseType === 'boolean') {
+    return value === 'true';
+  }
+
+  return value;
+}
+
+/**
+ * Recursively transforms mock data to match the schema types
+ */
+function transformObject(
+  mockData: Record<string, unknown>,
+  schema: Record<string, SchemaValue>,
+  path: string = '',
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+
+  for (const key of Object.keys(mockData)) {
+    const value = mockData[key];
+    const schemaValue = schema[key];
+    const currentPath = path ? `${path}.${key}` : key;
+
+    if (schemaValue === undefined) {
+      // No schema for this key, keep as-is
+      result[key] = value;
+      continue;
+    }
+
+    if (typeof schemaValue === 'string') {
+      // Schema is a type string like "string" or "string | undefined"
+      result[key] = transformValue(value, schemaValue);
+    } else if (
+      typeof schemaValue === 'object' &&
+      schemaValue !== null &&
+      !Array.isArray(schemaValue)
+    ) {
+      // Schema is a nested object
+      if (
+        typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value)
+      ) {
+        result[key] = transformObject(
+          value as Record<string, unknown>,
+          schemaValue as Record<string, SchemaValue>,
+          currentPath,
+        );
+      } else {
+        result[key] = value;
+      }
+    } else if (Array.isArray(schemaValue)) {
+      // Schema is an array - transform each item if value is also an array
+      if (Array.isArray(value) && schemaValue.length > 0) {
+        const itemSchema = schemaValue[0];
+        if (typeof itemSchema === 'object' && itemSchema !== null) {
+          result[key] = value.map((item, i) => {
+            if (typeof item === 'object' && item !== null) {
+              return transformObject(
+                item as Record<string, unknown>,
+                itemSchema as Record<string, SchemaValue>,
+                `${currentPath}[${i}]`,
+              );
+            }
+            return item;
+          });
+        } else {
+          result[key] = value;
+        }
+      } else {
+        result[key] = value;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Transforms scenario mock data to match expected schema types.
+ *
+ * @param mockData - The generated mock data from the LLM
+ * @param dataForMocks - The schema defining expected types
+ * @returns The transformed mock data with values matching expected types
+ */
+export default function transformMockDataToMatchSchema(
+  mockData: Record<string, unknown> | undefined,
+  dataForMocks: Record<string, unknown> | undefined,
+): Record<string, unknown> | undefined {
+  if (!mockData || !dataForMocks) {
+    return mockData;
+  }
+
+  return transformObject(mockData, dataForMocks as Record<string, SchemaValue>);
+}

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

@@ -22,6 +22,12 @@ 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>;
 }
 
 export interface SerializableFunctionResult {

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);
@@ -348,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 [
@@ -383,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,
@@ -706,8 +849,9 @@ export class FileAnalyzer {
   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

@@ -163,7 +163,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/sourceFiles/getAllExportedNodes.ts

@@ -54,13 +54,15 @@ export function getAllExportedNodes(
   }
 
   function processNamedExports(node: ts.NamedExports) {
+    const parent = node.parent as ts.ExportDeclaration | undefined;
+
     node.elements.forEach((element) => {
       const name = element.name.text;
       const propertyName = element.propertyName
         ? element.propertyName.text
         : name;
-      const importedSource = node.parent.moduleSpecifier
-        ? node.parent.moduleSpecifier.getText(sourceFile)
+      const importedSource = parent?.moduleSpecifier
+        ? parent.moduleSpecifier.getText(sourceFile)
         : undefined;
 
       if (importedSource) {

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;
 }
@@ -103,19 +104,21 @@ export function getAllExports(
   }
 
   function processNamedExports(node: ts.NamedExports) {
+    const parent = node.parent as ts.ExportDeclaration | undefined;
+
     node.elements.forEach((element) => {
       const name = element.name.text;
       const propertyName = element.propertyName
         ? element.propertyName.text
         : name;
-      const importedSource = node.parent.moduleSpecifier
-        ? node.parent.moduleSpecifier.getText(sourceFile)
+      const importedSource = parent?.moduleSpecifier
+        ? parent.moduleSpecifier.getText(sourceFile)
         : undefined;
 
       if (importedSource) {
         const directImportPath = importedSource?.replace(/['"]/g, '');
         const directImport = (
-          node.parent.exportClause as ts.NamedExports
+          parent?.exportClause as ts.NamedExports | undefined
         )?.elements?.find(
           (e) => (e.propertyName || e.name).text === propertyName,
         );
@@ -200,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,
+        };
       }
     }
   });