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

package/analyzer-template/packages/ai/src/lib/astScopes/methodSemantics.ts

@@ -423,6 +423,194 @@ export class ArrayMapSemantics implements MethodSemantics {
   }
 }
 
+/**
+ * Array flatMap method semantics
+ *
+ * flatMap() maps each element using a mapping function, then flattens the result into a new array
+ */
+export class ArrayFlatMapSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'array';
+  }
+
+  addEquivalences(
+    methodCallPath: StructuredPath,
+    sourcePath: StructuredPath,
+    context: AnalysisContext,
+  ): void {
+    // Mark source as array
+    context.addType(sourcePath, 'array');
+
+    // Get the last function call segment to access the arguments
+    const lastFunctionCallSegment = methodCallPath.getLastFunctionCallSegment();
+
+    if (lastFunctionCallSegment && lastFunctionCallSegment.args.length > 0) {
+      // The first argument is the callback
+      const callbackPath = lastFunctionCallSegment.args[0];
+
+      // Add the callback to the structure
+      context.addType(callbackPath, 'function');
+
+      // Mark that the callback's first parameter receives array elements
+      context.addEquivalence(
+        callbackPath.withParameter(0),
+        sourcePath.withElement('*'),
+      );
+    }
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
+/**
+ * Array at method semantics
+ *
+ * at() returns the element at the given index, supporting negative indices
+ */
+export class ArrayAtSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'unknown'; // Returns element type or undefined
+  }
+
+  addEquivalences(
+    methodCallPath: StructuredPath,
+    sourcePath: StructuredPath,
+    context: AnalysisContext,
+  ): void {
+    // Mark source as array
+    context.addType(sourcePath, 'array');
+
+    // The return value is equivalent to an array element
+    context.addEquivalence(
+      methodCallPath.withReturnValues(),
+      sourcePath.withElement('*'),
+    );
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
+/**
+ * Array findLast method semantics
+ *
+ * findLast() returns the last element that passes the test, or undefined
+ */
+export class ArrayFindLastSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'unknown'; // Could be any type from the array or undefined
+  }
+
+  addEquivalences(
+    methodCallPath: StructuredPath,
+    sourcePath: StructuredPath,
+    context: AnalysisContext,
+  ): void {
+    // Mark source as array
+    context.addType(sourcePath, 'array');
+
+    // Get the last function call segment to access the arguments
+    const functionCallSegment = methodCallPath.getLastFunctionCallSegment();
+
+    if (functionCallSegment && functionCallSegment.args.length > 0) {
+      // The first argument is the callback
+      const callbackPath = functionCallSegment.args[0];
+
+      // Add the callback to the structure
+      context.addType(callbackPath, 'function');
+
+      // Mark that the callback's first parameter receives array elements
+      context.addEquivalence(
+        callbackPath.withParameter(0),
+        sourcePath.withElement('*'),
+      );
+    }
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
+/**
+ * Object.fromEntries method semantics
+ *
+ * fromEntries() transforms a list of key-value pairs into an object
+ */
+export class ObjectFromEntriesSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'object';
+  }
+
+  addEquivalences(
+    methodCallPath: StructuredPath,
+    sourcePath: StructuredPath,
+    context: AnalysisContext,
+  ): void {
+    // The source path would be Object, not particularly useful
+    // The argument is an iterable of key-value pairs
+    const functionCallSegment = methodCallPath.getLastFunctionCallSegment();
+
+    if (functionCallSegment && functionCallSegment.args.length > 0) {
+      // Mark the argument as an array (iterable of entries)
+      const entriesPath = functionCallSegment.args[0];
+      context.addType(entriesPath, 'array');
+    }
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
+/**
+ * Promise.then method semantics
+ *
+ * then() registers a callback to be called when the promise resolves,
+ * and returns a new promise that resolves to the callback's return value
+ */
+export class PromiseThenSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'unknown'; // Returns a Promise resolving to the callback's return
+  }
+
+  addEquivalences(
+    methodCallPath: StructuredPath,
+    sourcePath: StructuredPath,
+    context: AnalysisContext,
+  ): void {
+    // Get the callback argument
+    const functionCallSegment = methodCallPath.getLastFunctionCallSegment();
+
+    if (functionCallSegment && functionCallSegment.args.length > 0) {
+      const callbackPath = functionCallSegment.args[0];
+
+      // Mark the callback as a function
+      context.addType(callbackPath, 'function');
+
+      // The callback's first parameter receives the resolved value of the source promise
+      // For promise.then(response => ...), response = promise's resolved value
+      // Note: Don't add .functionCallReturnValue - the system adds it automatically
+      // via toRightHandSideString() when storing equivalences
+      context.addEquivalence(callbackPath.withParameter(0), sourcePath);
+
+      // The .then() return value (when chained) resolves to the callback's return
+      // This enables chained .then() calls to track through
+      context.addEquivalence(
+        methodCallPath.withProperty('functionCallReturnValue'),
+        callbackPath.withProperty('returnValue'),
+      );
+    }
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
 /**
  * UseMemo React hook semantics
  *
@@ -513,13 +701,22 @@ export function createMethodRegistry(): MethodSemanticsRegistry {
   // Register array methods
   registry.register('filter', new ArrayFilterSemantics(), 'Array');
   registry.register('map', new ArrayMapSemantics(), 'Array');
+  registry.register('flatMap', new ArrayFlatMapSemantics(), 'Array');
   registry.register('join', new ArrayJoinSemantics(), 'Array');
   registry.register('find', new ArrayFindSemantics(), 'Array');
+  registry.register('findLast', new ArrayFindLastSemantics(), 'Array');
+  registry.register('at', new ArrayAtSemantics(), 'Array');
   registry.register('reduce', new ArrayReduceSemantics(), 'Array');
   registry.register('concat', new ArrayConcatSemantics(), 'Array');
   registry.register('slice', new ArraySliceSemantics(), 'Array');
   registry.register('splice', new ArraySpliceSemantics(), 'Array');
 
+  // Register Object methods
+  registry.register('fromEntries', new ObjectFromEntriesSemantics(), 'Object');
+
+  // Register Promise methods
+  registry.register('then', new PromiseThenSemantics(), 'Promise');
+
   // Register React hooks
   registry.register('useState', new UseStateSemantics(), 'React');
   registry.register('useMemo', new UseMemoSemantics(), 'React');

package/analyzer-template/packages/ai/src/lib/astScopes/paths.ts

@@ -17,6 +17,25 @@ interface ToStringWithSegmentsOptions {
   withNestedReturnValues?: boolean;
 }
 
+/**
+ * Check if a string is a valid JavaScript identifier (can use dot notation)
+ * Valid identifiers start with a letter, underscore, or dollar sign
+ * and contain only letters, digits, underscores, and dollar signs
+ *
+ * Also allows computed property markers like *f.path* (wrapped in asterisks)
+ * which are used internally to represent dynamic property accesses
+ */
+function isValidIdentifier(name: string): boolean {
+  if (!name || name.length === 0) return false;
+  // First char: letter, underscore, or dollar sign
+  // Rest: letter, digit, underscore, or dollar sign
+  // Also allow computed property markers like *expression*
+  return (
+    /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ||
+    (name.startsWith('*') && name.endsWith('*'))
+  );
+}
+
 /**
  * A structured representation of a variable or property path
  *
@@ -335,8 +354,15 @@ export class StructuredPath {
       switch (segment.type) {
         case PathRelationship.PROPERTY:
           const propSegment = segment as PropertySegment;
-          if (result) result += '.';
-          result += propSegment.name;
+          // Use bracket notation for property names that aren't valid identifiers
+          // (e.g. names with spaces, hyphens, starting with numbers, etc.)
+          if (isValidIdentifier(propSegment.name)) {
+            if (result) result += '.';
+            result += propSegment.name;
+          } else {
+            // Use bracket notation with quoted string for non-identifier names
+            result += `['${propSegment.name}']`;
+          }
           break;
 
         case PathRelationship.ELEMENT:

package/analyzer-template/packages/ai/src/lib/astScopes/processExpression.ts

@@ -326,6 +326,46 @@ export function processExpression({
     if (targetPath) {
       context.addEquivalence(targetPath, nodePath);
       context.addType(targetPath, inferredNodeType);
+
+      // Propagate sub-properties from the identifier to the targetPath
+      // This handles cases like: dataItem={{ structure: completeDataStructure }}
+      // where completeDataStructure was defined as { 'Function Arguments': dataStructure.arguments }
+      // We need to propagate completeDataStructure['Function Arguments'] to
+      // ChildComponent().signature[0].dataItem.structure['Function Arguments']
+      const nodePathStr = nodePath.toString();
+      const equivalentVariables = context.getEquivalentVariables();
+      const structure = context.getStructure();
+
+      // Propagate existing equivalencies for sub-properties
+      for (const [key, value] of Object.entries(equivalentVariables)) {
+        // Check if this equivalency is for a sub-property of the identifier
+        // e.g., completeDataStructure['Function Arguments'] or completeDataStructure.foo
+        if (
+          key.startsWith(nodePathStr + '.') ||
+          key.startsWith(nodePathStr + '[')
+        ) {
+          const subPath = key.substring(nodePathStr.length);
+          const newTargetPath = StructuredPath.fromBase(
+            targetPath.toString() + subPath,
+          );
+          const valuePath = StructuredPath.fromBase(value);
+          context.addEquivalence(newTargetPath, valuePath);
+        }
+      }
+
+      // Propagate existing structure entries for sub-properties
+      for (const [key, value] of Object.entries(structure)) {
+        if (
+          key.startsWith(nodePathStr + '.') ||
+          key.startsWith(nodePathStr + '[')
+        ) {
+          const subPath = key.substring(nodePathStr.length);
+          const newTargetPath = StructuredPath.fromBase(
+            targetPath.toString() + subPath,
+          );
+          context.addType(newTargetPath, value);
+        }
+      }
     }
     context.addType(nodePath, inferredNodeType);
     return true;
@@ -756,6 +796,9 @@ export function processExpression({
         } else {
           resultType = rightType || 'unknown';
         }
+        // For || and ??, create an equivalence to the left side
+        // This ensures the equivalency chain is preserved through fallback expressions
+        // e.g., `const tab = segments[0] || 'default'` should trace tab back to segments[0]
         if (operatorKind === ts.SyntaxKind.QuestionQuestionToken) {
           // specifically for ?? we create an equivalence to the left side
           if (targetPath) {
@@ -774,6 +817,17 @@ export function processExpression({
               context.sourceFile,
             );
           }
+        } else if (operatorKind === ts.SyntaxKind.BarBarToken) {
+          // For ||, also create an equivalence to the left side
+          // This enables data flow tracing through fallback expressions
+          if (targetPath) {
+            resultPath = StructuredPath.fromNode(
+              unwrappedNode.left,
+              context.sourceFile,
+            );
+          }
+          // Note: Unlike ??, we don't set targetPath when there's no target
+          // because || is often used in boolean contexts where the full expression matters
         }
       } else if (operatorKind === ts.SyntaxKind.InstanceOfKeyword) {
         resultType = 'boolean';
@@ -1009,24 +1063,27 @@ export function processExpression({
           context.addType(valuePath, valueType);
         } else if (ts.isSpreadAssignment(property)) {
           // Handle spread: { ...obj }
-          // Process the spread expression first (without targetPath for now)
-          processExpression({ node: property.expression, context });
-
           // Create a path for this spread source
           let spreadSourcePath: StructuredPath | null = null;
 
           // Handle simple identifier spread: { ...obj }
           if (ts.isIdentifier(property.expression)) {
+            // Process the spread expression first
+            processExpression({ node: property.expression, context });
+
             spreadSourcePath = StructuredPath.fromBase(
               property.expression.text,
             );
             // Establish equivalence between the target and the spread source
             context.addEquivalence(targetPath, spreadSourcePath);
-            // and we kow obj is an object
+            // and we know obj is an object
             context.addType(spreadSourcePath, 'object');
           }
           // Handle property access spread: { ...obj.prop }
           else if (ts.isPropertyAccessExpression(property.expression)) {
+            // Process the spread expression first
+            processExpression({ node: property.expression, context });
+
             spreadSourcePath = StructuredPath.fromNode(
               property.expression,
               context.sourceFile,
@@ -1035,8 +1092,55 @@ export function processExpression({
               context.addEquivalence(targetPath, spreadSourcePath);
             }
           }
+          // Handle object literal spread: { ...{ key: value } }
+          // This propagates sub-properties from the spread object to the target
+          else if (ts.isObjectLiteralExpression(property.expression)) {
+            // Recursively process the spread object literal WITH targetPath
+            // This ensures sub-properties like { args: x } become targetPath.args = x
+            processExpression({
+              node: property.expression,
+              context,
+              targetPath,
+            });
+          }
+          // Handle conditional spread: { ...(x ? {...} : {}) }
+          else if (ts.isParenthesizedExpression(property.expression)) {
+            // Unwrap parentheses and process
+            const unwrapped = property.expression.expression;
+
+            // Handle conditional expression inside parens: (x ? {...} : {})
+            if (ts.isConditionalExpression(unwrapped)) {
+              // Process both branches - whenTrue and whenFalse
+              // For tracing, we care about non-empty branches
+              if (ts.isObjectLiteralExpression(unwrapped.whenTrue)) {
+                processExpression({
+                  node: unwrapped.whenTrue,
+                  context,
+                  targetPath,
+                });
+              } else {
+                processExpression({ node: unwrapped.whenTrue, context });
+              }
+
+              if (ts.isObjectLiteralExpression(unwrapped.whenFalse)) {
+                processExpression({
+                  node: unwrapped.whenFalse,
+                  context,
+                  targetPath,
+                });
+              } else {
+                processExpression({ node: unwrapped.whenFalse, context });
+              }
+            } else {
+              // Other parenthesized expression - just process normally
+              processExpression({ node: property.expression, context });
+            }
+          }
           // Handle other expression types
           else {
+            // Process the spread expression
+            processExpression({ node: property.expression, context });
+
             // For complex expressions, use their source representation
             spreadSourcePath = nodeToSource(
               property.expression,
@@ -1960,6 +2064,25 @@ export function processExpression({
     return result;
   }
 
+  // Handle yield expressions in generator functions
+  if (ts.isYieldExpression(unwrappedNode)) {
+    // yield returns whatever is yielded, or undefined if no expression
+    if (unwrappedNode.expression) {
+      // Process the yielded expression
+      const result = processExpression({
+        node: unwrappedNode.expression,
+        context,
+        targetPath,
+      });
+      return result;
+    }
+    // yield with no expression returns undefined
+    if (targetPath) {
+      context.addType(targetPath, 'undefined');
+    }
+    return true;
+  }
+
   if (ts.isRegularExpressionLiteral(unwrappedNode)) {
     // Regular expressions are treated as string literals
     const regexPath = StructuredPath.createLiteralPath(

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

@@ -1,7 +1,5 @@
 export default function checkAllAttributes(data: { [key: string]: unknown }) {
-  if (data === null) return data;
-
-  for (const key of Object.keys(data)) {
+  for (const key of Object.keys(data || {})) {
     try {
       if (data[key] === undefined) {
         delete data[key];