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

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

@@ -4,6 +4,292 @@ 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 };
+}
+
+/**
+ * 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';
+  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 +298,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 +345,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)) {