@codeyam/codeyam-cli 0.1.0-staging.dd216e0 → 0.1.0-staging.e057775

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('*'),
@@ -616,6 +730,45 @@ export class ObjectFromEntriesSemantics implements MethodSemantics {
   }
 }
 
+/**
+ * String split method semantics
+ *
+ * split() returns an array of strings by splitting the source string on a delimiter.
+ * This is commonly used for URL path parsing: splat?.split('/') → segments[]
+ *
+ * Important for controllability: if the source string is controllable (e.g., from useParams()),
+ * then the resulting array elements are also controllable.
+ */
+export class StringSplitSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'string[]';
+  }
+
+  addEquivalences(
+    methodCallPath: StructuredPath,
+    sourcePath: StructuredPath,
+    context: AnalysisContext,
+  ): void {
+    // Mark source as string
+    context.addType(sourcePath, 'string');
+
+    // Mark the result as a string array
+    context.addType(methodCallPath, 'string[]');
+
+    // Establish equivalence: each element of the result derives from the source string
+    // This enables controllability tracking: if sourcePath is controllable,
+    // then methodCallPath[] elements are controllable via the same mock
+    context.addEquivalence(
+      methodCallPath.withReturnValues().withElement('*'),
+      sourcePath,
+    );
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
 /**
  * Promise.then method semantics
  *
@@ -761,10 +914,15 @@ 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');
 
+  // Register String methods
+  registry.register('split', new StringSplitSemantics(), 'String');
+
   // Register Promise methods
   registry.register('then', new PromiseThenSemantics(), 'Promise');
 

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

@@ -22,11 +22,8 @@ export class ForInStatementHandler implements PatternHandler {
     // Process the expression being iterated over first (e.g., object)
     context.processExpression(node.expression);
 
-    // Get the path of the object being iterated
-    const expressionPath = context.getStructuralPath(node.expression);
-
-    // If the initializer is a variable declaration with an identifier, establish equivalence
-    // to indicate it's iterating over the keys of the expression
+    // If the initializer is a variable declaration with an identifier,
+    // type it as 'string' since for-in keys are always strings
     if (ts.isVariableDeclarationList(node.initializer)) {
       const declarations = node.initializer.declarations;
       if (
@@ -36,25 +33,21 @@ export class ForInStatementHandler implements PatternHandler {
       ) {
         const variableName = StructuredPath.fromBase(declarations[0].name.text);
 
-        // Add type for the key variable (string for object keys)
+        // Type the key variable as 'string' — for-in keys are always strings.
+        // Note: We intentionally do NOT equivalence the key variable to
+        // expressionPath[*key*]. The key variable is the KEY (a string),
+        // while [*key*] in the schema represents the VALUE at a dynamic key.
+        // Creating that equivalence would cause the 'string' type to propagate
+        // to the value path. The value access (e.g., obj[key]) is handled
+        // correctly by the element access handler in processExpression.
         context.addType(variableName, 'string');
-
-        if (expressionPath) {
-          // For for...in loops, the variable is equivalent to the keys of the object
-          // We represent this with a *key* suffix to indicate it's a key, not a value
-          context.addEquivalence(variableName, expressionPath.withKey('key'));
-        }
       }
     } else if (ts.isIdentifier(node.initializer)) {
       // If the initializer is directly an identifier (rare but possible)
       const variableName = StructuredPath.fromBase(node.initializer.text);
 
-      // Add type for the key variable
+      // See comment above — type as string but don't equivalence to value path
       context.addType(variableName, 'string');
-
-      if (expressionPath) {
-        context.addEquivalence(variableName, expressionPath.withKey('key'));
-      }
     } else {
       context.processExpression(node.initializer);
     }

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

@@ -5,6 +5,10 @@ import {
   markConditionVariablesAsNullable,
   extractConditionalUsage,
 } from '../processExpression';
+import {
+  extractConditionalEffectsFromIfStatement,
+  findUseStateSetters,
+} from '../conditionalEffectsExtractor';
 
 /**
  * Handler for if statements
@@ -13,6 +17,7 @@ import {
  * - The condition expression
  * - The then block
  * - The else block if present
+ * - Conditional effects (setter calls inside conditionals)
  */
 export class IfStatementHandler implements PatternHandler {
   canHandle(node: ts.Node): boolean {
@@ -31,6 +36,19 @@ export class IfStatementHandler implements PatternHandler {
     // Process the condition expression first
     context.processExpression(node.expression);
 
+    // Extract conditional effects (setter calls inside this if statement)
+    const knownSetters = findUseStateSetters(context.sourceFile);
+
+    const effects = extractConditionalEffectsFromIfStatement(
+      node,
+      context,
+      knownSetters,
+    );
+
+    for (const effect of effects) {
+      context.addConditionalEffect(effect);
+    }
+
     // Process the 'then' statement block
     context.processNode(node.thenStatement);
 

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

@@ -1,7 +1,32 @@
 import ts from 'typescript';
-import { AnalysisContext } from '../types';
+import { AnalysisContext, ConditionalUsage } from '../types';
 import { PatternHandler } from './patternHandler';
 import { StructuredPath } from '../paths';
+import {
+  extractConditionalEffectsFromSwitchStatement,
+  findUseStateSetters,
+} from '../conditionalEffectsExtractor';
+
+/**
+ * Helper to extract source location from an AST node
+ */
+function getSourceLocation(
+  node: ts.Node,
+  sourceFile: ts.SourceFile,
+): ConditionalUsage['sourceLocation'] {
+  const start = node.getStart(sourceFile);
+  const { line, character } = sourceFile.getLineAndCharacterOfPosition(start);
+  const codeSnippet = node.getText(sourceFile);
+
+  return {
+    lineNumber: line + 1, // Convert to 1-based
+    column: character,
+    codeSnippet:
+      codeSnippet.length > 100
+        ? codeSnippet.slice(0, 100) + '...'
+        : codeSnippet,
+  };
+}
 
 /**
  * Handler for switch statements
@@ -48,6 +73,7 @@ export class SwitchStatementHandler implements PatternHandler {
         conditionType: 'switch',
         comparedValues: caseValues.length > 0 ? caseValues : undefined,
         location: 'switch',
+        sourceLocation: getSourceLocation(node, context.sourceFile),
       });
 
       // Update the schema type to be a union of the case values
@@ -58,6 +84,17 @@ export class SwitchStatementHandler implements PatternHandler {
       }
     }
 
+    // Extract conditional effects (setter calls inside switch cases)
+    const knownSetters = findUseStateSetters(context.sourceFile);
+    const effects = extractConditionalEffectsFromSwitchStatement(
+      node,
+      context,
+      knownSetters,
+    );
+    for (const effect of effects) {
+      context.addConditionalEffect(effect);
+    }
+
     // Process each clause in the switch statement
     for (const clause of node.caseBlock.clauses) {
       // Process the case expression if it's a case clause (not default)

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

@@ -3,6 +3,172 @@ import { AnalysisContext } from '../types';
 import { PatternHandler } from './patternHandler';
 import { StructuredPath } from '../paths';
 import { processBindingPattern } from '../processBindings';
+import {
+  getSimplePath,
+  detectArrayPredicatePattern,
+} from '../arrayDerivationDetector';
+
+/**
+ * Detects if an expression is a boolean derivation pattern and extracts the info.
+ * Patterns detected:
+ * - x !== null / x != null → { sourcePath: 'x', operation: 'notNull' }
+ * - x === null / x == null → { sourcePath: 'x', operation: 'isNull' }
+ * - x === 'value' → { sourcePath: 'x', operation: 'equals', comparedValue: 'value' }
+ * - x !== 'value' → { sourcePath: 'x', operation: 'notEquals', comparedValue: 'value' }
+ * - a || b → { operation: 'or', sourcePaths: ['a', 'b'] }
+ * - a && b → { operation: 'and', sourcePaths: ['a', 'b'] }
+ * - arr.includes(x) → { sourcePath: 'arr', operation: 'arrayIncludes' }
+ * - arr.some(fn) → { sourcePath: 'arr', operation: 'arraySome' }
+ * - arr.every(fn) → { sourcePath: 'arr', operation: 'arrayEvery' }
+ */
+function detectDerivationPattern(expr: ts.Expression): {
+  sourcePath?: string;
+  sourcePaths?: string[];
+  operation:
+    | 'notNull'
+    | 'isNull'
+    | 'equals'
+    | 'notEquals'
+    | 'or'
+    | 'and'
+    | 'arrayIncludes'
+    | 'arraySome'
+    | 'arrayEvery'
+    | 'arrayLength';
+  comparedValue?: string;
+} | null {
+  // Check for array predicate methods first
+  const arrayPredicate = detectArrayPredicatePattern(expr);
+  if (arrayPredicate) {
+    return arrayPredicate;
+  }
+  // Binary expressions: a !== null, a === 'value', a || b, a && b
+  if (ts.isBinaryExpression(expr)) {
+    const left = expr.left;
+    const right = expr.right;
+    const op = expr.operatorToken.kind;
+
+    // Check for null comparisons: x !== null, x === null
+    if (
+      op === ts.SyntaxKind.ExclamationEqualsEqualsToken ||
+      op === ts.SyntaxKind.ExclamationEqualsToken
+    ) {
+      // x !== null or x != null
+      if (
+        right.kind === ts.SyntaxKind.NullKeyword ||
+        (ts.isIdentifier(right) && right.text === 'undefined')
+      ) {
+        const sourcePath = getSimplePath(left);
+        if (sourcePath) {
+          return { sourcePath, operation: 'notNull' };
+        }
+      }
+      // null !== x or null != x
+      if (
+        left.kind === ts.SyntaxKind.NullKeyword ||
+        (ts.isIdentifier(left) && left.text === 'undefined')
+      ) {
+        const sourcePath = getSimplePath(right);
+        if (sourcePath) {
+          return { sourcePath, operation: 'notNull' };
+        }
+      }
+      // x !== 'value'
+      if (ts.isStringLiteral(right)) {
+        const sourcePath = getSimplePath(left);
+        if (sourcePath) {
+          return {
+            sourcePath,
+            operation: 'notEquals',
+            comparedValue: right.text,
+          };
+        }
+      }
+    }
+
+    if (
+      op === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+      op === ts.SyntaxKind.EqualsEqualsToken
+    ) {
+      // x === null or x == null
+      if (
+        right.kind === ts.SyntaxKind.NullKeyword ||
+        (ts.isIdentifier(right) && right.text === 'undefined')
+      ) {
+        const sourcePath = getSimplePath(left);
+        if (sourcePath) {
+          return { sourcePath, operation: 'isNull' };
+        }
+      }
+      // null === x or null == x
+      if (
+        left.kind === ts.SyntaxKind.NullKeyword ||
+        (ts.isIdentifier(left) && left.text === 'undefined')
+      ) {
+        const sourcePath = getSimplePath(right);
+        if (sourcePath) {
+          return { sourcePath, operation: 'isNull' };
+        }
+      }
+      // x === 'value'
+      if (ts.isStringLiteral(right)) {
+        const sourcePath = getSimplePath(left);
+        if (sourcePath) {
+          return { sourcePath, operation: 'equals', comparedValue: right.text };
+        }
+      }
+    }
+
+    // a || b
+    if (op === ts.SyntaxKind.BarBarToken) {
+      const leftPath = getSimplePath(left);
+      const rightPath = getSimplePath(right);
+      if (leftPath && rightPath) {
+        return { operation: 'or', sourcePaths: [leftPath, rightPath] };
+      }
+      // Handle chained OR: (a || b) || c
+      const leftDerivation = detectDerivationPattern(left);
+      if (
+        leftDerivation?.operation === 'or' &&
+        leftDerivation.sourcePaths &&
+        rightPath
+      ) {
+        return {
+          operation: 'or',
+          sourcePaths: [...leftDerivation.sourcePaths, rightPath],
+        };
+      }
+    }
+
+    // a && b
+    if (op === ts.SyntaxKind.AmpersandAmpersandToken) {
+      const leftPath = getSimplePath(left);
+      const rightPath = getSimplePath(right);
+      if (leftPath && rightPath) {
+        return { operation: 'and', sourcePaths: [leftPath, rightPath] };
+      }
+      // Handle chained AND: (a && b) && c
+      const leftDerivation = detectDerivationPattern(left);
+      if (
+        leftDerivation?.operation === 'and' &&
+        leftDerivation.sourcePaths &&
+        rightPath
+      ) {
+        return {
+          operation: 'and',
+          sourcePaths: [...leftDerivation.sourcePaths, rightPath],
+        };
+      }
+    }
+  }
+
+  // Parenthesized expressions: unwrap and recurse
+  if (ts.isParenthesizedExpression(expr)) {
+    return detectDerivationPattern(expr.expression);
+  }
+
+  return null;
+}
 
 /**
  * Handler for variable declarations
@@ -12,6 +178,11 @@ import { processBindingPattern } from '../processBindings';
  * - const x = obj.prop;
  * - const { a, b } = obj;
  * - const [a, b] = arr;
+ *
+ * Also detects derived boolean variables like:
+ * - const hasAnalysis = analysis !== null
+ * - const isLoading = status === 'loading'
+ * - const isBusy = isRunning || isQueued
  */
 export class VariableDeclarationHandler implements PatternHandler {
   canHandle(node: ts.Node): boolean {
@@ -54,8 +225,17 @@ export class VariableDeclarationHandler implements PatternHandler {
     }
     // Regular variable declaration with a single identifier
     else if (ts.isIdentifier(declaration.name)) {
+      const variableName = declaration.name.text;
+
       // Create structured path for the variable
-      const variablePath = StructuredPath.fromBase(declaration.name.text);
+      const variablePath = StructuredPath.fromBase(variableName);
+
+      // Check if this is a derived boolean variable (e.g., const hasX = x !== null)
+      // Record the derivation info so we can trace back when this variable is used in conditionals
+      const derivationInfo = detectDerivationPattern(declaration.initializer);
+      if (derivationInfo) {
+        context.addDerivedVariable(variableName, derivationInfo);
+      }
 
       // Capture equivalencies to child boundaries as they will otherwise be skipped
       if (context.isChildBoundary(declaration.initializer)) {