@veraxhq/verax 0.1.0 → 0.2.0

package/src/verax/intel/vue-navigation-extractor.js

@@ -0,0 +1,579 @@
+/**
+ * CODE INTELLIGENCE v1 — Vue Navigation Promise Extraction (AST-based)
+ * 
+ * Extracts navigation promises from Vue components:
+ * - <router-link to="/path">
+ * - <RouterLink :to="{ path: '/path' }">
+ * - router.push('/path'), router.replace('/path')
+ * - Dynamic targets: router.push(`/users/${id}`)
+ */
+
+import ts from 'typescript';
+import { parseFile, findNodes, getStringLiteral, getNodeLocation } from './ts-program.js';
+import { readFileSync, existsSync } from 'fs';
+import { resolve, extname } from 'path';
+import { normalizeDynamicRoute, normalizeTemplateLiteral } from '../shared/dynamic-route-utils.js';
+
+/**
+ * Extract navigation promises from Vue components.
+ * 
+ * @param {Object} program - TypeScript program
+ * @param {string} projectRoot - Project root
+ * @returns {Promise<Array>} - Array of navigation expectation objects
+ */
+export async function extractVueNavigationPromises(program, projectRoot) {
+  const expectations = [];
+  
+  if (!program || !program.program) return expectations;
+  
+  // Find Vue component files (.vue, .ts, .js, .tsx, .jsx)
+  const vueFiles = [];
+  const sourceFiles = program.getSourceFiles ? program.getSourceFiles() : (program.sourceFiles || []);
+  
+  for (const sourceFile of sourceFiles) {
+    // sourceFiles can be either file paths (strings) or SourceFile objects
+    const filePath = typeof sourceFile === 'string' ? sourceFile : (sourceFile.fileName || sourceFile);
+    if (!filePath) continue;
+    const ext = extname(filePath);
+    if (['.vue', '.ts', '.js', '.tsx', '.jsx'].includes(ext)) {
+      vueFiles.push(filePath);
+    }
+  }
+  
+  // Also explicitly glob for .vue files since TypeScript might not include them
+  try {
+    const { glob } = await import('glob');
+    const vueGlobPattern = resolve(projectRoot, '**/*.vue');
+    const vueFilesFromGlob = await glob(vueGlobPattern, { cwd: projectRoot });
+    for (const filePath of vueFilesFromGlob) {
+      const absPath = resolve(projectRoot, filePath);
+      if (!vueFiles.includes(absPath) && !vueFiles.find(f => f.endsWith(filePath))) {
+        vueFiles.push(absPath);
+      }
+    }
+  } catch (err) {
+    // glob not available, skip
+  }
+  
+  for (const filePath of vueFiles) {
+    const fileExpectations = extractFromFile(filePath, projectRoot, program);
+    expectations.push(...fileExpectations);
+  }
+  
+  return expectations;
+}
+
+/**
+ * Extract navigation promises from a single file.
+ * 
+ * @param {string} filePath - File path
+ * @param {string} projectRoot - Project root
+ * @param {Object} program - TypeScript program
+ * @returns {Array} - Navigation expectations
+ */
+function extractFromFile(filePath, projectRoot, program) {
+  const expectations = [];
+  
+  // Check if it's a .vue file (SFC)
+  if (extname(filePath) === '.vue') {
+    const sfcExpectations = extractFromVueSFC(filePath, projectRoot);
+    expectations.push(...sfcExpectations);
+  }
+  
+  // Extract from script section (TypeScript/JavaScript)
+  const ast = parseFile(filePath, true);
+  if (!ast) return expectations;
+  
+  // Extract router.push/replace calls
+  const routerCalls = findRouterCalls(ast);
+  for (const call of routerCalls) {
+    const expectation = extractFromRouterCall(call, ast, projectRoot);
+    if (expectation) {
+      expectations.push(expectation);
+    }
+  }
+  
+  // Extract RouterLink JSX/TSX components
+  const routerLinks = findRouterLinkElements(ast);
+  for (const element of routerLinks) {
+    const expectation = extractFromRouterLink(element, ast, projectRoot);
+    if (expectation) {
+      expectations.push(expectation);
+    }
+  }
+  
+  return expectations;
+}
+
+/**
+ * Extract navigation promises from Vue SFC (.vue file).
+ * 
+ * @param {string} filePath - File path
+ * @param {string} projectRoot - Project root
+ * @returns {Array} - Navigation expectations
+ */
+function extractFromVueSFC(filePath, projectRoot) {
+  const expectations = [];
+  const { relative } = require('path');
+  
+  if (!existsSync(filePath)) return expectations;
+  
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    
+    // Extract template section
+    const templateMatch = content.match(/<template[^>]*>([\s\S]*?)<\/template>/);
+    if (templateMatch) {
+      const templateContent = templateMatch[1];
+      
+      // Pattern 1: <router-link to="/path">
+      const routerLinkRegex = /<router-link[^>]*\s+to=["']([^"']+)["'][^>]*>/g;
+      let match;
+      while ((match = routerLinkRegex.exec(templateContent)) !== null) {
+        const path = match[1];
+        if (path && path.startsWith('/')) {
+          const normalized = normalizeDynamicRoute(path);
+          const line = (templateContent.substring(0, match.index).match(/\n/g) || []).length + 1;
+          
+          if (normalized) {
+            // Dynamic route
+            expectations.push({
+              type: 'spa_navigation',
+              targetPath: normalized.examplePath,
+              originalPattern: normalized.originalPattern,
+              isDynamic: true,
+              exampleExecution: true,
+              matchAttribute: 'to',
+              proof: 'PROVEN_EXPECTATION',
+              sourceRef: `${relative(projectRoot, filePath).replace(/\\/g, '/')}:${line}`,
+              selectorHint: 'router-link',
+              metadata: {
+                elementFile: relative(projectRoot, filePath).replace(/\\/g, '/'),
+                elementLine: line,
+                eventType: 'click'
+              }
+            });
+          } else {
+            // Static route
+            expectations.push({
+              type: 'spa_navigation',
+              targetPath: path,
+              matchAttribute: 'to',
+              proof: 'PROVEN_EXPECTATION',
+              sourceRef: `${relative(projectRoot, filePath).replace(/\\/g, '/')}:${line}`,
+              selectorHint: 'router-link',
+              metadata: {
+                elementFile: relative(projectRoot, filePath).replace(/\\/g, '/'),
+                elementLine: line,
+                eventType: 'click'
+              }
+            });
+          }
+        }
+      }
+      
+      // Pattern 2: <RouterLink :to="{ path: '/path' }">
+      const routerLinkBindingRegex = /<RouterLink\s+[^>]*:to=["']\{[^}]*path:\s*["']([^"']+)["'][^}]*\}[^>]*>/g;
+      while ((match = routerLinkBindingRegex.exec(templateContent)) !== null) {
+        const path = match[1];
+        if (path && path.startsWith('/')) {
+          const normalized = normalizeDynamicRoute(path);
+          const line = (templateContent.substring(0, match.index).match(/\n/g) || []).length + 1;
+          
+          if (normalized) {
+            // Dynamic route
+            expectations.push({
+              type: 'spa_navigation',
+              targetPath: normalized.examplePath,
+              originalPattern: normalized.originalPattern,
+              isDynamic: true,
+              exampleExecution: true,
+              matchAttribute: 'to',
+              proof: 'PROVEN_EXPECTATION',
+              sourceRef: `${relative(projectRoot, filePath).replace(/\\/g, '/')}:${line}`,
+              selectorHint: 'RouterLink',
+              metadata: {
+                elementFile: relative(projectRoot, filePath).replace(/\\/g, '/'),
+                elementLine: line,
+                eventType: 'click'
+              }
+            });
+          } else {
+            // Static route
+            expectations.push({
+              type: 'spa_navigation',
+              targetPath: path,
+              matchAttribute: 'to',
+              proof: 'PROVEN_EXPECTATION',
+              sourceRef: `${relative(projectRoot, filePath).replace(/\\/g, '/')}:${line}`,
+              selectorHint: 'RouterLink',
+              metadata: {
+                elementFile: relative(projectRoot, filePath).replace(/\\/g, '/'),
+                elementLine: line,
+                eventType: 'click'
+              }
+            });
+          }
+        }
+      }
+    }
+    
+    // Extract script section for router.push/replace
+    const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/);
+    if (scriptMatch) {
+      const scriptContent = scriptMatch[1];
+      const routerPushRegex = /router\.(push|replace)\s*\(\s*["']([^"']+)["']\s*\)/g;
+      while ((match = routerPushRegex.exec(scriptContent)) !== null) {
+        const method = match[1];
+        const path = match[2];
+        if (path && path.startsWith('/')) {
+          const normalized = normalizeDynamicRoute(path);
+          const line = (scriptContent.substring(0, match.index).match(/\n/g) || []).length + 1;
+          
+          if (normalized) {
+            // Dynamic route
+            expectations.push({
+              type: 'spa_navigation',
+              targetPath: normalized.examplePath,
+              originalPattern: normalized.originalPattern,
+              isDynamic: true,
+              exampleExecution: true,
+              navigationMethod: method,
+              proof: 'PROVEN_EXPECTATION',
+              sourceRef: `${relative(projectRoot, filePath).replace(/\\/g, '/')}:${line}`,
+              selectorHint: null,
+              metadata: {
+                elementFile: relative(projectRoot, filePath).replace(/\\/g, '/'),
+                elementLine: line,
+                handlerName: `router.${method}`,
+                eventType: 'programmatic'
+              }
+            });
+          } else {
+            // Static route
+            expectations.push({
+              type: 'spa_navigation',
+              targetPath: path,
+              navigationMethod: method,
+              proof: 'PROVEN_EXPECTATION',
+              sourceRef: `${relative(projectRoot, filePath).replace(/\\/g, '/')}:${line}`,
+              selectorHint: null,
+              metadata: {
+                elementFile: relative(projectRoot, filePath).replace(/\\/g, '/'),
+                elementLine: line,
+                handlerName: `router.${method}`,
+                eventType: 'programmatic'
+              }
+            });
+          }
+        }
+      }
+    }
+  } catch (err) {
+    // Skip if file can't be parsed
+  }
+  
+  return expectations;
+}
+
+/**
+ * Find router.push/replace calls in AST.
+ * 
+ * @param {ts.SourceFile} ast - Source file
+ * @returns {Array} - Call expression nodes
+ */
+function findRouterCalls(ast) {
+  const calls = [];
+  
+  const callExpressions = findNodes(ast, node => {
+    if (!ts.isCallExpression(node)) return false;
+    const expr = node.expression;
+    if (!ts.isPropertyAccessExpression(expr)) return false;
+    
+    const obj = expr.expression;
+    const prop = expr.name;
+    
+    if (!ts.isIdentifier(obj) || !ts.isIdentifier(prop)) return false;
+    
+    return obj.text === 'router' && (prop.text === 'push' || prop.text === 'replace');
+  });
+  
+  return callExpressions;
+}
+
+/**
+ * Extract expectation from router call.
+ * 
+ * @param {ts.CallExpression} call - Call expression
+ * @param {ts.SourceFile} ast - Source file
+ * @param {string} projectRoot - Project root
+ * @returns {Object|null} - Expectation or null
+ */
+function extractFromRouterCall(call, ast, projectRoot) {
+  const expr = call.expression;
+  if (!ts.isPropertyAccessExpression(expr)) return null;
+  
+  const prop = expr.name;
+  const method = prop.text; // 'push' or 'replace'
+  
+  if (call.arguments.length === 0) return null;
+  
+  const arg = call.arguments[0];
+  const location = getNodeLocation(ast, call, projectRoot);
+  
+  // String literal: router.push('/path')
+  const path = getStringLiteral(arg);
+  if (path && path.startsWith('/')) {
+    // Normalize dynamic routes
+    const normalized = normalizeDynamicRoute(path);
+    if (normalized) {
+      return {
+        type: 'spa_navigation',
+        targetPath: normalized.examplePath,
+        originalPattern: normalized.originalPattern,
+        isDynamic: true,
+        exampleExecution: true,
+        navigationMethod: method,
+        proof: 'PROVEN_EXPECTATION',
+        sourceRef: location.sourceRef,
+        selectorHint: null,
+        metadata: {
+          elementFile: location.file,
+          elementLine: location.line,
+          handlerName: `router.${method}`,
+          eventType: 'programmatic'
+        }
+      };
+    }
+    // Static route
+    return {
+      type: 'spa_navigation',
+      targetPath: path,
+      navigationMethod: method,
+      proof: 'PROVEN_EXPECTATION',
+      sourceRef: location.sourceRef,
+      selectorHint: null,
+      metadata: {
+        elementFile: location.file,
+        elementLine: location.line,
+        handlerName: `router.${method}`,
+        eventType: 'programmatic'
+      }
+    };
+  }
+  
+  // Template literal: router.push(`/users/${id}`)
+  if (ts.isTemplateExpression(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) {
+    let templateText = null;
+    if (ts.isTemplateExpression(arg)) {
+      // Build template string with ${} placeholders
+      let text = arg.head?.text || '';
+      for (const span of arg.templateSpans || []) {
+        const expr = span.expression;
+        if (ts.isIdentifier(expr)) {
+          text += '${' + expr.text + '}';
+        } else {
+          // Complex expression - cannot normalize safely
+          return null;
+        }
+        text += span.literal?.text || '';
+      }
+      templateText = text;
+    } else if (ts.isNoSubstitutionTemplateLiteral(arg)) {
+      templateText = arg.text;
+    }
+    
+    if (templateText && templateText.startsWith('/')) {
+      // Normalize template literal
+      const normalized = normalizeTemplateLiteral(templateText) || normalizeDynamicRoute(templateText);
+      if (normalized) {
+        return {
+          type: 'spa_navigation',
+          targetPath: normalized.examplePath,
+          originalPattern: normalized.originalPattern,
+          isDynamic: true,
+          exampleExecution: true,
+          navigationMethod: method,
+          proof: 'PROVEN_EXPECTATION',
+          sourceRef: location.sourceRef,
+          selectorHint: null,
+          metadata: {
+            elementFile: location.file,
+            elementLine: location.line,
+            handlerName: `router.${method}`,
+            eventType: 'programmatic'
+          }
+        };
+      }
+    }
+  }
+  
+  // Object literal: router.push({ path: '/path' })
+  if (ts.isObjectLiteralExpression(arg)) {
+    for (const prop of arg.properties) {
+      if (!ts.isPropertyAssignment(prop)) continue;
+      const name = prop.name;
+      if (!ts.isIdentifier(name)) continue;
+      if (name.text !== 'path') continue;
+      
+      const pathValue = getStringLiteral(prop.initializer);
+      if (pathValue && pathValue.startsWith('/')) {
+        // Normalize dynamic routes
+        const normalized = normalizeDynamicRoute(pathValue);
+        if (normalized) {
+          return {
+            type: 'spa_navigation',
+            targetPath: normalized.examplePath,
+            originalPattern: normalized.originalPattern,
+            isDynamic: true,
+            exampleExecution: true,
+            navigationMethod: method,
+            proof: 'PROVEN_EXPECTATION',
+            sourceRef: location.sourceRef,
+            selectorHint: null,
+            metadata: {
+              elementFile: location.file,
+              elementLine: location.line,
+              handlerName: `router.${method}`,
+              eventType: 'programmatic'
+            }
+          };
+        }
+        // Static route
+        return {
+          type: 'spa_navigation',
+          targetPath: pathValue,
+          navigationMethod: method,
+          proof: 'PROVEN_EXPECTATION',
+          sourceRef: location.sourceRef,
+          selectorHint: null,
+          metadata: {
+            elementFile: location.file,
+            elementLine: location.line,
+            handlerName: `router.${method}`,
+            eventType: 'programmatic'
+          }
+        };
+      }
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Find RouterLink JSX elements.
+ * 
+ * @param {ts.SourceFile} ast - Source file
+ * @returns {Array} - JSX element nodes
+ */
+function findRouterLinkElements(ast) {
+  const elements = [];
+  
+  const jsxElements = findNodes(ast, node => {
+    if (!ts.isJsxOpeningElement(node) && !ts.isJsxSelfClosingElement(node)) return false;
+    
+    const tagName = node.tagName;
+    if (!ts.isIdentifier(tagName)) return false;
+    
+    return tagName.text === 'RouterLink' || tagName.text === 'router-link';
+  });
+  
+  return jsxElements;
+}
+
+/**
+ * Extract expectation from RouterLink element.
+ * 
+ * @param {ts.Node} element - JSX element
+ * @param {ts.SourceFile} ast - Source file
+ * @param {string} projectRoot - Project root
+ * @returns {Object|null} - Expectation or null
+ */
+function extractFromRouterLink(element, ast, projectRoot) {
+  const attributes = element.attributes;
+  if (!attributes || !attributes.properties) return null;
+  
+  let targetPath = null;
+  
+  for (const attr of attributes.properties) {
+    if (!ts.isJsxAttribute(attr)) continue;
+    
+    const name = attr.name;
+    if (!ts.isIdentifier(name)) continue;
+    
+    if (name.text === 'to') {
+      const initializer = attr.initializer;
+      
+      // String literal: to="/path"
+      if (ts.isStringLiteral(initializer)) {
+        targetPath = initializer.text;
+      }
+      // JSX expression: to={"/path"} or to={{ path: "/path" }}
+      else if (ts.isJsxExpression(initializer)) {
+        const expr = initializer.expression;
+        
+        // String literal in expression
+        if (ts.isStringLiteral(expr)) {
+          targetPath = expr.text;
+        }
+        // Object literal: to={{ path: "/path" }}
+        else if (ts.isObjectLiteralExpression(expr)) {
+          for (const prop of expr.properties) {
+            if (!ts.isPropertyAssignment(prop)) continue;
+            const propName = prop.name;
+            if (!ts.isIdentifier(propName)) continue;
+            if (propName.text !== 'path') continue;
+            
+            const pathValue = getStringLiteral(prop.initializer);
+            if (pathValue) {
+              targetPath = pathValue;
+            }
+          }
+        }
+      }
+    }
+  }
+  
+  if (targetPath && targetPath.startsWith('/')) {
+    const location = getNodeLocation(ast, element, projectRoot);
+    const normalized = normalizeDynamicRoute(targetPath);
+    
+    if (normalized) {
+      // Dynamic route
+      return {
+        type: 'spa_navigation',
+        targetPath: normalized.examplePath,
+        originalPattern: normalized.originalPattern,
+        isDynamic: true,
+        exampleExecution: true,
+        matchAttribute: 'to',
+        proof: 'PROVEN_EXPECTATION',
+        sourceRef: location.sourceRef,
+        selectorHint: 'RouterLink',
+        metadata: {
+          elementFile: location.file,
+          elementLine: location.line,
+          eventType: 'click'
+        }
+      };
+    }
+    
+    // Static route
+    return {
+      type: 'spa_navigation',
+      targetPath: targetPath,
+      matchAttribute: 'to',
+      proof: 'PROVEN_EXPECTATION',
+      sourceRef: location.sourceRef,
+      selectorHint: 'RouterLink',
+      metadata: {
+        elementFile: location.file,
+        elementLine: location.line,
+        eventType: 'click'
+      }
+    };
+  }
+  
+  return null;
+}