@veraxhq/verax 0.3.0 → 0.4.0

package/src/cli/util/expectation-extractor.js

@@ -1,24 +1,12 @@
 import { readdirSync, readFileSync, statSync } from 'fs';
 import { join, relative, resolve } from 'path';
 import { expIdFromHash, compareExpectations } from './idgen.js';
-import { detectNetworkCallsAST } from './ast-network-detector.js';
-import { detectUseStatePromises } from './ast-usestate-detector.js';
-import { detectInteractiveElementsAST } from './ast-interactive-detector.js';
-import { extractVueSFC, extractTemplateBindings, mapTemplateHandlersToScript } from './vue-sfc-extractor.js';
-import { detectVueNavigationPromises } from './vue-navigation-detector.js';
-import { detectVueStatePromises } from './vue-state-detector.js';
-import { extractSvelteSFC, extractTemplateBindings as extractSvelteTemplateBindings, mapTemplateHandlersToScript as mapSvelteTemplateHandlersToScript } from './svelte-sfc-extractor.js';
-import { detectSvelteNavigation } from './svelte-navigation-detector.js';
-import { detectSvelteNetwork } from './svelte-network-detector.js';
-import { detectSvelteState } from './svelte-state-detector.js';
-import { extractAngularComponent, extractTemplateBindings as extractAngularTemplateBindings, mapTemplateHandlersToClass } from './angular-component-extractor.js';
-import { detectAngularNavigation } from './angular-navigation-detector.js';
-import { detectAngularNetwork } from './angular-network-detector.js';
-import { detectAngularState } from './angular-state-detector.js';
+import { extractPromisesFromAST } from './ast-promise-extractor.js';
 
 /**
  * Static Expectation Extractor
- * Extracts explicit, static expectations from source files
+ * PHASE H2/M2: AST-based promise extraction
+ * Extracts explicit, static expectations from source files using AST parsing
  */
 
 export async function extractExpectations(projectProfile, _srcPath) {
@@ -75,7 +63,16 @@ function getScanPaths(projectProfile, sourceRoot) {
   }
   
   if (framework === 'react-vite' || framework === 'react-cra') {
-    return [resolve(sourceRoot, 'src')];
+    const srcPath = resolve(sourceRoot, 'src');
+    try {
+      if (statSync(srcPath).isDirectory()) {
+        return [srcPath];
+      }
+    } catch (error) {
+      // src doesn't exist - scan root for React files
+    }
+    // Fallback: scan root directory for React files
+    return [sourceRoot];
   }
   
   if (framework === 'static-html') {
@@ -92,7 +89,7 @@ function getScanPaths(projectProfile, sourceRoot) {
     }
   }
   
-  // Unknown framework - scan src if it exists
+  // Unknown framework - scan src if it exists, otherwise scan root
   const srcPath = resolve(sourceRoot, 'src');
   try {
     if (statSync(srcPath).isDirectory()) {
@@ -102,7 +99,8 @@ function getScanPaths(projectProfile, sourceRoot) {
     // src doesn't exist
   }
   
-  return [];
+  // Fallback: scan root directory
+  return [sourceRoot];
 }
 
 /**
@@ -162,8 +160,8 @@ function shouldSkipDirectory(name) {
  * Check if file should be scanned
  */
 function shouldScanFile(name) {
-  const extensions = ['.js', '.jsx', '.ts', '.tsx', '.html', '.mjs', '.vue', '.svelte'];
-  return extensions.some(ext => name.endsWith(ext)) || (name.endsWith('.component.ts') || name.endsWith('.service.ts'));
+  const extensions = ['.js', '.jsx', '.ts', '.tsx', '.html', '.mjs'];
+  return extensions.some(ext => name.endsWith(ext));
 }
 
 /**
@@ -177,18 +175,15 @@ function scanFile(filePath, sourceRoot, skipped) {
     const relPath = relative(sourceRoot, filePath);
     
     if (filePath.endsWith('.html')) {
+      // HTML files: Use regex-based extraction (static HTML fallback)
       const htmlExpectations = extractHtmlExpectations(content, filePath, relPath);
       expectations.push(...htmlExpectations);
-    } else if (filePath.endsWith('.vue')) {
-      const vueExpectations = extractVueExpectations(content, filePath, relPath, skipped);
-      expectations.push(...vueExpectations);
-    } else if (filePath.endsWith('.svelte')) {
-      const svelteExpectations = extractSvelteExpectations(content, filePath, relPath, skipped);
-      expectations.push(...svelteExpectations);
-    } else if (filePath.endsWith('.component.ts') || (filePath.endsWith('.ts') && content.includes('@Component'))) {
-      const angularExpectations = extractAngularExpectations(content, filePath, relPath, skipped);
-      expectations.push(...angularExpectations);
     } else {
+      // JS/JSX/TS/TSX files: Use AST-based extraction (PHASE H2)
+      const astPromises = extractPromisesFromAST(content, filePath, relPath);
+      expectations.push(...astPromises);
+      
+      // Legacy regex-based extraction (preserved for navigation/network/state)
       const jsExpectations = extractJsExpectations(content, filePath, relPath, skipped);
       expectations.push(...jsExpectations);
     }
@@ -201,13 +196,12 @@ function scanFile(filePath, sourceRoot, skipped) {
 
 /**
  * Extract expectations from HTML files
- * PHASE 9: Enhanced to extract network calls from <script> tags using AST
+ * PHASE H2: Enhanced with button, form, and validation detection
  */
 function extractHtmlExpectations(content, filePath, relPath) {
   const expectations = [];
-  const skipped = { dynamic: 0, computed: 0, external: 0, parseError: 0, other: 0 };
   
-  // Extract <a href="/path"> links
+  // Extract <a href="/path"> links (navigation)
   const hrefRegex = /<a\s+[^>]*href=["']([^"']+)["']/gi;
   let match;
   
@@ -233,233 +227,143 @@ function extractHtmlExpectations(content, filePath, relPath) {
     }
   }
   
-  // PHASE 9: Extract JavaScript from <script> tags and detect network calls
-  const scriptRegex = /<script[^>]*>([\s\S]*?)<\/script>/gi;
-  let scriptMatch;
-  let scriptIndex = 0;
-  
-  while ((scriptMatch = scriptRegex.exec(content)) !== null) {
-    const scriptContent = scriptMatch[1].trim();
-    const scriptStartIndex = scriptMatch.index;
-    const scriptStartLine = content.substring(0, scriptStartIndex).split('\n').length;
+  // Extract <button> elements (interaction promise)
+  const buttonRegex = /<button\s+[^>]*>/gi;
+  while ((match = buttonRegex.exec(content)) !== null) {
+    const lineNum = content.substring(0, match.index).split('\n').length;
+    const buttonText = extractTextFromTag(content, match.index, 'button');
     
-    // Skip empty scripts and external scripts
-    if (!scriptContent || scriptMatch[0].includes('src=')) {
-      continue;
-    }
+    expectations.push({
+      category: 'button',
+      type: 'interaction',
+      promise: {
+        kind: 'click',
+        value: buttonText || 'button click',
+      },
+      source: {
+        file: relPath,
+        line: lineNum,
+        column: match.index - content.lastIndexOf('\n', match.index),
+      },
+      selector: buttonText ? `button:contains("${buttonText}")` : 'button',
+      action: 'click',
+      expectedOutcome: 'ui-change',
+      confidenceHint: 'low',
+    });
+  }
+  
+  // Extract <form> elements (submission promise)
+  const formRegex = /<form\s+[^>]*>/gi;
+  while ((match = formRegex.exec(content)) !== null) {
+    const lineNum = content.substring(0, match.index).split('\n').length;
+    const formTag = match[0];
     
-    // Use AST-based network detection on script content
-    try {
-      const networkCalls = detectNetworkCallsAST(scriptContent, filePath, relPath);
-      
-      for (const call of networkCalls) {
-        const url = call.url;
-        
-        // Skip dynamic URLs but count them
-        if (url === '<dynamic>') {
-          skipped.dynamic++;
-          continue;
-        }
-        
-        // Only extract absolute URLs (http/https) or relative API paths
-        if (url.startsWith('http://') || url.startsWith('https://') || url.startsWith('/api/')) {
-          // Calculate correct line number in HTML file
-          const callLineInScript = call.location.line || 1;
-          const htmlLineNumber = scriptStartLine + callLineInScript - 1;
-          
-          expectations.push({
-            type: 'network',
-            promise: {
-              kind: 'request',
-              value: url,
-              method: call.method,
-            },
-            source: {
-              file: relPath,
-              line: htmlLineNumber,
-              column: call.location.column || 0,
-              context: call.context,
-              astSource: call.astSource || null,
-            },
-            confidence: call.isUIBound ? 1.0 : 0.9,
-            metadata: {
-              networkKind: call.kind,
-              isUIBound: call.isUIBound || false,
-              astSource: call.astSource || null,
-            },
-          });
-        } else {
-          skipped.external++;
-        }
-      }
-    } catch (error) {
-      skipped.parseError++;
-    }
+    // Check for action attribute
+    const actionMatch = /action=["']([^"']+)["']/.exec(formTag);
+    const hasAction = actionMatch && actionMatch[1];
     
-    scriptIndex++;
+    expectations.push({
+      category: 'form',
+      type: 'interaction',
+      promise: {
+        kind: 'submit',
+        value: hasAction ? `form submit to ${actionMatch[1]}` : 'form submission',
+      },
+      source: {
+        file: relPath,
+        line: lineNum,
+        column: match.index - content.lastIndexOf('\n', match.index),
+      },
+      selector: hasAction ? `form[action="${actionMatch[1]}"]` : 'form',
+      action: 'submit',
+      expectedOutcome: hasAction ? 'navigation' : 'ui-change',
+      confidenceHint: hasAction ? 'medium' : 'low',
+    });
   }
   
-  return expectations;
-}
-
-/**
- * Extract expectations from JavaScript/TypeScript files
- */
-function extractJsExpectations(content, filePath, relPath, skipped) {
-  const expectations = [];
-  const lines = content.split('\n');
-  
-    // PHASE 9: AST-based network detection (handles nested contexts)
-    const networkCalls = detectNetworkCallsAST(content, filePath, relPath);
-    for (const call of networkCalls) {
-      const url = call.url;
-      
-      // Skip dynamic URLs but count them
-      if (url === '<dynamic>') {
-        skipped.dynamic++;
-        continue;
-      }
-      
-      // Only extract absolute URLs (http/https)
-      if (url.startsWith('http://') || url.startsWith('https://')) {
-        expectations.push({
-          type: 'network',
-          promise: {
-            kind: 'request',
-            value: url,
-            method: call.method,
-          },
-          source: {
-            file: relPath,
-            line: call.location.line,
-            column: call.location.column,
-            context: call.context,
-            // PHASE 9: Include AST source code for evidence
-            astSource: call.astSource || null,
-          },
-          confidence: call.isUIBound ? 1.0 : 0.9, // Higher confidence for UI-bound handlers
-          metadata: {
-            networkKind: call.kind,
-            isUIBound: call.isUIBound || false,
-            // PHASE 9: Include AST source in metadata for evidence generation
-            astSource: call.astSource || null,
-          },
-        });
-      } else {
-        // Relative or non-http URLs
-        skipped.external++;
-      }
-    }
-  
-  // PHASE 10: AST-based useState detection (state-driven UI promises)
-  const statePromises = detectUseStatePromises(content, filePath, relPath);
-  for (const statePromise of statePromises) {
-    // PHASE 10: Extract context and AST source from first setter call
-    const firstSetterCall = statePromise.metadata.setterCalls?.[0];
-    const context = firstSetterCall?.context || `component:${statePromise.componentName}`;
-    const astSource = firstSetterCall?.astSource || null;
-    const isUIBound = firstSetterCall?.isUIBound || false;
+  // Extract required input fields (validation promise)
+  const requiredRegex = /<input\s+[^>]*required[^>]*>/gi;
+  while ((match = requiredRegex.exec(content)) !== null) {
+    const lineNum = content.substring(0, match.index).split('\n').length;
+    const inputTag = match[0];
+    
+    // Extract name or id for selector
+    const nameMatch = /name=["']([^"']+)["']/.exec(inputTag);
+    const idMatch = /id=["']([^"']+)["']/.exec(inputTag);
+    const selector = nameMatch ? `input[name="${nameMatch[1]}"]` : 
+                     idMatch ? `input#${idMatch[1]}` : 'input[required]';
     
     expectations.push({
-      type: 'state',
+      category: 'validation',
+      type: 'feedback',
       promise: {
-        kind: 'ui_state_change',
-        value: `${statePromise.stateName} in ${statePromise.componentName}`,
-        stateName: statePromise.stateName,
-        setterName: statePromise.setterName,
+        kind: 'validation',
+        value: 'required field validation',
       },
       source: {
         file: relPath,
-        line: statePromise.location.line,
-        column: statePromise.location.column,
-        context: context, // PHASE 10: Enhanced context (handler/hook/function)
-        astSource: astSource, // PHASE 10: AST source for evidence
-      },
-      confidence: isUIBound ? 1.0 : 0.9, // PHASE 10: Higher confidence for UI-bound handlers
-      metadata: {
-        componentName: statePromise.componentName,
-        setterCallCount: statePromise.setterCallCount,
-        jsxUsageCount: statePromise.jsxUsageCount,
-        usageTypes: statePromise.usageTypes,
-        hasUpdaterFunction: statePromise.metadata.hasUpdaterFunction,
-        // PHASE 10: Include all setter calls with context and AST source
-        setterCalls: statePromise.metadata.setterCalls || [],
-        isUIBound: isUIBound,
-        astSource: astSource, // PHASE 10: AST source in metadata for evidence generation
+        line: lineNum,
+        column: match.index - content.lastIndexOf('\n', match.index),
       },
+      selector,
+      action: 'observe',
+      expectedOutcome: 'feedback',
+      confidenceHint: 'medium',
     });
   }
   
-  // PHASE 11: AST-based interactive element detection (elements without href)
-  const interactiveElements = detectInteractiveElementsAST(content, filePath, relPath);
-  for (const element of interactiveElements) {
-    // Only create expectations for elements with navigation promises
-    if (element.navigationPromise) {
-      const promise = element.navigationPromise;
-      
-      // Skip dynamic targets
-      if (promise.target === '<dynamic>') {
-        skipped.dynamic++;
-        continue;
-      }
-      
-      expectations.push({
-        type: 'navigation',
-        promise: {
-          kind: 'navigate',
-          value: promise.target,
-          method: promise.method || 'push',
-        },
-        source: {
-          file: relPath,
-          line: element.location.line,
-          column: element.location.column,
-          context: element.context,
-          astSource: element.astSource || promise.astSource || null,
-        },
-        confidence: element.isUIBound ? 1.0 : 0.9,
-        metadata: {
-          tagName: element.tagName,
-          role: element.role,
-          hasOnClick: element.hasOnClick,
-          hasOnSubmit: element.hasOnSubmit,
-          isRouterLink: element.isRouterLink,
-          navigationType: promise.type,
-          selectorHint: element.selectorHint,
-          isUIBound: element.isUIBound,
-          astSource: element.astSource || promise.astSource || null,
-        },
-      });
-    } else if (element.isRouterLink && (element.linkTo || element.linkHref)) {
-      // Router Link component with static href/to
-      const target = element.linkTo || element.linkHref;
-      
-      if (target && target !== '<dynamic>') {
-        expectations.push({
-          type: 'navigation',
-          promise: {
-            kind: 'navigate',
-            value: target,
-          },
-          source: {
-            file: relPath,
-            line: element.location.line,
-            column: element.location.column,
-            context: element.context,
-            astSource: element.astSource || null,
-          },
-          confidence: 1.0,
-          metadata: {
-            tagName: element.tagName,
-            isRouterLink: true,
-            selectorHint: element.selectorHint,
-            astSource: element.astSource || null,
-          },
-        });
-      }
-    }
+  // Extract aria-live regions (feedback promise)
+  const ariaLiveRegex = /<[^>]+aria-live=["']([^"']+)["'][^>]*>/gi;
+  while ((match = ariaLiveRegex.exec(content)) !== null) {
+    const lineNum = content.substring(0, match.index).split('\n').length;
+    
+    expectations.push({
+      category: 'feedback',
+      type: 'feedback',
+      promise: {
+        kind: 'ui-feedback',
+        value: 'live region update',
+      },
+      source: {
+        file: relPath,
+        line: lineNum,
+        column: match.index - content.lastIndexOf('\n', match.index),
+      },
+      selector: '[aria-live]',
+      action: 'observe',
+      expectedOutcome: 'feedback',
+      confidenceHint: 'medium',
+    });
   }
   
+  return expectations;
+}
+
+/**
+ * Extract text content from HTML tag
+ */
+function extractTextFromTag(content, startIndex, tagName) {
+  const closeTagRegex = new RegExp(`</${tagName}>`, 'i');
+  const closeMatch = closeTagRegex.exec(content.substring(startIndex));
+  
+  if (!closeMatch) return '';
+  
+  const endOfOpenTag = content.indexOf('>', startIndex);
+  if (endOfOpenTag === -1) return '';
+  
+  const textContent = content.substring(endOfOpenTag + 1, startIndex + closeMatch.index);
+  
+  // Strip HTML tags and trim
+  return textContent.replace(/<[^>]+>/g, '').trim();
+}
+
+/**
+ * Extract expectations from JavaScript/TypeScript files
+ */
+function extractJsExpectations(content, filePath, relPath, skipped) {
+  const expectations = [];
+  const lines = content.split('\n');
+  
   lines.forEach((line, lineIdx) => {
     const lineNum = lineIdx + 1;
     
@@ -518,6 +422,77 @@ function extractJsExpectations(content, filePath, relPath, skipped) {
       }
     }
     
+    // Extract fetch("https://...")
+    const fetchRegex = /fetch\(["']([^"']+)["']\)/g;
+    while ((match = fetchRegex.exec(line)) !== null) {
+      const url = match[1];
+      
+      // Only extract absolute URLs (https://)
+      if (url.startsWith('http://') || url.startsWith('https://')) {
+        expectations.push({
+          type: 'network',
+          promise: {
+            kind: 'request',
+            value: url,
+          },
+          source: {
+            file: relPath,
+            line: lineNum,
+            column: match.index,
+          },
+          confidence: 1.0,
+        });
+      } else if (!url.includes('${') && !url.includes('+') && !url.includes('`')) {
+        skipped.external++;
+      } else {
+        skipped.dynamic++;
+      }
+    }
+    
+    // Extract axios.get/post("https://...")
+    const axiosRegex = /axios\.(get|post|put|delete|patch)\(["']([^"']+)["']\)/g;
+    while ((match = axiosRegex.exec(line)) !== null) {
+      const url = match[2];
+      
+      if (url.startsWith('http://') || url.startsWith('https://')) {
+        expectations.push({
+          type: 'network',
+          promise: {
+            kind: 'request',
+            value: url,
+          },
+          source: {
+            file: relPath,
+            line: lineNum,
+            column: match.index,
+          },
+          confidence: 1.0,
+        });
+      } else if (!url.includes('${') && !url.includes('+') && !url.includes('`')) {
+        skipped.external++;
+      } else {
+        skipped.dynamic++;
+      }
+    }
+    
+    // Extract useState setters
+    const useStateRegex = /useState\([^)]*\)/g;
+    if ((match = useStateRegex.exec(line)) !== null) {
+      expectations.push({
+        type: 'state',
+        promise: {
+          kind: 'state_mutation',
+          value: 'state management',
+        },
+        source: {
+          file: relPath,
+          line: lineNum,
+          column: match.index,
+        },
+        confidence: 0.8,
+      });
+    }
+    
     // Extract Redux dispatch calls
     const dispatchRegex = /dispatch\(\{/g;
     if ((match = dispatchRegex.exec(line)) !== null) {
@@ -557,128 +532,3 @@ function extractJsExpectations(content, filePath, relPath, skipped) {
   
   return expectations;
 }
-
-/**
- * PHASE 20: Extract expectations from Vue SFC files
- */
-function extractVueExpectations(content, filePath, relPath, skipped) {
-  const expectations = [];
-  
-  try {
-    // Extract SFC blocks
-    const sfc = extractVueSFC(content);
-    
-    // Extract template bindings
-    let templateBindings = null;
-    if (sfc.template) {
-      templateBindings = extractTemplateBindings(sfc.template.content);
-    }
-    
-    // Process each script block
-    for (const scriptBlock of sfc.scriptBlocks) {
-      const scriptContent = scriptBlock.content;
-      const startLine = scriptBlock.startLine;
-      
-      // Map template handlers to script functions
-      let handlerMap = new Map();
-      if (templateBindings) {
-        handlerMap = mapTemplateHandlersToScript(templateBindings, [scriptBlock]);
-      }
-      
-      // PHASE 20: Detect Vue navigation promises (router-link, router.push/replace)
-      const navigationPromises = detectVueNavigationPromises(
-        scriptContent,
-        filePath,
-        relPath,
-        scriptBlock,
-        templateBindings
-      );
-      
-      for (const navPromise of navigationPromises) {
-        // Adjust line numbers for SFC
-        navPromise.source.line = startLine + (navPromise.source.line || 1) - 1;
-        expectations.push(navPromise);
-      }
-      
-      // PHASE 20: Detect network calls in Vue script blocks
-      const networkCalls = detectNetworkCallsAST(scriptContent, filePath, relPath);
-      for (const call of networkCalls) {
-        const url = call.url;
-        
-        if (url === '<dynamic>') {
-          skipped.dynamic++;
-          continue;
-        }
-        
-        // Check if handler is UI-bound via template
-        const isUIBound = handlerMap.has(call.handlerName || '');
-        
-        if (url.startsWith('http://') || url.startsWith('https://') || url.startsWith('/api/')) {
-          expectations.push({
-            type: 'network',
-            promise: {
-              kind: 'request',
-              value: url,
-              method: call.method,
-            },
-            source: {
-              file: relPath,
-              line: startLine + (call.location.line || 1) - 1,
-              column: call.location.column || 0,
-              context: call.context,
-              astSource: call.astSource || null,
-            },
-            confidence: isUIBound ? 1.0 : 0.9,
-            metadata: {
-              networkKind: call.kind,
-              isUIBound: isUIBound || false,
-              astSource: call.astSource || null,
-            },
-          });
-        } else {
-          skipped.external++;
-        }
-      }
-      
-      // PHASE 20: Detect Vue state promises (ref/reactive)
-      if (templateBindings) {
-        const statePromises = detectVueStatePromises(
-          scriptContent,
-          filePath,
-          relPath,
-          scriptBlock,
-          templateBindings
-        );
-        
-        for (const statePromise of statePromises) {
-          statePromise.source.line = startLine + (statePromise.source.line || 1) - 1;
-          expectations.push(statePromise);
-        }
-      }
-      
-      // PHASE 20: Detect interactive elements from template
-      if (templateBindings) {
-        for (const routerLink of templateBindings.routerLinks) {
-          expectations.push({
-            type: 'navigation',
-            promise: {
-              kind: 'navigate',
-              value: routerLink.to,
-            },
-            source: {
-              file: relPath,
-              line: sfc.template.startLine,
-              column: 0,
-              context: 'template',
-            },
-            confidence: 1.0,
-          });
-        }
-      }
-    }
-  } catch (error) {
-    skipped.parseError++;
-  }
-  
-  return expectations;
-}