@veraxhq/verax 0.3.0 → 0.4.0

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

@@ -8,12 +8,10 @@
  * 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, existsSync } from 'fs';
-import { relative, sep, dirname, resolve, extname } from 'path';
-import { isViewSwitchFunction, isDetectableLiteralArg, VIEW_SWITCH_REASON_CODES } from '../shared/view-switch-rules.js';
+import { readFileSync } from 'fs';
+import { relative, sep } from 'path';
 
 /**
  * Extract action contracts from a source file.
@@ -32,41 +30,18 @@ export function extractActionContracts(filePath, workspaceRoot) {
   }
 }
 
-export function extractActionContractsFromCode(filePath, workspaceRoot, code, lineOffset = 0) {
+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 });
@@ -81,11 +56,8 @@ export function extractActionContractsFromCode(filePath, workspaceRoot, code, li
       ) {
         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;
@@ -103,8 +75,7 @@ export function extractActionContractsFromCode(filePath, workspaceRoot, code, li
         value.expression.type === 'ArrowFunctionExpression'
       ) {
         const handlerBody = value.expression.body;
-        const networkCalls = findNetworkCallsInNode(handlerBody, functionBodies, importMap, filePath, workspaceRoot, 0);
-        const viewSwitchCalls = findViewSwitchCallsInNode(handlerBody, functionBodies, importMap, filePath, workspaceRoot, 0);
+        const networkCalls = findNetworkCallsInNode(handlerBody);
 
         for (const call of networkCalls) {
           const loc = path.node.loc;
@@ -121,116 +92,52 @@ export function extractActionContractsFromCode(filePath, workspaceRoot, code, li
               selectorHint: null
             });
           } else if (call.kind !== 'VALIDATION_BLOCK') {
-            const contract = {
+            contracts.push({
               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) {
-          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;
+        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
+              });
             }
-            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'
-          });
-        }
       }
     },
 
@@ -260,68 +167,12 @@ export function extractActionContractsFromCode(filePath, workspaceRoot, code, li
           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, functionBodies, importMap, filePath, workspaceRoot, 0);
-        const viewSwitchCalls = findViewSwitchCallsInNode(handlerBody, functionBodies, importMap, filePath, workspaceRoot, 0);
+        const networkCalls = findNetworkCallsInNode(handlerBody);
         const isSubmitEvent = eventType === 'submit';
         
         for (const call of networkCalls) {
@@ -338,20 +189,14 @@ export function extractActionContractsFromCode(filePath, workspaceRoot, code, li
               selectorHint: null
             });
           } else if (call.kind !== 'VALIDATION_BLOCK') {
-            const contract = {
+            contracts.push({
               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);
+            });
           }
         }
       }
@@ -364,37 +209,22 @@ export function extractActionContractsFromCode(filePath, workspaceRoot, code, li
 /**
  * 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 with ${param} placeholders
+  // Build template string
   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 (truth boundary)
+    // Only support simple identifiers
     if (expr.type === 'Identifier') {
-      const paramName = expr.name;
-      templateStr += '${' + paramName + '}';
-      dynamicSegments.push(paramName);
+      templateStr += '${' + expr.name + '}';
     } else {
-      // Complex expression - reject (truth boundary)
       return null;
     }
     
@@ -403,150 +233,7 @@ function extractTemplateLiteralPath(node) {
     }
   }
   
-  // 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 [];
+  return templateStr;
 }
 
 /**
@@ -554,14 +241,9 @@ function followCrossFileFunction(importInfo, workspaceRoot, depth) {
  * 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, functionBodies = new Map(), importMap = new Map(), filePath = '', workspaceRoot = '', depth = 0) {
+function findNetworkCallsInNode(node) {
   const calls = [];
   
   // Track if we found preventDefault or return false for validation block detection
@@ -575,57 +257,27 @@ function findNetworkCallsInNode(node, functionBodies = new Map(), importMap = ne
     // 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];
 
-        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();
+        // 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();
+            }
           }
-        }
 
-        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
-            });
-          }
         }
       }
 
@@ -640,57 +292,7 @@ function findNetworkCallsInNode(node, functionBodies = new Map(), importMap = ne
        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
-              });
-            }
-          }
         }
       }
 
@@ -704,30 +306,15 @@ function findNetworkCallsInNode(node, functionBodies = new Map(), importMap = ne
        const methodArg = n.arguments[0];
        const urlArg = n.arguments[1];
 
-        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
-              });
-            }
-          }
+        if (
+          methodArg && methodArg.type === 'StringLiteral' &&
+          urlArg && urlArg.type === 'StringLiteral'
+        ) {
+          calls.push({
+            kind: 'NETWORK_ACTION',
+            method: methodArg.value.toUpperCase(),
+            url: urlArg.value,
+          });
         }
       }
       
@@ -832,211 +419,6 @@ function findNetworkCallsInNode(node, functionBodies = new Map(), importMap = ne
   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.
@@ -1108,10 +490,13 @@ export async function scanForContracts(rootPath, workspaceRoot) {
               const html = readFileSync(fullPath, 'utf-8');
               const scriptRegex = /<script[^>]*>([\s\S]*?)<\/script>/gi;
               let match;
+  // @ts-expect-error - readFileSync with encoding returns string
               while ((match = scriptRegex.exec(html)) !== null) {
                 const tagOpen = html.slice(match.index, html.indexOf('>', match.index) + 1);
+  // @ts-expect-error - readFileSync with encoding returns string
                 if (/\ssrc=/i.test(tagOpen)) continue; // skip external scripts
                 const before = html.slice(0, match.index);
+                // @ts-expect-error - readFileSync with encoding returns string
                 const lineOffset = (before.match(/\n/g) || []).length;
                 const code = match[1];
                 const blockContracts = extractActionContractsFromCode(fullPath, workspaceRoot, code, lineOffset + 1);