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

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

@@ -139,6 +139,96 @@ export class ArrayFilterSemantics implements MethodSemantics {
   }
 }
 
+/**
+ * Array some method semantics
+ *
+ * some() returns true if at least one element passes the test, false otherwise
+ * The callback receives array elements to test
+ */
+export class ArraySomeSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'boolean';
+  }
+
+  addEquivalences(
+    methodCallPath: StructuredPath,
+    sourcePath: StructuredPath,
+    context: AnalysisContext,
+  ): void {
+    // Mark source as array
+    context.addType(sourcePath, 'array');
+
+    // Mark return as boolean
+    context.addType(methodCallPath, 'boolean');
+
+    // 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 every method semantics
+ *
+ * every() returns true if all elements pass the test, false otherwise
+ * The callback receives array elements to test
+ */
+export class ArrayEverySemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'boolean';
+  }
+
+  addEquivalences(
+    methodCallPath: StructuredPath,
+    sourcePath: StructuredPath,
+    context: AnalysisContext,
+  ): void {
+    // Mark source as array
+    context.addType(sourcePath, 'array');
+
+    // Mark return as boolean
+    context.addType(methodCallPath, 'boolean');
+
+    // 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 find method semantics
  *
@@ -173,12 +263,12 @@ export class ArrayFindSemantics implements MethodSemantics {
         sourcePath.withElement('*'),
       );
 
-      // THIS IS PRODUCING STRANGE RESULTS SUCH AS
-      // 'people.filter(cyScope2()).find(cyScope3())': 'people.filter(cyScope2()).functionCallReturnValue[]',
-      // 'personWithHome.places.find(cyScope5())': 'personWithHome.places[]'
-      // WHICH DO NOT MAKES SENSE
-      // REMOVING BUT LEAVING IN PLACE IN CASE THERE IS A VALID USE CASE
-      // The result is an element from the array that matches the callback condition
+      // NOTE: We intentionally do NOT create an equivalency from the find result
+      // to the array element here. While semantically correct (find returns an element),
+      // doing so causes type inference issues where the array element gets typed as
+      // 'function' instead of 'object'. The tracing back to source arrays happens
+      // through the || operator processing and null guard in addEquivalence.
+      // See: analyzeScopeNoAI1.test.ts for tests that break if this is uncommented.
       // context.addEquivalence(methodCallPath, sourcePath.withElement('*'));
     }
   }
@@ -239,11 +329,17 @@ export class ArrayReduceSemantics implements MethodSemantics {
 /**
  * Array concat method semantics
  *
- * concat() returns a new array combining the original array and additional items
+ * concat() returns a new array/string combining the original and additional items
+ *
+ * NOTE: We intentionally do NOT type the source as 'array' here because
+ * .concat() exists on both arrays AND strings. Typing the source prematurely
+ * causes type contamination when the source is equivalent to other paths
+ * via ?? chains. Type inference happens later in checkIfKnownType() based
+ * on accumulated evidence from all methods called on a path.
  */
 export class ArrayConcatSemantics implements MethodSemantics {
   getReturnType(): string {
-    return 'array';
+    return 'unknown'; // Could be array or string depending on source
   }
 
   addEquivalences(
@@ -251,23 +347,24 @@ export class ArrayConcatSemantics implements MethodSemantics {
     sourcePath: StructuredPath,
     context: AnalysisContext,
   ): void {
-    // Mark source as array
-    context.addType(sourcePath, 'array');
+    // NOTE: We use 'unknown' instead of 'array' for the source because .concat()
+    // exists on both arrays AND strings. Using 'array' causes type contamination
+    // when the source is equivalent to other paths via ?? chains.
+    context.addType(sourcePath, 'unknown');
 
-    // Any arguments are also added to the array
+    // Any arguments are also added to the result
     const functionCallSegment = methodCallPath.getLastFunctionCallSegment();
 
     if (functionCallSegment) {
       // Each argument could be an array or single element
       functionCallSegment.args.forEach((argPath) => {
         // No need to guess the type - we'll discover it through normal processing
-        // But we can indicate that these elements will be in the result array
+        // But we can indicate that these elements will be in the result
         context.addEquivalence(methodCallPath, argPath);
       });
     }
 
-    // The original array elements are also in the result
-    context.addType(methodCallPath, 'array');
+    // The original elements are also in the result
     context.addEquivalence(methodCallPath, sourcePath.withElement('*'));
   }
 
@@ -279,11 +376,17 @@ export class ArrayConcatSemantics implements MethodSemantics {
 /**
  * Array slice method semantics
  *
- * slice() returns a shallow copy of a portion of an array
+ * slice() returns a shallow copy of a portion of an array (or string)
+ *
+ * NOTE: We intentionally do NOT type the source as 'array' here because
+ * .slice() exists on both arrays AND strings. Typing the source prematurely
+ * causes type contamination when the source is equivalent to other paths
+ * via ?? chains. Type inference happens later in checkIfKnownType() based
+ * on accumulated evidence from all methods called on a path.
  */
 export class ArraySliceSemantics implements MethodSemantics {
   getReturnType(): string {
-    return 'array';
+    return 'unknown'; // Could be array or string depending on source
   }
 
   addEquivalences(
@@ -291,12 +394,15 @@ export class ArraySliceSemantics implements MethodSemantics {
     sourcePath: StructuredPath,
     context: AnalysisContext,
   ): void {
-    // Mark source as array
-    context.addType(sourcePath, 'array');
+    // NOTE: We use 'unknown' instead of 'array' for the source because .slice()
+    // exists on both arrays AND strings. Using 'array' causes type contamination
+    // when the source is equivalent to other paths via ?? chains.
+    // Type inference happens later in checkIfKnownType() based on accumulated evidence.
+    context.addType(sourcePath, 'unknown');
 
-    // The elements in the result are the same type as the source array
+    // Still track the return value type for data structure tracking
     const methodCallPathWithReturnValues = methodCallPath.withReturnValues();
-    context.addType(methodCallPathWithReturnValues, 'array');
+    context.addType(methodCallPathWithReturnValues, 'unknown');
   }
 
   isComplete(): boolean {
@@ -518,6 +624,12 @@ export class ArrayFlatMapSemantics implements MethodSemantics {
  * Array at method semantics
  *
  * at() returns the element at the given index, supporting negative indices
+ *
+ * NOTE: We intentionally do NOT type the source as 'array' here because
+ * .at() exists on both arrays AND strings. Typing the source prematurely
+ * causes type contamination when the source is equivalent to other paths
+ * via ?? chains. Type inference happens later in checkIfKnownType() based
+ * on accumulated evidence from all methods called on a path.
  */
 export class ArrayAtSemantics implements MethodSemantics {
   getReturnType(): string {
@@ -529,10 +641,12 @@ export class ArrayAtSemantics implements MethodSemantics {
     sourcePath: StructuredPath,
     context: AnalysisContext,
   ): void {
-    // Mark source as array
-    context.addType(sourcePath, 'array');
+    // NOTE: We use 'unknown' instead of 'array' for the source because .at()
+    // exists on both arrays AND strings. Using 'array' causes type contamination
+    // when the source is equivalent to other paths via ?? chains.
+    context.addType(sourcePath, 'unknown');
 
-    // The return value is equivalent to an array element
+    // The return value is equivalent to an element
     context.addEquivalence(
       methodCallPath.withReturnValues(),
       sourcePath.withElement('*'),
@@ -800,6 +914,8 @@ export function createMethodRegistry(): MethodSemanticsRegistry {
   registry.register('slice', new ArraySliceSemantics(), 'Array');
   registry.register('splice', new ArraySpliceSemantics(), 'Array');
   registry.register('push', new ArrayPushSemantics(), 'Array');
+  registry.register('some', new ArraySomeSemantics(), 'Array');
+  registry.register('every', new ArrayEverySemantics(), 'Array');
 
   // Register Object methods
   registry.register('fromEntries', new ObjectFromEntriesSemantics(), 'Object');

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

@@ -3,131 +3,10 @@ import { AnalysisContext } from '../types';
 import { PatternHandler } from './patternHandler';
 import { StructuredPath } from '../paths';
 import { processBindingPattern } from '../processBindings';
-
-/**
- * Extracts a simple path string from an expression.
- * Returns the path for identifiers and property access chains.
- */
-function getSimplePath(node: ts.Expression): string | null {
-  if (ts.isIdentifier(node)) {
-    return node.text;
-  }
-  if (ts.isPropertyAccessExpression(node)) {
-    const objectPath = getSimplePath(node.expression);
-    if (objectPath) {
-      return `${objectPath}.${node.name.text}`;
-    }
-  }
-  // Handle optional chaining: a?.b
-  if (ts.isNonNullExpression(node)) {
-    return getSimplePath(node.expression);
-  }
-  return null;
-}
-
-/** Array methods that return boolean predicates */
-const ARRAY_PREDICATE_METHODS = ['includes', 'some', 'every'] as const;
-type ArrayPredicateMethod = (typeof ARRAY_PREDICATE_METHODS)[number];
-
-/**
- * Maps array method names to derivation operation names
- */
-function getArrayPredicateOperation(
-  methodName: string,
-): 'arrayIncludes' | 'arraySome' | 'arrayEvery' | null {
-  switch (methodName) {
-    case 'includes':
-      return 'arrayIncludes';
-    case 'some':
-      return 'arraySome';
-    case 'every':
-      return 'arrayEvery';
-    default:
-      return null;
-  }
-}
-
-/**
- * Detects if an expression is an array predicate call and extracts the array path.
- * Patterns detected:
- * - arr.includes(x) → { sourcePath: 'arr', operation: 'arrayIncludes' }
- * - arr?.includes(x) → { sourcePath: 'arr', operation: 'arrayIncludes' }
- * - arr.some(fn) → { sourcePath: 'arr', operation: 'arraySome' }
- * - arr.every(fn) → { sourcePath: 'arr', operation: 'arrayEvery' }
- * - Boolean(x && arr?.includes(y)) → { sourcePath: 'arr', operation: 'arrayIncludes' }
- */
-function detectArrayPredicatePattern(expr: ts.Expression): {
-  sourcePath: string;
-  operation: 'arrayIncludes' | 'arraySome' | 'arrayEvery';
-} | null {
-  // Unwrap Boolean() calls: Boolean(x) → x
-  if (
-    ts.isCallExpression(expr) &&
-    ts.isIdentifier(expr.expression) &&
-    expr.expression.text === 'Boolean' &&
-    expr.arguments.length === 1
-  ) {
-    return detectArrayPredicatePattern(expr.arguments[0]);
-  }
-
-  // Handle logical AND: a && b - check both sides for array predicates
-  if (
-    ts.isBinaryExpression(expr) &&
-    expr.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
-  ) {
-    // Try the right side first (more likely to have the predicate)
-    const rightResult = detectArrayPredicatePattern(expr.right);
-    if (rightResult) return rightResult;
-    // Try the left side
-    const leftResult = detectArrayPredicatePattern(expr.left);
-    if (leftResult) return leftResult;
-    return null;
-  }
-
-  // Handle parenthesized expressions
-  if (ts.isParenthesizedExpression(expr)) {
-    return detectArrayPredicatePattern(expr.expression);
-  }
-
-  if (!ts.isCallExpression(expr)) {
-    return null;
-  }
-
-  const callExpr = expr.expression;
-
-  // Handle both regular property access (arr.includes) and optional chaining (arr?.includes)
-  let objectExpr: ts.Expression | null = null;
-  let methodName: string | null = null;
-
-  if (ts.isPropertyAccessExpression(callExpr)) {
-    objectExpr = callExpr.expression;
-    methodName = callExpr.name.text;
-  } else if (
-    ts.isElementAccessExpression(callExpr) &&
-    ts.isStringLiteral(callExpr.argumentExpression)
-  ) {
-    // Handle arr["includes"]() syntax (rare but possible)
-    objectExpr = callExpr.expression;
-    methodName = callExpr.argumentExpression.text;
-  }
-
-  if (!objectExpr || !methodName) {
-    return null;
-  }
-
-  const operation = getArrayPredicateOperation(methodName);
-  if (!operation) {
-    return null;
-  }
-
-  // Get the source path for the array
-  const sourcePath = getSimplePath(objectExpr);
-  if (!sourcePath) {
-    return null;
-  }
-
-  return { sourcePath, operation };
-}
+import {
+  getSimplePath,
+  detectArrayPredicatePattern,
+} from '../arrayDerivationDetector';
 
 /**
  * Detects if an expression is a boolean derivation pattern and extracts the info.
@@ -154,7 +33,8 @@ function detectDerivationPattern(expr: ts.Expression): {
     | 'and'
     | 'arrayIncludes'
     | 'arraySome'
-    | 'arrayEvery';
+    | 'arrayEvery'
+    | 'arrayLength';
   comparedValue?: string;
 } | null {
   // Check for array predicate methods first