@veraxhq/verax 0.1.0 → 0.2.0

package/src/verax/learn/state-extractor.js

@@ -0,0 +1,212 @@
+import { parse } from '@babel/parser';
+import traverse from '@babel/traverse';
+import { readFileSync } from 'fs';
+import { glob } from 'glob';
+import { resolve } from 'path';
+import { ExpectationProof } from '../shared/expectation-proof.js';
+
+const MAX_FILES_TO_SCAN = 200;
+
+/**
+ * Extracts static string value from call expression arguments.
+ * Returns null if value is dynamic.
+ */
+function extractStaticActionName(node) {
+  if (!node) return null;
+  
+  // String literal: dispatch('increment')
+  if (node.type === 'StringLiteral') {
+    return node.value;
+  }
+  
+  // Template literal without interpolation: `increment`
+  if (node.type === 'TemplateLiteral' && node.expressions.length === 0) {
+    if (node.quasis.length === 1) {
+      return node.quasis[0].value.cooked;
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Extracts PROVEN state action expectations from Redux and Zustand patterns.
+ * 
+ * Supported patterns (all require static string literals):
+ * - Redux Toolkit: dispatch(increment()), dispatch(decrement())
+ * - Redux Toolkit: dispatch(slice.actions.increment())
+ * - Zustand: set((state) => ({ ... })) with key names
+ * 
+ * Returns array of state expectations with:
+ * - type: 'state_action'
+ * - expectedTarget: action name or store key
+ * - storeType: 'redux' | 'zustand'
+ * - sourceFile: string
+ * - proof: PROVEN_EXPECTATION
+ * - line: number
+ */
+function extractStateExpectations(filePath, fileContent) {
+  const expectations = [];
+  
+  try {
+    const ast = parse(fileContent, {
+      sourceType: 'module',
+      plugins: ['jsx', 'typescript']
+    });
+    
+    traverse.default(ast, {
+      // Redux dispatch(action())
+      CallExpression(path) {
+        const callee = path.node.callee;
+        
+        // dispatch(someAction())
+        if (callee.type === 'Identifier' && callee.name === 'dispatch') {
+          const firstArg = path.node.arguments[0];
+          
+          // dispatch(increment()) - action creator call
+          if (firstArg && firstArg.type === 'CallExpression') {
+            let actionName = null;
+            
+            // Simple action creator: increment()
+            if (firstArg.callee.type === 'Identifier') {
+              actionName = firstArg.callee.name;
+            }
+            
+            // Slice action: counterSlice.actions.increment()
+            else if (firstArg.callee.type === 'MemberExpression') {
+              const property = firstArg.callee.property;
+              if (property.type === 'Identifier') {
+                actionName = property.name;
+              }
+            }
+            
+            if (actionName) {
+              expectations.push({
+                type: 'state_action',
+                expectedTarget: actionName,
+                storeType: 'redux',
+                sourceFile: filePath,
+                proof: ExpectationProof.PROVEN_EXPECTATION,
+                line: path.node.loc?.start.line || null
+              });
+            }
+          }
+        }
+        
+        // Zustand set((state) => ({ key: value }))
+        if (callee.type === 'Identifier' && callee.name === 'set') {
+          const firstArg = path.node.arguments[0];
+          
+          // set((state) => ({ ... })) - arrow function returning object
+          if (firstArg && firstArg.type === 'ArrowFunctionExpression') {
+            const body = firstArg.body;
+            
+            // Arrow function body is object expression
+            if (body.type === 'ObjectExpression') {
+              for (const prop of body.properties) {
+                if (prop.type === 'ObjectProperty' && prop.key.type === 'Identifier') {
+                  const keyName = prop.key.name;
+                  expectations.push({
+                    type: 'state_action',
+                    expectedTarget: keyName,
+                    storeType: 'zustand',
+                    sourceFile: filePath,
+                    proof: ExpectationProof.PROVEN_EXPECTATION,
+                    line: path.node.loc?.start.line || null
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    });
+  } catch (error) {
+    // Parse error - skip this file
+    return [];
+  }
+  
+  return expectations;
+}
+
+/**
+ * Detects if project uses Redux or Zustand by scanning package.json and imports.
+ */
+function detectStateStores(projectDir) {
+  const stores = {
+    redux: false,
+    zustand: false
+  };
+  
+  try {
+    const pkgPath = resolve(projectDir, 'package.json');
+    const pkgContent = readFileSync(pkgPath, 'utf-8');
+    const pkg = JSON.parse(pkgContent);
+    
+    const allDeps = {
+      ...(pkg.dependencies || {}),
+      ...(pkg.devDependencies || {})
+    };
+    
+    if (allDeps['@reduxjs/toolkit'] || allDeps['redux']) {
+      stores.redux = true;
+    }
+    if (allDeps['zustand']) {
+      stores.zustand = true;
+    }
+  } catch (error) {
+    // No package.json or parse error
+  }
+  
+  return stores;
+}
+
+/**
+ * Scans project for state action expectations.
+ * Returns { expectations: [], storesDetected: { redux: bool, zustand: bool } }
+ */
+export async function extractStateExpectationsFromAST(projectDir) {
+  const storesDetected = detectStateStores(projectDir);
+  const expectations = [];
+  
+  // Only scan if supported stores are detected
+  if (!storesDetected.redux && !storesDetected.zustand) {
+    return { expectations: [], storesDetected };
+  }
+  
+  try {
+    const files = await glob('**/*.{js,jsx,ts,tsx}', {
+      cwd: projectDir,
+      absolute: false,
+      ignore: ['node_modules/**', 'dist/**', 'build/**', '.next/**', 'out/**']
+    });
+    
+    const filesToScan = files.slice(0, MAX_FILES_TO_SCAN);
+    
+    for (const file of filesToScan) {
+      try {
+        const filePath = resolve(projectDir, file);
+        const content = readFileSync(filePath, 'utf-8');
+        const fileExpectations = extractStateExpectations(file, content);
+        expectations.push(...fileExpectations);
+      } catch (error) {
+        continue;
+      }
+    }
+  } catch (error) {
+    return { expectations: [], storesDetected };
+  }
+  
+  // Deduplicate by target name
+  const seen = new Set();
+  const unique = [];
+  for (const exp of expectations) {
+    const key = `${exp.storeType}:${exp.expectedTarget}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      unique.push(exp);
+    }
+  }
+  
+  return { expectations: unique, storesDetected };
+}

package/src/verax/learn/static-extractor-navigation.js

@@ -0,0 +1,114 @@
+/**
+ * Extract navigation expectations from static HTML files.
+ * Detects router.push/replace/navigate calls in inline scripts.
+ */
+
+function extractNavigationExpectations(root, fromPath, file, projectDir) {
+  const expectations = [];
+  
+  // Extract from inline scripts
+  const scripts = root.querySelectorAll('script');
+  for (const script of scripts) {
+    const scriptContent = script.textContent || '';
+    if (!scriptContent) continue;
+    
+    // Find router.push/replace/navigate calls with string literals
+    const routerPushMatches = scriptContent.matchAll(/router\.push\s*\(\s*['"]([^'"]+)['"]/g);
+    const routerReplaceMatches = scriptContent.matchAll(/router\.replace\s*\(\s*['"]([^'"]+)['"]/g);
+    const navigateMatches = scriptContent.matchAll(/navigate\s*\(\s*['"]([^'"]+)['"]/g);
+    
+    for (const match of [...routerPushMatches, ...routerReplaceMatches, ...navigateMatches]) {
+      const target = match[1];
+      if (!target) continue;
+      
+      // Only extract if it's a relative path (starts with /)
+      if (!target.startsWith('/')) continue;
+      
+      // Find the button/function that triggers this
+      const buttonId = scriptContent.match(/getElementById\s*\(\s*['"]([^'"]+)['"]/)?.[1];
+      const functionName = scriptContent.match(/function\s+(\w+)\s*\(/)?.[1];
+      
+      let selectorHint = null;
+      if (buttonId) {
+        selectorHint = `#${buttonId}`;
+      } else if (functionName) {
+        // Try to find button with onclick that calls this function
+        const buttons = root.querySelectorAll(`button[onclick*="${functionName}"]`);
+        if (buttons.length > 0) {
+          const btn = buttons[0];
+          selectorHint = btn.id ? `#${btn.id}` : `button[onclick*="${functionName}"]`;
+        }
+      }
+      
+      if (selectorHint) {
+        // Determine method from match
+        let method = 'push';
+        if (match[0].includes('replace')) {
+          method = 'replace';
+        } else if (match[0].includes('navigate')) {
+          method = 'navigate';
+        }
+        
+        expectations.push({
+          fromPath: fromPath,
+          type: 'spa_navigation',
+          targetPath: target,
+          expectedTarget: target,
+          navigationMethod: method,
+          proof: 'PROVEN_EXPECTATION',
+          sourceRef: `${file}:${scriptContent.indexOf(match[0])}`,
+          selectorHint: selectorHint,
+          evidence: {
+            source: file,
+            selectorHint: selectorHint
+          }
+        });
+      }
+    }
+  }
+  
+  // Also check onclick attributes directly
+  const buttons = root.querySelectorAll('button[onclick]');
+  for (const button of buttons) {
+    const onclick = button.getAttribute('onclick') || '';
+    const routerPushMatch = onclick.match(/router\.push\s*\(\s*['"]([^'"]+)['"]/);
+    const routerReplaceMatch = onclick.match(/router\.replace\s*\(\s*['"]([^'"]+)['"]/);
+    const navigateMatch = onclick.match(/navigate\s*\(\s*['"]([^'"]+)['"]/);
+    
+    const match = routerPushMatch || routerReplaceMatch || navigateMatch;
+    if (match) {
+      const target = match[1];
+      if (target.startsWith('/')) {
+        const buttonId = button.getAttribute('id');
+        const selectorHint = buttonId ? `#${buttonId}` : `button[onclick*="${target}"]`;
+        
+        let method = 'push';
+        if (routerReplaceMatch) {
+          method = 'replace';
+        } else if (navigateMatch) {
+          method = 'navigate';
+        }
+        
+        expectations.push({
+          fromPath: fromPath,
+          type: 'spa_navigation',
+          targetPath: target,
+          expectedTarget: target,
+          navigationMethod: method,
+          proof: 'PROVEN_EXPECTATION',
+          sourceRef: `${file}:onclick`,
+          selectorHint: selectorHint,
+          evidence: {
+            source: file,
+            selectorHint: selectorHint
+          }
+        });
+      }
+    }
+  }
+  
+  return expectations;
+}
+
+export { extractNavigationExpectations };
+

package/src/verax/learn/static-extractor-validation.js

@@ -0,0 +1,88 @@
+/**
+ * Extract validation_block expectations from static HTML files.
+ * Detects preventDefault() calls in onSubmit handlers.
+ */
+
+function extractValidationExpectations(root, fromPath, file, projectDir) {
+  const expectations = [];
+  
+  // Extract from inline scripts
+  const scripts = root.querySelectorAll('script');
+  for (const script of scripts) {
+    const scriptContent = script.textContent || '';
+    if (!scriptContent) continue;
+    
+    // Find preventDefault() calls in functions that might be onSubmit handlers
+    const preventDefaultMatches = scriptContent.matchAll(/preventDefault\s*\(\s*\)/g);
+    
+    for (const match of preventDefaultMatches) {
+      // Check if this is in an onSubmit context
+      // Look for function definitions that might be onSubmit handlers
+      const beforeMatch = scriptContent.substring(0, match.index);
+      const afterMatch = scriptContent.substring(match.index);
+      
+      // Check if there's a function definition before this preventDefault
+      const functionMatch = beforeMatch.match(/function\s+(\w+)\s*\([^)]*event[^)]*\)/);
+      const onSubmitMatch = beforeMatch.match(/onsubmit\s*=\s*["'](\w+)["']/);
+      
+      let functionName = null;
+      if (functionMatch) {
+        functionName = functionMatch[1];
+      } else if (onSubmitMatch) {
+        functionName = onSubmitMatch[1];
+      }
+      
+      if (functionName) {
+        // Find form with onsubmit that calls this function
+        const forms = root.querySelectorAll(`form[onsubmit*="${functionName}"]`);
+        for (const form of forms) {
+          const formId = form.getAttribute('id');
+          const selectorHint = formId ? `#${formId}` : `form[onsubmit*="${functionName}"]`;
+          
+          expectations.push({
+            fromPath: fromPath,
+            type: 'validation_block',
+            proof: 'PROVEN_EXPECTATION',
+            sourceRef: `${file}:${scriptContent.substring(0, match.index).split('\n').length}`,
+            selectorHint: selectorHint,
+            handlerRef: `${file}:${functionName}`,
+            evidence: {
+              source: file,
+              selectorHint: selectorHint
+            }
+          });
+        }
+      }
+    }
+  }
+  
+  // Also check inline onsubmit attributes directly
+  const forms = root.querySelectorAll('form[onsubmit]');
+  for (const form of forms) {
+    const onsubmit = form.getAttribute('onsubmit') || '';
+    const preventDefaultMatch = onsubmit.match(/preventDefault\s*\(\s*\)/);
+    
+    if (preventDefaultMatch) {
+      const formId = form.getAttribute('id');
+      const selectorHint = formId ? `#${formId}` : `form[onsubmit*="preventDefault"]`;
+      
+      expectations.push({
+        fromPath: fromPath,
+        type: 'validation_block',
+        proof: 'PROVEN_EXPECTATION',
+        sourceRef: `${file}:onsubmit`,
+        selectorHint: selectorHint,
+        handlerRef: `${file}:onsubmit`,
+        evidence: {
+          source: file,
+          selectorHint: selectorHint
+        }
+      });
+    }
+  }
+  
+  return expectations;
+}
+
+export { extractValidationExpectations };
+

package/src/verax/learn/static-extractor.js

@@ -2,7 +2,6 @@ import { glob } from 'glob';
 import { resolve, dirname, join, relative } from 'path';
 import { readFileSync, existsSync } from 'fs';
 import { parse } from 'node-html-parser';
-import { ExpectationProof } from '../shared/expectation-proof.js';
 
 const MAX_HTML_FILES = 200;
 
@@ -121,7 +120,6 @@ function extractButtonNavigationExpectations(root, fromPath, file, routeMap, pro
         fromPath: fromPath,
         type: 'navigation',
         targetPath: targetPath,
-        proof: ExpectationProof.PROVEN_EXPECTATION,
         evidence: {
           source: file,
           selectorHint: selectorHint
@@ -151,7 +149,6 @@ function extractFormSubmissionExpectations(root, fromPath, file, routeMap, proje
       fromPath: fromPath,
       type: 'form_submission',
       targetPath: targetPath,
-      proof: ExpectationProof.PROVEN_EXPECTATION,
       evidence: {
         source: file,
         selectorHint: selectorHint
@@ -162,6 +159,105 @@ function extractFormSubmissionExpectations(root, fromPath, file, routeMap, proje
   return expectations;
 }
 
+function extractNetworkExpectations(root, fromPath, file, projectDir) {
+  const expectations = [];
+  
+  // Extract from inline scripts
+  const scripts = root.querySelectorAll('script');
+  for (const script of scripts) {
+    const scriptContent = script.textContent || '';
+    if (!scriptContent) continue;
+    
+    // Find fetch() calls with string literals
+    const fetchMatches = scriptContent.matchAll(/fetch\s*\(\s*['"]([^'"]+)['"]/g);
+    for (const match of fetchMatches) {
+      const endpoint = match[1];
+      if (!endpoint) continue;
+      
+      // Only extract if it's an API endpoint (starts with /api/)
+      if (!endpoint.startsWith('/api/')) continue;
+      
+      // Find the button/function that triggers this
+      // Look for onclick handlers or function definitions
+      const buttonId = scriptContent.match(/getElementById\s*\(\s*['"]([^'"]+)['"]/)?.[1];
+      const functionName = scriptContent.match(/function\s+(\w+)\s*\(/)?.[1];
+      
+      let selectorHint = null;
+      if (buttonId) {
+        selectorHint = `#${buttonId}`;
+      } else if (functionName) {
+        // Try to find button with onclick that calls this function
+        const buttons = root.querySelectorAll(`button[onclick*="${functionName}"]`);
+        if (buttons.length > 0) {
+          const btn = buttons[0];
+          selectorHint = btn.id ? `#${btn.id}` : `button[onclick*="${functionName}"]`;
+        }
+      }
+      
+      if (selectorHint) {
+        // Determine method from fetch options if present
+        let method = 'GET';
+        const methodMatch = scriptContent.match(/method\s*:\s*['"]([^'"]+)['"]/i);
+        if (methodMatch) {
+          method = methodMatch[1].toUpperCase();
+        }
+        
+        expectations.push({
+          fromPath: fromPath,
+          type: 'network_action',
+          expectedTarget: endpoint,
+          urlPath: endpoint,
+          method: method,
+          proof: 'PROVEN_EXPECTATION',
+          sourceRef: `${file}:${scriptContent.indexOf(match[0])}`,
+          selectorHint: selectorHint,
+          evidence: {
+            source: file,
+            selectorHint: selectorHint
+          }
+        });
+      }
+    }
+  }
+  
+  // Also check onclick attributes directly
+  const buttons = root.querySelectorAll('button[onclick]');
+  for (const button of buttons) {
+    const onclick = button.getAttribute('onclick') || '';
+    const fetchMatch = onclick.match(/fetch\s*\(\s*['"]([^'"]+)['"]/);
+    if (fetchMatch) {
+      const endpoint = fetchMatch[1];
+      if (endpoint.startsWith('/api/')) {
+        const buttonId = button.getAttribute('id');
+        const selectorHint = buttonId ? `#${buttonId}` : `button[onclick*="${endpoint}"]`;
+        
+        let method = 'GET';
+        const methodMatch = onclick.match(/method\s*:\s*['"]([^'"]+)['"]/i);
+        if (methodMatch) {
+          method = methodMatch[1].toUpperCase();
+        }
+        
+        expectations.push({
+          fromPath: fromPath,
+          type: 'network_action',
+          expectedTarget: endpoint,
+          urlPath: endpoint,
+          method: method,
+          proof: 'PROVEN_EXPECTATION',
+          sourceRef: `${file}:onclick`,
+          selectorHint: selectorHint,
+          evidence: {
+            source: file,
+            selectorHint: selectorHint
+          }
+        });
+      }
+    }
+  }
+  
+  return expectations;
+}
+
 export async function extractStaticExpectations(projectDir, routes) {
   const expectations = [];
   const routeMap = new Map(routes.map(r => [r.path, r]));
@@ -199,7 +295,6 @@ export async function extractStaticExpectations(projectDir, routes) {
           fromPath: fromPath,
           type: 'navigation',
           targetPath: targetPath,
-          proof: ExpectationProof.PROVEN_EXPECTATION,
           evidence: {
             source: file,
             selectorHint: selectorHint
@@ -212,6 +307,19 @@ export async function extractStaticExpectations(projectDir, routes) {
       
       const formExpectations = extractFormSubmissionExpectations(root, fromPath, file, routeMap, projectDir);
       expectations.push(...formExpectations);
+      
+      const networkExpectations = extractNetworkExpectations(root, fromPath, file, projectDir);
+      expectations.push(...networkExpectations);
+      
+      // NAVIGATION INTELLIGENCE v2: Extract navigation expectations from inline scripts
+      const { extractNavigationExpectations } = await import('./static-extractor-navigation.js');
+      const navigationExpectations = extractNavigationExpectations(root, fromPath, file, projectDir);
+      expectations.push(...navigationExpectations);
+      
+      // VALIDATION INTELLIGENCE v1: Extract validation_block expectations from inline scripts
+      const { extractValidationExpectations } = await import('./static-extractor-validation.js');
+      const validationExpectations = extractValidationExpectations(root, fromPath, file, projectDir);
+      expectations.push(...validationExpectations);
     } catch (error) {
       continue;
     }

package/src/verax/learn/truth-assessor.js

@@ -3,7 +3,7 @@ import { hasReactRouterDom } from './project-detector.js';
 
 const MAX_HTML_FILES = 200;
 
-export async function assessLearnTruth(projectDir, projectType, routes, staticExpectations, spaExpectations = null) {
+export async function assessLearnTruth(projectDir, projectType, routes, staticExpectations) {
   const truth = {
     routesDiscovered: routes.length,
     routesSource: 'none',
@@ -18,14 +18,24 @@ export async function assessLearnTruth(projectDir, projectType, routes, staticEx
   if (projectType === 'nextjs_app_router' || projectType === 'nextjs_pages_router') {
     truth.routesSource = 'nextjs_fs';
     truth.routesConfidence = 'HIGH';
+  } else if (projectType === 'vue_router') {
+    truth.routesSource = 'vue_router_ast';
+    truth.routesConfidence = 'HIGH';
     
-    // Wave 1 - CODE TRUTH ENGINE: Count AST-derived expectations
-    if (spaExpectations && spaExpectations.length > 0) {
-      truth.expectationsDiscovered = spaExpectations.length;
-      truth.expectationsStrong = spaExpectations.length;
+    if (staticExpectations && staticExpectations.length > 0) {
+      truth.expectationsDiscovered = staticExpectations.length;
+      truth.expectationsStrong = staticExpectations.filter(e => 
+        e.type === 'spa_navigation'
+      ).length;
       truth.expectationsWeak = 0;
-      truth.expectationsSource = 'ast_contracts';
     }
+  } else if (projectType === 'vue_spa') {
+    truth.routesSource = 'vue_no_router';
+    truth.routesConfidence = 'LOW';
+    truth.limitations.push({
+      code: 'VUE_ROUTER_NOT_INSTALLED',
+      message: 'Vue detected but vue-router not installed. Routes cannot be extracted from router configuration.'
+    });
   } else if (projectType === 'static') {
     truth.routesSource = 'static_html';
     
@@ -67,21 +77,14 @@ export async function assessLearnTruth(projectDir, projectType, routes, staticEx
       });
     }
     
-    // Wave 1 - CODE TRUTH ENGINE: Report AST-based expectations instead of routes
-    if (spaExpectations && spaExpectations.length > 0) {
-      truth.expectationsDiscovered = spaExpectations.length;
-      truth.expectationsStrong = spaExpectations.length;
-      truth.expectationsWeak = 0;
-      truth.expectationsSource = 'ast_contracts';
-    } else {
-      truth.expectationsDiscovered = 0;
-      truth.expectationsStrong = 0;
-      truth.expectationsWeak = 0;
-      truth.warnings.push({
-        code: 'NO_AST_CONTRACTS_FOUND',
-        message: 'No JSX Link/NavLink elements with static href/to found. No PROVEN expectations available.'
-      });
-    }
+    truth.warnings.push({
+      code: 'REACT_ROUTE_EXTRACTION_FRAGILE',
+      message: 'Route extraction uses regex parsing of source files. Dynamic routes, nested routers, and code-split route definitions may be missed.'
+    });
+    
+    truth.expectationsDiscovered = routes.length;
+    truth.expectationsStrong = routes.length;
+    truth.expectationsWeak = 0;
   } else if (projectType === 'unknown') {
     truth.routesSource = 'none';
     truth.routesConfidence = 'LOW';