@veraxhq/verax 0.2.0 → 0.3.0

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

@@ -1,13 +1,27 @@
 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';
 
 /**
  * Static Expectation Extractor
  * Extracts explicit, static expectations from source files
  */
 
-export async function extractExpectations(projectProfile, srcPath) {
+export async function extractExpectations(projectProfile, _srcPath) {
   const expectations = [];
   const skipped = {
     dynamic: 0,
@@ -68,6 +82,16 @@ function getScanPaths(projectProfile, sourceRoot) {
     return [sourceRoot];
   }
   
+  // Unknown framework or no framework detected - check if it's a static HTML project
+  // (This handles cases where framework detection failed but HTML files exist)
+  if (framework === 'unknown') {
+    const htmlFiles = readdirSync(sourceRoot, { withFileTypes: true })
+      .filter(e => e.isFile() && e.name.endsWith('.html'));
+    if (htmlFiles.length > 0) {
+      return [sourceRoot];
+    }
+  }
+  
   // Unknown framework - scan src if it exists
   const srcPath = resolve(sourceRoot, 'src');
   try {
@@ -138,8 +162,8 @@ function shouldSkipDirectory(name) {
  * Check if file should be scanned
  */
 function shouldScanFile(name) {
-  const extensions = ['.js', '.jsx', '.ts', '.tsx', '.html', '.mjs'];
-  return extensions.some(ext => name.endsWith(ext));
+  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'));
 }
 
 /**
@@ -155,6 +179,15 @@ function scanFile(filePath, sourceRoot, skipped) {
     if (filePath.endsWith('.html')) {
       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 {
       const jsExpectations = extractJsExpectations(content, filePath, relPath, skipped);
       expectations.push(...jsExpectations);
@@ -168,9 +201,11 @@ function scanFile(filePath, sourceRoot, skipped) {
 
 /**
  * Extract expectations from HTML files
+ * PHASE 9: Enhanced to extract network calls from <script> tags using AST
  */
 function extractHtmlExpectations(content, filePath, relPath) {
   const expectations = [];
+  const skipped = { dynamic: 0, computed: 0, external: 0, parseError: 0, other: 0 };
   
   // Extract <a href="/path"> links
   const hrefRegex = /<a\s+[^>]*href=["']([^"']+)["']/gi;
@@ -198,6 +233,72 @@ 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;
+    
+    // Skip empty scripts and external scripts
+    if (!scriptContent || scriptMatch[0].includes('src=')) {
+      continue;
+    }
+    
+    // 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++;
+    }
+    
+    scriptIndex++;
+  }
+  
   return expectations;
 }
 
@@ -208,76 +309,178 @@ function extractJsExpectations(content, filePath, relPath, skipped) {
   const expectations = [];
   const lines = content.split('\n');
   
-  lines.forEach((line, lineIdx) => {
-    const lineNum = lineIdx + 1;
-    
-    // Skip comments
-    if (line.trim().startsWith('//') || line.trim().startsWith('*')) {
-      return;
-    }
-    
-    // Extract Next.js <Link href="/path">
-    const linkRegex = /<Link\s+[^>]*href=["']([^"']+)["']/g;
-    let match;
-    while ((match = linkRegex.exec(line)) !== null) {
-      const href = match[1];
+    // 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 hrefs
-      if (!href.includes('${') && !href.includes('+') && !href.includes('`')) {
+      // 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: 'navigation',
+          type: 'network',
           promise: {
-            kind: 'navigate',
-            value: href,
+            kind: 'request',
+            value: url,
+            method: call.method,
           },
           source: {
             file: relPath,
-            line: lineNum,
-            column: match.index,
+            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,
           },
-          confidence: 1.0,
         });
       } else {
-        skipped.dynamic++;
+        // 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 router.push("/path")
-    const routerPushRegex = /router\.push\(["']([^"']+)["']\)/g;
-    while ((match = routerPushRegex.exec(line)) !== null) {
-      const path = match[1];
+    expectations.push({
+      type: 'state',
+      promise: {
+        kind: 'ui_state_change',
+        value: `${statePromise.stateName} in ${statePromise.componentName}`,
+        stateName: statePromise.stateName,
+        setterName: statePromise.setterName,
+      },
+      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
+      },
+    });
+  }
+  
+  // 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;
       
-      if (!path.includes('${') && !path.includes('+') && !path.includes('`')) {
+      // 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: path,
+            value: target,
           },
           source: {
             file: relPath,
-            line: lineNum,
-            column: match.index,
+            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,
+          },
         });
-      } else {
-        skipped.dynamic++;
       }
     }
+  }
+  
+  lines.forEach((line, lineIdx) => {
+    const lineNum = lineIdx + 1;
+    
+    // Skip comments
+    if (line.trim().startsWith('//') || line.trim().startsWith('*')) {
+      return;
+    }
     
-    // Extract fetch("https://...")
-    const fetchRegex = /fetch\(["']([^"']+)["']\)/g;
-    while ((match = fetchRegex.exec(line)) !== null) {
-      const url = match[1];
+    // Extract Next.js <Link href="/path">
+    const linkRegex = /<Link\s+[^>]*href=["']([^"']+)["']/g;
+    let match;
+    while ((match = linkRegex.exec(line)) !== null) {
+      const href = match[1];
       
-      // Only extract absolute URLs (https://)
-      if (url.startsWith('http://') || url.startsWith('https://')) {
+      // Skip dynamic hrefs
+      if (!href.includes('${') && !href.includes('+') && !href.includes('`')) {
         expectations.push({
-          type: 'network',
+          type: 'navigation',
           promise: {
-            kind: 'request',
-            value: url,
+            kind: 'navigate',
+            value: href,
           },
           source: {
             file: relPath,
@@ -286,24 +489,22 @@ function extractJsExpectations(content, filePath, relPath, skipped) {
           },
           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];
+    // Extract router.push("/path")
+    const routerPushRegex = /router\.push\(["']([^"']+)["']\)/g;
+    while ((match = routerPushRegex.exec(line)) !== null) {
+      const path = match[1];
       
-      if (url.startsWith('http://') || url.startsWith('https://')) {
+      if (!path.includes('${') && !path.includes('+') && !path.includes('`')) {
         expectations.push({
-          type: 'network',
+          type: 'navigation',
           promise: {
-            kind: 'request',
-            value: url,
+            kind: 'navigate',
+            value: path,
           },
           source: {
             file: relPath,
@@ -312,31 +513,11 @@ function extractJsExpectations(content, filePath, relPath, skipped) {
           },
           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) {
@@ -376,3 +557,128 @@ 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;
+}