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

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

@@ -0,0 +1,644 @@
+import ts from 'typescript';
+import { AnalysisContext, ConditionalEffect } from './types';
+
+/**
+ * Represents a condition extracted from an if statement
+ */
+interface ExtractedCondition {
+  path: string;
+  conditionType: 'truthiness' | 'comparison' | 'switch';
+  comparedValues?: string[];
+  requiredValue: string | boolean;
+}
+
+/**
+ * Extract conditions from a binary expression (handles && chains)
+ */
+function extractConditionsFromExpression(
+  expression: ts.Expression,
+  context: AnalysisContext,
+  isNegated = false,
+): ExtractedCondition[] {
+  const conditions: ExtractedCondition[] = [];
+
+  // Handle && chains
+  if (
+    ts.isBinaryExpression(expression) &&
+    expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
+  ) {
+    conditions.push(
+      ...extractConditionsFromExpression(expression.left, context, isNegated),
+    );
+    conditions.push(
+      ...extractConditionsFromExpression(expression.right, context, isNegated),
+    );
+    return conditions;
+  }
+
+  // Handle negation (!foo)
+  if (
+    ts.isPrefixUnaryExpression(expression) &&
+    expression.operator === ts.SyntaxKind.ExclamationToken
+  ) {
+    return extractConditionsFromExpression(
+      expression.operand,
+      context,
+      !isNegated,
+    );
+  }
+
+  // Handle comparison (===, !==, >, <, etc.)
+  if (ts.isBinaryExpression(expression)) {
+    const operator = expression.operatorToken.kind;
+    if (
+      operator === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+      operator === ts.SyntaxKind.EqualsEqualsToken ||
+      operator === ts.SyntaxKind.ExclamationEqualsEqualsToken ||
+      operator === ts.SyntaxKind.ExclamationEqualsToken ||
+      operator === ts.SyntaxKind.GreaterThanToken ||
+      operator === ts.SyntaxKind.LessThanToken ||
+      operator === ts.SyntaxKind.GreaterThanEqualsToken ||
+      operator === ts.SyntaxKind.LessThanEqualsToken
+    ) {
+      const { path, literalValue } = extractPathAndLiteral(expression, context);
+      if (path) {
+        const isEquality =
+          operator === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+          operator === ts.SyntaxKind.EqualsEqualsToken;
+        const isInequality =
+          operator === ts.SyntaxKind.ExclamationEqualsEqualsToken ||
+          operator === ts.SyntaxKind.ExclamationEqualsToken;
+
+        let requiredValue: string | boolean;
+        if (literalValue !== undefined) {
+          if (isEquality) {
+            requiredValue = isNegated ? false : literalValue;
+          } else if (isInequality) {
+            requiredValue = isNegated ? literalValue : false;
+          } else {
+            // For >, <, >=, <= we need the literal for context
+            requiredValue = isNegated ? false : true;
+          }
+        } else {
+          requiredValue = isNegated ? false : true;
+        }
+
+        conditions.push({
+          path,
+          conditionType: 'comparison',
+          comparedValues: literalValue !== undefined ? [literalValue] : [],
+          requiredValue,
+        });
+      }
+      return conditions;
+    }
+  }
+
+  // Handle optional chaining (foo?.bar)
+  if (
+    ts.isPropertyAccessExpression(expression) ||
+    ts.isIdentifier(expression)
+  ) {
+    const path = getExpressionPath(expression, context);
+    if (path) {
+      conditions.push({
+        path,
+        conditionType: 'truthiness',
+        requiredValue: isNegated ? false : true,
+      });
+    }
+    return conditions;
+  }
+
+  // Handle call expressions used as conditions (e.g., Array.isArray(x))
+  if (ts.isCallExpression(expression)) {
+    const path = getExpressionPath(expression.expression, context);
+    if (path) {
+      conditions.push({
+        path: path + '()',
+        conditionType: 'truthiness',
+        requiredValue: isNegated ? false : true,
+      });
+    }
+    return conditions;
+  }
+
+  return conditions;
+}
+
+/**
+ * Extract path and literal value from a binary comparison
+ */
+function extractPathAndLiteral(
+  expression: ts.BinaryExpression,
+  context: AnalysisContext,
+): { path: string | null; literalValue: string | undefined } {
+  let path: string | null = null;
+  let literalValue: string | undefined;
+
+  // Check which side is the variable and which is the literal
+  if (isLiteralExpression(expression.right)) {
+    path = getExpressionPath(expression.left, context);
+    literalValue = getLiteralValue(expression.right);
+  } else if (isLiteralExpression(expression.left)) {
+    path = getExpressionPath(expression.right, context);
+    literalValue = getLiteralValue(expression.left);
+  } else {
+    // Both sides are expressions, use the left side as the path
+    path = getExpressionPath(expression.left, context);
+  }
+
+  return { path, literalValue };
+}
+
+/**
+ * Check if an expression is a literal
+ */
+function isLiteralExpression(expression: ts.Expression): boolean {
+  return (
+    ts.isStringLiteral(expression) ||
+    ts.isNumericLiteral(expression) ||
+    expression.kind === ts.SyntaxKind.TrueKeyword ||
+    expression.kind === ts.SyntaxKind.FalseKeyword ||
+    expression.kind === ts.SyntaxKind.NullKeyword ||
+    expression.kind === ts.SyntaxKind.UndefinedKeyword
+  );
+}
+
+/**
+ * Get the string value of a literal expression
+ */
+function getLiteralValue(expression: ts.Expression): string {
+  if (ts.isStringLiteral(expression)) {
+    return expression.text;
+  }
+  if (ts.isNumericLiteral(expression)) {
+    return expression.text;
+  }
+  if (expression.kind === ts.SyntaxKind.TrueKeyword) {
+    return 'true';
+  }
+  if (expression.kind === ts.SyntaxKind.FalseKeyword) {
+    return 'false';
+  }
+  if (expression.kind === ts.SyntaxKind.NullKeyword) {
+    return 'null';
+  }
+  if (expression.kind === ts.SyntaxKind.UndefinedKeyword) {
+    return 'undefined';
+  }
+  return expression.getText();
+}
+
+/**
+ * Get the path string for an expression
+ */
+function getExpressionPath(
+  expression: ts.Expression,
+  context: AnalysisContext,
+): string | null {
+  if (ts.isIdentifier(expression)) {
+    return expression.text;
+  }
+
+  if (ts.isPropertyAccessExpression(expression)) {
+    const objectPath = getExpressionPath(expression.expression, context);
+    if (objectPath) {
+      // Handle optional chaining - remove the ? for the path
+      return `${objectPath}.${expression.name.text}`;
+    }
+  }
+
+  if (ts.isElementAccessExpression(expression)) {
+    const objectPath = getExpressionPath(expression.expression, context);
+    if (objectPath && expression.argumentExpression) {
+      if (ts.isStringLiteral(expression.argumentExpression)) {
+        return `${objectPath}.${expression.argumentExpression.text}`;
+      }
+      if (ts.isNumericLiteral(expression.argumentExpression)) {
+        return `${objectPath}[${expression.argumentExpression.text}]`;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Information about a setter call found in a block
+ */
+interface SetterCallInfo {
+  setterName: string;
+  stateVariable: string;
+  value: string;
+  valueType: 'string' | 'number' | 'boolean' | 'null' | 'dynamic';
+  node: ts.CallExpression;
+}
+
+/**
+ * Extract all setter calls from a statement/block
+ */
+function extractSetterCalls(
+  node: ts.Node,
+  context: AnalysisContext,
+  knownSetters: Map<string, string>, // setterName -> stateVariable
+): SetterCallInfo[] {
+  const setterCalls: SetterCallInfo[] = [];
+
+  function visit(node: ts.Node) {
+    if (ts.isCallExpression(node)) {
+      const callee = node.expression;
+      if (ts.isIdentifier(callee)) {
+        const setterName = callee.text;
+        const stateVariable = knownSetters.get(setterName);
+
+        if (stateVariable && node.arguments.length > 0) {
+          const arg = node.arguments[0];
+          const { value, valueType } = getArgumentValueInfo(arg);
+
+          setterCalls.push({
+            setterName,
+            stateVariable,
+            value,
+            valueType,
+            node,
+          });
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  visit(node);
+  return setterCalls;
+}
+
+/**
+ * Get value information from a function argument
+ */
+function getArgumentValueInfo(arg: ts.Expression): {
+  value: string;
+  valueType: 'string' | 'number' | 'boolean' | 'null' | 'dynamic';
+} {
+  if (ts.isStringLiteral(arg)) {
+    return { value: arg.text, valueType: 'string' };
+  }
+  if (ts.isNumericLiteral(arg)) {
+    return { value: arg.text, valueType: 'number' };
+  }
+  if (arg.kind === ts.SyntaxKind.TrueKeyword) {
+    return { value: 'true', valueType: 'boolean' };
+  }
+  if (arg.kind === ts.SyntaxKind.FalseKeyword) {
+    return { value: 'false', valueType: 'boolean' };
+  }
+  if (arg.kind === ts.SyntaxKind.NullKeyword) {
+    return { value: 'null', valueType: 'null' };
+  }
+
+  // For any other expression, it's dynamic
+  return { value: arg.getText(), valueType: 'dynamic' };
+}
+
+/**
+ * Find all useState declarations and build a map of setter names to state variable names
+ */
+export function findUseStateSetters(
+  sourceFile: ts.SourceFile,
+): Map<string, string> {
+  const setters = new Map<string, string>();
+
+  function visit(node: ts.Node) {
+    // Look for: const [stateVar, setStateVar] = useState(...)
+    if (ts.isVariableDeclaration(node)) {
+      if (
+        node.name &&
+        ts.isArrayBindingPattern(node.name) &&
+        node.initializer &&
+        ts.isCallExpression(node.initializer)
+      ) {
+        const callExpr = node.initializer;
+        // Check if it's a useState call
+        if (ts.isIdentifier(callExpr.expression)) {
+          const funcName = callExpr.expression.text;
+          if (funcName === 'useState') {
+            const elements = node.name.elements;
+            if (elements.length >= 2) {
+              const stateElement = elements[0];
+              const setterElement = elements[1];
+
+              if (
+                ts.isBindingElement(stateElement) &&
+                ts.isIdentifier(stateElement.name) &&
+                ts.isBindingElement(setterElement) &&
+                ts.isIdentifier(setterElement.name)
+              ) {
+                const stateVar = stateElement.name.text;
+                const setterName = setterElement.name.text;
+                setters.set(setterName, stateVar);
+              }
+            }
+          }
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sourceFile);
+  return setters;
+}
+
+/**
+ * Extract conditional effects from an if statement
+ */
+export function extractConditionalEffectsFromIfStatement(
+  ifStatement: ts.IfStatement,
+  context: AnalysisContext,
+  knownSetters: Map<string, string>,
+  parentConditions: ExtractedCondition[] = [],
+): ConditionalEffect[] {
+  const effects: ConditionalEffect[] = [];
+
+  // Extract conditions from the if expression
+  const conditions = extractConditionsFromExpression(
+    ifStatement.expression,
+    context,
+  );
+
+  // Combine with parent conditions (for nested ifs)
+  const allConditions = [...parentConditions, ...conditions];
+
+  // Find setter calls in the then block
+  const thenSetters = extractSetterCalls(
+    ifStatement.thenStatement,
+    context,
+    knownSetters,
+  );
+
+  for (const setter of thenSetters) {
+    const effect = createConditionalEffect(
+      allConditions,
+      setter,
+      ifStatement,
+      context,
+    );
+    effects.push(effect);
+  }
+
+  // Find setter calls in the else block (with negated condition)
+  if (ifStatement.elseStatement) {
+    // For else branch, the original conditions should have requiredValue negated
+    const negatedConditions = conditions.map((c) => ({
+      ...c,
+      requiredValue:
+        typeof c.requiredValue === 'boolean' ? !c.requiredValue : false,
+    }));
+    const elseConditions = [...parentConditions, ...negatedConditions];
+
+    // Handle else-if chains
+    if (ts.isIfStatement(ifStatement.elseStatement)) {
+      effects.push(
+        ...extractConditionalEffectsFromIfStatement(
+          ifStatement.elseStatement,
+          context,
+          knownSetters,
+          parentConditions, // Pass parent conditions, not elseConditions
+        ),
+      );
+    } else {
+      const elseSetters = extractSetterCalls(
+        ifStatement.elseStatement,
+        context,
+        knownSetters,
+      );
+
+      for (const setter of elseSetters) {
+        const effect = createConditionalEffect(
+          elseConditions,
+          setter,
+          ifStatement,
+          context,
+        );
+        effects.push(effect);
+      }
+    }
+  }
+
+  // Handle nested if statements in the then block
+  findNestedIfStatements(ifStatement.thenStatement).forEach((nestedIf) => {
+    effects.push(
+      ...extractConditionalEffectsFromIfStatement(
+        nestedIf,
+        context,
+        knownSetters,
+        allConditions,
+      ),
+    );
+  });
+
+  return effects;
+}
+
+/**
+ * Find nested if statements (direct children only, not inside callbacks)
+ */
+function findNestedIfStatements(node: ts.Node): ts.IfStatement[] {
+  const nested: ts.IfStatement[] = [];
+
+  function visit(node: ts.Node) {
+    // Skip function expressions and arrow functions (different scope)
+    if (
+      ts.isFunctionExpression(node) ||
+      ts.isArrowFunction(node) ||
+      ts.isFunctionDeclaration(node)
+    ) {
+      return;
+    }
+
+    if (ts.isIfStatement(node)) {
+      nested.push(node);
+      return; // Don't recurse into nested if, it will be handled separately
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  // Start visiting children of the node (not the node itself)
+  ts.forEachChild(node, visit);
+  return nested;
+}
+
+/**
+ * Create a ConditionalEffect from extracted data
+ */
+function createConditionalEffect(
+  conditions: ExtractedCondition[],
+  setter: SetterCallInfo,
+  ifStatement: ts.IfStatement,
+  context: AnalysisContext,
+): ConditionalEffect {
+  const sourceLocation = getSourceLocation(ifStatement, context);
+
+  if (conditions.length === 1) {
+    return {
+      condition: {
+        path: conditions[0].path,
+        conditionType: conditions[0].conditionType,
+        comparedValues: conditions[0].comparedValues,
+        requiredValue: conditions[0].requiredValue,
+      },
+      effect: {
+        type: 'setter',
+        stateVariable: setter.stateVariable,
+        setterName: setter.setterName,
+        value: setter.value,
+        valueType: setter.valueType,
+      },
+      sourceLocation,
+    };
+  }
+
+  return {
+    conditions: conditions.map((c) => ({
+      path: c.path,
+      conditionType: c.conditionType,
+      comparedValues: c.comparedValues,
+      requiredValue: c.requiredValue,
+    })),
+    effect: {
+      type: 'setter',
+      stateVariable: setter.stateVariable,
+      setterName: setter.setterName,
+      value: setter.value,
+      valueType: setter.valueType,
+    },
+    sourceLocation,
+  };
+}
+
+/**
+ * Get source location for a node
+ */
+function getSourceLocation(
+  node: ts.Node,
+  context: AnalysisContext,
+): { lineNumber: number; column: number; codeSnippet: string } {
+  const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
+    node.getStart(),
+  );
+
+  return {
+    lineNumber: line + 1,
+    column: character,
+    codeSnippet: node.getText(context.sourceFile).slice(0, 100),
+  };
+}
+
+/**
+ * Extract conditional effects from a switch statement
+ */
+export function extractConditionalEffectsFromSwitchStatement(
+  switchStatement: ts.SwitchStatement,
+  context: AnalysisContext,
+  knownSetters: Map<string, string>,
+): ConditionalEffect[] {
+  const effects: ConditionalEffect[] = [];
+  const discriminantPath = getExpressionPath(
+    switchStatement.expression,
+    context,
+  );
+
+  if (!discriminantPath) return effects;
+
+  for (const clause of switchStatement.caseBlock.clauses) {
+    if (ts.isCaseClause(clause) && clause.expression) {
+      const caseValue = getLiteralValue(clause.expression);
+
+      const setters = extractSetterCalls(clause, context, knownSetters);
+
+      for (const setter of setters) {
+        effects.push({
+          condition: {
+            path: discriminantPath,
+            conditionType: 'comparison',
+            comparedValues: [caseValue],
+            requiredValue: caseValue,
+          },
+          effect: {
+            type: 'setter',
+            stateVariable: setter.stateVariable,
+            setterName: setter.setterName,
+            value: setter.value,
+            valueType: setter.valueType,
+          },
+          sourceLocation: getSourceLocation(clause, context),
+        });
+      }
+    }
+  }
+
+  return effects;
+}
+
+/**
+ * Extract conditional effects from a ternary expression
+ */
+export function extractConditionalEffectsFromTernary(
+  conditional: ts.ConditionalExpression,
+  context: AnalysisContext,
+  knownSetters: Map<string, string>,
+): ConditionalEffect[] {
+  const effects: ConditionalEffect[] = [];
+
+  const conditions = extractConditionsFromExpression(
+    conditional.condition,
+    context,
+  );
+
+  if (conditions.length === 0) return effects;
+
+  // Check the whenTrue branch
+  const trueSetters = extractSetterCalls(
+    conditional.whenTrue,
+    context,
+    knownSetters,
+  );
+  for (const setter of trueSetters) {
+    effects.push(
+      createConditionalEffect(
+        conditions,
+        setter,
+        conditional as unknown as ts.IfStatement, // Type hack for source location
+        context,
+      ),
+    );
+  }
+
+  // Check the whenFalse branch with negated conditions
+  const negatedConditions = conditions.map((c) => ({
+    ...c,
+    requiredValue:
+      typeof c.requiredValue === 'boolean' ? !c.requiredValue : false,
+  }));
+
+  const falseSetters = extractSetterCalls(
+    conditional.whenFalse,
+    context,
+    knownSetters,
+  );
+  for (const setter of falseSetters) {
+    effects.push(
+      createConditionalEffect(
+        negatedConditions,
+        setter,
+        conditional as unknown as ts.IfStatement,
+        context,
+      ),
+    );
+  }
+
+  return effects;
+}