@veraxhq/verax 0.2.0 → 0.3.0

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

@@ -11,24 +11,29 @@
 import ts from 'typescript';
 import { parseFile, findNodes, getStringLiteral, getNodeLocation } from './ts-program.js';
 import { readFileSync, existsSync } from 'fs';
-import { resolve, extname } from 'path';
+import { resolve, extname, relative } from 'path';
+import { globSync } from 'glob';
 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
+ * @param {Object|string} programOrProjectRoot - TypeScript program object or project root path
+ * @param {string|Object} [maybeProjectRoot] - Project root string or program object (supports both call signatures)
+ * @returns {Array} - Array of navigation expectation objects
  */
-export async function extractVueNavigationPromises(program, projectRoot) {
-  const expectations = [];
+export function extractVueNavigationPromises(programOrProjectRoot, maybeProjectRoot) {
+  // Accept both (program, projectRoot) and (projectRoot, program) call signatures
+  const program = programOrProjectRoot && programOrProjectRoot.program ? programOrProjectRoot : maybeProjectRoot;
+  const projectRoot = programOrProjectRoot && programOrProjectRoot.program ? (maybeProjectRoot || process.cwd()) : programOrProjectRoot;
   
-  if (!program || !program.program) return expectations;
+  if (!program || !program.program || !projectRoot) return [];
+  const expectations = [];
   
   // Find Vue component files (.vue, .ts, .js, .tsx, .jsx)
   const vueFiles = [];
-  const sourceFiles = program.getSourceFiles ? program.getSourceFiles() : (program.sourceFiles || []);
+  const tsProgram = program.program || program;
+  const sourceFiles = tsProgram.getSourceFiles ? tsProgram.getSourceFiles() : (program.sourceFiles || []);
   
   for (const sourceFile of sourceFiles) {
     // sourceFiles can be either file paths (strings) or SourceFile objects
@@ -42,11 +47,9 @@ export async function extractVueNavigationPromises(program, projectRoot) {
   
   // 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 });
+    const vueFilesFromGlob = globSync('**/*.vue', { cwd: projectRoot, absolute: true, nodir: true });
     for (const filePath of vueFilesFromGlob) {
-      const absPath = resolve(projectRoot, filePath);
+      const absPath = resolve(filePath);
       if (!vueFiles.includes(absPath) && !vueFiles.find(f => f.endsWith(filePath))) {
         vueFiles.push(absPath);
       }
@@ -68,16 +71,54 @@ export async function extractVueNavigationPromises(program, projectRoot) {
  * 
  * @param {string} filePath - File path
  * @param {string} projectRoot - Project root
- * @param {Object} program - TypeScript program
  * @returns {Array} - Navigation expectations
  */
-function extractFromFile(filePath, projectRoot, program) {
+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);
+    
+    // For .vue files, also parse the script section as AST
+    // to handle template literals and complex navigation calls
+    try {
+      const content = readFileSync(filePath, 'utf-8');
+      const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/);
+      if (scriptMatch) {
+        const scriptContent = scriptMatch[1];
+        // Parse script content as TypeScript/JavaScript
+        const ast = ts.createSourceFile(
+          filePath,
+          scriptContent,
+          ts.ScriptTarget.Latest,
+          true,
+          ts.ScriptKind.TS
+        );
+        
+        // Extract router.push/replace calls
+        const routerCalls = findRouterCalls(ast);
+        for (const call of routerCalls) {
+          const expectation = extractFromRouterCall(call, ast, projectRoot, filePath);
+          if (expectation) {
+            // Check for duplicates (might already be extracted by regex)
+            const isDupe = expectations.some(e => 
+              e.targetPath === expectation.targetPath && 
+              e.navigationMethod === expectation.navigationMethod &&
+              e.sourceRef === expectation.sourceRef
+            );
+            if (!isDupe) {
+              expectations.push(expectation);
+            }
+          }
+        }
+      }
+    } catch (err) {
+      // If script parsing fails, fall back to regex-based extraction (already done)
+    }
+    
+    return expectations;
   }
   
   // Extract from script section (TypeScript/JavaScript)
@@ -114,7 +155,6 @@ function extractFromFile(filePath, projectRoot, program) {
  */
 function extractFromVueSFC(filePath, projectRoot) {
   const expectations = [];
-  const { relative } = require('path');
   
   if (!existsSync(filePath)) return expectations;
   
@@ -141,8 +181,10 @@ function extractFromVueSFC(filePath, projectRoot) {
               type: 'spa_navigation',
               targetPath: normalized.examplePath,
               originalPattern: normalized.originalPattern,
+              originalTarget: normalized.originalPattern,
               isDynamic: true,
               exampleExecution: true,
+              parameters: normalized.parameters || [],
               matchAttribute: 'to',
               proof: 'PROVEN_EXPECTATION',
               sourceRef: `${relative(projectRoot, filePath).replace(/\\/g, '/')}:${line}`,
@@ -186,8 +228,10 @@ function extractFromVueSFC(filePath, projectRoot) {
               type: 'spa_navigation',
               targetPath: normalized.examplePath,
               originalPattern: normalized.originalPattern,
+              originalTarget: normalized.originalPattern,
               isDynamic: true,
               exampleExecution: true,
+              parameters: normalized.parameters || [],
               matchAttribute: 'to',
               proof: 'PROVEN_EXPECTATION',
               sourceRef: `${relative(projectRoot, filePath).replace(/\\/g, '/')}:${line}`,
@@ -223,6 +267,7 @@ function extractFromVueSFC(filePath, projectRoot) {
     if (scriptMatch) {
       const scriptContent = scriptMatch[1];
       const routerPushRegex = /router\.(push|replace)\s*\(\s*["']([^"']+)["']\s*\)/g;
+      let match;
       while ((match = routerPushRegex.exec(scriptContent)) !== null) {
         const method = match[1];
         const path = match[2];
@@ -236,8 +281,10 @@ function extractFromVueSFC(filePath, projectRoot) {
               type: 'spa_navigation',
               targetPath: normalized.examplePath,
               originalPattern: normalized.originalPattern,
+              originalTarget: normalized.originalPattern,
               isDynamic: true,
               exampleExecution: true,
+              parameters: normalized.parameters || [],
               navigationMethod: method,
               proof: 'PROVEN_EXPECTATION',
               sourceRef: `${relative(projectRoot, filePath).replace(/\\/g, '/')}:${line}`,
@@ -283,7 +330,7 @@ function extractFromVueSFC(filePath, projectRoot) {
  * @returns {Array} - Call expression nodes
  */
 function findRouterCalls(ast) {
-  const calls = [];
+  const _calls = [];
   
   const callExpressions = findNodes(ast, node => {
     if (!ts.isCallExpression(node)) return false;
@@ -307,9 +354,10 @@ function findRouterCalls(ast) {
  * @param {ts.CallExpression} call - Call expression
  * @param {ts.SourceFile} ast - Source file
  * @param {string} projectRoot - Project root
+ * @param {string} [filePathOverride] - Optional file path override for .vue files
  * @returns {Object|null} - Expectation or null
  */
-function extractFromRouterCall(call, ast, projectRoot) {
+function extractFromRouterCall(call, ast, projectRoot, filePathOverride = null) {
   const expr = call.expression;
   if (!ts.isPropertyAccessExpression(expr)) return null;
   
@@ -321,6 +369,13 @@ function extractFromRouterCall(call, ast, projectRoot) {
   const arg = call.arguments[0];
   const location = getNodeLocation(ast, call, projectRoot);
   
+  // Override file path if provided (for .vue files)
+  if (filePathOverride) {
+    const relativePath = relative(projectRoot, filePathOverride);
+    location.file = relativePath.replace(/\\/g, '/');
+    location.sourceRef = `${relativePath.replace(/\\/g, '/')}:${location.line}`;
+  }
+  
   // String literal: router.push('/path')
   const path = getStringLiteral(arg);
   if (path && path.startsWith('/')) {
@@ -331,8 +386,10 @@ function extractFromRouterCall(call, ast, projectRoot) {
         type: 'spa_navigation',
         targetPath: normalized.examplePath,
         originalPattern: normalized.originalPattern,
+        originalTarget: normalized.originalPattern,
         isDynamic: true,
         exampleExecution: true,
+        parameters: normalized.parameters || [],
         navigationMethod: method,
         proof: 'PROVEN_EXPECTATION',
         sourceRef: location.sourceRef,
@@ -391,8 +448,10 @@ function extractFromRouterCall(call, ast, projectRoot) {
           type: 'spa_navigation',
           targetPath: normalized.examplePath,
           originalPattern: normalized.originalPattern,
+          originalTarget: normalized.originalPattern,
           isDynamic: true,
           exampleExecution: true,
+          parameters: normalized.parameters || [],
           navigationMethod: method,
           proof: 'PROVEN_EXPECTATION',
           sourceRef: location.sourceRef,
@@ -425,8 +484,10 @@ function extractFromRouterCall(call, ast, projectRoot) {
             type: 'spa_navigation',
             targetPath: normalized.examplePath,
             originalPattern: normalized.originalPattern,
+            originalTarget: normalized.originalPattern,
             isDynamic: true,
             exampleExecution: true,
+            parameters: normalized.parameters || [],
             navigationMethod: method,
             proof: 'PROVEN_EXPECTATION',
             sourceRef: location.sourceRef,
@@ -468,7 +529,7 @@ function extractFromRouterCall(call, ast, projectRoot) {
  * @returns {Array} - JSX element nodes
  */
 function findRouterLinkElements(ast) {
-  const elements = [];
+  const _elements = [];
   
   const jsxElements = findNodes(ast, node => {
     if (!ts.isJsxOpeningElement(node) && !ts.isJsxSelfClosingElement(node)) return false;
@@ -545,8 +606,10 @@ function extractFromRouterLink(element, ast, projectRoot) {
         type: 'spa_navigation',
         targetPath: normalized.examplePath,
         originalPattern: normalized.originalPattern,
+        originalTarget: normalized.originalPattern,
         isDynamic: true,
         exampleExecution: true,
+        parameters: normalized.parameters || [],
         matchAttribute: 'to',
         proof: 'PROVEN_EXPECTATION',
         sourceRef: location.sourceRef,

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

@@ -298,7 +298,8 @@ function extractRouteFromObject(objNode, ast, projectRoot, parentPath) {
       file: location.file,
       line: location.line,
       framework: 'vue-router',
-      public: !isInternalRoute(normalized.examplePath)
+      public: !isInternalRoute(normalized.examplePath),
+      children: null // Will be set below if children exist
     };
   } else {
     // Static route
@@ -308,7 +309,8 @@ function extractRouteFromObject(objNode, ast, projectRoot, parentPath) {
       file: location.file,
       line: location.line,
       framework: 'vue-router',
-      public: !isInternalRoute(fullPath)
+      public: !isInternalRoute(fullPath),
+      children: null // Will be set below if children exist
     };
   }