@veraxhq/verax 0.1.0 → 0.2.0

package/src/verax/detect/index.js

@@ -1,29 +1,13 @@
 import { readFileSync, existsSync } from 'fs';
-import { getExpectation } from './expectation-model.js';
+import { dirname } from 'path';
+import { expectsNavigation } from './expectation-model.js';
 import { hasMeaningfulUrlChange, hasVisibleChange, hasDomChange } from './comparison.js';
 import { writeFindings } from './findings-writer.js';
 import { getUrlPath } from './evidence-validator.js';
 import { classifySkipReason, collectSkipReasons } from './skip-classifier.js';
-import { ExpectationProof } from '../shared/expectation-proof.js';
-import { computeConfidence } from './confidence-engine.js';
+import { detectInteractiveFindings } from './interactive-findings.js';
 
-// Helper to create finding with confidence score
-function createFindingWithConfidence(baseFinding, expectationInfo, sensors, comparisons) {
-  const confidence = computeConfidence({
-    findingType: baseFinding.type,
-    expectation: expectationInfo,
-    sensors: sensors,
-    comparisons: comparisons,
-    attemptMeta: {}
-  });
-  
-  return {
-    ...baseFinding,
-    confidence
-  };
-}
-
-export async function detect(manifestPath, tracesPath, validation = null, artifactPaths = null) {
+export async function detect(manifestPath, tracesPath, validation = null) {
   if (!existsSync(manifestPath)) {
     throw new Error(`Manifest not found: ${manifestPath}`);
   }
@@ -52,334 +36,236 @@ export async function detect(manifestPath, tracesPath, validation = null, artifa
     const beforeScreenshot = trace.before.screenshot;
     const afterScreenshot = trace.after.screenshot;
     
-    // Get expectation with proof status (Wave 0 - TRUTH LOCK, Wave 5 - ACTION CONTRACTS)
-    const attemptMeta = trace.meta || {};
-    const expectationInfo = getExpectation(manifest, interaction, beforeUrl, attemptMeta);
+    const expectsNav = expectsNavigation(manifest, interaction, beforeUrl);
     
-    // Only analyze interactions with PROVEN expectations
-    if (!expectationInfo.hasExpectation || expectationInfo.proof !== ExpectationProof.PROVEN_EXPECTATION) {
+    if (!expectsNav) {
       interactionsSkippedNoExpectation++;
-      const skipReason = {
-        code: 'UNPROVEN_EXPECTATION',
-        message: 'No proven code-derived expectation for this interaction',
-        interaction: {
-          type: interaction.type,
-          selector: interaction.selector,
-          label: interaction.label
-        },
-        expectationProof: expectationInfo.proof
-      };
-      skips.push(skipReason);
+      const skipReason = classifySkipReason(manifest, interaction, beforeUrl, validation);
+      if (skipReason) {
+        skips.push({
+          code: skipReason.code,
+          message: skipReason.message,
+          interaction: {
+            type: interaction.type,
+            selector: interaction.selector,
+            label: interaction.label
+          }
+        });
+      }
       continue;
     }
     
-    const expectedTargetPath = expectationInfo.expectedTargetPath;
-    const expectationType = expectationInfo.expectationType;
-    
-    // Expectation is PROVEN, proceed with analysis
-    interactionsAnalyzed++;
+    let expectedTargetPath = null;
+    let expectationType = null;
+    let selectorMismatch = false;
+    let multipleMatches = false;
     
-    const hasUrlChange = hasMeaningfulUrlChange(beforeUrl, afterUrl);
-    const hasVisibleChangeResult = hasVisibleChange(beforeScreenshot, afterScreenshot, projectDir);
-    const hasDomChangeResult = hasDomChange(trace);
-    
-    // Wave 3: Analyze sensor data for silent failures
-    const sensorData = trace.sensors || {};
-    const networkSummary = sensorData.network || {};
-    const consoleSummary = sensorData.console || {};
-    const uiSignalChanges = sensorData.uiSignals?.changes || {};
-    
-    // All expectations reaching here are PROVEN with explicit target paths
-    const afterPath = getUrlPath(afterUrl);
-    const normalizedTarget = expectedTargetPath.replace(/\/$/, '') || '/';
-    const normalizedAfter = afterPath ? afterPath.replace(/\/$/, '') || '/' : '';
-    
-    if (expectationType === 'form_submission') {
-      if (normalizedAfter !== normalizedTarget && !hasUrlChange && !hasDomChangeResult) {
-        // Check for network errors during form submission
-        if (networkSummary.failedRequests > 0) {
-          const finding = createFindingWithConfidence({
-            type: 'network_silent_failure',
-            interaction: {
-              type: interaction.type,
-              selector: interaction.selector,
-              label: interaction.label
-            },
-            reason: 'Form submission triggered network errors with no UI feedback',
-            expectationProof: ExpectationProof.PROVEN_EXPECTATION,
-            evidence: {
-              before: beforeScreenshot,
-              after: afterScreenshot,
-              beforeUrl: beforeUrl,
-              afterUrl: afterUrl,
-              networkErrors: networkSummary.failedRequests,
-              failedByStatus: networkSummary.failedByStatus,
-              topFailedUrls: networkSummary.topFailedUrls
+    if (manifest.staticExpectations && manifest.staticExpectations.length > 0) {
+      const beforePath = getUrlPath(beforeUrl);
+      if (beforePath) {
+        const normalizedBefore = beforePath.replace(/\/$/, '') || '/';
+        const matchingExpectations = [];
+        
+        for (const expectation of manifest.staticExpectations) {
+          const normalizedFrom = expectation.fromPath.replace(/\/$/, '') || '/';
+          if (normalizedFrom === normalizedBefore) {
+            const selectorHint = expectation.selectorHint || '';
+            const interactionSelector = interaction.selector || '';
+            
+            if (selectorHint && interactionSelector) {
+              const normalizedSelectorHint = selectorHint.replace(/[\[\]()]/g, '');
+              const normalizedInteractionSelector = interactionSelector.replace(/[\[\]()]/g, '');
+              
+              if (selectorHint === interactionSelector || 
+                  selectorHint.includes(interactionSelector) || 
+                  interactionSelector.includes(normalizedSelectorHint) ||
+                  normalizedSelectorHint === normalizedInteractionSelector) {
+                if (expectation.type === 'navigation' && (interaction.type === 'link' || interaction.type === 'button')) {
+                  matchingExpectations.push(expectation);
+                } else if (expectation.type === 'form_submission' && interaction.type === 'form') {
+                  matchingExpectations.push(expectation);
+                }
+              } else {
+                if (expectation.type === 'navigation' && (interaction.type === 'link' || interaction.type === 'button')) {
+                  selectorMismatch = true;
+                } else if (expectation.type === 'form_submission' && interaction.type === 'form') {
+                  selectorMismatch = true;
+                }
+              }
+            } else if (!selectorHint && !interactionSelector) {
+              if (expectation.type === 'navigation' && (interaction.type === 'link' || interaction.type === 'button')) {
+                matchingExpectations.push(expectation);
+              } else if (expectation.type === 'form_submission' && interaction.type === 'form') {
+                matchingExpectations.push(expectation);
+              }
             }
-          }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
-          findings.push(finding);
+          }
         }
-        // Check for validation errors (console errors with no feedback)
-        else if (consoleSummary.hasErrors && !uiSignalChanges.changed) {
-          const finding = createFindingWithConfidence({
-            type: 'validation_silent_failure',
+        
+        if (matchingExpectations.length > 1) {
+          multipleMatches = true;
+        } else if (matchingExpectations.length === 1) {
+          expectedTargetPath = matchingExpectations[0].targetPath;
+          expectationType = matchingExpectations[0].type;
+        } else if (selectorMismatch) {
+          skips.push({
+            code: 'SELECTOR_MISMATCH',
+            message: 'Expectations exist but selector mismatch and no safe fallback match',
             interaction: {
               type: interaction.type,
               selector: interaction.selector,
               label: interaction.label
-            },
-            reason: 'Form validation errors logged to console with no visible feedback',
-            expectationProof: ExpectationProof.PROVEN_EXPECTATION,
-            evidence: {
-              before: beforeScreenshot,
-              after: afterScreenshot,
-              beforeUrl: beforeUrl,
-              afterUrl: afterUrl,
-              consoleErrors: consoleSummary.consoleErrorCount,
-              errorMessages: consoleSummary.lastErrors?.slice(0, 3)
             }
-          }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
-          findings.push(finding);
+          });
+          interactionsSkippedNoExpectation++;
+          continue;
         }
-        // Check for missing loading/error feedback
-        else if (!uiSignalChanges.changed) {
-          const finding = createFindingWithConfidence({
-            type: 'missing_feedback_failure',
-            interaction: {
-              type: interaction.type,
-              selector: interaction.selector,
-              label: interaction.label
-            },
-            reason: 'Form submission occurred with no loading or error feedback',
-            expectationProof: ExpectationProof.PROVEN_EXPECTATION,
-            evidence: {
-              before: beforeScreenshot,
-              after: afterScreenshot,
-              beforeUrl: beforeUrl,
-              afterUrl: afterUrl,
-              networkActivity: networkSummary.totalRequests || 0,
-              hadFeedback: uiSignalChanges.changed || false
+      }
+    }
+    
+    if (!expectedTargetPath && manifest.projectType === 'react_spa' && interaction.type === 'link') {
+      const beforePath = getUrlPath(beforeUrl);
+      if (beforePath) {
+        const matchingRoutes = [];
+        const unreachableRoutes = new Set();
+        
+        if (validation && validation.details) {
+          for (const detail of validation.details) {
+            if (detail.status === 'UNREACHABLE') {
+              unreachableRoutes.add(detail.path);
             }
-          }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
-          findings.push(finding);
+          }
+        }
+        
+        for (const route of manifest.routes) {
+          if (!route.public) continue;
+          if (unreachableRoutes.has(route.path)) {
+            continue;
+          }
+          const routePath = route.path.toLowerCase();
+          const routeName = routePath.split('/').pop() || 'home';
+          const interactionLabel = (interaction.label || '').toLowerCase().trim();
+          
+          if (interactionLabel.includes(routeName) || routeName.includes(interactionLabel)) {
+            matchingRoutes.push(route.path);
+          }
         }
-        // Generic no-effect failure (no network, no console errors, no visible changes)
-        else {
-          const finding = createFindingWithConfidence({
-            type: 'no_effect_silent_failure',
+        
+        if (matchingRoutes.length > 1) {
+          skips.push({
+            code: 'AMBIGUOUS_MATCH',
+            message: 'Multiple expectations could match; conservative approach requires single clear match',
             interaction: {
               type: interaction.type,
               selector: interaction.selector,
               label: interaction.label
-            },
-            reason: 'Expected form submission did not occur',
-            expectationProof: ExpectationProof.PROVEN_EXPECTATION,
-            evidence: {
-              before: beforeScreenshot,
-              after: afterScreenshot,
-              beforeUrl: beforeUrl,
-              afterUrl: afterUrl
             }
-          }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
-          findings.push(finding);
+          });
+          interactionsSkippedNoExpectation++;
+          continue;
+        } else if (matchingRoutes.length === 1) {
+          expectedTargetPath = matchingRoutes[0];
+          expectationType = 'navigation';
         }
       }
-    } else if (expectationType === 'navigation' || expectationType === 'spa_navigation') {
-      // Wave 1: spa_navigation expectations from AST contracts
-      const urlMatchesTarget = normalizedAfter === normalizedTarget;
-      const hasEffect = urlMatchesTarget || hasVisibleChangeResult || hasDomChangeResult;
+    }
+    
+    if (multipleMatches) {
+      skips.push({
+        code: 'AMBIGUOUS_MATCH',
+        message: 'Multiple expectations could match; conservative approach requires single clear match',
+        interaction: {
+          type: interaction.type,
+          selector: interaction.selector,
+          label: interaction.label
+        }
+      });
+      interactionsSkippedNoExpectation++;
+      continue;
+    }
+    
+    interactionsAnalyzed++;
+    
+    const hasUrlChange = hasMeaningfulUrlChange(beforeUrl, afterUrl);
+    const hasVisibleChangeResult = hasVisibleChange(beforeScreenshot, afterScreenshot, projectDir);
+    const hasDomChangeResult = hasDomChange(trace);
+    
+    if (expectedTargetPath) {
+      const afterPath = getUrlPath(afterUrl);
+      const normalizedTarget = expectedTargetPath.replace(/\/$/, '') || '/';
+      const normalizedAfter = afterPath ? afterPath.replace(/\/$/, '') || '/' : '';
       
-      if (!hasEffect) {
-        // Check what prevented the navigation
-        if (networkSummary.failedRequests > 0) {
-          const finding = createFindingWithConfidence({
-            type: 'network_silent_failure',
+      if (expectationType === 'form_submission') {
+        if (normalizedAfter !== normalizedTarget && !hasUrlChange && !hasDomChangeResult) {
+          findings.push({
+            type: 'silent_failure',
             interaction: {
               type: interaction.type,
               selector: interaction.selector,
               label: interaction.label
             },
-            reason: 'Navigation attempt resulted in network errors with no UI feedback',
-            expectationProof: ExpectationProof.PROVEN_EXPECTATION,
-            evidence: {
-              before: beforeScreenshot,
-              after: afterScreenshot,
-              beforeUrl: beforeUrl,
-              afterUrl: afterUrl,
-              networkErrors: networkSummary.failedRequests,
-              topFailedUrls: networkSummary.topFailedUrls
-            }
-          }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
-          findings.push(finding);
-        } else if (consoleSummary.hasErrors) {
-          const finding = createFindingWithConfidence({
-            type: 'validation_silent_failure',
-            interaction: {
-              type: interaction.type,
-              selector: interaction.selector,
-              label: interaction.label
-            },
-            reason: 'Navigation blocked by client-side validation errors',
-            expectationProof: ExpectationProof.PROVEN_EXPECTATION,
-            evidence: {
-              before: beforeScreenshot,
-              after: afterScreenshot,
-              beforeUrl: beforeUrl,
-              afterUrl: afterUrl,
-              consoleErrors: consoleSummary.consoleErrorCount,
-              errorMessages: consoleSummary.lastErrors?.slice(0, 3)
-            }
-          }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
-          findings.push(finding);
-        } else if (networkSummary.slowRequestsCount > 0 && !uiSignalChanges.changed) {
-          const finding = createFindingWithConfidence({
-            type: 'missing_feedback_failure',
-            interaction: {
-              type: interaction.type,
-              selector: interaction.selector,
-              label: interaction.label
-            },
-            reason: 'Slow navigation request with no loading indicator',
-            expectationProof: ExpectationProof.PROVEN_EXPECTATION,
+            reason: 'Expected form submission did not occur',
             evidence: {
               before: beforeScreenshot,
               after: afterScreenshot,
               beforeUrl: beforeUrl,
-              afterUrl: afterUrl,
-              slowRequests: networkSummary.slowRequestsCount,
-              slowRequestDurations: networkSummary.slowRequests?.map(r => r.duration)
+              afterUrl: afterUrl
             }
-          }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
-          findings.push(finding);
-        } else {
-          const finding = createFindingWithConfidence({
-            type: 'no_effect_silent_failure',
+          });
+        }
+      } else if (expectationType === 'navigation') {
+        const urlMatchesTarget = normalizedAfter === normalizedTarget;
+        const hasEffect = urlMatchesTarget || hasVisibleChangeResult || hasDomChangeResult;
+        
+        if (!hasEffect) {
+          findings.push({
+            type: 'silent_failure',
             interaction: {
               type: interaction.type,
               selector: interaction.selector,
               label: interaction.label
             },
             reason: 'Expected user-visible outcome did not occur',
-            expectationProof: ExpectationProof.PROVEN_EXPECTATION,
             evidence: {
               before: beforeScreenshot,
               after: afterScreenshot,
               beforeUrl: beforeUrl,
               afterUrl: afterUrl
             }
-          }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
-          findings.push(finding);
+          });
         }
       }
-     } else if (expectationType === 'network_action') {
-       // Wave 5: Network action expectations from AST action contracts
-       // Check if promised network request actually occurred
-       if (networkSummary.totalRequests === 0) {
-         // Code promised a fetch/axios call but no network activity detected
-         const finding = createFindingWithConfidence({
-           type: 'missing_network_action',
-           interaction: {
-             type: interaction.type,
-             selector: interaction.selector,
-             label: interaction.label
-           },
-           reason: 'Code contract promises network request but none was made',
-           expectationProof: ExpectationProof.PROVEN_EXPECTATION,
-           evidence: {
-             before: beforeScreenshot,
-             after: afterScreenshot,
-             beforeUrl: beforeUrl,
-             afterUrl: afterUrl,
-             expectedMethod: expectationInfo.method,
-             expectedUrl: expectationInfo.urlPath,
-             sourceRef: attemptMeta.sourceRef
-           }
-         }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
-         findings.push(finding);
-       }
-       // Check for network errors without feedback
-       else if (networkSummary.failedRequests > 0 && !uiSignalChanges.changed) {
-         const finding = createFindingWithConfidence({
-           type: 'network_silent_failure',
-           interaction: {
-             type: interaction.type,
-             selector: interaction.selector,
-             label: interaction.label
-           },
-           reason: 'Network action failed with no UI feedback',
-           expectationProof: ExpectationProof.PROVEN_EXPECTATION,
-           evidence: {
-             before: beforeScreenshot,
-             after: afterScreenshot,
-             beforeUrl: beforeUrl,
-             afterUrl: afterUrl,
-             networkErrors: networkSummary.failedRequests,
-             failedByStatus: networkSummary.failedByStatus,
-             topFailedUrls: networkSummary.topFailedUrls,
-             expectedMethod: expectationInfo.method,
-             expectedUrl: expectationInfo.urlPath,
-             sourceRef: attemptMeta.sourceRef
-           }
-         }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
-         findings.push(finding);
-       }
-       // Check for missing feedback on slow requests
-       else if (networkSummary.slowRequestsCount > 0 && !uiSignalChanges.changed) {
-         const finding = createFindingWithConfidence({
-           type: 'missing_feedback_failure',
-           interaction: {
-             type: interaction.type,
-             selector: interaction.selector,
-             label: interaction.label
-           },
-           reason: 'Slow network action with no loading feedback',
-           expectationProof: ExpectationProof.PROVEN_EXPECTATION,
-           evidence: {
-             before: beforeScreenshot,
-             after: afterScreenshot,
-             beforeUrl: beforeUrl,
-             afterUrl: afterUrl,
-             slowRequests: networkSummary.slowRequestsCount,
-             expectedMethod: expectationInfo.method,
-             expectedUrl: expectationInfo.urlPath,
-             sourceRef: attemptMeta.sourceRef
-           }
-         }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
-         findings.push(finding);
-       }
-    } else if (expectationType === 'state_action') {
-      // Wave 8: State action expectations from AST state contracts
-      const stateUIData = sensorData.stateUI || {};
-      const stateChanged = stateUIData.changed === true;
-      
-      // Check if promised state mutation actually occurred
-      if (!stateChanged && !hasUrlChange && !hasDomChangeResult && networkSummary.totalRequests === 0) {
-        const finding = createFindingWithConfidence({
-          type: 'missing_state_action',
+    } else {
+      if (!hasUrlChange && !hasVisibleChangeResult && !hasDomChangeResult) {
+        findings.push({
+          type: 'silent_failure',
           interaction: {
             type: interaction.type,
             selector: interaction.selector,
             label: interaction.label
           },
-          reason: `Code contract promises state mutation (${expectationInfo.stateKind}) but state UI did not change`,
-          expectationProof: ExpectationProof.PROVEN_EXPECTATION,
+          reason: 'Expected user-visible outcome did not occur',
           evidence: {
             before: beforeScreenshot,
             after: afterScreenshot,
             beforeUrl: beforeUrl,
-            afterUrl: afterUrl,
-            expectedStateKind: expectationInfo.stateKind,
-            sourceRef: attemptMeta.sourceRef,
-            handlerRef: attemptMeta.handlerRef,
-            stateUIReasons: stateUIData.reasons || []
+            afterUrl: afterUrl
           }
-        }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
-        findings.push(finding);
+        });
       }
     }
   }
   
-  const findingsResult = writeFindings(projectDir, observation.url, findings, artifactPaths);
+  // Interactive and accessibility intelligence
+  detectInteractiveFindings(observation.traces, manifest, findings);
+  
+  // Infer canonical run directory from tracesPath when available
+  let runDir = null;
+  try {
+    runDir = dirname(tracesPath);
+  } catch {}
+
+  const findingsResult = writeFindings(projectDir, observation.url, findings, [], runDir);
   
   const skipSummary = collectSkipReasons(skips);