@veraxhq/verax 0.1.0 → 0.2.1

package/src/verax/learn/project-detector.js

@@ -44,6 +44,34 @@ async function hasReactRouter(projectDir) {
   }
 }
 
+async function hasVue(projectDir) {
+  try {
+    const packageJsonPath = resolve(projectDir, 'package.json');
+    if (!existsSync(packageJsonPath)) return false;
+    
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    
+    return !!deps.vue;
+  } catch (error) {
+    return false;
+  }
+}
+
+async function hasVueRouter(projectDir) {
+  try {
+    const packageJsonPath = resolve(projectDir, 'package.json');
+    if (!existsSync(packageJsonPath)) return false;
+    
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    
+    return !!deps['vue-router'];
+  } catch (error) {
+    return false;
+  }
+}
+
 export async function detectProjectType(projectDir) {
   const appDir = resolve(projectDir, 'app');
   const pagesDir = resolve(projectDir, 'pages');
@@ -62,6 +90,17 @@ export async function detectProjectType(projectDir) {
         return 'nextjs_pages_router';
       }
     }
+
+    const hasVueDep = await hasVue(projectDir);
+    const hasVueRouterDep = await hasVueRouter(projectDir);
+    
+    if (hasVueDep && hasVueRouterDep) {
+      return 'vue_router';
+    }
+    
+    if (hasVueDep && !hasVueRouterDep) {
+      return 'vue_spa';
+    }
     
     const hasReact = await hasReactDependency(projectDir);
     const hasNext = await hasNextJs(projectDir);
@@ -85,3 +124,4 @@ export async function hasReactRouterDom(projectDir) {
   return await hasReactRouter(projectDir);
 }
 
+

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

@@ -1,5 +1,7 @@
-import { glob } from 'glob';
-import { resolve } from 'path';
+// resolve import removed - currently unused
+import { extractStaticRoutes } from './static-extractor.js';
+import { createTSProgram } from '../intel/ts-program.js';
+import { extractRoutes as extractRoutesAST } from '../intel/route-extractor.js';
 
 const INTERNAL_PATH_PATTERNS = [
   /^\/admin/,
@@ -14,109 +16,38 @@ function isInternalRoute(path) {
   return INTERNAL_PATH_PATTERNS.some(pattern => pattern.test(path));
 }
 
-function fileToAppRouterPath(file) {
-  let path = file.replace(/[\\\/]/g, '/');
-  path = path.replace(/(^|\/)page\.(js|jsx|ts|tsx)$/, '');
-  path = path.replace(/^\./, '');
-  
-  if (path === '' || path === '/') {
-    return '/';
-  }
-  
-  if (!path.startsWith('/')) {
-    path = '/' + path;
-  }
-  
-  path = path.replace(/\[([^\]]+)\]/g, ':$1');
-  path = path.replace(/\([^)]+\)/g, '');
-  
-  return path || '/';
-}
-
-function fileToPagesRouterPath(file) {
-  let path = file.replace(/[\\\/]/g, '/');
-  path = path.replace(/\.(js|jsx|ts|tsx)$/, '');
-  path = path.replace(/^index$/, '');
-  path = path.replace(/^\./, '');
-  
-  if (path === '' || path === '/') {
-    return '/';
-  }
-  if (!path.startsWith('/')) {
-    path = '/' + path;
-  }
-  
-  path = path.replace(/\[([^\]]+)\]/g, ':$1');
-  
-  return path || '/';
-}
-
-import { extractStaticRoutes } from './static-extractor.js';
-import { extractReactRouterRoutes } from './react-router-extractor.js';
-import { hasReactRouterDom } from './project-detector.js';
-
 export async function extractRoutes(projectDir, projectType) {
-  const routes = [];
-  const routeSet = new Set();
-  
+  // Static sites: use file-based extractor (no regex, just file system)
   if (projectType === 'static') {
     return await extractStaticRoutes(projectDir);
   }
-  
-  if (projectType === 'react_spa') {
-    const hasRouter = await hasReactRouterDom(projectDir);
-    if (hasRouter) {
-      return await extractReactRouterRoutes(projectDir);
-    }
-    return [];
-  }
-  
-  if (projectType === 'nextjs_app_router') {
-    const appDir = resolve(projectDir, 'app');
-    const pageFiles = await glob('**/page.{js,jsx,ts,tsx}', {
-      cwd: appDir,
-      absolute: false,
-      ignore: ['node_modules/**']
-    });
+
+  // React SPAs, Next.js, and Vue: use AST-based intel module (NO REGEX)
+  if (projectType === 'react_spa' || 
+      projectType === 'nextjs_app_router' || 
+      projectType === 'nextjs_pages_router' ||
+      projectType === 'vue_router' ||
+      projectType === 'vue_spa') {
+    const program = createTSProgram(projectDir, { includeJs: true });
     
-    for (const file of pageFiles) {
-      const routePath = fileToAppRouterPath(file);
-      const routeKey = routePath;
-      
-      if (!routeSet.has(routeKey)) {
-        routeSet.add(routeKey);
-        routes.push({
-          path: routePath,
-          source: `app/${file}`,
-          public: !isInternalRoute(routePath)
-        });
-      }
+    if (program.error) {
+      // Fallback: return empty routes if TS program creation fails
+      return [];
     }
-  } else if (projectType === 'nextjs_pages_router') {
-    const pagesDir = resolve(projectDir, 'pages');
-    const pageFiles = await glob('**/*.{js,jsx,ts,tsx}', {
-      cwd: pagesDir,
-      absolute: false,
-      ignore: ['node_modules/**', '_app.*', '_document.*', '_error.*']
-    });
     
-    for (const file of pageFiles) {
-      const routePath = fileToPagesRouterPath(file);
-      const routeKey = routePath;
-      
-      if (!routeSet.has(routeKey)) {
-        routeSet.add(routeKey);
-        routes.push({
-          path: routePath,
-          source: `pages/${file}`,
-          public: !isInternalRoute(routePath)
-        });
-      }
-    }
+    const astRoutes = extractRoutesAST(projectDir, program);
+    
+    // Convert AST routes to manifest format and sort for determinism
+    const routes = astRoutes.map(r => ({
+      path: r.path,
+      source: r.sourceRef || r.file || 'unknown',
+      public: r.public !== undefined ? r.public : !isInternalRoute(r.path),
+      sourceRef: r.sourceRef
+    }));
+    routes.sort((a, b) => a.path.localeCompare(b.path));
+    return routes;
   }
   
-  routes.sort((a, b) => a.path.localeCompare(b.path));
-  
-  return routes;
+  return [];
 }
 

package/src/verax/learn/route-validator.js

@@ -99,14 +99,15 @@ export async function validateRoutes(manifest, baseUrl) {
           
           const request = response.request();
           
-          // Use redirectChain() if available (preferred), otherwise use redirectedFrom()
+          // Use redirectChain property if available (Playwright API)
           let redirectChain = [];
-          if (typeof request.redirectChain === 'function') {
-            try {
-              redirectChain = request.redirectChain();
-            } catch (e) {
-              // redirectChain may not be available, fall back to redirectedFrom
-            }
+          // @ts-expect-error - redirectChain exists in Playwright runtime but not in TypeScript types
+          if (request.redirectChain && Array.isArray(request.redirectChain)) {
+            // @ts-expect-error - redirectChain exists in Playwright runtime but not in TypeScript types
+            redirectChain = request.redirectChain;
+          } else if (request.redirectedFrom) {
+            // Fall back to redirectedFrom if redirectChain not available
+            redirectChain = [request.redirectedFrom];
           }
           
           // If redirectChain is empty or not available, build chain from redirectedFrom

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 };
+