@agentic-qe/v3 3.0.0-alpha.3

package/tests/unit/cli/commands.test.ts

@@ -0,0 +1,414 @@
+/**
+ * Agentic QE v3 - CLI Commands Tests
+ * Tests for various aqe-v3 CLI commands
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { ALL_DOMAINS, type DomainName } from '../../../src/shared/types';
+
+describe('CLI Commands', () => {
+  describe('Status Command', () => {
+    it('should format health status with colors', () => {
+      const getStatusColor = (status: string): string => {
+        switch (status) {
+          case 'healthy':
+          case 'completed':
+            return 'green';
+          case 'degraded':
+          case 'running':
+            return 'yellow';
+          case 'unhealthy':
+          case 'failed':
+            return 'red';
+          default:
+            return 'gray';
+        }
+      };
+
+      expect(getStatusColor('healthy')).toBe('green');
+      expect(getStatusColor('completed')).toBe('green');
+      expect(getStatusColor('degraded')).toBe('yellow');
+      expect(getStatusColor('running')).toBe('yellow');
+      expect(getStatusColor('unhealthy')).toBe('red');
+      expect(getStatusColor('failed')).toBe('red');
+      expect(getStatusColor('unknown')).toBe('gray');
+    });
+
+    it('should format duration correctly', () => {
+      const formatDuration = (ms: number): string => {
+        if (ms < 1000) return `${ms}ms`;
+        if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+        if (ms < 3600000) return `${(ms / 60000).toFixed(1)}m`;
+        return `${(ms / 3600000).toFixed(1)}h`;
+      };
+
+      expect(formatDuration(500)).toBe('500ms');
+      expect(formatDuration(1500)).toBe('1.5s');
+      expect(formatDuration(90000)).toBe('1.5m');
+      expect(formatDuration(5400000)).toBe('1.5h');
+    });
+
+    it('should format uptime correctly', () => {
+      const formatUptime = (ms: number): string => {
+        const hours = Math.floor(ms / 3600000);
+        const minutes = Math.floor((ms % 3600000) / 60000);
+        const seconds = Math.floor((ms % 60000) / 1000);
+        return `${hours}h ${minutes}m ${seconds}s`;
+      };
+
+      expect(formatUptime(0)).toBe('0h 0m 0s');
+      expect(formatUptime(3661000)).toBe('1h 1m 1s');
+      expect(formatUptime(86400000)).toBe('24h 0m 0s');
+    });
+
+    it('should support verbose flag', () => {
+      const options = { verbose: true };
+      expect(options.verbose).toBe(true);
+    });
+  });
+
+  describe('Health Command', () => {
+    it('should accept domain filter', () => {
+      const options = { domain: 'test-generation' };
+      expect(ALL_DOMAINS).toContain(options.domain);
+    });
+
+    it('should validate domain name', () => {
+      const isValidDomain = (domain: string): boolean => {
+        return ALL_DOMAINS.includes(domain as DomainName);
+      };
+
+      expect(isValidDomain('test-generation')).toBe(true);
+      expect(isValidDomain('coverage-analysis')).toBe(true);
+      expect(isValidDomain('invalid-domain')).toBe(false);
+    });
+  });
+
+  describe('Test Command', () => {
+    it('should accept generate action', () => {
+      const action = 'generate';
+      expect(['generate', 'execute']).toContain(action);
+    });
+
+    it('should accept execute action', () => {
+      const action = 'execute';
+      expect(['generate', 'execute']).toContain(action);
+    });
+
+    it('should accept framework option', () => {
+      const options = { framework: 'vitest' };
+      expect(['jest', 'vitest', 'mocha']).toContain(options.framework);
+    });
+
+    it('should accept test type option', () => {
+      const options = { type: 'unit' };
+      expect(['unit', 'integration', 'e2e']).toContain(options.type);
+    });
+
+    it('should accept target path', () => {
+      const target = 'src/services/user.ts';
+      expect(typeof target).toBe('string');
+      expect(target.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Coverage Command', () => {
+    it('should accept target path', () => {
+      const target = './src';
+      expect(typeof target).toBe('string');
+    });
+
+    it('should default target to current directory', () => {
+      const target = undefined;
+      const effectiveTarget = target || '.';
+      expect(effectiveTarget).toBe('.');
+    });
+
+    it('should support risk flag', () => {
+      const options = { risk: true };
+      expect(options.risk).toBe(true);
+    });
+
+    it('should support gaps flag', () => {
+      const options = { gaps: true };
+      expect(options.gaps).toBe(true);
+    });
+
+    it('should format coverage percentage with color', () => {
+      const getColorForPercent = (percent: number): string => {
+        if (percent >= 80) return 'green';
+        if (percent >= 50) return 'yellow';
+        return 'red';
+      };
+
+      expect(getColorForPercent(90)).toBe('green');
+      expect(getColorForPercent(80)).toBe('green');
+      expect(getColorForPercent(65)).toBe('yellow');
+      expect(getColorForPercent(50)).toBe('yellow');
+      expect(getColorForPercent(30)).toBe('red');
+    });
+  });
+
+  describe('Security Command', () => {
+    it('should support sast flag', () => {
+      const options = { sast: true };
+      expect(options.sast).toBe(true);
+    });
+
+    it('should support dast flag', () => {
+      const options = { dast: true };
+      expect(options.dast).toBe(true);
+    });
+
+    it('should support compliance frameworks', () => {
+      const options = { compliance: 'gdpr,hipaa,soc2' };
+      const frameworks = options.compliance.split(',');
+
+      expect(frameworks).toContain('gdpr');
+      expect(frameworks).toContain('hipaa');
+      expect(frameworks).toContain('soc2');
+    });
+
+    it('should accept target path', () => {
+      const options = { target: './src' };
+      expect(options.target).toBe('./src');
+    });
+
+    it('should default target to current directory', () => {
+      const options = { target: undefined };
+      const effectiveTarget = options.target || '.';
+      expect(effectiveTarget).toBe('.');
+    });
+  });
+
+  describe('Code Command', () => {
+    it('should accept index action', () => {
+      const action = 'index';
+      expect(['index', 'search', 'impact', 'deps']).toContain(action);
+    });
+
+    it('should accept search action', () => {
+      const action = 'search';
+      expect(['index', 'search', 'impact', 'deps']).toContain(action);
+    });
+
+    it('should accept impact action', () => {
+      const action = 'impact';
+      expect(['index', 'search', 'impact', 'deps']).toContain(action);
+    });
+
+    it('should accept deps action', () => {
+      const action = 'deps';
+      expect(['index', 'search', 'impact', 'deps']).toContain(action);
+    });
+
+    it('should support depth option', () => {
+      const options = { depth: '3' };
+      expect(parseInt(options.depth, 10)).toBe(3);
+    });
+
+    it('should support include-tests flag', () => {
+      const options = { includeTests: true };
+      expect(options.includeTests).toBe(true);
+    });
+  });
+
+  describe('Quality Command', () => {
+    it('should support gate flag', () => {
+      const options = { gate: true };
+      expect(options.gate).toBe(true);
+    });
+  });
+
+  describe('Task Command', () => {
+    describe('Submit Subcommand', () => {
+      it('should accept task type', () => {
+        const taskTypes = [
+          'generate-tests',
+          'execute-tests',
+          'analyze-coverage',
+          'assess-quality',
+          'predict-defects',
+          'validate-requirements',
+          'index-code',
+          'scan-security',
+          'validate-contracts',
+          'test-accessibility',
+          'run-chaos',
+          'optimize-learning',
+        ];
+
+        for (const type of taskTypes) {
+          expect(typeof type).toBe('string');
+        }
+        expect(taskTypes.length).toBe(12);
+      });
+
+      it('should accept priority option', () => {
+        const priorities = ['p0', 'p1', 'p2', 'p3'];
+        for (const priority of priorities) {
+          expect(priorities).toContain(priority);
+        }
+      });
+
+      it('should accept domain option', () => {
+        const options = { domain: 'test-generation' };
+        expect(ALL_DOMAINS).toContain(options.domain);
+      });
+
+      it('should accept timeout option', () => {
+        const options = { timeout: '300000' };
+        const timeout = parseInt(options.timeout, 10);
+        expect(timeout).toBe(300000);
+        expect(timeout).toBeGreaterThan(0);
+      });
+
+      it('should accept payload option as JSON', () => {
+        const options = { payload: '{"source":"test.ts"}' };
+        const payload = JSON.parse(options.payload);
+        expect(payload.source).toBe('test.ts');
+      });
+    });
+
+    describe('List Subcommand', () => {
+      it('should accept status filter', () => {
+        const options = { status: 'running' };
+        expect(['pending', 'running', 'completed', 'failed']).toContain(options.status);
+      });
+
+      it('should accept priority filter', () => {
+        const options = { priority: 'p1' };
+        expect(['p0', 'p1', 'p2', 'p3']).toContain(options.priority);
+      });
+
+      it('should accept domain filter', () => {
+        const options = { domain: 'test-generation' };
+        expect(ALL_DOMAINS).toContain(options.domain);
+      });
+    });
+
+    describe('Status Subcommand', () => {
+      it('should accept task ID', () => {
+        const taskId = 'task-12345';
+        expect(typeof taskId).toBe('string');
+        expect(taskId.length).toBeGreaterThan(0);
+      });
+    });
+
+    describe('Cancel Subcommand', () => {
+      it('should accept task ID', () => {
+        const taskId = 'task-12345';
+        expect(typeof taskId).toBe('string');
+      });
+    });
+  });
+
+  describe('Agent Command', () => {
+    describe('List Subcommand', () => {
+      it('should accept domain filter', () => {
+        const options = { domain: 'test-generation' };
+        expect(ALL_DOMAINS).toContain(options.domain);
+      });
+
+      it('should accept status filter', () => {
+        const options = { status: 'active' };
+        expect(typeof options.status).toBe('string');
+      });
+    });
+
+    describe('Spawn Subcommand', () => {
+      it('should accept domain argument', () => {
+        const domain = 'test-generation';
+        expect(ALL_DOMAINS).toContain(domain);
+      });
+
+      it('should accept type option', () => {
+        const options = { type: 'worker' };
+        expect(['worker', 'specialist', 'coordinator']).toContain(options.type);
+      });
+
+      it('should accept capabilities option', () => {
+        const options = { capabilities: 'unit-test,integration-test' };
+        const capabilities = options.capabilities.split(',');
+        expect(capabilities.length).toBe(2);
+        expect(capabilities).toContain('unit-test');
+        expect(capabilities).toContain('integration-test');
+      });
+    });
+  });
+
+  describe('Domain Command', () => {
+    describe('List Subcommand', () => {
+      it('should list all 12 domains', () => {
+        expect(ALL_DOMAINS.length).toBe(12);
+      });
+    });
+
+    describe('Health Subcommand', () => {
+      it('should accept domain argument', () => {
+        const domain = 'test-generation';
+        expect(ALL_DOMAINS).toContain(domain);
+      });
+    });
+  });
+
+  describe('Protocol Command', () => {
+    describe('Run Subcommand', () => {
+      it('should accept protocol ID', () => {
+        const protocolId = 'comprehensive-testing';
+        expect(typeof protocolId).toBe('string');
+      });
+
+      it('should accept params option as JSON', () => {
+        const options = { params: '{"threshold":80}' };
+        const params = JSON.parse(options.params);
+        expect(params.threshold).toBe(80);
+      });
+    });
+  });
+});
+
+describe('CLI Error Handling', () => {
+  it('should handle invalid JSON in payload', () => {
+    const parsePayload = (payload: string) => {
+      try {
+        return JSON.parse(payload);
+      } catch {
+        return {};
+      }
+    };
+
+    expect(parsePayload('invalid')).toEqual({});
+    expect(parsePayload('{"valid":true}')).toEqual({ valid: true });
+  });
+
+  it('should handle invalid domain names', () => {
+    const isValidDomain = (domain: string): boolean => {
+      return ALL_DOMAINS.includes(domain as DomainName);
+    };
+
+    expect(isValidDomain('invalid')).toBe(false);
+    expect(isValidDomain('')).toBe(false);
+    expect(isValidDomain('test-generation')).toBe(true);
+  });
+
+  it('should handle invalid priority values', () => {
+    const isValidPriority = (priority: string): boolean => {
+      return ['p0', 'p1', 'p2', 'p3'].includes(priority);
+    };
+
+    expect(isValidPriority('p1')).toBe(true);
+    expect(isValidPriority('p5')).toBe(false);
+    expect(isValidPriority('high')).toBe(false);
+  });
+
+  it('should handle missing required arguments', () => {
+    const validateArgs = (args: { taskId?: string }): boolean => {
+      return !!args.taskId && args.taskId.length > 0;
+    };
+
+    expect(validateArgs({})).toBe(false);
+    expect(validateArgs({ taskId: '' })).toBe(false);
+    expect(validateArgs({ taskId: 'task-123' })).toBe(true);
+  });
+});

package/tests/unit/cli/init-command.test.ts

@@ -0,0 +1,274 @@
+/**
+ * Agentic QE v3 - Init Command Tests
+ * Tests for the aqe-v3 init command
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { InitOrchestrator, type InitOrchestratorOptions } from '../../../src/init/init-wizard';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Mock fs module
+vi.mock('fs', async () => {
+  const actual = await vi.importActual('fs');
+  return {
+    ...actual,
+    existsSync: vi.fn(),
+    mkdirSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    readFileSync: vi.fn(),
+    readdirSync: vi.fn(),
+    statSync: vi.fn(),
+  };
+});
+
+describe('Init Command', () => {
+  const testProjectRoot = '/tmp/test-project';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('InitOrchestrator', () => {
+    it('should create orchestrator with default options', () => {
+      const orchestrator = new InitOrchestrator({
+        projectRoot: testProjectRoot,
+      });
+
+      expect(orchestrator).toBeDefined();
+    });
+
+    it('should create orchestrator with auto mode', () => {
+      const orchestrator = new InitOrchestrator({
+        projectRoot: testProjectRoot,
+        autoMode: true,
+      });
+
+      expect(orchestrator).toBeDefined();
+    });
+
+    it('should create orchestrator with minimal mode', () => {
+      const orchestrator = new InitOrchestrator({
+        projectRoot: testProjectRoot,
+        minimal: true,
+      });
+
+      expect(orchestrator).toBeDefined();
+    });
+
+    it('should create orchestrator with skipPatterns', () => {
+      const orchestrator = new InitOrchestrator({
+        projectRoot: testProjectRoot,
+        skipPatterns: true,
+      });
+
+      expect(orchestrator).toBeDefined();
+    });
+
+    it('should return wizard steps', () => {
+      const orchestrator = new InitOrchestrator({
+        projectRoot: testProjectRoot,
+      });
+
+      const steps = orchestrator.getWizardSteps();
+      expect(Array.isArray(steps)).toBe(true);
+      expect(steps.length).toBeGreaterThan(0);
+
+      // Each step should have title and description
+      for (const step of steps) {
+        expect(step).toHaveProperty('title');
+        expect(step).toHaveProperty('description');
+        expect(typeof step.title).toBe('string');
+        expect(typeof step.description).toBe('string');
+      }
+    });
+  });
+
+  describe('Init Options Validation', () => {
+    it('should accept valid domain list', () => {
+      const domains = 'test-generation,coverage-analysis,quality-assessment';
+      const domainList = domains.split(',');
+
+      expect(domainList).toContain('test-generation');
+      expect(domainList).toContain('coverage-analysis');
+      expect(domainList).toContain('quality-assessment');
+    });
+
+    it('should accept "all" for domains', () => {
+      const domains = 'all';
+      expect(domains).toBe('all');
+    });
+
+    it('should accept valid memory backend options', () => {
+      const validBackends = ['sqlite', 'hybrid', 'agentdb'];
+
+      for (const backend of validBackends) {
+        expect(validBackends).toContain(backend);
+      }
+    });
+
+    it('should accept valid max agents value', () => {
+      const maxAgents = '15';
+      const parsed = parseInt(maxAgents, 10);
+
+      expect(parsed).toBe(15);
+      expect(parsed).toBeGreaterThan(0);
+      expect(parsed).toBeLessThanOrEqual(50);
+    });
+
+    it('should validate lazy loading flag', () => {
+      const lazy = true;
+      expect(typeof lazy).toBe('boolean');
+    });
+  });
+
+  describe('Init Directory Structure', () => {
+    it('should define correct v3 directory structure', () => {
+      const v3Dir = '.aqe-v3';
+      const expectedDirs = [
+        v3Dir,
+        `${v3Dir}/agentdb`,
+        `${v3Dir}/reasoning-bank`,
+        `${v3Dir}/cache`,
+        `${v3Dir}/logs`,
+      ];
+
+      for (const dir of expectedDirs) {
+        expect(dir).toMatch(/^\.aqe-v3/);
+      }
+    });
+
+    it('should define correct config file path', () => {
+      const configPath = '.aqe-v3/config.json';
+      expect(configPath).toBe('.aqe-v3/config.json');
+    });
+  });
+
+  describe('Init Config Generation', () => {
+    it('should generate valid v3 config structure', () => {
+      const config = {
+        version: '3.0.0',
+        kernel: {
+          eventBus: 'in-memory',
+          coordinator: 'queen',
+        },
+        domains: {
+          'test-generation': { enabled: true },
+          'test-execution': { enabled: true },
+          'coverage-analysis': { enabled: true, algorithm: 'hnsw', dimensions: 128 },
+          'quality-assessment': { enabled: true },
+          'defect-intelligence': { enabled: true },
+          'requirements-validation': { enabled: true },
+          'code-intelligence': { enabled: true },
+          'security-compliance': { enabled: true },
+          'contract-testing': { enabled: true },
+          'visual-accessibility': { enabled: false },
+          'chaos-resilience': { enabled: true },
+          'learning-optimization': { enabled: true },
+        },
+        memory: {
+          backend: 'hybrid',
+          path: '.aqe-v3/agentdb/',
+          hnsw: { M: 16, efConstruction: 200 },
+        },
+        learning: {
+          reasoningBank: true,
+          sona: true,
+          patternRetention: 180,
+        },
+      };
+
+      expect(config.version).toBe('3.0.0');
+      expect(config.kernel.coordinator).toBe('queen');
+      expect(config.domains['test-generation'].enabled).toBe(true);
+      expect(config.memory.backend).toBe('hybrid');
+      expect(config.learning.reasoningBank).toBe(true);
+    });
+
+    it('should support HNSW configuration', () => {
+      const hnswConfig = {
+        M: 16,
+        efConstruction: 200,
+        efSearch: 50,
+      };
+
+      expect(hnswConfig.M).toBeGreaterThan(0);
+      expect(hnswConfig.efConstruction).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Init Success Output', () => {
+    it('should define expected next steps', () => {
+      const nextSteps = [
+        'Add MCP: claude mcp add aqe-v3 -- npx @agentic-qe/v3 mcp',
+        'Run tests: aqe-v3 test <path>',
+        'Check status: aqe-v3 status',
+      ];
+
+      expect(nextSteps.length).toBe(3);
+      expect(nextSteps[0]).toContain('mcp');
+      expect(nextSteps[1]).toContain('test');
+      expect(nextSteps[2]).toContain('status');
+    });
+  });
+});
+
+describe('Init Command Integration', () => {
+  describe('Domain Validation', () => {
+    const ALL_DOMAINS = [
+      'test-generation',
+      'test-execution',
+      'coverage-analysis',
+      'quality-assessment',
+      'defect-intelligence',
+      'requirements-validation',
+      'code-intelligence',
+      'security-compliance',
+      'contract-testing',
+      'visual-accessibility',
+      'chaos-resilience',
+      'learning-optimization',
+    ] as const;
+
+    it('should have 12 bounded contexts', () => {
+      expect(ALL_DOMAINS.length).toBe(12);
+    });
+
+    it('should validate all domain names', () => {
+      for (const domain of ALL_DOMAINS) {
+        expect(typeof domain).toBe('string');
+        expect(domain.length).toBeGreaterThan(0);
+        expect(domain).toMatch(/^[a-z-]+$/);
+      }
+    });
+
+    it('should filter invalid domains', () => {
+      const inputDomains = 'test-generation,invalid-domain,coverage-analysis';
+      const filtered = inputDomains
+        .split(',')
+        .filter((d) => ALL_DOMAINS.includes(d as typeof ALL_DOMAINS[number]));
+
+      expect(filtered).toContain('test-generation');
+      expect(filtered).toContain('coverage-analysis');
+      expect(filtered).not.toContain('invalid-domain');
+    });
+  });
+
+  describe('Memory Backend Selection', () => {
+    it('should select sqlite for minimal mode', () => {
+      const minimal = true;
+      const backend = minimal ? 'sqlite' : 'hybrid';
+      expect(backend).toBe('sqlite');
+    });
+
+    it('should select hybrid for standard mode', () => {
+      const minimal = false;
+      const backend = minimal ? 'sqlite' : 'hybrid';
+      expect(backend).toBe('hybrid');
+    });
+  });
+});