@veraxhq/verax 0.1.0 → 0.2.0

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

@@ -0,0 +1,172 @@
+/**
+ * FLOW INTELLIGENCE v1 — Flow Extractor
+ * 
+ * Extracts multi-step flows from PROVEN expectations.
+ * NO HEURISTICS: Only sequences with explicit PROVEN expectations qualify as flows.
+ */
+
+import { createHash } from 'crypto';
+import { isProvenExpectation } from '../shared/expectation-prover.js';
+
+/**
+ * Generate stable flow ID from ordered steps
+ */
+function generateFlowId(steps) {
+  const hashInput = steps.map(s => `${s.expectationType}:${s.source || s.handlerRef}`).join('|');
+  const hash = createHash('sha256').update(hashInput).digest('hex');
+  return `flow-${hash.substring(0, 8)}`;
+}
+
+/**
+ * Determine if an expectation can be part of a flow.
+ * Only PROVEN expectations with clear sequential intent qualify.
+ */
+function isFlowableExpectation(exp) {
+  // Navigation expectations: always flowable (user journey)
+  if (exp.expectationType === 'navigation') return true;
+  
+  // Network actions: flowable (form submissions, API calls)
+  if (exp.kind === 'NETWORK_ACTION') return true;
+  
+  // State actions: flowable (state updates in sequence)
+  if (exp.kind === 'STATE_ACTION') return true;
+  
+  // Validation blocks: NOT flowable alone (they block, don't progress)
+  if (exp.kind === 'VALIDATION_BLOCK') return false;
+  
+  return false;
+}
+
+/**
+ * Extract flows from manifest expectations.
+ * 
+ * Flow definition:
+ * - Sequence of 2-5 PROVEN expectations
+ * - Temporally ordered within same route/page
+ * - Each step must be deterministically executable
+ * 
+ * @param {Object} manifest - Learned manifest
+ * @returns {Array} Array of flow definitions
+ */
+export function extractFlows(manifest) {
+  const flows = [];
+  
+  // Collect all flowable expectations
+  const flowableExpectations = [];
+  
+  // SPA expectations (navigation)
+  if (manifest.spaExpectations && manifest.spaExpectations.length > 0) {
+    for (const exp of manifest.spaExpectations) {
+      if (isFlowableExpectation(exp)) {
+        flowableExpectations.push({
+          source: exp.source || exp.sourceFile,
+          expectationType: 'navigation',
+          targetPath: exp.targetPath,
+          proof: 'PROVEN_EXPECTATION',
+          raw: exp
+        });
+      }
+    }
+  }
+  
+  // Action contracts (network, state)
+  if (manifest.actionContracts && manifest.actionContracts.length > 0) {
+    for (const contract of manifest.actionContracts) {
+      if (isFlowableExpectation(contract)) {
+        flowableExpectations.push({
+          source: contract.source,
+          handlerRef: contract.handlerRef,
+          expectationType: contract.kind === 'NETWORK_ACTION' ? 'network_action' : 'state_action',
+          method: contract.method,
+          urlPath: contract.urlPath,
+          proof: 'PROVEN_EXPECTATION',
+          raw: contract
+        });
+      }
+    }
+  }
+  
+  // Static expectations (navigation, network_action, form submissions)
+  if (manifest.staticExpectations && manifest.staticExpectations.length > 0) {
+    for (const exp of manifest.staticExpectations) {
+      // FLOW INTELLIGENCE v1: Only include PROVEN expectations
+      if (!isProvenExpectation(exp)) continue;
+      
+      let expType = null;
+      if (exp.type === 'navigation' || exp.type === 'spa_navigation') {
+        expType = 'navigation';
+      } else if (exp.type === 'network_action') {
+        expType = 'network_action';
+      } else if (exp.type === 'form_submission') {
+        expType = 'network_action'; // Form submissions are network actions
+      } else {
+        continue; // Skip non-flowable types
+      }
+      
+      flowableExpectations.push({
+        source: exp.evidence?.source || exp.fromPath || exp.metadata?.elementFile,
+        handlerRef: exp.handlerRef || exp.metadata?.handlerFile,
+        expectationType: expType,
+        targetPath: exp.targetPath || exp.expectedTarget,
+        urlPath: exp.urlPath || exp.expectedTarget,
+        method: exp.method,
+        proof: 'PROVEN_EXPECTATION',
+        raw: exp
+      });
+    }
+  }
+  
+  // DETERMINISTIC FLOW DETECTION: Group by source page
+  // Flows are sequences on the same page (same source file/route)
+  const bySource = new Map();
+  
+  for (const exp of flowableExpectations) {
+    // Extract file name from source (e.g., "index.html" from "index.html:56:68")
+    let sourceKey = 'unknown';
+    if (exp.source) {
+      sourceKey = exp.source.split(':')[0]; // Get filename part
+    } else if (exp.handlerRef) {
+      sourceKey = exp.handlerRef.split(':')[0];
+    }
+    
+    if (!bySource.has(sourceKey)) {
+      bySource.set(sourceKey, []);
+    }
+    bySource.get(sourceKey).push(exp);
+  }
+  
+  // For each source, create flows of 2-5 sequential expectations
+  for (const [source, expectations] of bySource.entries()) {
+    if (expectations.length < 2) continue; // Need at least 2 for a flow
+    
+    // Take sequences of 2-5 expectations as potential flows
+    const maxFlowLength = Math.min(5, expectations.length);
+    
+    for (let length = 2; length <= maxFlowLength; length++) {
+      // Only create one flow per source (the full sequence up to 5 steps)
+      if (length === Math.min(expectations.length, 5)) {
+        const flowSteps = expectations.slice(0, length).map((exp, idx) => ({
+          stepIndex: idx,
+          expectationType: exp.expectationType,
+          source: exp.source,
+          handlerRef: exp.handlerRef,
+          targetPath: exp.targetPath,
+          method: exp.method,
+          urlPath: exp.urlPath
+        }));
+        
+        const flowId = generateFlowId(flowSteps);
+        
+        flows.push({
+          flowId,
+          source,
+          stepCount: length,
+          steps: flowSteps,
+          proof: 'PROVEN_EXPECTATION'
+        });
+      }
+    }
+  }
+  
+  return flows;
+}

package/src/verax/learn/manifest-writer.js

@@ -2,10 +2,11 @@ import { resolve } from 'path';
 import { writeFileSync, mkdirSync } from 'fs';
 import { extractStaticExpectations } from './static-extractor.js';
 import { assessLearnTruth } from './truth-assessor.js';
-import { ExpectationProof } from '../shared/expectation-proof.js';
-import { extractASTContracts, contractsToExpectations } from './ast-contract-extractor.js';
-import { scanForContracts } from './action-contract-extractor.js';
-import { resolveActionContracts } from './ts-contract-resolver.js';
+import { runCodeIntelligence } from '../intel/index.js';
+import { isProvenExpectation } from '../shared/expectation-prover.js';
+import { extractFlows } from './flow-extractor.js';
+import { createTSProgram } from '../intel/ts-program.js';
+import { extractVueNavigationPromises } from '../intel/vue-navigation-extractor.js';
 
 export async function writeManifest(projectDir, projectType, routes) {
   const publicRoutes = routes.filter(r => r.public).map(r => r.path);
@@ -19,7 +20,8 @@ export async function writeManifest(projectDir, projectType, routes) {
     routes: routes.map(r => ({
       path: r.path,
       source: r.source,
-      public: r.public
+      public: r.public,
+      sourceRef: r.sourceRef || null
     })),
     publicRoutes: publicRoutes,
     internalRoutes: internalRoutes,
@@ -27,49 +29,110 @@ export async function writeManifest(projectDir, projectType, routes) {
   };
   
   let staticExpectations = null;
-  let spaExpectations = null;
-  let actionContracts = null;
+  let intelExpectations = [];
+  let allExpectations = [];
   
+  // Static sites: extract from HTML
   if (projectType === 'static' && routes.length > 0) {
     staticExpectations = await extractStaticExpectations(projectDir, routes);
     manifest.staticExpectations = staticExpectations;
-    manifest.expectationProof = ExpectationProof.PROVEN_EXPECTATION;
-  } else if (projectType === 'react_spa' || projectType.startsWith('nextjs_')) {
-    // Wave 1 - CODE TRUTH ENGINE: Extract PROVEN contracts from AST
-    const contracts = await extractASTContracts(projectDir);
-    spaExpectations = contractsToExpectations(contracts, projectType);
+    allExpectations = staticExpectations || [];
+  }
+
+  // Vue projects: extract navigation promises from code
+  if (projectType === 'vue_router' || projectType === 'vue_spa') {
+    const program = createTSProgram(projectDir, { includeJs: true });
     
-    if (spaExpectations.length > 0) {
-      manifest.spaExpectations = spaExpectations;
-      manifest.expectationProof = ExpectationProof.PROVEN_EXPECTATION;
-    } else {
-      manifest.expectationProof = ExpectationProof.UNKNOWN_EXPECTATION;
+    if (!program.error) {
+      const vueNavPromises = extractVueNavigationPromises(program, projectDir);
+      
+      if (vueNavPromises && vueNavPromises.length > 0) {
+        intelExpectations = vueNavPromises.filter(exp => isProvenExpectation(exp));
+        
+        if (!manifest.staticExpectations) {
+          manifest.staticExpectations = [];
+        }
+        manifest.staticExpectations.push(...intelExpectations);
+        allExpectations = intelExpectations;
+      }
     }
-  } else {
-    manifest.expectationProof = ExpectationProof.UNKNOWN_EXPECTATION;
   }
   
-  // Wave 5/6 - ACTION CONTRACTS: Extract network action contracts (Babel inline + TS cross-file)
-  const shouldExtractActions = projectType === 'react_spa' || projectType.startsWith('nextjs_');
-  if (shouldExtractActions) {
-    const [babelContracts, tsContracts] = await Promise.all([
-      scanForContracts(projectDir, projectDir),
-      resolveActionContracts(projectDir, projectDir).catch(() => [])
-    ]);
-    const merged = dedupeActionContracts([...(babelContracts || []), ...(tsContracts || [])]);
-    if (merged.length > 0) {
-      actionContracts = merged;
-      manifest.actionContracts = actionContracts;
+  // React SPAs, Next.js, and Vue: use code intelligence (AST-based) - NO FALLBACKS
+  if (projectType === 'react_spa' || 
+      projectType === 'nextjs_app_router' || 
+      projectType === 'nextjs_pages_router' ||
+      projectType === 'vue_router' ||
+      projectType === 'vue_spa') {
+    const intelResult = await runCodeIntelligence(projectDir);
+    
+    if (!intelResult.error && intelResult.expectations) {
+      // ZERO-HEURISTIC: Only include expectations that pass isProvenExpectation()
+      intelExpectations = intelResult.expectations.filter(exp => isProvenExpectation(exp));
+      
+      // STATE INTELLIGENCE: Also extract state expectations from AST
+      const { extractStateExpectationsFromAST } = await import('./state-extractor.js');
+      const stateResult = await extractStateExpectationsFromAST(projectDir);
+      
+      if (stateResult.expectations && stateResult.expectations.length > 0) {
+        // Convert state expectations to manifest format with sourceRef
+        const stateExpectations = stateResult.expectations.map(exp => ({
+          type: 'state_action',
+          expectedTarget: exp.expectedTarget,
+          storeType: exp.storeType,
+          proof: 'PROVEN_EXPECTATION',
+          sourceRef: exp.line ? `${exp.sourceFile}:${exp.line}` : exp.sourceFile,
+          selectorHint: null, // State actions don't have selector hints from AST
+          metadata: {
+            sourceFile: exp.sourceFile,
+            line: exp.line
+          }
+        })).filter(exp => isProvenExpectation(exp));
+        
+        intelExpectations.push(...stateExpectations);
+      }
+      
+      // Add intel expectations to manifest
+      if (!manifest.staticExpectations) {
+        manifest.staticExpectations = [];
+      }
+      manifest.staticExpectations.push(...intelExpectations);
+      allExpectations = intelExpectations;
     }
   }
-
-  const learnTruth = await assessLearnTruth(projectDir, projectType, routes, staticExpectations, spaExpectations);
+  
+  // ZERO-HEURISTIC: Set expectationsStatus and coverageGaps
+  const provenCount = allExpectations.filter(exp => isProvenExpectation(exp)).length;
+  
+  if (provenCount === 0 && (projectType === 'react_spa' || 
+      projectType === 'nextjs_app_router' || 
+      projectType === 'nextjs_pages_router' ||
+      projectType === 'vue_router' ||
+      projectType === 'vue_spa')) {
+    manifest.expectationsStatus = 'NO_PROVEN_EXPECTATIONS';
+    manifest.coverageGaps = [{
+      reason: 'NO_PROVEN_EXPECTATIONS_AVAILABLE',
+      message: 'Code intelligence found no extractable literal effects (navigation, network, validation) with static string literals',
+      projectType: projectType
+    }];
+  } else {
+    manifest.expectationsStatus = 'PROVEN_EXPECTATIONS_AVAILABLE';
+    manifest.coverageGaps = [];
+  }
+  
+  // FLOW INTELLIGENCE v1: Extract flows from PROVEN expectations
+  const flows = extractFlows(manifest);
+  if (flows.length > 0) {
+    manifest.flows = flows;
+  }
+  
+  const learnTruth = await assessLearnTruth(projectDir, projectType, routes, allExpectations);
   manifest.notes.push({
     type: 'truth',
     learn: learnTruth
   });
   
-  const manifestDir = resolve(projectDir, '.verax', 'learn');
+  const manifestDir = resolve(projectDir, '.veraxverax', 'learn');
   mkdirSync(manifestDir, { recursive: true });
   
   const manifestPath = resolve(manifestDir, 'site-manifest.json');
@@ -78,20 +141,7 @@ export async function writeManifest(projectDir, projectType, routes) {
   return {
     ...manifest,
     manifestPath: manifestPath,
-    learnTruth: learnTruth,
-    actionContracts
+    learnTruth: learnTruth
   };
 }
 
-function dedupeActionContracts(contracts) {
-  const seen = new Set();
-  const out = [];
-  for (const c of contracts) {
-    const key = `${c.kind}|${c.method}|${c.urlPath}|${c.source || ''}|${c.handlerRef || ''}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push(c);
-  }
-  return out;
-}
-

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';
+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 [];
 }