@codeyam/codeyam-cli 0.1.0-staging.596f0eb → 0.1.0-staging.76566f9

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

@@ -1,5 +1,10 @@
 import ts from 'typescript';
-import { AnalysisContext, ConditionalUsage } from './types';
+import * as crypto from 'crypto';
+import {
+  AnalysisContext,
+  CompoundConditional,
+  ConditionalUsage,
+} from './types';
 import { StructuredPath } from './paths';
 import { nodeToSource } from './nodeToSource';
 import { methodRegistry, ArrayPushSemantics } from './methodSemantics';
@@ -15,6 +20,82 @@ import {
 } from './sharedPatterns';
 import { processBindingPattern } from './processBindings';
 
+/**
+ * Converts a call expression argument to a StructuredPath.
+ *
+ * IMPORTANT: We always use the original source text for callbacks, never cyScope names.
+ * cyScope names are internal identifiers for child scopes and should NEVER appear
+ * in schema paths or call signatures. Using cyScope names causes data merge conflicts
+ * because the same callback gets different identifiers in different contexts.
+ */
+function getArgPathForCallSignature(
+  arg: ts.Expression,
+  context: AnalysisContext,
+): StructuredPath {
+  // Always use the standard path conversion - never replace with cyScope names
+  return (
+    StructuredPath.fromNode(arg, context.sourceFile) ||
+    nodeToSource(arg, context.sourceFile)
+  );
+}
+
+/**
+ * Builds a StructuredPath for a call expression using the original source text.
+ *
+ * IMPORTANT: This function ensures consistent call signatures by always using
+ * the original callback text, never cyScope names. This prevents schema path
+ * conflicts where the same call would have different paths.
+ */
+function buildCallPathFromSource(
+  node: ts.CallExpression,
+  context: AnalysisContext,
+): StructuredPath | null {
+  const expression = node.expression;
+
+  // Convert arguments using original source text
+  const argPaths = node.arguments.map((arg) =>
+    getArgPathForCallSignature(arg, context),
+  );
+
+  // Handle type arguments if present
+  let typeArgs: string[] | undefined = undefined;
+  if (node.typeArguments && node.typeArguments.length > 0) {
+    typeArgs = node.typeArguments.map((typeArg) =>
+      typeArg.getText(context.sourceFile),
+    );
+  }
+
+  if (ts.isIdentifier(expression)) {
+    // Simple function call: func(arg1, arg2)
+    return StructuredPath.fromFunction(expression.text, argPaths, typeArgs);
+  } else if (ts.isPropertyAccessExpression(expression)) {
+    // Method call: obj.method(arg1, arg2)
+    const objPath = StructuredPath.fromNode(
+      expression.expression,
+      context.sourceFile,
+    );
+    if (!objPath) return null;
+    return objPath
+      .withProperty(expression.name.text)
+      .withFunctionCall(argPaths, typeArgs);
+  } else if (ts.isCallExpression(expression)) {
+    // Chained call: func(arg1)(arg2)
+    const funcPath = buildCallPathFromSource(expression, context);
+    if (!funcPath) return null;
+    return funcPath.withFunctionCall(argPaths, typeArgs);
+  } else if (ts.isElementAccessExpression(expression)) {
+    // Element access call: obj[key](args)
+    const basePath = StructuredPath.fromNode(expression, context.sourceFile);
+    if (!basePath) return null;
+    return basePath.withFunctionCall(argPaths, typeArgs);
+  } else {
+    // Complex call expression
+    const basePath = StructuredPath.fromNode(expression, context.sourceFile);
+    if (!basePath) return null;
+    return basePath.withFunctionCall(argPaths, typeArgs);
+  }
+}
+
 /**
  * Checks if an expression is likely an array type.
  * Uses TypeScript's type checker when available, falls back to heuristics.
@@ -113,9 +194,69 @@ export function markConditionVariablesAsNullable(
   }
 }
 
+/**
+ * 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,
+  };
+}
+
+/**
+ * Counts the number of conditions in an && chain (excluding JSX consequence)
+ */
+function countConditionsInAndChain(expr: ts.Expression): number {
+  const unwrapped = unwrapExpression(expr);
+
+  if (
+    ts.isBinaryExpression(unwrapped) &&
+    unwrapped.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
+  ) {
+    const leftCount = countConditionsInAndChain(unwrapped.left);
+    const rightUnwrapped = unwrapExpression(unwrapped.right);
+    const isJsxConsequence =
+      ts.isJsxElement(rightUnwrapped) ||
+      ts.isJsxSelfClosingElement(rightUnwrapped) ||
+      ts.isJsxFragment(rightUnwrapped);
+
+    if (isJsxConsequence) {
+      return leftCount;
+    }
+    return leftCount + countConditionsInAndChain(unwrapped.right);
+  }
+
+  // Single condition (not an && chain)
+  return 1;
+}
+
+/**
+ * Chain tracking info for compound conditionals
+ */
+interface ChainInfo {
+  chainId: string;
+  chainLength: number;
+  chainExpression: string;
+  currentPosition: number;
+  compound: CompoundConditional;
+}
+
 /**
  * Extracts conditional usages from a condition expression for key attribute detection.
  * This function identifies which attributes are used in conditionals and how they're used.
+ * It also tracks compound conditionals (&&-chains) where all conditions must be true together.
  *
  * @param condition The condition expression to analyze
  * @param context The analysis context
@@ -126,119 +267,236 @@ export function extractConditionalUsage(
   context: AnalysisContext,
   location: ConditionalUsage['location'],
 ): void {
-  const unwrapped = unwrapExpression(condition);
+  // Internal recursive function with chain tracking
+  function extractWithChainTracking(
+    expr: ts.Expression,
+    chainInfo: ChainInfo | null,
+    isNegated: boolean,
+  ): void {
+    const unwrapped = unwrapExpression(expr);
+
+    // Handle binary expressions with && (logical AND chains)
+    // Example: `a && b && <Component />` - both a and b are conditional checks
+    if (
+      ts.isBinaryExpression(unwrapped) &&
+      unwrapped.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
+    ) {
+      // Track if we're creating the chain at this level (root of the chain)
+      const isChainRoot = !chainInfo;
+
+      // If no chainInfo, this is the root of a new chain
+      if (isChainRoot) {
+        const chainLength = countConditionsInAndChain(unwrapped);
+        // Only create chain tracking for chains with 2+ conditions
+        if (chainLength >= 2) {
+          const chainId = `chain_${crypto.randomUUID().slice(0, 8)}`;
+          const chainExpression = unwrapped.getText(context.sourceFile);
+          const compound: CompoundConditional = {
+            chainId,
+            expression:
+              chainExpression.length > 200
+                ? chainExpression.slice(0, 200) + '...'
+                : chainExpression,
+            conditions: [],
+            location,
+            sourceLocation: getSourceLocation(unwrapped, context.sourceFile),
+          };
+          chainInfo = {
+            chainId,
+            chainLength,
+            chainExpression: compound.expression,
+            currentPosition: 0,
+            compound,
+          };
+        }
+      }
 
-  // Handle binary expressions with && (logical AND chains)
-  // Example: `a && b && <Component />` - both a and b are conditional checks
-  if (
-    ts.isBinaryExpression(unwrapped) &&
-    unwrapped.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
-  ) {
-    // Recursively process left side
-    extractConditionalUsage(unwrapped.left, context, location);
+      // Recursively process left side
+      extractWithChainTracking(unwrapped.left, chainInfo, false);
 
-    // Process right side if it's not JSX (JSX is the consequence, not the condition)
-    const rightUnwrapped = unwrapExpression(unwrapped.right);
-    const isJsxConsequence =
-      ts.isJsxElement(rightUnwrapped) ||
-      ts.isJsxSelfClosingElement(rightUnwrapped) ||
-      ts.isJsxFragment(rightUnwrapped);
+      // Process right side if it's not JSX (JSX is the consequence, not the condition)
+      const rightUnwrapped = unwrapExpression(unwrapped.right);
+      const isJsxConsequence =
+        ts.isJsxElement(rightUnwrapped) ||
+        ts.isJsxSelfClosingElement(rightUnwrapped) ||
+        ts.isJsxFragment(rightUnwrapped);
 
-    if (!isJsxConsequence) {
-      extractConditionalUsage(unwrapped.right, context, location);
+      if (!isJsxConsequence) {
+        extractWithChainTracking(unwrapped.right, chainInfo, false);
+      }
+
+      // If this is the root of the chain, register the compound conditional
+      if (isChainRoot && chainInfo) {
+        context.addCompoundConditional(chainInfo.compound);
+      }
+      return;
     }
-    return;
-  }
 
-  // Handle binary expressions with || (logical OR)
-  if (
-    ts.isBinaryExpression(unwrapped) &&
-    unwrapped.operatorToken.kind === ts.SyntaxKind.BarBarToken
-  ) {
-    // Both sides of || are conditional checks
-    extractConditionalUsage(unwrapped.left, context, location);
-    extractConditionalUsage(unwrapped.right, context, location);
-    return;
-  }
+    // Handle binary expressions with || (logical OR)
+    // OR breaks the chain - each side is independent
+    if (
+      ts.isBinaryExpression(unwrapped) &&
+      unwrapped.operatorToken.kind === ts.SyntaxKind.BarBarToken
+    ) {
+      // Both sides of || are independent conditional checks (no chain tracking)
+      extractWithChainTracking(unwrapped.left, null, false);
+      extractWithChainTracking(unwrapped.right, null, false);
+      return;
+    }
 
-  // Handle comparison operators (===, !==, <, >, <=, >=)
-  // Example: `if (status === 'active')` - status is compared against 'active'
-  if (
-    ts.isBinaryExpression(unwrapped) &&
-    isComparisonOperator(unwrapped.operatorToken.kind)
-  ) {
-    // Try to extract the variable and the compared value
-    const leftPath = StructuredPath.fromNode(
-      unwrapped.left,
-      context.sourceFile,
-    );
-    const rightPath = StructuredPath.fromNode(
-      unwrapped.right,
-      context.sourceFile,
-    );
+    // Handle comparison operators (===, !==, <, >, <=, >=)
+    // Example: `if (status === 'active')` - status is compared against 'active'
+    if (
+      ts.isBinaryExpression(unwrapped) &&
+      isComparisonOperator(unwrapped.operatorToken.kind)
+    ) {
+      // Try to extract the variable and the compared value
+      const leftPath = StructuredPath.fromNode(
+        unwrapped.left,
+        context.sourceFile,
+      );
+      const rightPath = StructuredPath.fromNode(
+        unwrapped.right,
+        context.sourceFile,
+      );
 
-    // Check if left is a variable and right is a literal
-    if (leftPath && isLiteralExpression(unwrapped.right)) {
-      const literalValue = getLiteralValue(unwrapped.right, context);
-      context.addConditionalUsage({
-        path: leftPath.toLeftHandSideString(),
-        conditionType: 'comparison',
-        comparedValues: literalValue !== undefined ? [literalValue] : undefined,
-        location,
-      });
+      // Determine the compared value for computing requiredValue
+      const getRequiredValue = (
+        literalValue: string | undefined,
+        isNegatedComparison: boolean,
+      ): string | boolean | undefined => {
+        if (literalValue === undefined) return undefined;
+        // For !== comparisons, the condition is true when NOT equal to the value
+        // For === comparisons, the condition is true when equal to the value
+        const isNotEqual =
+          unwrapped.operatorToken.kind ===
+            ts.SyntaxKind.ExclamationEqualsEqualsToken ||
+          unwrapped.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken;
+        if (isNotEqual) {
+          // !== 'value' means requiredValue is NOT 'value', but we express this as "not 'value'"
+          return `not ${literalValue}`;
+        }
+        return literalValue;
+      };
+
+      // Helper to add a condition
+      const addCondition = (
+        path: string,
+        conditionType: 'comparison' | 'truthiness',
+        comparedValues?: string[],
+        requiredValue?: string | boolean,
+      ) => {
+        const usage: ConditionalUsage = {
+          path,
+          conditionType,
+          comparedValues,
+          location,
+          sourceLocation: getSourceLocation(unwrapped, context.sourceFile),
+          isNegated,
+        };
+
+        // Add chain info if part of a compound conditional
+        if (chainInfo) {
+          usage.chainId = chainInfo.chainId;
+          usage.chainPosition = chainInfo.currentPosition;
+          usage.chainLength = chainInfo.chainLength;
+          usage.chainExpression = chainInfo.chainExpression;
+          chainInfo.currentPosition++;
+
+          // Add to compound conditional conditions
+          chainInfo.compound.conditions.push({
+            path,
+            conditionType,
+            comparedValues,
+            isNegated,
+            requiredValue,
+          });
+        }
+
+        context.addConditionalUsage(usage);
+      };
+
+      // Check if left is a variable and right is a literal
+      if (leftPath && isLiteralExpression(unwrapped.right)) {
+        const literalValue = getLiteralValue(unwrapped.right, context);
+        addCondition(
+          leftPath.toLeftHandSideString(),
+          'comparison',
+          literalValue !== undefined ? [literalValue] : undefined,
+          getRequiredValue(literalValue, isNegated),
+        );
+        return;
+      }
+
+      // Check if right is a variable and left is a literal
+      if (rightPath && isLiteralExpression(unwrapped.left)) {
+        const literalValue = getLiteralValue(unwrapped.left, context);
+        addCondition(
+          rightPath.toLeftHandSideString(),
+          'comparison',
+          literalValue !== undefined ? [literalValue] : undefined,
+          getRequiredValue(literalValue, isNegated),
+        );
+        return;
+      }
+
+      // Both sides are variables - record both as comparisons without specific values
+      if (leftPath) {
+        addCondition(leftPath.toLeftHandSideString(), 'comparison');
+      }
+      if (rightPath) {
+        addCondition(rightPath.toLeftHandSideString(), 'comparison');
+      }
       return;
     }
 
-    // Check if right is a variable and left is a literal
-    if (rightPath && isLiteralExpression(unwrapped.left)) {
-      const literalValue = getLiteralValue(unwrapped.left, context);
-      context.addConditionalUsage({
-        path: rightPath.toLeftHandSideString(),
-        conditionType: 'comparison',
-        comparedValues: literalValue !== undefined ? [literalValue] : undefined,
-        location,
-      });
+    // Handle prefix unary NOT expression: !variable
+    // Example: `if (!isVisible)` - isVisible is a truthiness check (negated)
+    if (
+      ts.isPrefixUnaryExpression(unwrapped) &&
+      unwrapped.operator === ts.SyntaxKind.ExclamationToken
+    ) {
+      extractWithChainTracking(unwrapped.operand, chainInfo, !isNegated);
       return;
     }
 
-    // Both sides are variables - record both as comparisons without specific values
-    if (leftPath) {
-      context.addConditionalUsage({
-        path: leftPath.toLeftHandSideString(),
-        conditionType: 'comparison',
-        location,
-      });
-    }
-    if (rightPath) {
-      context.addConditionalUsage({
-        path: rightPath.toLeftHandSideString(),
-        conditionType: 'comparison',
+    // Handle simple identifiers or property accesses (truthiness checks)
+    // Example: `if (x)` or `x && <JSX />` - x is checked for truthiness
+    const path = StructuredPath.fromNode(unwrapped, context.sourceFile);
+    if (path && !path.isLiteral()) {
+      const pathStr = path.toLeftHandSideString();
+      const usage: ConditionalUsage = {
+        path: pathStr,
+        conditionType: 'truthiness',
         location,
-      });
-    }
-    return;
-  }
+        sourceLocation: getSourceLocation(unwrapped, context.sourceFile),
+        isNegated,
+      };
+
+      // Add chain info if part of a compound conditional
+      if (chainInfo) {
+        usage.chainId = chainInfo.chainId;
+        usage.chainPosition = chainInfo.currentPosition;
+        usage.chainLength = chainInfo.chainLength;
+        usage.chainExpression = chainInfo.chainExpression;
+        chainInfo.currentPosition++;
+
+        // Add to compound conditional conditions
+        // For truthiness, requiredValue is true if not negated, false if negated
+        chainInfo.compound.conditions.push({
+          path: pathStr,
+          conditionType: 'truthiness',
+          isNegated,
+          requiredValue: !isNegated,
+        });
+      }
 
-  // Handle prefix unary NOT expression: !variable
-  // Example: `if (!isVisible)` - isVisible is a truthiness check
-  if (
-    ts.isPrefixUnaryExpression(unwrapped) &&
-    unwrapped.operator === ts.SyntaxKind.ExclamationToken
-  ) {
-    extractConditionalUsage(unwrapped.operand, context, location);
-    return;
+      context.addConditionalUsage(usage);
+    }
   }
 
-  // Handle simple identifiers or property accesses (truthiness checks)
-  // Example: `if (x)` or `x && <JSX />` - x is checked for truthiness
-  const path = StructuredPath.fromNode(unwrapped, context.sourceFile);
-  if (path && !path.isLiteral()) {
-    context.addConditionalUsage({
-      path: path.toLeftHandSideString(),
-      conditionType: 'truthiness',
-      location,
-    });
-  }
+  // Start extraction with no chain info
+  extractWithChainTracking(condition, null, false);
 }
 
 /**
@@ -341,7 +599,16 @@ export function processExpression({
   ) {
     markConditionVariablesAsNullable(unwrappedNode, context);
     // Extract conditional usages for key attribute detection
-    extractConditionalUsage(unwrappedNode, context, 'logical-and');
+    // Only call from the OUTERMOST && expression to avoid duplicates
+    // Check if parent is also a && (meaning we're nested)
+    const parent = unwrappedNode.parent;
+    const parentIsAndChain =
+      parent &&
+      ts.isBinaryExpression(parent) &&
+      parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken;
+    if (!parentIsAndChain) {
+      extractConditionalUsage(unwrappedNode, context, 'logical-and');
+    }
   }
 
   // If the node falls within an excluded child scope, stop processing it.
@@ -930,9 +1197,10 @@ export function processExpression({
       return false;
     }
 
-    // Construct empty arguments list just to get the call path
-    // We'll process each argument with its parameter path as targetPath
-    const callPath = StructuredPath.fromNode(unwrappedNode, context.sourceFile);
+    // Build call path using original source text for consistent schema paths.
+    // IMPORTANT: Never use cyScope names in call paths - they are internal identifiers
+    // that should not appear in schema paths or call signatures.
+    const callPath = buildCallPathFromSource(unwrappedNode, context);
 
     // 2. Process all arguments recursively WITH targetPath for proper equivalence
     for (let i = 0; i < unwrappedNode.arguments.length; i++) {
@@ -1099,6 +1367,13 @@ export function processExpression({
           // Create a path for this property within the base
           const propPath = targetPath.withProperty(propName);
 
+          // Handle child boundaries (callback functions) in object properties
+          // This establishes equivalency between the property path and the child scope
+          // e.g., columns[0].renderCell → cyScope1()
+          if (context.isChildBoundary(property.initializer)) {
+            context.addChildBoundaryEquivalence(propPath, property.initializer);
+          }
+
           // Process the property value with propPath as targetPath
           // This allows nested object literals to work correctly
           processExpression({
@@ -1404,8 +1679,13 @@ export function processExpression({
       context,
       typeHint: 'boolean | unknown',
     }); //TODO: could we capture that this is evidence of a boolean type?
-    processExpression({ node: unwrappedNode.whenTrue, context });
-    processExpression({ node: unwrappedNode.whenFalse, context });
+
+    // Process both branches WITH targetPath to establish equivalencies
+    // This is critical for tracing nested properties through ternary assignments
+    // e.g., const items = condition ? arr1 : arr2; items.map(i => i.prop)
+    // We need items to be equivalent to both arr1 AND arr2 for proper tracing
+    processExpression({ node: unwrappedNode.whenTrue, context, targetPath });
+    processExpression({ node: unwrappedNode.whenFalse, context, targetPath });
 
     // Create a path for the whole expression
     const expressionSourcePath = nodeToSource(
@@ -1428,10 +1708,22 @@ export function processExpression({
     // Register type for the expression
     context.addType(expressionSourcePath, resultType);
 
-    // If targetPath is provided, establish equivalence and register type
+    // If targetPath is provided, only register type (don't overwrite branch equivalencies)
+    // The equivalencies to individual branches (set above) are more useful for tracing
+    // than an equivalency to the entire ternary expression text
     if (targetPath) {
-      context.addEquivalence(targetPath, expressionSourcePath);
-      context.addType(targetPath, resultType);
+      // NOTE: We intentionally do NOT add equivalence here.
+      // The branch processing above already added equivalencies:
+      //   targetPath -> whenTrue branch
+      //   targetPath -> whenFalse branch
+      // Adding an equivalence to expressionSourcePath would overwrite those
+      // with a useless equivalence to the ternary text itself.
+      //
+      // Use updateSchemaType instead of addType because:
+      // 1. Branch processing may have already set a type on targetPath
+      // 2. addType has a guard that prevents overwriting specific types with 'unknown'
+      // 3. updateSchemaType bypasses this guard, ensuring the ternary's computed type is used
+      context.updateSchemaType(targetPath, resultType);
     }
 
     return true;
@@ -2232,6 +2524,9 @@ function processJsxAttribute(
   if (ts.isJsxExpression(attr.initializer) && attr.initializer.expression) {
     const expression = attr.initializer.expression;
     if (context.isChildBoundary(expression)) {
+      // Create equivalency between attribute path and child scope
+      // e.g., Grid().signature[0].renderRow → cyScope1()
+      context.addChildBoundaryEquivalence(attributePath, expression);
       return true;
     }
 

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

@@ -159,6 +159,9 @@ export interface AstScopeAnalysisResult {
   // Maps attribute path to array of conditional usages
   conditionalUsages: Record<string, ConditionalUsage[]>;
 
+  // Compound conditionals grouped by chain (all conditions must be true together)
+  compoundConditionals?: CompoundConditional[];
+
   // Whether the analysis is complete enough to skip LLM calls
   isComplete: boolean;
 
@@ -191,6 +194,57 @@ export interface ConditionalUsage {
    * Where this conditional usage occurs
    */
   location: 'if' | 'ternary' | 'logical-and' | 'switch';
+
+  /**
+   * Source location information for this conditional usage
+   */
+  sourceLocation?: {
+    /** Line number (1-based) */
+    lineNumber: number;
+    /** Column number (0-based) */
+    column: number;
+    /** The code snippet containing this conditional */
+    codeSnippet: string;
+  };
+
+  /** Unique ID for this compound conditional chain (shared by all conditions in same && chain) */
+  chainId?: string;
+  /** Position in the chain (0 = leftmost) */
+  chainPosition?: number;
+  /** Total number of conditions in this chain */
+  chainLength?: number;
+  /** The full original expression (e.g., "a && b && c") */
+  chainExpression?: string;
+  /** Whether this condition is negated (e.g., !foo) */
+  isNegated?: boolean;
+}
+
+/**
+ * Represents a compound conditional (e.g., a && b && c) where all conditions
+ * must be satisfied together for a code path to execute.
+ */
+export interface CompoundConditional {
+  /** Unique identifier for this compound conditional */
+  chainId: string;
+  /** The full expression (e.g., "scenarios.length > 0 && !displayState.isQueued") */
+  expression: string;
+  /** Individual conditions in order */
+  conditions: {
+    path: string;
+    conditionType: 'truthiness' | 'comparison' | 'switch';
+    comparedValues?: string[];
+    isNegated: boolean;
+    /** Required value for this condition to be true */
+    requiredValue?: string | boolean;
+  }[];
+  /** Where this compound conditional occurs */
+  location: 'if' | 'ternary' | 'logical-and' | 'switch';
+  /** Source location for the entire compound expression */
+  sourceLocation: {
+    lineNumber: number;
+    column: number;
+    codeSnippet: string;
+  };
 }
 
 /**
@@ -318,6 +372,12 @@ export interface AnalysisContext {
   // Get all conditional usages
   getConditionalUsages(): Record<string, ConditionalUsage[]>;
 
+  // Add a compound conditional for key attribute dependency detection
+  addCompoundConditional(compound: CompoundConditional): void;
+
+  // Get all compound conditionals
+  getCompoundConditionals(): CompoundConditional[];
+
   // Update a schema type, typically used when switch statements reveal
   // the valid values for a parameter (creating a union type)
   updateSchemaType(path: string | StructuredPath, newType: string): void;