@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.7

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

@@ -1,414 +0,0 @@
-/**
- * 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

@@ -1,274 +0,0 @@
-/**
- * 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');
-    });
-  });
-});