@veraxhq/verax 0.2.1 → 0.4.0

package/src/cli/commands/truth.js

@@ -0,0 +1,113 @@
+/**
+ * PHASE 21.11 — Truth Command
+ * 
+ * `verax truth` - Shows truth certificate summary
+ */
+
+import { findLatestRunId } from '../util/run-resolver.js';
+import { generateTruthCertificate, loadTruthCertificate } from '../../verax/core/truth/truth.certificate.js';
+
+/**
+ * Truth command
+ * 
+ * @param {string} projectDir - Project directory
+ * @param {Object} options - Command options
+ */
+export async function truthCommand(projectDir, options = {}) {
+  const { json = false, runId: runIdOpt = null } = options;
+  
+  const runId = runIdOpt || findLatestRunId(projectDir);
+  
+  if (!runId) {
+    if (json) {
+      console.log(JSON.stringify({
+        error: 'NO_RUNS_FOUND',
+        message: 'No runs found. Run a scan first.'
+      }, null, 2));
+    } else {
+      console.log('\n=== Truth Certificate ===\n');
+      console.log('Error: No runs found. Run a scan first.\n');
+    }
+    return;
+  }
+  
+  // Try to load existing certificate, otherwise generate
+  let certificate = loadTruthCertificate(projectDir, runId);
+  
+  if (!certificate) {
+    certificate = await generateTruthCertificate(projectDir, runId);
+    if (certificate) {
+      const { writeTruthCertificate } = await import('../../verax/core/truth/truth.certificate.js');
+      writeTruthCertificate(projectDir, runId, certificate);
+    }
+  }
+  
+  if (!certificate) {
+    if (json) {
+      console.log(JSON.stringify({
+        error: 'CERTIFICATE_GENERATION_FAILED',
+        message: 'Failed to generate truth certificate'
+      }, null, 2));
+    } else {
+      console.log('\n=== Truth Certificate ===\n');
+      console.log('Error: Failed to generate truth certificate\n');
+    }
+    return;
+  }
+  
+  if (json) {
+    console.log(JSON.stringify(certificate, null, 2));
+  } else {
+    console.log('\n=== Truth Certificate ===\n');
+    console.log(`Run ID: ${certificate.runId}`);
+    console.log(`URL: ${certificate.url || 'N/A'}`);
+    console.log(`Generated: ${certificate.generatedAt}`);
+    
+    console.log('\nEvidence Law:');
+    console.log(`  Status: ${certificate.evidenceLaw.status}`);
+    console.log(`  Violated: ${certificate.evidenceLaw.violated ? 'YES' : 'NO'}`);
+    
+    console.log('\nDeterminism:');
+    console.log(`  Verdict: ${certificate.determinism.verdict}`);
+    console.log(`  Message: ${certificate.determinism.message}`);
+    
+    console.log('\nFailures:');
+    console.log(`  Total: ${certificate.failures.total}`);
+    console.log(`  Blocking: ${certificate.failures.blocking ? 'YES' : 'NO'}`);
+    console.log(`  Degraded: ${certificate.failures.degraded ? 'YES' : 'NO'}`);
+    console.log(`  By Severity: ${JSON.stringify(certificate.failures.bySeverity)}`);
+    
+    console.log('\nGA:');
+    console.log(`  Verdict: ${certificate.ga.verdict}`);
+    console.log(`  Ready: ${certificate.ga.ready ? 'YES' : 'NO'}`);
+    console.log(`  Blockers: ${certificate.ga.blockers}`);
+    console.log(`  Warnings: ${certificate.ga.warnings}`);
+    
+    console.log('\nSecurity:');
+    console.log(`  Overall: ${certificate.security.overall}`);
+    console.log(`  Secrets: ${certificate.security.secrets}`);
+    console.log(`  Vulnerabilities: ${certificate.security.vulnerabilities}`);
+    
+    console.log('\nPerformance:');
+    console.log(`  Verdict: ${certificate.performance.verdict}`);
+    console.log(`  OK: ${certificate.performance.ok ? 'YES' : 'NO'}`);
+    console.log(`  Violations: ${certificate.performance.violations}`);
+    
+    console.log('\nBaseline:');
+    console.log(`  Hash: ${certificate.baseline.hash || 'N/A'}`);
+    console.log(`  Frozen: ${certificate.baseline.frozen ? 'YES' : 'NO'}`);
+    console.log(`  Version: ${certificate.baseline.version || 'N/A'}`);
+    
+    console.log('\nProvenance:');
+    console.log(`  Hash: ${certificate.provenance.hash || 'N/A'}`);
+    console.log(`  Version: ${certificate.provenance.version || 'N/A'}`);
+    
+    console.log('\nOverall Verdict:');
+    console.log(`  Status: ${certificate.overallVerdict.status}`);
+    if (certificate.overallVerdict.reasons.length > 0) {
+      console.log(`  Reasons: ${certificate.overallVerdict.reasons.join('; ')}`);
+    }
+    console.log('');
+  }
+}
+

package/src/cli/entry.js

@@ -4,7 +4,6 @@
  * VERAX CLI Entry Point
  * 
  * Commands:
- * - verax                    (smart default with URL detection/prompting)
  * - verax run --url <url>    (strict, non-interactive)
  * - verax inspect <runPath>  (read and display run summary)
  * 
@@ -13,25 +12,42 @@
  * - 2:  internal crash
  * - 64: invalid CLI usage
  * - 65: invalid input data
+ * 
+ * DESIGN: Lazy imports for heavy modules
+ * --version and --help are fast and don't load Playwright or observation-engine
+ * Heavy modules are only loaded when running actual commands (run, inspect, doctor)
  */
 
 import { fileURLToPath } from 'url';
 import { dirname, resolve } from 'path';
 import { readFileSync } from 'fs';
-import { defaultCommand } from './commands/default.js';
-import { runCommand } from './commands/run.js';
-import { inspectCommand } from './commands/inspect.js';
-import { doctorCommand } from './commands/doctor.js';
 import { getExitCode, UsageError } from './util/errors.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+// Lazy loaders for heavy modules (loaded only when needed)
+async function loadRunCommand() {
+  const mod = await import('./commands/run.js');
+  return mod.runCommand;
+}
+
+async function loadInspectCommand() {
+  const mod = await import('./commands/inspect.js');
+  return mod.inspectCommand;
+}
+
+async function loadDoctorCommand() {
+  const mod = await import('./commands/doctor.js');
+  return mod.doctorCommand;
+}
+
 // Read package.json for version
 function getVersion() {
   try {
     const pkgPath = resolve(__dirname, '../../package.json');
-    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+  // @ts-expect-error - readFileSync with encoding returns string
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
     return pkg.version;
   } catch {
     return 'unknown';
@@ -54,10 +70,10 @@ async function main() {
       process.exit(0);
     }
     
-    // If no args, run default command
+    // If no args, show help (no interactive mode)
     if (args.length === 0) {
-      await defaultCommand({});
-      process.exit(0);
+      showHelp();
+      process.exit(64);
     }
     
     const command = args[0];
@@ -74,6 +90,7 @@ async function main() {
         throw new UsageError('run command requires --url <url> argument');
       }
       
+      const runCommand = await loadRunCommand();
       await runCommand({ url, src, out, json, verbose });
       process.exit(0);
     }
@@ -87,6 +104,7 @@ async function main() {
       const runPath = args[1];
       const json = args.includes('--json');
       
+      const inspectCommand = await loadInspectCommand();
       await inspectCommand(runPath, { json });
       process.exit(0);
     }
@@ -96,6 +114,7 @@ async function main() {
       const allowedFlags = new Set(['--json']);
       const extraFlags = args.slice(1).filter((a) => a.startsWith('-') && !allowedFlags.has(a));
       const json = args.includes('--json');
+      const doctorCommand = await loadDoctorCommand();
       await doctorCommand({ json, extraFlags });
       process.exit(0);
     }
@@ -106,16 +125,8 @@ async function main() {
       process.exit(0);
     }
     
-    // Default command: smart scanning mode
-    // Options can be passed as flags before/after the default command position
-    const url = parseArg(args, '--url');
-    const src = parseArg(args, '--src') || '.';
-    const out = parseArg(args, '--out') || '.verax';
-    const json = args.includes('--json');
-    const verbose = args.includes('--verbose');
-    
-    await defaultCommand({ url, src, out, json, verbose });
-    process.exit(0);
+    // Interactive mode removed
+    throw new UsageError('Interactive mode is disabled. Use: verax run --url <url>');
   } catch (error) {
     // Print error message
     if (error.message) {
@@ -135,7 +146,6 @@ verax ${version}
 VERAX — Silent failure detection for websites
 
 USAGE:
-  verax [options]                              Smart mode (detects/prompts for URL)
   verax run --url <url> [options]             Strict mode (non-interactive, CI-friendly)
   verax inspect <runPath> [--json]            Inspect an existing run
   verax doctor [--json]                       Diagnose local environment

package/src/cli/util/angular-component-extractor.js

@@ -0,0 +1,179 @@
+/**
+ * PHASE 20 — Angular Component Extractor
+ * 
+ * Extracts component metadata, template, and class content from Angular TypeScript files.
+ * Handles @Component decorators, template files, and component class methods.
+ * Deterministic and robust (no external runtime execution).
+ */
+
+/**
+ * PHASE 20: Extract Angular component metadata
+ * 
+ * @param {string} content - Full .ts file content
+ * @param {string} filePath - Path to the .ts file (for context)
+ * @param {string} projectRoot - Project root directory
+ * @returns {Object} { componentClass: {content, startLine}, template: {content, path, isInline}, decorator: {content, startLine} }
+ */
+export function extractAngularComponent(content, filePath, projectRoot) {
+  const result = {
+    componentClass: null,
+    template: null,
+    decorator: null,
+  };
+  
+  try {
+    // Extract @Component decorator
+    const decoratorRegex = /@Component\s*\(\s*\{([\s\S]*?)\}\s*\)/;
+    const decoratorMatch = content.match(decoratorRegex);
+    
+    if (decoratorMatch) {
+      const _decoratorContent = decoratorMatch[0];
+      const decoratorConfig = decoratorMatch[1];
+      const beforeDecorator = content.substring(0, decoratorMatch.index);
+      const decoratorStartLine = (beforeDecorator.match(/\n/g) || []).length + 1;
+      
+      result.decorator = {
+        content: decoratorConfig,
+        startLine: decoratorStartLine,
+      };
+      
+      // Extract template (inline or external file)
+      const templateMatch = decoratorConfig.match(/template\s*:\s*['"`]([\s\S]*?)['"`]/);
+      const templateUrlMatch = decoratorConfig.match(/templateUrl\s*:\s*['"`]([^'"`]+)['"`]/);
+      
+      if (templateMatch) {
+        // Inline template
+        result.template = {
+          content: templateMatch[1],
+          path: filePath,
+          isInline: true,
+        };
+      } else if (templateUrlMatch) {
+        // External template file
+        const templateUrl = templateUrlMatch[1];
+        const templatePath = resolveTemplatePath(templateUrl, filePath, projectRoot);
+        result.template = {
+          path: templatePath,
+          isInline: false,
+        };
+      }
+    }
+    
+    // Extract component class
+    const classRegex = /export\s+class\s+(\w+)\s*(?:extends\s+\w+)?\s*\{([\s\S]*?)\n\}/;
+    const classMatch = content.match(classRegex);
+    
+    if (classMatch) {
+      const beforeClass = content.substring(0, classMatch.index);
+      const classStartLine = (beforeClass.match(/\n/g) || []).length + 1;
+      
+      result.componentClass = {
+        content: classMatch[2],
+        className: classMatch[1],
+        startLine: classStartLine,
+      };
+    }
+  } catch (error) {
+    // Skip if extraction fails
+  }
+  
+  return result;
+}
+
+/**
+ * Resolve template path from templateUrl
+ * 
+ * @param {string} templateUrl - Template URL from decorator
+ * @param {string} componentPath - Path to component file
+ * @param {string} projectRoot - Project root directory
+ * @returns {string} Resolved template path
+ */
+function resolveTemplatePath(templateUrl, componentPath, projectRoot) {
+  const { join: _join, dirname, resolve } = require('path');
+  
+  if (templateUrl.startsWith('./') || templateUrl.startsWith('../')) {
+    // Relative path
+    return resolve(dirname(componentPath), templateUrl);
+  } else {
+    // Absolute path from project root
+    return resolve(projectRoot, templateUrl);
+  }
+}
+
+/**
+ * Extract template bindings from Angular template
+ * Detects event handlers, property bindings, and structural directives
+ * 
+ * @param {string} templateContent - Template content
+ * @returns {Object} { eventHandlers: [], propertyBindings: [], structuralDirectives: [] }
+ */
+export function extractTemplateBindings(templateContent) {
+  const eventHandlers = [];
+  const propertyBindings = [];
+  const structuralDirectives = [];
+  
+  // Extract event handlers: (click)="handler()", (submit)="onSubmit()"
+  const eventHandlerRegex = /\((\w+)\)\s*=\s*["']([^"']+)["']/g;
+  let handlerMatch;
+  while ((handlerMatch = eventHandlerRegex.exec(templateContent)) !== null) {
+    eventHandlers.push({
+      event: handlerMatch[1],
+      handler: handlerMatch[2],
+      line: (templateContent.substring(0, handlerMatch.index).match(/\n/g) || []).length + 1,
+    });
+  }
+  
+  // Extract property bindings: [property]="value", [disabled]="isDisabled"
+  const propertyBindingRegex = /\[(\w+)\]\s*=\s*["']([^"']+)["']/g;
+  let bindingMatch;
+  while ((bindingMatch = propertyBindingRegex.exec(templateContent)) !== null) {
+    propertyBindings.push({
+      property: bindingMatch[1],
+      value: bindingMatch[2],
+      line: (templateContent.substring(0, bindingMatch.index).match(/\n/g) || []).length + 1,
+    });
+  }
+  
+  // Extract structural directives: *ngIf="condition", *ngFor="item of items"
+  const structuralDirectiveRegex = /\*ng(If|For|Switch)\s*=\s*["']([^"']+)["']/g;
+  let directiveMatch;
+  while ((directiveMatch = structuralDirectiveRegex.exec(templateContent)) !== null) {
+    structuralDirectives.push({
+      directive: directiveMatch[1],
+      expression: directiveMatch[2],
+      line: (templateContent.substring(0, directiveMatch.index).match(/\n/g) || []).length + 1,
+    });
+  }
+  
+  return {
+    eventHandlers,
+    propertyBindings,
+    structuralDirectives,
+  };
+}
+
+/**
+ * Map template handlers to component class methods
+ * 
+ * @param {Array} eventHandlers - Event handlers from template
+ * @param {string} classContent - Component class content
+ * @returns {Array} Mapped handlers with method references
+ */
+export function mapTemplateHandlersToClass(eventHandlers, classContent) {
+  return eventHandlers.map(handler => {
+    // Extract method name from handler expression
+    const methodName = handler.handler.split('(')[0].trim();
+    
+    // Try to find method definition in class
+    const methodRegex = new RegExp(`(?:public|private|protected)?\\s*(?:async\\s+)?${methodName}\\s*\\(`, 'g');
+    const methodMatch = methodRegex.exec(classContent);
+    
+    return {
+      ...handler,
+      methodName,
+      methodFound: !!methodMatch,
+      methodLine: methodMatch ? (classContent.substring(0, methodMatch.index).match(/\n/g) || []).length + 1 : null,
+    };
+  });
+}
+

package/src/cli/util/angular-navigation-detector.js

@@ -0,0 +1,141 @@
+/**
+ * PHASE 20 — Angular Navigation Detector
+ * 
+ * Detects navigation promises in Angular applications:
+ * - routerLink directive in templates
+ * - Router.navigate() calls in component methods
+ * - ActivatedRoute navigation
+ */
+
+import { extractAngularComponent, extractTemplateBindings, mapTemplateHandlersToClass } from './angular-component-extractor.js'; // eslint-disable-line no-unused-vars
+import { parse } from '@babel/parser';
+import traverse from '@babel/traverse';
+import { readFileSync, existsSync } from 'fs';
+
+/**
+ * Detect navigation promises in Angular component
+ * 
+ * @param {string} filePath - Path to .ts file
+ * @param {string} content - Full file content
+ * @param {string} projectRoot - Project root directory
+ * @returns {Array} Array of navigation expectations
+ */
+export function detectAngularNavigation(filePath, content, projectRoot) {
+  const expectations = [];
+  
+  try {
+    const component = extractAngularComponent(content, filePath, projectRoot);
+    
+    // Extract navigation from template (routerLink)
+    if (component.template) {
+      let templateContent = null;
+      
+      if (component.template.isInline) {
+        templateContent = component.template.content;
+      } else if (existsSync(component.template.path)) {
+        templateContent = readFileSync(component.template.path, 'utf8');
+      }
+      
+      if (templateContent) {
+        const _templateBindings = extractTemplateBindings(templateContent);
+        
+        // Extract routerLink directives
+        const routerLinkRegex = /routerLink\s*=\s*["']([^"']+)["']/g;
+        let linkMatch;
+        while ((linkMatch = routerLinkRegex.exec(templateContent)) !== null) {
+          const href = linkMatch[1];
+          // Skip external links and hash-only links
+          if (href.startsWith('http://') || href.startsWith('https://') || href.startsWith('#')) {
+            continue;
+          }
+          
+          const beforeMatch = templateContent.substring(0, linkMatch.index);
+          const line = (beforeMatch.match(/\n/g) || []).length + 1;
+          
+          expectations.push({
+            type: 'navigation',
+            target: href,
+            context: 'template',
+            sourceRef: {
+              file: component.template.isInline ? filePath : component.template.path,
+              line,
+              snippet: linkMatch[0],
+            },
+            proof: 'PROVEN_EXPECTATION',
+            metadata: {
+              navigationType: 'routerLink',
+            },
+          });
+        }
+      }
+    }
+    
+    // Extract navigation from component class (Router.navigate())
+    if (component.componentClass && component.componentClass.content) {
+      try {
+        const ast = parse(component.componentClass.content, {
+          sourceType: 'module',
+          plugins: ['typescript', 'decorators-legacy', 'classProperties'],
+        });
+        
+        traverse.default(ast, {
+          CallExpression(path) {
+            const { node } = path;
+            
+            // Detect router.navigate() calls
+            if (
+              node.callee.type === 'MemberExpression' &&
+              node.callee.property.name === 'navigate' &&
+              node.arguments.length > 0
+            ) {
+              const arg = node.arguments[0];
+              let target = null;
+              
+              if (arg.type === 'StringLiteral') {
+                target = arg.value;
+              } else if (arg.type === 'ArrayExpression' && arg.elements.length > 0) {
+                // Router.navigate(['/path']) or Router.navigate(['/path', param])
+                const firstElement = arg.elements[0];
+                if (firstElement.type === 'StringLiteral') {
+                  target = firstElement.value;
+                }
+              } else if (arg.type === 'TemplateLiteral' && arg.quasis.length === 1) {
+                target = arg.quasis[0].value.raw;
+              }
+              
+              if (target && !target.startsWith('http://') && !target.startsWith('https://') && !target.startsWith('#')) {
+                const location = node.loc;
+                const line = component.componentClass.startLine + (location ? location.start.line - 1 : 0);
+                
+                expectations.push({
+                  type: 'navigation',
+                  target,
+                  context: 'router-navigate',
+                  sourceRef: {
+                    file: filePath,
+                    line,
+                    snippet: component.componentClass.content.substring(
+                      node.start - (ast.program.body[0]?.start || 0),
+                      node.end - (ast.program.body[0]?.start || 0)
+                    ),
+                  },
+                  proof: arg.type === 'StringLiteral' ? 'PROVEN_EXPECTATION' : 'LIKELY_EXPECTATION',
+                  metadata: {
+                    navigationType: 'router-navigate',
+                  },
+                });
+              }
+            }
+          },
+        });
+      } catch (parseError) {
+        // Skip if parsing fails
+      }
+    }
+  } catch (error) {
+    // Skip if extraction fails
+  }
+  
+  return expectations;
+}
+