@avi770/testteam 1.2.0

package/agents/__tests__/base-agent.test.ts

@@ -0,0 +1,188 @@
+import { describe, it, expect } from 'vitest';
+import { BaseAgent } from '../base-agent';
+import type { Finding, Phase } from '../../core/types';
+import type { ValidatedConfig } from '../../core/config';
+
+const stubConfig = {
+  schemaVersion: 1,
+  name: 'test',
+  auth: { loginUrl: 'http://localhost' },
+  modules: [{ id: 'mod', route: '/mod', sidebarIcon: true }],
+  environments: {},
+  portals: [],
+  breakpoints: [],
+  integrations: [],
+  workers: [],
+  workflows: [],
+  accuracy: { enabled: false, decimalPrecision: 2, currencySymbol: '$', timezone: 'UTC' },
+  tenancy: { enabled: false, isolationField: 'firmId', testFirms: [] },
+  costBudget: { maxPerRun: 100, maxPerAgent: 10, alertThreshold: 0.8, onExceeded: 'abort' as const },
+  agentClassification: { blocking: [], advisory: [] },
+  thresholds: {
+    unitCoverage: { lines: 80, functions: 80, branches: 80, statements: 80 },
+    lighthouse: { accessibility: 90, performance: 90, bestPractices: 90, seo: 90 },
+    apiResponseTime: 2000,
+    bundleSizeLimit: 500000,
+    maxConsoleErrors: 0,
+  },
+  disabledAgents: [],
+  disabledAgentSet: new Set<number>(),
+} satisfies ValidatedConfig;
+
+class TestAgent extends BaseAgent {
+  readonly agentId = 99;
+  readonly agentName = 'test-agent';
+  preFlightFn: () => Promise<void> = async () => {};
+  executeFn: () => Promise<Finding[]> = async () => [];
+
+  protected async preFlight(): Promise<void> { await this.preFlightFn(); }
+  protected async execute(): Promise<Finding[]> { return this.executeFn(); }
+}
+
+function createAgent(phase: Phase = 'alpha'): TestAgent {
+  return new TestAgent(stubConfig, phase, '/tmp/test-run');
+}
+
+describe('BaseAgent', () => {
+  it('calls preFlight() then execute() in order', async () => {
+    const agent = createAgent();
+    const callOrder: string[] = [];
+    agent.preFlightFn = async () => { callOrder.push('preFlight'); };
+    agent.executeFn = async () => { callOrder.push('execute'); return []; };
+
+    await agent.run();
+
+    expect(callOrder).toEqual(['preFlight', 'execute']);
+  });
+
+  it('returns failed status with error when preFlight() throws', async () => {
+    const agent = createAgent();
+    agent.preFlightFn = async () => { throw new Error('pre-flight boom'); };
+
+    const result = await agent.run();
+
+    expect(result.status).toBe('failed');
+    expect(result.findings).toHaveLength(1);
+    expect(result.findings[0].severity).toBe('critical');
+    expect(result.findings[0].description).toBe('pre-flight boom');
+    expect(result.findings[0].type).toBe('infra-issue');
+    expect(result.summary).toContain('pre-flight boom');
+  });
+
+  it('returns failed status when execute() returns critical findings', async () => {
+    const agent = createAgent();
+    agent.executeFn = async () => [{
+      id: '99-crit',
+      type: 'code-bug-logic',
+      severity: 'critical',
+      agentId: 99,
+      module: 'test',
+      description: 'critical issue',
+    }];
+
+    const result = await agent.run();
+
+    expect(result.status).toBe('failed');
+    expect(result.findings).toHaveLength(1);
+  });
+
+  it('returns failed status when execute() returns high severity findings', async () => {
+    const agent = createAgent();
+    agent.executeFn = async () => [{
+      id: '99-high',
+      type: 'code-bug-logic',
+      severity: 'high',
+      agentId: 99,
+      module: 'test',
+      description: 'high issue',
+    }];
+
+    const result = await agent.run();
+
+    expect(result.status).toBe('failed');
+  });
+
+  it('returns passed status when execute() returns only low findings', async () => {
+    const agent = createAgent();
+    agent.executeFn = async () => [{
+      id: '99-low',
+      type: 'code-bug-cosmetic',
+      severity: 'low',
+      agentId: 99,
+      module: 'test',
+      description: 'minor issue',
+    }];
+
+    const result = await agent.run();
+
+    expect(result.status).toBe('passed');
+    expect(result.summary).toContain('1 findings');
+    expect(result.summary).toContain('1 low');
+  });
+
+  it('returns passed status when execute() returns only medium findings', async () => {
+    const agent = createAgent();
+    agent.executeFn = async () => [{
+      id: '99-med',
+      type: 'code-bug-cosmetic',
+      severity: 'medium',
+      agentId: 99,
+      module: 'test',
+      description: 'medium issue',
+    }];
+
+    const result = await agent.run();
+
+    expect(result.status).toBe('passed');
+  });
+
+  it('includes evidence items added during execution in the result', async () => {
+    const agent = createAgent();
+    agent.executeFn = async () => {
+      agent['addEvidence']({ type: 'log', path: '/tmp/log.txt', description: 'test log' });
+      agent['addEvidence']({ type: 'screenshot', path: '/tmp/shot.png', description: 'test shot' });
+      return [];
+    };
+
+    const result = await agent.run();
+
+    expect(result.evidence).toHaveLength(2);
+    expect(result.evidence[0].type).toBe('log');
+    expect(result.evidence[1].type).toBe('screenshot');
+  });
+
+  it('produces a clean summary when no findings exist', async () => {
+    const agent = createAgent();
+    const result = await agent.run();
+
+    expect(result.summary).toBe('test-agent: All checks passed');
+  });
+
+  it('captures non-Error throws in the error finding', async () => {
+    const agent = createAgent();
+    agent.preFlightFn = async () => { throw 'string-error'; };
+
+    const result = await agent.run();
+
+    expect(result.status).toBe('failed');
+    expect(result.findings[0].description).toBe('string-error');
+    expect(result.findings[0].stackTrace).toBeUndefined();
+  });
+
+  it('populates agentId, agentName, and phase correctly', async () => {
+    const agent = createAgent('beta');
+    const result = await agent.run();
+
+    expect(result.agentId).toBe(99);
+    expect(result.agentName).toBe('test-agent');
+    expect(result.phase).toBe('beta');
+  });
+
+  it('computes durationMs as a non-negative number', async () => {
+    const agent = createAgent();
+    const result = await agent.run();
+
+    expect(result.durationMs).toBeGreaterThanOrEqual(0);
+    expect(typeof result.durationMs).toBe('number');
+  });
+});

package/agents/__tests__/registry.test.ts

@@ -0,0 +1,218 @@
+import { describe, it, expect, vi } from 'vitest';
+import {
+  AGENT_TIERS,
+  getAgentTier,
+  isAgentAvailable,
+  type LicenseTier,
+} from '../registry';
+
+describe('AGENT_TIERS', () => {
+  it('should contain exactly 23 agents', () => {
+    expect(Object.keys(AGENT_TIERS)).toHaveLength(23);
+  });
+
+  it('should have 8 free-tier agents', () => {
+    const freeAgents = Object.entries(AGENT_TIERS).filter(([, t]) => t === 'free');
+    expect(freeAgents).toHaveLength(8);
+  });
+
+  it('should have 9 pro-tier agents', () => {
+    const proAgents = Object.entries(AGENT_TIERS).filter(([, t]) => t === 'pro');
+    expect(proAgents).toHaveLength(9);
+  });
+
+  it('should have 6 enterprise-tier agents', () => {
+    const entAgents = Object.entries(AGENT_TIERS).filter(([, t]) => t === 'enterprise');
+    expect(entAgents).toHaveLength(6);
+  });
+
+  it('should classify known agents correctly', () => {
+    expect(AGENT_TIERS[1]).toBe('free');      // Analyst
+    expect(AGENT_TIERS[5]).toBe('free');      // Browser Crawler
+    expect(AGENT_TIERS[7]).toBe('pro');       // Security Scout
+    expect(AGENT_TIERS[13]).toBe('pro');      // Performance Profiler
+    expect(AGENT_TIERS[16]).toBe('enterprise'); // Chaos Agent
+    expect(AGENT_TIERS[19]).toBe('enterprise'); // Tenant Isolation Auditor
+  });
+});
+
+describe('getAgentTier', () => {
+  it('should return the correct tier for each agent', () => {
+    expect(getAgentTier(1)).toBe('free');
+    expect(getAgentTier(6)).toBe('pro');
+    expect(getAgentTier(14)).toBe('enterprise');
+  });
+
+  it('should throw for an unknown agent number', () => {
+    expect(() => getAgentTier(99)).toThrow('Unknown agent number: 99');
+    expect(() => getAgentTier(0)).toThrow('Unknown agent number: 0');
+    expect(() => getAgentTier(-1)).toThrow('Unknown agent number: -1');
+  });
+});
+
+describe('isAgentAvailable', () => {
+  const freeAgents = [1, 2, 3, 4, 5, 9, 10, 11];
+  const proAgents = [6, 7, 8, 12, 13, 15, 21, 22, 23];
+  const enterpriseAgents = [14, 16, 17, 18, 19, 20];
+
+  describe('free license', () => {
+    it('should allow free-tier agents', () => {
+      for (const id of freeAgents) {
+        expect(isAgentAvailable(id, 'free')).toBe(true);
+      }
+    });
+
+    it('should deny pro-tier agents', () => {
+      for (const id of proAgents) {
+        expect(isAgentAvailable(id, 'free')).toBe(false);
+      }
+    });
+
+    it('should deny enterprise-tier agents', () => {
+      for (const id of enterpriseAgents) {
+        expect(isAgentAvailable(id, 'free')).toBe(false);
+      }
+    });
+  });
+
+  describe('pro license', () => {
+    it('should allow free-tier agents', () => {
+      for (const id of freeAgents) {
+        expect(isAgentAvailable(id, 'pro')).toBe(true);
+      }
+    });
+
+    it('should allow pro-tier agents', () => {
+      for (const id of proAgents) {
+        expect(isAgentAvailable(id, 'pro')).toBe(true);
+      }
+    });
+
+    it('should deny enterprise-tier agents', () => {
+      for (const id of enterpriseAgents) {
+        expect(isAgentAvailable(id, 'pro')).toBe(false);
+      }
+    });
+  });
+
+  describe('enterprise license', () => {
+    it('should allow all agents', () => {
+      for (const id of [...freeAgents, ...proAgents, ...enterpriseAgents]) {
+        expect(isAgentAvailable(id, 'enterprise')).toBe(true);
+      }
+    });
+  });
+
+  it('should throw for unknown agent numbers', () => {
+    expect(() => isAgentAvailable(99, 'free')).toThrow('Unknown agent number: 99');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// registerAllAgents
+// ---------------------------------------------------------------------------
+
+describe('registerAllAgents', () => {
+  // We need to test that registerAllAgents creates 23 agents and registers them all.
+  // We mock the orchestrator's registerAgent method.
+
+  it('registers all 23 agents with the orchestrator', async () => {
+    // We need to dynamically import to avoid circular dependencies with mocked modules
+    // Instead, test the function signature by checking it registers the right count
+    const { registerAllAgents } = await import('../registry');
+
+    const mockOrchestrator = {
+      registerAgent: vi.fn(),
+    };
+
+    const stubConfig = {
+      schemaVersion: 1,
+      name: 'test',
+      auth: { loginUrl: '/login' },
+      modules: [],
+      environments: {},
+      portals: [],
+      breakpoints: [],
+      integrations: [],
+      workers: [],
+      workflows: [],
+      accuracy: { enabled: false, decimalPrecision: 2, currencySymbol: '$', timezone: 'UTC' },
+      tenancy: { enabled: false, isolationField: 'firmId', testFirms: [] },
+      costBudget: { maxPerRun: 100, maxPerAgent: 10, alertThreshold: 0.8, onExceeded: 'abort' as const },
+      agentClassification: { blocking: [], advisory: [] },
+      thresholds: {
+        unitCoverage: { lines: 80, functions: 80, branches: 80, statements: 80 },
+        lighthouse: { accessibility: 90, performance: 90, bestPractices: 90, seo: 90 },
+        apiResponseTime: 2000,
+        bundleSizeLimit: 500000,
+        maxConsoleErrors: 0,
+      },
+      disabledAgents: [],
+      disabledAgentSet: new Set<number>(),
+    };
+
+    registerAllAgents(
+      mockOrchestrator as any,
+      stubConfig as any,
+      'alpha',
+      '/tmp/run',
+    );
+
+    expect(mockOrchestrator.registerAgent).toHaveBeenCalledTimes(23);
+
+    // Verify agent IDs 1-23 are all registered
+    const registeredIds = mockOrchestrator.registerAgent.mock.calls.map(
+      (call: unknown[]) => call[0],
+    );
+    for (let i = 1; i <= 23; i++) {
+      expect(registeredIds).toContain(i);
+    }
+  });
+
+  it('passes correct config, phase, and runDir to each agent', async () => {
+    const { registerAllAgents } = await import('../registry');
+
+    const mockOrchestrator = {
+      registerAgent: vi.fn(),
+    };
+
+    const stubConfig = {
+      schemaVersion: 1,
+      name: 'my-project',
+      auth: { loginUrl: '/login' },
+      modules: [],
+      environments: {},
+      portals: [],
+      breakpoints: [],
+      integrations: [],
+      workers: [],
+      workflows: [],
+      accuracy: { enabled: false, decimalPrecision: 2, currencySymbol: '$', timezone: 'UTC' },
+      tenancy: { enabled: false, isolationField: 'firmId', testFirms: [] },
+      costBudget: { maxPerRun: 100, maxPerAgent: 10, alertThreshold: 0.8, onExceeded: 'abort' as const },
+      agentClassification: { blocking: [], advisory: [] },
+      thresholds: {
+        unitCoverage: { lines: 80, functions: 80, branches: 80, statements: 80 },
+        lighthouse: { accessibility: 90, performance: 90, bestPractices: 90, seo: 90 },
+        apiResponseTime: 2000,
+        bundleSizeLimit: 500000,
+        maxConsoleErrors: 0,
+      },
+      disabledAgents: [],
+      disabledAgentSet: new Set<number>(),
+    };
+
+    registerAllAgents(
+      mockOrchestrator as any,
+      stubConfig as any,
+      'beta',
+      '/tmp/my-run',
+    );
+
+    // Check that each registered agent has the right agentId property matching the first arg
+    for (const call of mockOrchestrator.registerAgent.mock.calls) {
+      const [agentId, agent] = call as [number, { agentId: number }];
+      expect(agent.agentId).toBe(agentId);
+    }
+  });
+});

package/agents/base-agent.ts

@@ -0,0 +1,77 @@
+import type { AgentResult, Finding, Phase, EvidenceItem } from '../core/types';
+import type { ValidatedConfig } from '../core/config';
+
+export abstract class BaseAgent {
+  constructor(
+    protected readonly config: ValidatedConfig,
+    protected readonly phase: Phase,
+    protected readonly runDir: string,
+  ) {}
+
+  abstract readonly agentId: number;
+  abstract readonly agentName: string;
+
+  async run(): Promise<AgentResult> {
+    const startedAt = new Date().toISOString();
+    try {
+      await this.preFlight();
+      const findings = await this.execute();
+      const completedAt = new Date().toISOString();
+      return {
+        agentId: this.agentId,
+        agentName: this.agentName,
+        phase: this.phase,
+        status: findings.some(f => f.severity === 'critical' || f.severity === 'high') ? 'failed' : 'passed',
+        startedAt,
+        completedAt,
+        durationMs: new Date(completedAt).getTime() - new Date(startedAt).getTime(),
+        findings,
+        evidence: this.evidence,
+        summary: this.buildSummary(findings),
+      };
+    } catch (error) {
+      const completedAt = new Date().toISOString();
+      return {
+        agentId: this.agentId,
+        agentName: this.agentName,
+        phase: this.phase,
+        status: 'failed',
+        startedAt,
+        completedAt,
+        durationMs: new Date(completedAt).getTime() - new Date(startedAt).getTime(),
+        findings: [{
+          id: `${this.agentId}-error`,
+          type: 'infra-issue',
+          severity: 'critical',
+          agentId: this.agentId,
+          module: 'agent-runtime',
+          description: error instanceof Error ? error.message : String(error),
+          stackTrace: error instanceof Error ? error.stack : undefined,
+        }],
+        evidence: this.evidence,
+        summary: `Agent ${this.agentName} failed with error: ${error instanceof Error ? error.message : String(error)}`,
+      };
+    }
+  }
+
+  protected evidence: EvidenceItem[] = [];
+
+  /** AVI-OS pre-flight: audit dependencies, validate plan, check pre-conditions */
+  protected abstract preFlight(): Promise<void>;
+
+  /** Main execution logic -- single pass, no incremental fix-and-see */
+  protected abstract execute(): Promise<Finding[]>;
+
+  protected addEvidence(item: EvidenceItem): void {
+    this.evidence.push(item);
+  }
+
+  private buildSummary(findings: Finding[]): string {
+    if (findings.length === 0) return `${this.agentName}: All checks passed`;
+    const critical = findings.filter(f => f.severity === 'critical').length;
+    const high = findings.filter(f => f.severity === 'high').length;
+    const medium = findings.filter(f => f.severity === 'medium').length;
+    const low = findings.filter(f => f.severity === 'low').length;
+    return `${this.agentName}: ${findings.length} findings (${critical} critical, ${high} high, ${medium} medium, ${low} low)`;
+  }
+}

package/agents/registry.ts

@@ -0,0 +1,136 @@
+import type { ValidatedConfig } from '../core/config';
+import type { Phase } from '../core/types';
+import type { Orchestrator } from '../core/orchestrator';
+
+/** License tier type used for agent gating */
+export type LicenseTier = 'free' | 'pro' | 'enterprise';
+
+/**
+ * Maps each agent number to its license tier.
+ * - free (8 agents): core testing pipeline
+ * - pro (9 agents): advanced testing capabilities
+ * - enterprise (6 agents): full platform auditing
+ */
+export const AGENT_TIERS: Record<number, LicenseTier> = {
+  /* ── Free tier (8) ── */
+  1: 'free',   // Analyst
+  2: 'free',   // Seed Architect
+  3: 'free',   // Test Generator
+  4: 'free',   // Unit Runner
+  5: 'free',   // Browser Crawler
+  9: 'free',   // Healer
+  10: 'free',  // Reporter
+  11: 'free',  // Fixer
+
+  /* ── Pro tier (9) ── */
+  6: 'pro',    // API Exerciser
+  7: 'pro',    // Security Scout
+  8: 'pro',    // A11y Guardian
+  12: 'pro',   // UX Inspector
+  13: 'pro',   // Performance Profiler
+  15: 'pro',   // Regression Sentinel
+  21: 'pro',   // State & Session Tester
+  22: 'pro',   // Email Notification Verifier
+  23: 'pro',   // Migration Tester
+
+  /* ── Enterprise tier (6) ── */
+  14: 'enterprise', // Data Integrity Auditor
+  16: 'enterprise', // Chaos Agent
+  17: 'enterprise', // Documentation Validator
+  18: 'enterprise', // Integration Watchdog
+  19: 'enterprise', // Tenant Isolation Auditor
+  20: 'enterprise', // Workflow Completion Tester
+};
+
+/** Returns the tier classification for a given agent number. */
+export function getAgentTier(agentNumber: number): LicenseTier {
+  const tier = AGENT_TIERS[agentNumber];
+  if (!tier) {
+    throw new Error(`Unknown agent number: ${agentNumber}`);
+  }
+  return tier;
+}
+
+const TIER_HIERARCHY: Record<LicenseTier, ReadonlySet<LicenseTier>> = {
+  free: new Set<LicenseTier>(['free']),
+  pro: new Set<LicenseTier>(['free', 'pro']),
+  enterprise: new Set<LicenseTier>(['free', 'pro', 'enterprise']),
+};
+
+/**
+ * Checks whether an agent is available under the given license tier.
+ * - free: only free agents
+ * - pro: free + pro agents
+ * - enterprise: all agents
+ */
+export function isAgentAvailable(agentNumber: number, licenseTier: LicenseTier): boolean {
+  const agentTier = getAgentTier(agentNumber);
+  return TIER_HIERARCHY[licenseTier].has(agentTier);
+}
+
+import { AnalystAgent } from './01-analyst';
+import { SeedArchitectAgent } from './02-seed-architect';
+import { TestGeneratorAgent } from './03-test-generator';
+import { UnitRunnerAgent } from './04-unit-runner';
+import { BrowserCrawlerAgent } from './05-browser-crawler';
+import { ApiExerciserAgent } from './06-api-exerciser';
+import { SecurityScoutAgent } from './07-security-scout';
+import { A11yGuardianAgent } from './08-a11y-guardian';
+import { HealerAgent } from './09-healer';
+import { ReporterAgent } from './10-reporter';
+import { FixerAgent } from './11-fixer';
+import { UxInspectorAgent } from './12-ux-inspector';
+import { PerformanceProfilerAgent } from './13-performance-profiler';
+import { DataIntegrityAuditorAgent } from './14-data-integrity-auditor';
+import { RegressionSentinelAgent } from './15-regression-sentinel';
+import { ChaosAgent } from './16-chaos-agent';
+import { DocumentationValidatorAgent } from './17-documentation-validator';
+import { IntegrationWatchdogAgent } from './18-integration-watchdog';
+import { TenantIsolationAuditorAgent } from './19-tenant-isolation-auditor';
+import { WorkflowCompletionTesterAgent } from './20-workflow-completion-tester';
+import { StateSessionTesterAgent } from './21-state-session-tester';
+import { EmailNotificationVerifierAgent } from './22-email-notification-verifier';
+import { MigrationTesterAgent } from './23-migration-tester';
+
+/**
+ * Register all 23 agents with the orchestrator.
+ * Each agent is instantiated with the validated config, phase, and run directory.
+ * Since agents may run in different phases, we register them for all phases
+ * and the orchestrator handles dispatching only the ones needed per phase.
+ */
+export function registerAllAgents(
+  orchestrator: Orchestrator,
+  config: ValidatedConfig,
+  phase: Phase,
+  runDir: string,
+): void {
+  const agents = [
+    new AnalystAgent(config, phase, runDir),
+    new SeedArchitectAgent(config, phase, runDir),
+    new TestGeneratorAgent(config, phase, runDir),
+    new UnitRunnerAgent(config, phase, runDir),
+    new BrowserCrawlerAgent(config, phase, runDir),
+    new ApiExerciserAgent(config, phase, runDir),
+    new SecurityScoutAgent(config, phase, runDir),
+    new A11yGuardianAgent(config, phase, runDir),
+    new HealerAgent(config, phase, runDir),
+    new ReporterAgent(config, phase, runDir),
+    new FixerAgent(config, phase, runDir),
+    new UxInspectorAgent(config, phase, runDir),
+    new PerformanceProfilerAgent(config, phase, runDir),
+    new DataIntegrityAuditorAgent(config, phase, runDir),
+    new RegressionSentinelAgent(config, phase, runDir),
+    new ChaosAgent(config, phase, runDir),
+    new DocumentationValidatorAgent(config, phase, runDir),
+    new IntegrationWatchdogAgent(config, phase, runDir),
+    new TenantIsolationAuditorAgent(config, phase, runDir),
+    new WorkflowCompletionTesterAgent(config, phase, runDir),
+    new StateSessionTesterAgent(config, phase, runDir),
+    new EmailNotificationVerifierAgent(config, phase, runDir),
+    new MigrationTesterAgent(config, phase, runDir),
+  ];
+
+  for (const agent of agents) {
+    orchestrator.registerAgent(agent.agentId, agent);
+  }
+}

package/bin/testteam.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const cli = join(__dirname, '..', 'core', 'cli.ts');
+
+execFileSync('npx', ['tsx', cli, ...process.argv.slice(2)], { stdio: 'inherit' });