@avi770/testteam 3.0.0 → 3.2.0

package/core/__tests__/cli.test.ts

@@ -1,387 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { join } from 'path';
-import { writeFileSync, mkdirSync, rmSync, existsSync } from 'fs';
-
-// ── Shared mock state ──────────────────────────────────────────────────────
-
-const mockDryRun = vi.fn();
-const mockRunPhase = vi.fn();
-const mockRunInitWizard = vi.fn();
-
-// ── Module mocks ───────────────────────────────────────────────────────────
-
-vi.mock('../init', () => ({
-  runInitWizard: (...args: unknown[]) => mockRunInitWizard(...args),
-}));
-
-vi.mock('../config', () => ({
-  validateConfig: vi.fn((c: unknown) => ({
-    ...(c as Record<string, unknown>),
-    disabledAgentSet: new Set(),
-  })),
-}));
-
-vi.mock('../orchestrator', () => {
-  return {
-    Orchestrator: class MockOrchestrator {
-      dryRun(...args: unknown[]) { return mockDryRun(...args); }
-      runPhase(...args: unknown[]) { return mockRunPhase(...args); }
-    },
-  };
-});
-
-vi.mock('../../agents/registry', () => ({
-  registerAllAgents: vi.fn(),
-}));
-
-vi.mock('../ci-output', () => ({
-  determineExitCode: vi.fn().mockReturnValue(0),
-  writeCISummary: vi.fn(),
-  detectCIEnvironment: vi.fn().mockReturnValue('none'),
-  EXIT_CODE: { SUCCESS: 0, BLOCKING_FAILURE: 1, ADVISORY_WARNINGS: 2 },
-}));
-
-import { parseArgs, main } from '../cli';
-import { determineExitCode, detectCIEnvironment, writeCISummary } from '../ci-output';
-
-// ── Create a temp config file that dynamic import() can actually load ──────
-
-const TEMP_DIR = join(__dirname, '__temp_cli_test__');
-let TEMP_CONFIG = '';
-let configCounter = 0;
-
-function ensureTempConfig(): void {
-  if (!existsSync(TEMP_DIR)) {
-    mkdirSync(TEMP_DIR, { recursive: true });
-  }
-  // Use a unique filename per test to bust Node's ESM import cache
-  configCounter++;
-  TEMP_CONFIG = join(TEMP_DIR, `test-${configCounter}-${Date.now()}.config.mjs`);
-  writeFileSync(
-    TEMP_CONFIG,
-    `export default {
-      schemaVersion: 1,
-      name: 'test',
-      modules: [{ id: 'home', route: '/', sidebarIcon: true }],
-      environments: { alpha: { baseUrl: 'http://localhost:3000' } },
-      auth: { credentials: {}, roles: [] },
-    };`,
-    'utf-8',
-  );
-}
-
-function cleanupTempConfig(): void {
-  try {
-    rmSync(TEMP_DIR, { recursive: true, force: true });
-  } catch {
-    // ignore cleanup errors
-  }
-}
-
-// Default mock implementations — re-applied each test since clearAllMocks resets them
-function setupDefaultMocks(): void {
-  mockRunInitWizard.mockResolvedValue(0);
-  mockDryRun.mockReturnValue([
-    { agentId: 1, status: 'scheduled' },
-  ]);
-  mockRunPhase.mockResolvedValue({
-    skippedAgents: [],
-    agentResults: { 1: { agentId: 1, status: 'passed' } },
-    gate: { passed: true, failedBlockingAgents: [] },
-  });
-  // These are defined via vi.mock factory but clearAllMocks resets them
-  vi.mocked(determineExitCode).mockReturnValue(0);
-  vi.mocked(detectCIEnvironment).mockReturnValue('none');
-}
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  setupDefaultMocks();
-  vi.spyOn(console, 'log').mockImplementation(() => {});
-  vi.spyOn(console, 'error').mockImplementation(() => {});
-  // Prevent the module-level auto-execution from calling process.exit
-  vi.spyOn(process, 'exit').mockImplementation((() => {}) as never);
-  ensureTempConfig();
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-  cleanupTempConfig();
-});
-
-// Helper to build argv with our temp config
-function argv(...args: string[]): string[] {
-  return ['node', 'cli.ts', ...args, '--config', TEMP_CONFIG];
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// parseArgs
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe('parseArgs', () => {
-  it('parses --phase alpha', () => {
-    const result = parseArgs(['node', 'cli.ts', '--phase', 'alpha']);
-    expect(result.phase).toBe('alpha');
-    expect(result.dryRun).toBe(false);
-    expect(result.agent).toBeNull();
-  });
-
-  it('parses --phase beta', () => {
-    const result = parseArgs(['node', 'cli.ts', '--phase', 'beta']);
-    expect(result.phase).toBe('beta');
-  });
-
-  it('parses --phase uat', () => {
-    const result = parseArgs(['node', 'cli.ts', '--phase', 'uat']);
-    expect(result.phase).toBe('uat');
-  });
-
-  it('parses --phase release', () => {
-    const result = parseArgs(['node', 'cli.ts', '--phase', 'release']);
-    expect(result.phase).toBe('release');
-  });
-
-  it('parses --phase all', () => {
-    const result = parseArgs(['node', 'cli.ts', '--phase', 'all']);
-    expect(result.phase).toBe('all');
-  });
-
-  it('parses --dry-run flag', () => {
-    const result = parseArgs(['node', 'cli.ts', '--dry-run']);
-    expect(result.dryRun).toBe(true);
-  });
-
-  it('parses --agent flag with valid ID', () => {
-    const result = parseArgs(['node', 'cli.ts', '--agent', '5']);
-    expect(result.agent).toBe(5);
-  });
-
-  it('parses --config flag', () => {
-    const result = parseArgs(['node', 'cli.ts', '--config', 'custom.config.ts']);
-    expect(result.configPath).toBe('custom.config.ts');
-  });
-
-  it('parses combined flags', () => {
-    const result = parseArgs([
-      'node', 'cli.ts',
-      '--phase', 'alpha',
-      '--dry-run',
-      '--agent', '3',
-      '--config', 'my.config.ts',
-    ]);
-    expect(result.phase).toBe('alpha');
-    expect(result.dryRun).toBe(true);
-    expect(result.agent).toBe(3);
-    expect(result.configPath).toBe('my.config.ts');
-  });
-
-  it('defaults configPath to testteam.config.ts', () => {
-    const result = parseArgs(['node', 'cli.ts', '--phase', 'alpha']);
-    expect(result.configPath).toBe('testteam.config.ts');
-  });
-
-  it('defaults phase to null', () => {
-    const result = parseArgs(['node', 'cli.ts', '--dry-run']);
-    expect(result.phase).toBeNull();
-  });
-
-  // ── Error cases ─────────────────────────────────────────────────────
-
-  it('throws on invalid phase', () => {
-    expect(() => parseArgs(['node', 'cli.ts', '--phase', 'invalid']))
-      .toThrow('Invalid phase: invalid');
-  });
-
-  it('throws on missing phase value', () => {
-    expect(() => parseArgs(['node', 'cli.ts', '--phase']))
-      .toThrow('Invalid phase');
-  });
-
-  it('throws on invalid agent ID (non-number)', () => {
-    expect(() => parseArgs(['node', 'cli.ts', '--agent', 'abc']))
-      .toThrow('Invalid agent ID: abc');
-  });
-
-  it('throws on invalid agent ID (zero)', () => {
-    expect(() => parseArgs(['node', 'cli.ts', '--agent', '0']))
-      .toThrow('Invalid agent ID: 0');
-  });
-
-  it('throws on invalid agent ID (negative)', () => {
-    expect(() => parseArgs(['node', 'cli.ts', '--agent', '-1']))
-      .toThrow('Invalid agent ID: -1');
-  });
-
-  it('throws on missing agent value', () => {
-    expect(() => parseArgs(['node', 'cli.ts', '--agent']))
-      .toThrow('Invalid agent ID');
-  });
-
-  it('throws on missing config path', () => {
-    expect(() => parseArgs(['node', 'cli.ts', '--config']))
-      .toThrow('--config requires a path');
-  });
-
-  it('throws on unknown argument', () => {
-    expect(() => parseArgs(['node', 'cli.ts', '--unknown']))
-      .toThrow('Unknown argument: --unknown');
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// main
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe('main', () => {
-  // ── Init command ──────────────────────────────────────────────────────
-
-  it('routes to init wizard when "init" is in args', async () => {
-    const code = await main(['node', 'cli.ts', 'init']);
-    expect(mockRunInitWizard).toHaveBeenCalled();
-    expect(code).toBe(0);
-  });
-
-  it('routes to init wizard when "--init" is in args', async () => {
-    const code = await main(['node', 'cli.ts', '--init']);
-    expect(mockRunInitWizard).toHaveBeenCalled();
-    expect(code).toBe(0);
-  });
-
-  // ── No arguments ──────────────────────────────────────────────────────
-
-  it('prints usage and returns 1 when no arguments', async () => {
-    const code = await main(['node', 'cli.ts']);
-    expect(code).toBe(1);
-  });
-
-  // ── Missing phase ─────────────────────────────────────────────────────
-
-  it('returns 1 when phase is missing and not dry-run', async () => {
-    const code = await main(['node', 'cli.ts', '--agent', '1', '--config', TEMP_CONFIG]);
-    expect(code).toBe(1);
-    expect(console.error).toHaveBeenCalledWith(
-      expect.stringContaining('--phase is required'),
-    );
-  });
-
-  // ── Invalid args ──────────────────────────────────────────────────────
-
-  it('returns 1 on invalid args', async () => {
-    const code = await main(['node', 'cli.ts', '--phase', 'bogus']);
-    expect(code).toBe(1);
-    expect(console.error).toHaveBeenCalledWith(
-      expect.stringContaining('Invalid phase'),
-    );
-  });
-
-  // ── Dry-run mode ──────────────────────────────────────────────────────
-
-  it('dry-run without phase runs all phases and returns 0', async () => {
-    const code = await main(['node', 'cli.ts', '--dry-run', '--config', TEMP_CONFIG]);
-    expect(code).toBe(0);
-    expect(mockDryRun).toHaveBeenCalledTimes(4);
-  });
-
-  it('dry-run with specific phase runs only that phase', async () => {
-    const code = await main(argv('--dry-run', '--phase', 'alpha'));
-    expect(code).toBe(0);
-    expect(mockDryRun).toHaveBeenCalledTimes(1);
-    expect(mockDryRun).toHaveBeenCalledWith('alpha');
-  });
-
-  it('dry-run with --phase all runs all phases', async () => {
-    const code = await main(argv('--dry-run', '--phase', 'all'));
-    expect(code).toBe(0);
-    expect(mockDryRun).toHaveBeenCalledTimes(4);
-  });
-
-  // ── Run mode ──────────────────────────────────────────────────────────
-
-  it('runs single phase and returns 0 on success', async () => {
-    const code = await main(argv('--phase', 'alpha'));
-    expect(mockRunPhase).toHaveBeenCalledWith('alpha');
-    expect(code).toBe(0);
-  });
-
-  it('runs all phases when --phase all', async () => {
-    const code = await main(argv('--phase', 'all'));
-    expect(code).toBe(0);
-    expect(mockRunPhase).toHaveBeenCalledTimes(4);
-  });
-
-  it('logs skipped agents when present', async () => {
-    mockRunPhase.mockResolvedValueOnce({
-      skippedAgents: [16, 17],
-      agentResults: {},
-      gate: { passed: true, failedBlockingAgents: [] },
-    });
-
-    await main(argv('--phase', 'alpha'));
-
-    expect(console.log).toHaveBeenCalledWith(
-      expect.stringContaining('Skipped agents: 16, 17'),
-    );
-  });
-
-  it('logs gate FAILED with blocking agents', async () => {
-    mockRunPhase.mockResolvedValueOnce({
-      skippedAgents: [],
-      agentResults: { 1: { agentId: 1, status: 'failed' } },
-      gate: { passed: false, failedBlockingAgents: [1, 3] },
-    });
-
-    await main(argv('--phase', 'alpha'));
-
-    expect(console.log).toHaveBeenCalledWith(
-      expect.stringContaining('Gate: FAILED'),
-    );
-  });
-
-  // ── Exit codes ────────────────────────────────────────────────────────
-
-  it('returns exit code 1 when phase throws error', async () => {
-    mockRunPhase.mockRejectedValueOnce(new Error('boom'));
-
-    const code = await main(argv('--phase', 'alpha'));
-
-    expect(code).toBe(1);
-    expect(console.error).toHaveBeenCalledWith(
-      expect.stringContaining('Phase alpha error: boom'),
-    );
-  });
-
-  it('returns exit code 2 for advisory warnings', async () => {
-    vi.mocked(determineExitCode).mockReturnValueOnce(2);
-
-    const code = await main(argv('--phase', 'alpha'));
-    expect(code).toBe(2);
-  });
-
-  // ── CI summary ────────────────────────────────────────────────────────
-
-  it('writes CI summary when running in CI environment', async () => {
-    vi.mocked(detectCIEnvironment).mockReturnValueOnce('github');
-
-    await main(argv('--phase', 'alpha'));
-
-    expect(writeCISummary).toHaveBeenCalled();
-  });
-
-  it('does not write CI summary when not in CI', async () => {
-    vi.mocked(detectCIEnvironment).mockReturnValueOnce('none');
-
-    await main(argv('--phase', 'alpha'));
-
-    expect(writeCISummary).not.toHaveBeenCalled();
-  });
-
-  // ── Config loading failure ────────────────────────────────────────────
-
-  it('returns 1 when config file fails to load', async () => {
-    const code = await main(['node', 'cli.ts', '--phase', 'alpha', '--config', 'nonexistent-config-xyz.ts']);
-    expect(code).toBe(1);
-    expect(console.error).toHaveBeenCalledWith(
-      expect.stringContaining('Failed to load config'),
-    );
-  });
-});

package/core/__tests__/config.test.ts

@@ -1,78 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import type { TestTeamConfig } from '../config';
-import { validateConfig } from '../config';
-
-describe('TestTeamConfig', () => {
-  it('rejects config missing schemaVersion', () => {
-    const invalid = { name: 'test' } as unknown as TestTeamConfig;
-    expect(() => validateConfig(invalid)).toThrow('schemaVersion is required');
-  });
-
-  it('rejects config with empty modules array', () => {
-    const invalid = { schemaVersion: 1, name: 'test', modules: [] } as unknown as TestTeamConfig;
-    expect(() => validateConfig(invalid)).toThrow('at least one module');
-  });
-
-  it('accepts credentials with non-empty passwords', () => {
-    const valid = {
-      schemaVersion: 1,
-      name: 'test',
-      auth: { credentials: { alpha: { email: 'a@b.com', password: 'literal' } } },
-    } as unknown as TestTeamConfig;
-    expect(() => validateConfig(valid)).not.toThrow();
-  });
-
-  it('throws when ALL credentials have empty passwords', () => {
-    const invalid = {
-      schemaVersion: 1,
-      name: 'test',
-      auth: { credentials: { alpha: { email: 'a@b.com', password: '' }, beta: { email: 'b@b.com', password: '' } } },
-      modules: [{ id: 'home', route: '/', sidebarIcon: true }],
-    } as unknown as TestTeamConfig;
-    expect(() => validateConfig(invalid)).toThrow('All credentials have empty passwords');
-  });
-
-  it('accepts valid complete config', () => {
-    const valid = createValidConfig();
-    expect(() => validateConfig(valid)).not.toThrow();
-  });
-
-  it('returns disabled agents as a Set for O(1) lookup', () => {
-    const config = createValidConfig({ disabledAgents: [16, 17] });
-    const validated = validateConfig(config);
-    expect(validated.disabledAgentSet.has(16)).toBe(true);
-    expect(validated.disabledAgentSet.has(1)).toBe(false);
-  });
-});
-
-function createValidConfig(overrides = {}) {
-  return {
-    schemaVersion: 1,
-    name: 'test-project',
-    auth: {
-      loginUrl: '/login',
-      credentials: { alpha: { email: 'test@test.com', password: 'pass' } },
-      roles: [{ name: 'admin', email: 'admin@test.com' }],
-    },
-    modules: [{ id: 'home', route: '/', sidebarIcon: true }],
-    environments: { alpha: { baseUrl: 'http://localhost:3000', seed: true } },
-    portals: [{ name: 'main', queryParam: null }],
-    breakpoints: [1920],
-    integrations: [],
-    workers: [],
-    workflows: [],
-    accuracy: { enabled: false, decimalPrecision: 2, currencySymbol: 'USD', timezone: 'UTC' },
-    tenancy: { enabled: false, isolationField: 'tenantId', testFirms: [] },
-    costBudget: { maxPerRun: 50, maxPerAgent: 10, alertThreshold: 0.8, onExceeded: 'abort' as const },
-    agentClassification: { blocking: [1], advisory: [] },
-    thresholds: {
-      unitCoverage: { lines: 80, functions: 80, branches: 70, statements: 80 },
-      lighthouse: { accessibility: 90, performance: 85, bestPractices: 85, seo: 80 },
-      apiResponseTime: 500,
-      bundleSizeLimit: 500,
-      maxConsoleErrors: 0,
-    },
-    disabledAgents: [],
-    ...overrides,
-  };
-}

package/core/__tests__/cost-tracker.test.ts

@@ -1,158 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { CostTracker } from '../cost-tracker';
-import type { CostBudget } from '../cost-tracker';
-
-const defaultBudget: CostBudget = {
-  maxPerRun: 50,
-  maxPerAgent: 10,
-  alertThreshold: 0.8,
-  onExceeded: 'abort',
-};
-
-describe('CostTracker', () => {
-  let tracker: CostTracker;
-
-  beforeEach(() => {
-    tracker = new CostTracker(defaultBudget);
-  });
-
-  describe('constructor', () => {
-    it('accepts a CostBudget config', () => {
-      expect(tracker).toBeDefined();
-    });
-
-    it('starts with zero total cost', () => {
-      expect(tracker.getTotalCost()).toBe(0);
-    });
-  });
-
-  describe('trackCost(agentId, amount)', () => {
-    it('accumulates cost for a single agent', () => {
-      tracker.trackCost('agent-1', 3);
-      tracker.trackCost('agent-1', 2);
-      expect(tracker.getAgentCost('agent-1')).toBe(5);
-    });
-
-    it('accumulates total cost across multiple agents', () => {
-      tracker.trackCost('agent-1', 5);
-      tracker.trackCost('agent-2', 7);
-      expect(tracker.getTotalCost()).toBe(12);
-    });
-
-    it('tracks costs per agent independently', () => {
-      tracker.trackCost('agent-1', 4);
-      tracker.trackCost('agent-2', 6);
-      expect(tracker.getAgentCost('agent-1')).toBe(4);
-      expect(tracker.getAgentCost('agent-2')).toBe(6);
-    });
-  });
-
-  describe('getTotalCost()', () => {
-    it('returns 0 with no costs tracked', () => {
-      expect(tracker.getTotalCost()).toBe(0);
-    });
-
-    it('returns accumulated total after multiple tracks', () => {
-      tracker.trackCost('agent-1', 10);
-      tracker.trackCost('agent-2', 15);
-      tracker.trackCost('agent-1', 5);
-      expect(tracker.getTotalCost()).toBe(30);
-    });
-  });
-
-  describe('getAgentCost(agentId)', () => {
-    it('returns 0 for unknown agent', () => {
-      expect(tracker.getAgentCost('unknown-agent')).toBe(0);
-    });
-
-    it('returns correct cost for tracked agent', () => {
-      tracker.trackCost('agent-42', 7.5);
-      expect(tracker.getAgentCost('agent-42')).toBe(7.5);
-    });
-  });
-
-  describe('checkBudget()', () => {
-    it('returns status ok when under alert threshold', () => {
-      // maxPerRun=50, alertThreshold=0.8 → alert at 40
-      tracker.trackCost('agent-1', 30); // 30/50 = 0.6 → ok
-      const result = tracker.checkBudget();
-      expect(result.status).toBe('ok');
-      expect(result.totalCost).toBe(30);
-      expect(result.budgetRemaining).toBe(20);
-    });
-
-    it('returns status alert when above threshold but under max', () => {
-      // 80% of 50 = 40; spending 42 → alert
-      tracker.trackCost('agent-1', 42);
-      const result = tracker.checkBudget();
-      expect(result.status).toBe('alert');
-      expect(result.totalCost).toBe(42);
-      expect(result.budgetRemaining).toBe(8);
-    });
-
-    it('returns status exceeded when above max', () => {
-      tracker.trackCost('agent-1', 55); // 55 > 50
-      const result = tracker.checkBudget();
-      expect(result.status).toBe('exceeded');
-      expect(result.totalCost).toBe(55);
-      expect(result.budgetRemaining).toBe(-5);
-    });
-
-    it('returns status ok when exactly at zero cost', () => {
-      const result = tracker.checkBudget();
-      expect(result.status).toBe('ok');
-      expect(result.budgetRemaining).toBe(50);
-    });
-
-    it('returns status alert when exactly at alert threshold', () => {
-      // exactly 80% of 50 = 40
-      tracker.trackCost('agent-1', 40);
-      const result = tracker.checkBudget();
-      expect(result.status).toBe('alert');
-    });
-
-    it('returns status exceeded when exactly at max', () => {
-      tracker.trackCost('agent-1', 50);
-      const result = tracker.checkBudget();
-      expect(result.status).toBe('exceeded');
-    });
-  });
-
-  describe('isAgentOverBudget(agentId)', () => {
-    it('returns false when agent has not been tracked', () => {
-      expect(tracker.isAgentOverBudget('agent-1')).toBe(false);
-    });
-
-    it('returns false when agent cost is under maxPerAgent', () => {
-      tracker.trackCost('agent-1', 5); // 5 < 10
-      expect(tracker.isAgentOverBudget('agent-1')).toBe(false);
-    });
-
-    it('returns true when agent cost exceeds maxPerAgent', () => {
-      tracker.trackCost('agent-1', 11); // 11 > 10
-      expect(tracker.isAgentOverBudget('agent-1')).toBe(true);
-    });
-
-    it('returns true when agent cost is exactly at maxPerAgent', () => {
-      tracker.trackCost('agent-1', 10); // exactly 10
-      expect(tracker.isAgentOverBudget('agent-1')).toBe(true);
-    });
-
-    it('does not affect other agents budget check', () => {
-      tracker.trackCost('agent-1', 15); // over budget
-      expect(tracker.isAgentOverBudget('agent-2')).toBe(false);
-    });
-  });
-
-  describe('onExceeded config variants', () => {
-    it('accepts alert-continue as onExceeded policy', () => {
-      const t = new CostTracker({ ...defaultBudget, onExceeded: 'alert-continue' });
-      expect(t).toBeDefined();
-    });
-
-    it('accepts skip-remaining as onExceeded policy', () => {
-      const t = new CostTracker({ ...defaultBudget, onExceeded: 'skip-remaining' });
-      expect(t).toBeDefined();
-    });
-  });
-});