qa360 2.1.7 → 2.2.0

package/cli/scripts/validate-package.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+
+/**
+ * Package Validation Script
+ *
+ * Validates that the npm package doesn't contain forbidden files before publishing.
+ * Run automatically via "prepack" hook.
+ *
+ * Exit codes:
+ *   0 - Package valid
+ *   1 - Package contains forbidden files
+ */
+
+import { readdirSync, statSync } from 'fs';
+import { join } from 'path';
+
+// Patterns that should NEVER be published
+const FORBIDDEN_PATTERNS = [
+  /\.map$/,              // Sourcemaps (*.js.map, *.d.ts.map)
+  /^src\//,              // Source files
+  /\/__tests__\//,       // Test files
+  /\.test\.(ts|js)$/,    // Test files
+  /\.spec\.(ts|js)$/,    // Test files
+  /^scripts\//,          // Build scripts (except this one during dev)
+  /^coverage\//,         // Coverage reports
+  /^\.github\//,         // GitHub configs
+  /^\.vscode\//,         // VSCode configs
+  /^\.qa360\//,          // QA360 local data
+  /tsconfig.*\.json$/,   // TypeScript configs (except needed ones)
+  /vitest\.config/,      // Test configs
+  /jest\.config/,        // Test configs
+];
+
+// Allowed exceptions
+const ALLOWED_EXCEPTIONS = [
+  'scripts/validate-package.js',  // This script itself
+];
+
+function getAllFiles(dir, baseDir = dir) {
+  const files = [];
+
+  try {
+    const entries = readdirSync(dir);
+
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+      const stat = statSync(fullPath);
+
+      if (stat.isDirectory()) {
+        files.push(...getAllFiles(fullPath, baseDir));
+      } else {
+        // Get relative path from base
+        const relativePath = fullPath.substring(baseDir.length + 1);
+        files.push(relativePath);
+      }
+    }
+  } catch (err) {
+    // Ignore errors
+  }
+
+  return files;
+}
+
+function validatePackage() {
+  console.log('🔍 Validating package contents...\n');
+
+  // Get all files that will be published (check dist/ mainly)
+  const distFiles = getAllFiles(join(process.cwd(), 'dist'));
+
+  const forbiddenFiles = [];
+
+  for (const file of distFiles) {
+    const relativePath = `dist/${file}`;
+
+    // Skip allowed exceptions
+    if (ALLOWED_EXCEPTIONS.includes(relativePath)) {
+      continue;
+    }
+
+    // Check against forbidden patterns
+    for (const pattern of FORBIDDEN_PATTERNS) {
+      if (pattern.test(file)) {
+        forbiddenFiles.push({
+          file: relativePath,
+          reason: `Matches forbidden pattern: ${pattern}`
+        });
+        break;
+      }
+    }
+  }
+
+  // Report results
+  if (forbiddenFiles.length > 0) {
+    console.error('❌ Package validation FAILED\n');
+    console.error(`Found ${forbiddenFiles.length} forbidden file(s):\n`);
+
+    forbiddenFiles.forEach(({ file, reason }) => {
+      console.error(`  • ${file}`);
+      console.error(`    ${reason}\n`);
+    });
+
+    console.error('💡 Fix: Remove these files before publishing.');
+    console.error('    Most likely: disable sourcemaps in tsconfig.json\n');
+
+    process.exit(1);
+  }
+
+  console.log('✅ Package validation PASSED');
+  console.log(`   Checked ${distFiles.length} files in dist/`);
+  console.log('   No forbidden patterns detected\n');
+
+  process.exit(0);
+}
+
+// Run validation
+validatePackage();

package/cli/src/__tests__/commands/doctor.test.ts

@@ -0,0 +1,108 @@
+/**
+ * QA360 Doctor Command Tests
+ */
+
+import { QA360Doctor } from '../../commands/doctor';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+// Mock fs module
+vi.mock('fs');
+vi.mock('child_process');
+
+// Mock global fetch to avoid network calls in tests
+global.fetch = vi.fn();
+
+const mockExistsSync = existsSync as any;
+const mockFetch = global.fetch as any;
+
+describe('QA360Doctor', () => {
+  let doctor: QA360Doctor;
+
+  beforeEach(() => {
+    doctor = new QA360Doctor();
+    vi.clearAllMocks();
+
+    // Mock successful network check by default
+    mockFetch.mockResolvedValue({
+      ok: true,
+      status: 200,
+    } as Response);
+  });
+
+  describe('diagnose', () => {
+    // Increase timeout for this test as it performs multiple checks
+    it('should perform basic health checks', async () => {
+      mockExistsSync.mockReturnValue(true);
+
+      const result = await doctor.diagnose();
+
+      expect(result.checks).toBeDefined();
+      expect(result.summary).toBeDefined();
+      expect(result.checks.length).toBeGreaterThan(0);
+    });
+
+    it('should detect Node.js version correctly', async () => {
+      const result = await doctor.diagnose();
+      
+      const nodeCheck = result.checks.find(c => c.name === 'Node.js Version');
+      expect(nodeCheck).toBeDefined();
+      expect(nodeCheck?.status).toBe('ok'); // Assuming Node 18+ in test env
+    });
+
+    it('should identify missing directories', async () => {
+      mockExistsSync.mockReturnValue(false);
+      
+      const result = await doctor.diagnose();
+      
+      const dirCheck = result.checks.find(c => c.name === 'Structure QA360');
+      expect(dirCheck).toBeDefined();
+      expect(dirCheck?.status).toBe('warning');
+      expect(dirCheck?.code).toBe('QX002');
+    });
+
+    it('should provide fix functions for issues', async () => {
+      mockExistsSync.mockReturnValue(false);
+      
+      const result = await doctor.diagnose();
+      
+      const fixableChecks = result.checks.filter(c => c.fix);
+      expect(fixableChecks.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('auto-fix', () => {
+    it('should apply fixes when requested', async () => {
+      mockExistsSync.mockReturnValue(false);
+      
+      const result = await doctor.diagnose({ fix: true });
+      
+      // Should attempt to fix issues
+      expect(result.checks.some(c => c.status === 'ok')).toBe(true);
+    });
+  });
+
+  describe('exit codes', () => {
+    it('should return 0 for successful diagnosis', async () => {
+      mockExistsSync.mockReturnValue(true);
+      
+      const result = await doctor.diagnose();
+      
+      expect(result.exitCode).toBe(0);
+    });
+
+    it('should return 0 when warnings are found (not errors)', async () => {
+      // Mock a scenario that would cause warnings
+      const originalVersion = process.version;
+      Object.defineProperty(process, 'version', { value: 'v16.0.0' });
+      
+      const result = await doctor.diagnose();
+      
+      // Doctor returns 0 for warnings, only 1 for critical errors
+      expect(result.exitCode).toBe(0);
+      
+      // Restore original version
+      Object.defineProperty(process, 'version', { value: originalVersion });
+    });
+  });
+});

package/cli/src/__tests__/index.test.ts

@@ -0,0 +1,15 @@
+/**
+ * QA360 CLI Tests
+ */
+
+describe('QA360 CLI', () => {
+  it('should export version', () => {
+    // Basic test to ensure module loads
+    expect(true).toBe(true);
+  });
+
+  it('should have proper command structure', () => {
+    // Test command parsing (Phase 1)
+    expect(true).toBe(true);
+  });
+});

package/cli/src/cli-minimal.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+/**
+ * QA360 CLI - Minimal version for E2E tests
+ * Only includes doctor and verify commands
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { doctorCommand } from './commands/doctor.js';
+import { verifyCommand } from './commands/verify.js';
+
+const program = new Command();
+
+program
+  .name('qa360')
+  .description('QA360 Proof Bundle CLI')
+  .version('1.0.1');
+
+program
+  .command('doctor')
+  .description('Health check and auto-fix issues')
+  .option('--fix', 'Automatically fix detected issues')
+  .option('--json', 'Output results as JSON')
+  .option('--strict', 'Exit with code 1 on any error')
+  .action(async (options) => {
+    await doctorCommand(options);
+  });
+
+program
+  .command('verify [proof]')
+  .description('Verify proof authenticity and integrity')
+  .option('--json', 'Output results as JSON')
+  .option('--verbose', 'Show detailed verification information')
+  .action(async (proof, options) => {
+    await verifyCommand(proof, options);
+  });
+
+// Parse arguments (no banner for clean JSON output)
+program.parse();
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/cli/src/commands/__tests__/crawl.test.ts

@@ -0,0 +1,412 @@
+/**
+ * E2E Tests for Crawl Command
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { crawlCommand } from '../crawl.js';
+import type { CrawlResult } from '../../../core/src/crawler/index.js';
+
+// Mock core exports
+vi.mock('../../../core/src/index.js', () => ({
+  generatePackFromCrawl: vi.fn(),
+  quickCrawl: vi.fn(),
+}));
+
+describe('Crawl Command - E2E', () => {
+  let consoleLogSpy: any;
+  let consoleErrorSpy: any;
+
+  beforeEach(() => {
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  describe('Basic Crawl', () => {
+    it('should crawl a website and generate pack', async () => {
+      const mockResult: CrawlResult = {
+ success: true,
+ siteMap: {
+   baseUrl: 'https://example.com',
+   pages: [],
+   metadata: {
+     pagesCrawled: 5,
+     totalForms: 1,
+     avgLoadTime: 300,
+     crawledAt: new Date().toISOString(),
+   },
+   pageTypeDistribution: {
+     homepage: 1,
+     listing: 2,
+     detail: 2,
+     form: 0,
+     login: 0,
+     other: 0,
+   },
+ },
+ userJourneys: [
+   {
+     name: 'Navigation Journey',
+     description: 'Navigate through pages',
+     type: 'navigation',
+     steps: [
+   { action: 'navigate', value: 'https://example.com/page1' },
+     ],
+     entryPoint: 'https://example.com',
+     estimatedDuration: 2000,
+   },
+ ],
+ forms: [],
+ accessibilityIssues: [],
+      };
+
+      const { generatePackFromCrawl } = await import('../../../core/src/index.js');
+      (generatePackFromCrawl as any).mockResolvedValue({
+ success: true,
+ packPath: '/tmp/test-pack.yml',
+ result: mockResult,
+      });
+
+      await crawlCommand('https://example.com', {
+ output: '/tmp/test-pack.yml',
+      });
+
+      expect(generatePackFromCrawl).toHaveBeenCalledWith(
+ expect.objectContaining({
+   baseUrl: 'https://example.com',
+   output: '/tmp/test-pack.yml',
+ })
+      );
+    });
+
+    it('should show crawl summary on success', async () => {
+      const mockResult: CrawlResult = {
+ success: true,
+ siteMap: {
+   baseUrl: 'https://example.com',
+   pages: [],
+   metadata: {
+     pagesCrawled: 10,
+     totalForms: 3,
+     avgLoadTime: 450,
+     crawledAt: new Date().toISOString(),
+   },
+   pageTypeDistribution: {
+     homepage: 1,
+     listing: 3,
+     detail: 5,
+     form: 1,
+     login: 0,
+     other: 0,
+   },
+ },
+ userJourneys: [
+   {
+     name: 'Login Journey',
+     description: 'User login flow',
+     type: 'authentication',
+     steps: [],
+     entryPoint: 'https://example.com/login',
+     estimatedDuration: 3000,
+   },
+   {
+     name: 'Search Journey',
+     description: 'Search functionality',
+     type: 'search',
+     steps: [],
+     entryPoint: 'https://example.com',
+     estimatedDuration: 2000,
+   },
+ ],
+ forms: [],
+ accessibilityIssues: [],
+      };
+
+      const { generatePackFromCrawl } = await import('../../../core/src/index.js');
+      (generatePackFromCrawl as any).mockResolvedValue({
+ success: true,
+ packPath: 'pack.yml',
+ result: mockResult,
+      });
+
+      await crawlCommand('https://example.com');
+
+      // Verify console output contains summary
+      const outputs = consoleLogSpy.mock.calls.map((call: any[]) => call.join(' '));
+      const summaryOutput = outputs.join('\n');
+
+      expect(summaryOutput).toContain('Pages discovered');
+      expect(summaryOutput).toContain('Forms found');
+      expect(summaryOutput).toContain('User journeys');
+    });
+  });
+
+  describe('Quick Crawl', () => {
+    it('should use quick crawl settings when --quick flag is set', async () => {
+      const { quickCrawl } = await import('../../../core/src/index.js');
+      (quickCrawl as any).mockResolvedValue({
+ success: true,
+ packPath: 'pack.yml',
+      });
+
+      await crawlCommand('https://example.com', {
+ quick: true,
+ output: 'pack.yml',
+      });
+
+      expect(quickCrawl).toHaveBeenCalledWith('https://example.com', 'pack.yml');
+    });
+
+    it('should show quick crawl specific output', async () => {
+      const { quickCrawl } = await import('../../../core/src/index.js');
+      (quickCrawl as any).mockResolvedValue({
+ success: true,
+ packPath: 'quick-pack.yml',
+      });
+
+      await crawlCommand('https://example.com', {
+ quick: true,
+ output: 'quick-pack.yml',
+      });
+
+      const outputs = consoleLogSpy.mock.calls.map((call: any[]) => call.join(' '));
+      const output = outputs.join('\n');
+
+      expect(output).toContain('Quick crawl');
+      expect(output).toContain('quick-pack.yml');
+    });
+  });
+
+  describe('Crawl Options', () => {
+    it('should support custom max depth', async () => {
+      const { generatePackFromCrawl } = await import('../../../core/src/index.js');
+      (generatePackFromCrawl as any).mockResolvedValue({
+ success: true,
+ packPath: 'pack.yml',
+      });
+
+      await crawlCommand('https://example.com', {
+ maxDepth: '3',
+      });
+
+      expect(generatePackFromCrawl).toHaveBeenCalledWith(
+ expect.objectContaining({
+   crawl: expect.objectContaining({
+     maxDepth: 3,
+   }),
+ })
+      );
+    });
+
+    it('should support custom max pages', async () => {
+      const { generatePackFromCrawl } = await import('../../../core/src/index.js');
+      (generatePackFromCrawl as any).mockResolvedValue({
+ success: true,
+ packPath: 'pack.yml',
+      });
+
+      await crawlCommand('https://example.com', {
+ maxPages: '50',
+      });
+
+      expect(generatePackFromCrawl).toHaveBeenCalledWith(
+ expect.objectContaining({
+   crawl: expect.objectContaining({
+     maxPages: 50,
+   }),
+ })
+      );
+    });
+
+    it('should support exclude patterns', async () => {
+      const { generatePackFromCrawl } = await import('../../../core/src/index.js');
+      (generatePackFromCrawl as any).mockResolvedValue({
+ success: true,
+ packPath: 'pack.yml',
+      });
+
+      await crawlCommand('https://example.com', {
+ exclude: ['/admin', '/api'],
+      });
+
+      expect(generatePackFromCrawl).toHaveBeenCalledWith(
+ expect.objectContaining({
+   crawl: expect.objectContaining({
+     excludePatterns: ['/admin', '/api'],
+   }),
+ })
+      );
+    });
+
+    it('should support accessibility tests flag', async () => {
+      const { generatePackFromCrawl } = await import('../../../core/src/index.js');
+      (generatePackFromCrawl as any).mockResolvedValue({
+ success: true,
+ packPath: 'pack.yml',
+      });
+
+      await crawlCommand('https://example.com', {
+ a11y: true,
+      });
+
+      expect(generatePackFromCrawl).toHaveBeenCalledWith(
+ expect.objectContaining({
+   includeA11y: true,
+ })
+      );
+    });
+
+    it('should support custom pack name', async () => {
+      const { generatePackFromCrawl } = await import('../../../core/src/index.js');
+      (generatePackFromCrawl as any).mockResolvedValue({
+ success: true,
+ packPath: 'my-pack.yml',
+      });
+
+      await crawlCommand('https://example.com', {
+ name: 'My Custom Pack',
+ output: 'my-pack.yml',
+      });
+
+      expect(generatePackFromCrawl).toHaveBeenCalledWith(
+ expect.objectContaining({
+   packName: 'My Custom Pack',
+   output: 'my-pack.yml',
+ })
+      );
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle invalid URL', async () => {
+      await crawlCommand('not-a-valid-url');
+
+      const outputs = consoleErrorSpy.mock.calls.map((call: any[]) => call.join(' '));
+      const output = outputs.join('\n');
+
+      expect(output).toContain('Crawl error');
+    });
+
+    it('should handle crawl failure', async () => {
+      const { generatePackFromCrawl } = await import('../../../core/src/index.js');
+      (generatePackFromCrawl as any).mockResolvedValue({
+ success: false,
+ error: 'Connection refused',
+      });
+
+      await crawlCommand('https://example.com');
+
+      const outputs = consoleErrorSpy.mock.calls.map((call: any[]) => call.join(' '));
+      const output = outputs.join('\n');
+
+      expect(output).toContain('Crawl failed');
+      expect(output).toContain('Connection refused');
+    });
+
+    it('should show usage hint on URL error', async () => {
+      await crawlCommand('htt-p://invalid-url');
+
+      const outputs = consoleLogSpy.mock.calls.map((call: any[]) => call.join(' '));
+      const output = outputs.join('\n');
+
+      expect(output).toContain('Usage');
+    });
+  });
+
+  describe('Output Formatting', () => {
+    it('should show generated journeys', async () => {
+      const mockResult: CrawlResult = {
+ success: true,
+ siteMap: {
+   baseUrl: 'https://example.com',
+   pages: [],
+   metadata: {
+     pagesCrawled: 5,
+     totalForms: 1,
+     avgLoadTime: 300,
+     crawledAt: new Date().toISOString(),
+   },
+   pageTypeDistribution: {
+     homepage: 1,
+     listing: 2,
+     detail: 2,
+     form: 0,
+     login: 0,
+     other: 0,
+   },
+ },
+ userJourneys: [
+   { name: 'Journey 1', description: 'First', type: 'navigation', steps: [], entryPoint: '/', estimatedDuration: 1000 },
+   { name: 'Journey 2', description: 'Second', type: 'search', steps: [], entryPoint: '/', estimatedDuration: 2000 },
+   { name: 'Journey 3', description: 'Third', type: 'form-submission', steps: [], entryPoint: '/', estimatedDuration: 1500 },
+   { name: 'Journey 4', description: 'Fourth', type: 'authentication', steps: [], entryPoint: '/', estimatedDuration: 2500 },
+   { name: 'Journey 5', description: 'Fifth', type: 'navigation', steps: [], entryPoint: '/', estimatedDuration: 1800 },
+   { name: 'Journey 6', description: 'Sixth', type: 'other', steps: [], entryPoint: '/', estimatedDuration: 1200 },
+ ],
+ forms: [],
+ accessibilityIssues: [],
+      };
+
+      const { generatePackFromCrawl } = await import('../../../core/src/index.js');
+      (generatePackFromCrawl as any).mockResolvedValue({
+ success: true,
+ packPath: 'pack.yml',
+ result: mockResult,
+      });
+
+      await crawlCommand('https://example.com');
+
+      const outputs = consoleLogSpy.mock.calls.map((call: any[]) => call.join(' '));
+      const output = outputs.join('\n');
+
+      expect(output).toContain('Generated Journeys');
+      expect(output).toContain('Journey 1');
+      expect(output).toContain('and 1 more'); // More than 5 journeys
+    });
+
+    it('should show page type distribution', async () => {
+      const mockResult: CrawlResult = {
+ success: true,
+ siteMap: {
+   baseUrl: 'https://example.com',
+   pages: [],
+   metadata: {
+     pagesCrawled: 10,
+     totalForms: 2,
+     avgLoadTime: 400,
+     crawledAt: new Date().toISOString(),
+   },
+   pageTypeDistribution: {
+     homepage: 1,
+     listing: 3,
+     detail: 5,
+     form: 1,
+     login: 0,
+     other: 0,
+   },
+ },
+ userJourneys: [],
+ forms: [],
+ accessibilityIssues: [],
+      };
+
+      const { generatePackFromCrawl } = await import('../../../core/src/index.js');
+      (generatePackFromCrawl as any).mockResolvedValue({
+ success: true,
+ packPath: 'pack.yml',
+ result: mockResult,
+      });
+
+      await crawlCommand('https://example.com');
+
+      const outputs = consoleLogSpy.mock.calls.map((call: any[]) => call.join(' '));
+      const output = outputs.join('\n');
+
+      expect(output).toContain('Page Types');
+    });
+  });
+});