@veraxhq/verax 0.2.1 → 0.3.0

package/src/verax/learn/action-contract-extractor.js

@@ -8,10 +8,12 @@
  * NO HEURISTICS. Only static, deterministic analysis.
  */
 
-import { normalizeTemplateLiteral } from '../shared/dynamic-route-utils.js';import { parse } from '@babel/parser';
+import { normalizeTemplateLiteral } from '../shared/dynamic-route-utils.js';
+import { parse } from '@babel/parser';
 import traverse from '@babel/traverse';
-import { readFileSync } from 'fs';
-import { relative, sep } from 'path';
+import { readFileSync, existsSync } from 'fs';
+import { relative, sep, dirname, resolve, extname } from 'path';
+import { isViewSwitchFunction, isDetectableLiteralArg, VIEW_SWITCH_REASON_CODES } from '../shared/view-switch-rules.js';
 
 /**
  * Extract action contracts from a source file.
@@ -30,18 +32,41 @@ export function extractActionContracts(filePath, workspaceRoot) {
   }
 }
 
-function extractActionContractsFromCode(filePath, workspaceRoot, code, lineOffset = 0) {
+export function extractActionContractsFromCode(filePath, workspaceRoot, code, lineOffset = 0) {
   const contracts = [];
 
   // Track function declarations and arrow function assignments with location
   const functionBodies = new Map(); // name -> { body, loc }
+  
+  // Track imports for cross-file resolution
+  const importMap = new Map(); // localName -> { modulePath, exportName }
+  const fileDir = dirname(filePath);
 
   const ast = parse(code, {
     sourceType: 'unambiguous',
     plugins: ['jsx', 'typescript'],
   });
-
+  
+  // First pass: collect imports and function definitions
   traverse.default(ast, {
+    ImportDeclaration(path) {
+      const source = path.node.source.value;
+      if (!source.startsWith('.') && !source.startsWith('/')) {
+        return; // Skip external packages
+      }
+      
+      const resolvedPath = resolveModulePath(source, fileDir, workspaceRoot);
+      if (!resolvedPath) return;
+      
+      path.node.specifiers.forEach(spec => {
+        if (spec.type === 'ImportSpecifier' || spec.type === 'ImportDefaultSpecifier') {
+          const localName = spec.local.name;
+          const exportName = spec.type === 'ImportDefaultSpecifier' ? 'default' : (spec.imported?.name || localName);
+          importMap.set(localName, { modulePath: resolvedPath, exportName });
+        }
+      });
+    },
+    
     FunctionDeclaration(path) {
       if (path.node.id && path.node.id.name) {
         functionBodies.set(path.node.id.name, { body: path.node.body, loc: path.node.loc });
@@ -56,8 +81,11 @@ function extractActionContractsFromCode(filePath, workspaceRoot, code, lineOffse
       ) {
         functionBodies.set(path.node.id.name, { body: path.node.init.body, loc: path.node.loc });
       }
-    },
+    }
+  });
 
+  // Second pass: extract contracts with cross-file support
+  traverse.default(ast, {
     // JSX handlers (React)
     JSXAttribute(path) {
       const attrName = path.node.name.name;
@@ -75,7 +103,8 @@ function extractActionContractsFromCode(filePath, workspaceRoot, code, lineOffse
         value.expression.type === 'ArrowFunctionExpression'
       ) {
         const handlerBody = value.expression.body;
-        const networkCalls = findNetworkCallsInNode(handlerBody);
+        const networkCalls = findNetworkCallsInNode(handlerBody, functionBodies, importMap, filePath, workspaceRoot, 0);
+        const viewSwitchCalls = findViewSwitchCallsInNode(handlerBody, functionBodies, importMap, filePath, workspaceRoot, 0);
 
         for (const call of networkCalls) {
           const loc = path.node.loc;
@@ -92,52 +121,116 @@ function extractActionContractsFromCode(filePath, workspaceRoot, code, lineOffse
               selectorHint: null
             });
           } else if (call.kind !== 'VALIDATION_BLOCK') {
-            contracts.push({
+            const contract = {
               kind: call.kind || 'NETWORK_ACTION',
               method: call.method,
               urlPath: call.url,
               source: sourceRef,
               elementType: path.parent.name.name,
               handlerRef: sourceRef
-            });
+            };
+            if (call.isDynamic) {
+              contract.isDynamic = true;
+              contract.dynamicSegments = call.dynamicSegments;
+              if (call.astSnippet) contract.astSnippet = call.astSnippet;
+            }
+            contracts.push(contract);
           }
         }
+        
+        // Extract view switch promises
+        for (const call of viewSwitchCalls) {
+          const loc = path.node.loc;
+          const sourceRef = formatSourceRef(filePath, workspaceRoot, loc, lineOffset);
+          
+          contracts.push({
+            kind: 'VIEW_SWITCH_PROMISE',
+            target: call.target,
+            viewKind: call.viewKind,
+            pattern: call.pattern,
+            isUrlChanging: false,
+            source: sourceRef,
+            elementType: path.parent.name.name,
+            handlerRef: sourceRef,
+            astSnippet: call.astSnippet,
+            reasonCode: call.reasonCode,
+            confidenceHint: 'WEAK' // UI-bound but requires correlation
+          });
+        }
       } else if (
         value.type === 'JSXExpressionContainer' &&
         value.expression.type === 'Identifier'
       ) {
         const refName = value.expression.name;
         const handlerRecord = functionBodies.get(refName);
-
+        
+        // Try local function first
+        let networkCalls = [];
+        let viewSwitchCalls = [];
         if (handlerRecord) {
-          const networkCalls = findNetworkCallsInNode(handlerRecord.body);
-
-          for (const call of networkCalls) {
-            const loc = path.node.loc;
-            const sourceRef = formatSourceRef(filePath, workspaceRoot, loc, lineOffset);
-
-            if (call.kind === 'VALIDATION_BLOCK' && isSubmitHandler) {
-              contracts.push({
-                kind: 'VALIDATION_BLOCK',
-                method: call.method,
-                urlPath: null,
-                source: sourceRef,
-                elementType: path.parent.name.name,
-                handlerRef: sourceRef,
-                selectorHint: null
-              });
-            } else if (call.kind !== 'VALIDATION_BLOCK') {
-              contracts.push({
-                kind: call.kind || 'NETWORK_ACTION',
-                method: call.method,
-                urlPath: call.url,
-                source: sourceRef,
-                elementType: path.parent.name.name,
-                handlerRef: sourceRef
-              });
+          networkCalls = findNetworkCallsInNode(handlerRecord.body, functionBodies, importMap, filePath, workspaceRoot, 0);
+          viewSwitchCalls = findViewSwitchCallsInNode(handlerRecord.body, functionBodies, importMap, filePath, workspaceRoot, 0);
+        } else {
+          // Try cross-file resolution
+          const importInfo = importMap.get(refName);
+          if (importInfo) {
+            const crossFileCalls = followCrossFileFunction(importInfo, workspaceRoot, 0);
+            networkCalls = crossFileCalls.filter(c => c.kind !== 'VIEW_SWITCH_PROMISE');
+            viewSwitchCalls = crossFileCalls.filter(c => c.kind === 'VIEW_SWITCH_PROMISE');
+          }
+        }
+
+        for (const call of networkCalls) {
+          const loc = path.node.loc;
+          const sourceRef = formatSourceRef(filePath, workspaceRoot, loc, lineOffset);
+
+          if (call.kind === 'VALIDATION_BLOCK' && isSubmitHandler) {
+            contracts.push({
+              kind: 'VALIDATION_BLOCK',
+              method: call.method,
+              urlPath: null,
+              source: sourceRef,
+              elementType: path.parent.name.name,
+              handlerRef: call.handlerRef || sourceRef,
+              selectorHint: null
+            });
+          } else if (call.kind !== 'VALIDATION_BLOCK') {
+            const contract = {
+              kind: call.kind || 'NETWORK_ACTION',
+              method: call.method,
+              urlPath: call.url,
+              source: sourceRef,
+              elementType: path.parent.name.name,
+              handlerRef: call.handlerRef || sourceRef
+            };
+            if (call.isDynamic) {
+              contract.isDynamic = true;
+              contract.dynamicSegments = call.dynamicSegments;
+              if (call.astSnippet) contract.astSnippet = call.astSnippet;
             }
+            contracts.push(contract);
           }
         }
+        
+        // Extract view switch promises
+        for (const call of viewSwitchCalls) {
+          const loc = path.node.loc;
+          const sourceRef = formatSourceRef(filePath, workspaceRoot, loc, lineOffset);
+          
+          contracts.push({
+            kind: 'VIEW_SWITCH_PROMISE',
+            target: call.target,
+            viewKind: call.viewKind,
+            pattern: call.pattern,
+            isUrlChanging: false,
+            source: sourceRef,
+            elementType: path.parent.name.name,
+            handlerRef: sourceRef,
+            astSnippet: call.astSnippet,
+            reasonCode: call.reasonCode,
+            confidenceHint: 'WEAK'
+          });
+        }
       }
     },
 
@@ -167,12 +260,68 @@ function extractActionContractsFromCode(filePath, workspaceRoot, code, lineOffse
           if (record) {
             handlerBody = record.body;
             handlerLoc = record.loc || path.node.loc;
+          } else {
+            // Try cross-file resolution
+            const importInfo = importMap.get(handlerArg.name);
+            if (importInfo) {
+              const crossFileCalls = followCrossFileFunction(importInfo, workspaceRoot, 0);
+              if (crossFileCalls.length > 0) {
+                handlerBody = { type: 'BlockStatement', body: [] }; // Dummy body for location
+                handlerLoc = path.node.loc;
+                const handlerRef = formatSourceRef(filePath, workspaceRoot, handlerLoc, lineOffset);
+                
+                for (const call of crossFileCalls) {
+                  if (call.kind === 'VALIDATION_BLOCK' && isSubmitEvent) {
+                    contracts.push({
+                      kind: 'VALIDATION_BLOCK',
+                      method: call.method,
+                      urlPath: null,
+                      source: handlerRef,
+                      handlerRef: call.handlerRef || `${handlerRef}#${eventType}`,
+                      elementType: 'dom',
+                      selectorHint: null
+                    });
+                  } else if (call.kind === 'VIEW_SWITCH_PROMISE') {
+                    contracts.push({
+                      kind: 'VIEW_SWITCH_PROMISE',
+                      target: call.target,
+                      viewKind: call.viewKind,
+                      pattern: call.pattern,
+                      isUrlChanging: false,
+                      source: handlerRef,
+                      handlerRef: call.handlerRef || `${handlerRef}#${eventType}`,
+                      elementType: 'dom',
+                      astSnippet: call.astSnippet,
+                      reasonCode: call.reasonCode,
+                      confidenceHint: 'WEAK'
+                    });
+                  } else if (call.kind !== 'VALIDATION_BLOCK') {
+                    const contract = {
+                      kind: call.kind || 'NETWORK_ACTION',
+                      method: call.method,
+                      urlPath: call.url,
+                      source: handlerRef,
+                      handlerRef: call.handlerRef || `${handlerRef}#${eventType}`,
+                      elementType: 'dom'
+                    };
+                    if (call.isDynamic) {
+                      contract.isDynamic = true;
+                      contract.dynamicSegments = call.dynamicSegments;
+                      if (call.astSnippet) contract.astSnippet = call.astSnippet;
+                    }
+                    contracts.push(contract);
+                  }
+                }
+                return; // Already processed
+              }
+            }
           }
         }
 
         if (!handlerBody) return;
 
-        const networkCalls = findNetworkCallsInNode(handlerBody);
+        const networkCalls = findNetworkCallsInNode(handlerBody, functionBodies, importMap, filePath, workspaceRoot, 0);
+        const viewSwitchCalls = findViewSwitchCallsInNode(handlerBody, functionBodies, importMap, filePath, workspaceRoot, 0);
         const isSubmitEvent = eventType === 'submit';
         
         for (const call of networkCalls) {
@@ -189,14 +338,20 @@ function extractActionContractsFromCode(filePath, workspaceRoot, code, lineOffse
               selectorHint: null
             });
           } else if (call.kind !== 'VALIDATION_BLOCK') {
-            contracts.push({
+            const contract = {
               kind: call.kind || 'NETWORK_ACTION',
               method: call.method,
               urlPath: call.url,
               source: handlerRef,
               handlerRef: `${handlerRef}#${eventType}`,
               elementType: 'dom'
-            });
+            };
+            if (call.isDynamic) {
+              contract.isDynamic = true;
+              contract.dynamicSegments = call.dynamicSegments;
+              if (call.astSnippet) contract.astSnippet = call.astSnippet;
+            }
+            contracts.push(contract);
           }
         }
       }
@@ -209,22 +364,37 @@ function extractActionContractsFromCode(filePath, workspaceRoot, code, lineOffse
 /**
  * Extract template literal pattern from node.
  * Returns null if template has complex expressions.
+ * 
+ * TRUTH BOUNDARY:
+ * - Detectable: Template literals with simple Identifier expressions
+ *   - `/api/users/${id}` → `/api/users/:id`
+ *   - `/api/${resource}/${id}` → `/api/:resource/:id`
+ * - Ambiguous/Not detectable: Complex expressions (function calls, member access, etc.)
+ *   - `/api/${getPath()}` → null (rejected)
+ *   - `/api/${obj.prop}` → null (rejected)
+ * 
+ * @param {Object} node - AST TemplateLiteral node
+ * @returns {Object|null} - { templateStr, normalizedUrl, dynamicSegments, astSnippet } or null
  */
 function extractTemplateLiteralPath(node) {
   if (!node || node.type !== 'TemplateLiteral') {
     return null;
   }
   
-  // Build template string
+  // Build template string with ${param} placeholders
   let templateStr = node.quasis[0]?.value?.cooked || '';
+  const dynamicSegments = [];
   
   for (let i = 0; i < node.expressions.length; i++) {
     const expr = node.expressions[i];
     
-    // Only support simple identifiers
+    // Only support simple identifiers (truth boundary)
     if (expr.type === 'Identifier') {
-      templateStr += '${' + expr.name + '}';
+      const paramName = expr.name;
+      templateStr += '${' + paramName + '}';
+      dynamicSegments.push(paramName);
     } else {
+      // Complex expression - reject (truth boundary)
       return null;
     }
     
@@ -233,7 +403,150 @@ function extractTemplateLiteralPath(node) {
     }
   }
   
-  return templateStr;
+  // Normalize to :param format (not example values)
+  let normalizedUrl = templateStr;
+  for (const paramName of dynamicSegments) {
+    normalizedUrl = normalizedUrl.replace(`\${${paramName}}`, `:${paramName}`);
+  }
+  
+  // Preserve AST snippet for evidence
+  const astSnippet = {
+    type: 'TemplateLiteral',
+    quasis: node.quasis.map(q => ({ value: q.value?.cooked || '' })),
+    expressions: node.expressions.map(e => 
+      e.type === 'Identifier' ? { type: 'Identifier', name: e.name } : null
+    ).filter(Boolean)
+  };
+  
+  return {
+    templateStr,
+    normalizedUrl,
+    dynamicSegments,
+    astSnippet
+  };
+}
+
+/**
+ * Resolve module path from import specifier
+ */
+function resolveModulePath(specifier, fromDir, workspaceRoot) {
+  if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
+    return null; // External package
+  }
+  
+  let resolved = resolve(fromDir, specifier);
+  
+  // Try with extensions
+  const extensions = ['.js', '.jsx', '.ts', '.tsx', ''];
+  for (const ext of extensions) {
+    const withExt = ext ? resolved + ext : resolved;
+    if (existsSync(withExt)) {
+      return withExt;
+    }
+    // Try index files
+    const indexPath = resolve(withExt, 'index' + ext);
+    if (existsSync(indexPath)) {
+      return indexPath;
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Follow function call across files
+ */
+function followCrossFileFunction(importInfo, workspaceRoot, depth) {
+  if (depth > 3) return []; // Prevent infinite recursion
+  
+  const { modulePath, exportName } = importInfo;
+  if (!existsSync(modulePath)) return [];
+  
+  try {
+    const code = readFileSync(modulePath, 'utf-8');
+    const fileDir = dirname(modulePath);
+    const ast = parse(code, {
+      sourceType: 'unambiguous',
+      plugins: ['jsx', 'typescript'],
+    });
+    
+    const functionBodies = new Map();
+    const importMap = new Map();
+    
+    // Collect function definitions and imports
+    traverse.default(ast, {
+      ImportDeclaration(path) {
+        const source = path.node.source.value;
+        if (!source.startsWith('.') && !source.startsWith('/')) return;
+        const resolved = resolveModulePath(source, fileDir, workspaceRoot);
+        if (!resolved) return;
+        path.node.specifiers.forEach(spec => {
+          if (spec.type === 'ImportSpecifier' || spec.type === 'ImportDefaultSpecifier') {
+            const localName = spec.local.name;
+            const expName = spec.type === 'ImportDefaultSpecifier' ? 'default' : (spec.imported?.name || localName);
+            importMap.set(localName, { modulePath: resolved, exportName: expName });
+          }
+        });
+      },
+      FunctionDeclaration(path) {
+        if (path.node.id && path.node.id.name) {
+          functionBodies.set(path.node.id.name, { body: path.node.body, loc: path.node.loc });
+        }
+      },
+      VariableDeclarator(path) {
+        if (path.node.id.type === 'Identifier' && path.node.init && 
+            (path.node.init.type === 'ArrowFunctionExpression' || path.node.init.type === 'FunctionExpression')) {
+          functionBodies.set(path.node.id.name, { body: path.node.init.body, loc: path.node.loc });
+        }
+      },
+      ExportNamedDeclaration(path) {
+        if (exportName === 'default') return;
+        const decl = path.node.declaration;
+        if (decl && decl.type === 'FunctionDeclaration' && decl.id && decl.id.name === exportName) {
+          functionBodies.set(exportName, { body: decl.body, loc: decl.loc });
+        }
+      },
+      ExportDefaultDeclaration(path) {
+        if (exportName !== 'default') return;
+        const decl = path.node.declaration;
+        if (decl && decl.type === 'FunctionDeclaration' && decl.id) {
+          functionBodies.set(decl.id.name, { body: decl.body, loc: decl.loc });
+        } else if (decl && (decl.type === 'ArrowFunctionExpression' || decl.type === 'FunctionExpression')) {
+          // Anonymous default export - scan directly
+          const calls = findNetworkCallsInNode(decl.body, functionBodies, importMap, modulePath, workspaceRoot, depth + 1);
+          return calls.map(call => ({
+            ...call,
+            handlerRef: formatSourceRef(modulePath, workspaceRoot, decl.loc || { start: { line: 1, column: 0 } }, 0)
+          }));
+        }
+      }
+    });
+    
+    // Find the exported function
+    const funcDef = functionBodies.get(exportName);
+    if (funcDef) {
+      const networkCalls = findNetworkCallsInNode(funcDef.body, functionBodies, importMap, modulePath, workspaceRoot, depth + 1);
+      const viewSwitchCalls = findViewSwitchCallsInNode(funcDef.body, functionBodies, importMap, modulePath, workspaceRoot, depth + 1);
+      const handlerRef = formatSourceRef(modulePath, workspaceRoot, funcDef.loc || { start: { line: 1, column: 0 } }, 0);
+      
+      const allCalls = [
+        ...networkCalls.map(call => ({
+          ...call,
+          handlerRef
+        })),
+        ...viewSwitchCalls.map(call => ({
+          ...call,
+          handlerRef
+        }))
+      ];
+      
+      return allCalls;
+    }
+  } catch (err) {
+    // Ignore parse errors
+  }
+  
+  return [];
 }
 
 /**
@@ -241,9 +554,14 @@ function extractTemplateLiteralPath(node) {
  * Only returns calls with static URL/path literals or template patterns.
  * 
  * @param {Object} node - AST node to scan
+ * @param {Map} functionBodies - Map of function name -> body for local functions
+ * @param {Map} importMap - Map of import name -> module info
+ * @param {string} filePath - Current file path
+ * @param {string} workspaceRoot - Workspace root
+ * @param {number} depth - Recursion depth
  * @returns {Array<Object>} - Array of {kind, method, url} where kind is 'NETWORK_ACTION' or 'NAVIGATION_ACTION'
  */
-function findNetworkCallsInNode(node) {
+function findNetworkCallsInNode(node, functionBodies = new Map(), importMap = new Map(), filePath = '', workspaceRoot = '', depth = 0) {
   const calls = [];
   
   // Track if we found preventDefault or return false for validation block detection
@@ -257,27 +575,57 @@ function findNetworkCallsInNode(node) {
     // Check if this is a CallExpression
     if (n.type === 'CallExpression') {
       const callee = n.callee;
+      
+      // Follow function calls to their definitions (cross-file support)
+      if (callee.type === 'Identifier' && depth < 3) {
+        const funcName = callee.name;
+        const localFunc = functionBodies.get(funcName);
+        if (localFunc) {
+          // Recursively scan local function
+          const innerCalls = findNetworkCallsInNode(localFunc.body, functionBodies, importMap, filePath, workspaceRoot, depth + 1);
+          calls.push(...innerCalls);
+        } else {
+          // Try cross-file resolution
+          const importInfo = importMap.get(funcName);
+          if (importInfo) {
+            const crossFileCalls = followCrossFileFunction(importInfo, workspaceRoot, depth);
+            calls.push(...crossFileCalls);
+          }
+        }
+      }
 
       // Case 1: fetch(url, options)
       if (callee.type === 'Identifier' && callee.name === 'fetch') {
        const urlArg = n.arguments[0];
        const optionsArg = n.arguments[1];
 
-        // Only accept static string literals
-        if (urlArg && urlArg.type === 'StringLiteral') {
-          let method = 'GET'; // default
-          
-          // Try to extract method from options
-          if (optionsArg && optionsArg.type === 'ObjectExpression') {
-            const methodProp = optionsArg.properties.find(
-              (p) => p.key && p.key.name === 'method'
-            );
-            if (methodProp && methodProp.value.type === 'StringLiteral') {
-              method = methodProp.value.value.toUpperCase();
-            }
+        let method = 'GET'; // default
+        // Try to extract method from options
+        if (optionsArg && optionsArg.type === 'ObjectExpression') {
+          const methodProp = optionsArg.properties.find(
+            (p) => p.key && p.key.name === 'method'
+          );
+          if (methodProp && methodProp.value.type === 'StringLiteral') {
+            method = methodProp.value.value.toUpperCase();
           }
+        }
 
+        if (urlArg && urlArg.type === 'StringLiteral') {
+          // Static URL
           calls.push({ kind: 'NETWORK_ACTION', method, url: urlArg.value });
+        } else if (urlArg && urlArg.type === 'TemplateLiteral') {
+          // Dynamic URL: fetch(`/api/users/${id}`)
+          const templateInfo = extractTemplateLiteralPath(urlArg);
+          if (templateInfo && templateInfo.normalizedUrl.startsWith('/')) {
+            calls.push({
+              kind: 'NETWORK_ACTION',
+              method,
+              url: templateInfo.normalizedUrl,
+              isDynamic: true,
+              dynamicSegments: templateInfo.dynamicSegments.length,
+              astSnippet: templateInfo.astSnippet
+            });
+          }
         }
       }
 
@@ -292,7 +640,57 @@ function findNetworkCallsInNode(node) {
        const urlArg = n.arguments[0];
 
         if (urlArg && urlArg.type === 'StringLiteral') {
+          // Static URL
           calls.push({ kind: 'NETWORK_ACTION', method: methodName, url: urlArg.value });
+        } else if (urlArg && urlArg.type === 'TemplateLiteral') {
+          // Dynamic URL: axios.post(`/api/users/${id}`)
+          const templateInfo = extractTemplateLiteralPath(urlArg);
+          if (templateInfo && templateInfo.normalizedUrl.startsWith('/')) {
+            calls.push({
+              kind: 'NETWORK_ACTION',
+              method: methodName,
+              url: templateInfo.normalizedUrl,
+              isDynamic: true,
+              dynamicSegments: templateInfo.dynamicSegments.length,
+              astSnippet: templateInfo.astSnippet
+            });
+          }
+        }
+      }
+      
+      // Case 2b: apiClient.get(url), apiClient.post(url), http.get(url), etc. (wrapped API clients)
+      // Check this only if not axios (already handled above)
+      if (
+        callee.type === 'MemberExpression' &&
+        callee.object.type === 'Identifier' &&
+        callee.object.name !== 'axios' &&
+        callee.property.type === 'Identifier'
+      ) {
+        const objectName = callee.object.name;
+        const methodName = callee.property.name.toUpperCase();
+        const urlArg = n.arguments[0];
+        
+        // Common API client patterns (exclude axios which is handled above)
+        const apiClientNames = ['apiClient', 'http', 'request', 'api', 'client', 'httpClient'];
+        const httpMethods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'];
+        if (apiClientNames.includes(objectName) && httpMethods.includes(methodName)) {
+          if (urlArg && urlArg.type === 'StringLiteral') {
+            // Static URL
+            calls.push({ kind: 'NETWORK_ACTION', method: methodName, url: urlArg.value });
+          } else if (urlArg && urlArg.type === 'TemplateLiteral') {
+            // Dynamic URL: apiClient.post(`/api/users/${id}`)
+            const templateInfo = extractTemplateLiteralPath(urlArg);
+            if (templateInfo && templateInfo.normalizedUrl.startsWith('/')) {
+              calls.push({
+                kind: 'NETWORK_ACTION',
+                method: methodName,
+                url: templateInfo.normalizedUrl,
+                isDynamic: true,
+                dynamicSegments: templateInfo.dynamicSegments.length,
+                astSnippet: templateInfo.astSnippet
+              });
+            }
+          }
         }
       }
 
@@ -306,15 +704,30 @@ function findNetworkCallsInNode(node) {
        const methodArg = n.arguments[0];
        const urlArg = n.arguments[1];
 
-        if (
-          methodArg && methodArg.type === 'StringLiteral' &&
-          urlArg && urlArg.type === 'StringLiteral'
-        ) {
-          calls.push({
-            kind: 'NETWORK_ACTION',
-            method: methodArg.value.toUpperCase(),
-            url: urlArg.value,
-          });
+        if (methodArg && methodArg.type === 'StringLiteral') {
+          const method = methodArg.value.toUpperCase();
+          
+          if (urlArg && urlArg.type === 'StringLiteral') {
+            // Static URL
+            calls.push({
+              kind: 'NETWORK_ACTION',
+              method,
+              url: urlArg.value,
+            });
+          } else if (urlArg && urlArg.type === 'TemplateLiteral') {
+            // Dynamic URL: xhr.open('GET', `/api/users/${id}`)
+            const templateInfo = extractTemplateLiteralPath(urlArg);
+            if (templateInfo && templateInfo.normalizedUrl.startsWith('/')) {
+              calls.push({
+                kind: 'NETWORK_ACTION',
+                method,
+                url: templateInfo.normalizedUrl,
+                isDynamic: true,
+                dynamicSegments: templateInfo.dynamicSegments.length,
+                astSnippet: templateInfo.astSnippet
+              });
+            }
+          }
         }
       }
       
@@ -419,6 +832,211 @@ function findNetworkCallsInNode(node) {
   return calls;
 }
 
+/**
+ * Find view switch promise calls (setView, dispatch(NAVIGATE), etc.) in an AST node.
+ * TRUTH BOUNDARY: Only literal string/number arguments are accepted.
+ * 
+ * @param {Object} node - AST node to scan
+ * @param {Map} functionBodies - Map of function name -> body for local functions
+ * @param {Map} importMap - Map of import name -> module info
+ * @param {string} filePath - Current file path
+ * @param {string} workspaceRoot - Workspace root
+ * @param {number} depth - Recursion depth
+ * @returns {Array<Object>} - Array of {kind: 'VIEW_SWITCH_PROMISE', target, kind, isUrlChanging, astSnippet}
+ */
+function findViewSwitchCallsInNode(node, functionBodies = new Map(), importMap = new Map(), filePath = '', workspaceRoot = '', depth = 0) {
+  const calls = [];
+  
+  function scan(n) {
+    if (!n || typeof n !== 'object') return;
+    
+    if (n.type === 'CallExpression') {
+      const callee = n.callee;
+      
+      // Follow function calls to their definitions (cross-file support)
+      if (callee.type === 'Identifier' && depth < 3) {
+        const funcName = callee.name;
+        const localFunc = functionBodies.get(funcName);
+        if (localFunc) {
+          const innerCalls = findViewSwitchCallsInNode(localFunc.body, functionBodies, importMap, filePath, workspaceRoot, depth + 1);
+          calls.push(...innerCalls);
+        } else {
+          const importInfo = importMap.get(funcName);
+          if (importInfo) {
+            const crossFileCalls = followCrossFileFunction(importInfo, workspaceRoot, depth);
+            // Filter for view switch calls only
+            const viewSwitchCalls = crossFileCalls.filter(c => c.kind === 'VIEW_SWITCH_PROMISE');
+            calls.push(...viewSwitchCalls);
+          }
+        }
+      }
+      
+      // Case 1: React setState patterns: setView('settings'), setTab('billing')
+      if (callee.type === 'Identifier') {
+        const funcName = callee.name;
+        const viewSwitchInfo = isViewSwitchFunction(funcName);
+        
+        if (viewSwitchInfo) {
+          const firstArg = n.arguments[0];
+          const literalArg = isDetectableLiteralArg(firstArg);
+          
+          if (literalArg && literalArg.value) {
+            // Preserve AST snippet for evidence
+            const astSnippet = {
+              type: 'CallExpression',
+              callee: { type: 'Identifier', name: funcName },
+              arguments: [{
+                type: firstArg.type,
+                value: firstArg.type === 'StringLiteral' ? firstArg.value : firstArg.value
+              }]
+            };
+            
+            calls.push({
+              kind: 'VIEW_SWITCH_PROMISE',
+              target: literalArg.value,
+              viewKind: viewSwitchInfo.kind,
+              pattern: viewSwitchInfo.pattern,
+              isUrlChanging: false,
+              astSnippet,
+              reasonCode: literalArg.reasonCode
+            });
+          }
+        }
+      }
+      
+      // Case 2: Redux dispatch({type: 'NAVIGATE', to: 'profile'}) or dispatch(navigate('profile'))
+      if (callee.type === 'Identifier' && callee.name === 'dispatch') {
+        const firstArg = n.arguments[0];
+        
+        // dispatch({type: 'NAVIGATE', to: 'profile'})
+        if (firstArg && firstArg.type === 'ObjectExpression') {
+          const typeProp = firstArg.properties.find(p => 
+            p.key && p.key.type === 'Identifier' && p.key.name === 'type'
+          );
+          const toProp = firstArg.properties.find(p => 
+            p.key && (p.key.name === 'to' || p.key.name === 'target' || p.key.name === 'view')
+          );
+          
+          if (typeProp && typeProp.value && typeProp.value.type === 'StringLiteral') {
+            const actionType = typeProp.value.value;
+            const viewSwitchInfo = isViewSwitchFunction(actionType);
+            
+            if (viewSwitchInfo && toProp && toProp.value) {
+              const literalArg = isDetectableLiteralArg(toProp.value);
+              
+              if (literalArg && literalArg.value) {
+                const astSnippet = {
+                  type: 'CallExpression',
+                  callee: { type: 'Identifier', name: 'dispatch' },
+                  arguments: [{
+                    type: 'ObjectExpression',
+                    properties: [
+                      { key: 'type', value: actionType },
+                      { key: toProp.key.name, value: literalArg.value }
+                    ]
+                  }]
+                };
+                
+                calls.push({
+                  kind: 'VIEW_SWITCH_PROMISE',
+                  target: literalArg.value,
+                  viewKind: viewSwitchInfo.kind,
+                  pattern: 'redux',
+                  isUrlChanging: false,
+                  astSnippet,
+                  reasonCode: literalArg.reasonCode
+                });
+              }
+            }
+          }
+        }
+        
+        // dispatch(navigate('profile')) - action creator call
+        if (firstArg && firstArg.type === 'CallExpression') {
+          const actionCallee = firstArg.callee;
+          if (actionCallee.type === 'Identifier') {
+            const actionName = actionCallee.name;
+            const viewSwitchInfo = isViewSwitchFunction(actionName);
+            
+            if (viewSwitchInfo) {
+              const actionFirstArg = firstArg.arguments[0];
+              const literalArg = isDetectableLiteralArg(actionFirstArg);
+              
+              if (literalArg && literalArg.value) {
+                const astSnippet = {
+                  type: 'CallExpression',
+                  callee: { type: 'Identifier', name: 'dispatch' },
+                  arguments: [{
+                    type: 'CallExpression',
+                    callee: { type: 'Identifier', name: actionName },
+                    arguments: [{ type: actionFirstArg.type, value: literalArg.value }]
+                  }]
+                };
+                
+                calls.push({
+                  kind: 'VIEW_SWITCH_PROMISE',
+                  target: literalArg.value,
+                  viewKind: viewSwitchInfo.kind,
+                  pattern: 'redux',
+                  isUrlChanging: false,
+                  astSnippet,
+                  reasonCode: literalArg.reasonCode
+                });
+              }
+            }
+          }
+        }
+      }
+      
+      // Case 3: Generic function calls: showModal('login'), openDrawer('cart')
+      if (callee.type === 'Identifier') {
+        const funcName = callee.name;
+        const viewSwitchInfo = isViewSwitchFunction(funcName);
+        
+        if (viewSwitchInfo && viewSwitchInfo.pattern === 'generic') {
+          const firstArg = n.arguments[0];
+          const literalArg = isDetectableLiteralArg(firstArg);
+          
+          if (literalArg && literalArg.value) {
+            const astSnippet = {
+              type: 'CallExpression',
+              callee: { type: 'Identifier', name: funcName },
+              arguments: [{
+                type: firstArg.type,
+                value: literalArg.value
+              }]
+            };
+            
+            calls.push({
+              kind: 'VIEW_SWITCH_PROMISE',
+              target: literalArg.value,
+              viewKind: viewSwitchInfo.kind,
+              pattern: 'generic',
+              isUrlChanging: false,
+              astSnippet,
+              reasonCode: literalArg.reasonCode
+            });
+          }
+        }
+      }
+    }
+    
+    // Recursively scan child nodes
+    for (const key in n) {
+      if (key === 'parent' || key === 'leadingComments' || key === 'trailingComments') continue;
+      const child = n[key];
+      if (Array.isArray(child)) {
+        child.forEach(item => scan(item));
+      } else if (child && typeof child === 'object') {
+        scan(child);
+      }
+    }
+  }
+  
+  scan(node);
+  return calls;
+}
+
 /**
  * Format source reference as "file:line:col"
  * Normalizes Windows paths to use forward slashes.