@avi770/testteam 1.2.0 → 3.0.0

package/agents/69-type-safety-auditor.ts

@@ -0,0 +1,164 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type { Finding } from '../core/types';
+import { BaseAgent } from './base-agent';
+
+/** Find all .ts files under a directory (excluding tests and node_modules). */
+function findTsFiles(dir: string, results: string[] = []): string[] {
+  if (!fs.existsSync(dir)) return results;
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory() && entry.name !== 'node_modules' && entry.name !== '.git' && entry.name !== 'dist') {
+      findTsFiles(fullPath, results);
+    } else if (entry.isFile() && entry.name.endsWith('.ts') && !entry.name.endsWith('.d.ts')) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+export class TypeSafetyAuditorAgent extends BaseAgent {
+  readonly agentId = 69;
+  readonly agentName = 'Type Safety Auditor';
+
+  protected async preFlight(): Promise<void> {
+    // File-based agent
+  }
+
+  protected async execute(): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    const projectRoot = this.config.projectRoot ?? process.cwd();
+    const srcDir = path.join(projectRoot, 'src');
+
+    if (!fs.existsSync(srcDir)) {
+      findings.push({
+        id: `${this.agentId}-no-src-dir`,
+        type: 'infra-issue',
+        severity: 'low',
+        agentId: this.agentId,
+        module: 'type-safety-auditor',
+        description: 'No src/ directory found in project root',
+      });
+      return findings;
+    }
+
+    const tsFiles = findTsFiles(srcDir);
+    let anyCount = 0;
+    let tsIgnoreCount = 0;
+    let asAnyCount = 0;
+    let missingReturnTypeCount = 0;
+
+    for (const filePath of tsFiles) {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const lines = content.split('\n');
+      const relPath = path.relative(projectRoot, filePath);
+
+      for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+        const line = lines[lineNum];
+
+        // Check for : any (type annotation)
+        if (/:\s*any[^a-zA-Z]/.test(line) || /:\s*any\s*$/.test(line)) {
+          anyCount++;
+          if (anyCount <= 5) {
+            findings.push({
+              id: `${this.agentId}-any-type-${anyCount}`,
+              type: 'test-bug',
+              severity: 'low',
+              agentId: this.agentId,
+              module: 'type-safety-auditor',
+              file: filePath,
+              line: lineNum + 1,
+              description: `"any" type annotation in ${relPath}:${lineNum + 1}`,
+            });
+          }
+        }
+
+        // Check for @ts-ignore
+        if (/@ts-ignore/.test(line)) {
+          tsIgnoreCount++;
+          if (tsIgnoreCount <= 3) {
+            findings.push({
+              id: `${this.agentId}-ts-ignore-${tsIgnoreCount}`,
+              type: 'test-bug',
+              severity: 'low',
+              agentId: this.agentId,
+              module: 'type-safety-auditor',
+              file: filePath,
+              line: lineNum + 1,
+              description: `@ts-ignore comment in ${relPath}:${lineNum + 1}`,
+            });
+          }
+        }
+
+        // Check for "as any"
+        if (/as\s+any\b/.test(line)) {
+          asAnyCount++;
+          if (asAnyCount <= 3) {
+            findings.push({
+              id: `${this.agentId}-as-any-${asAnyCount}`,
+              type: 'test-bug',
+              severity: 'low',
+              agentId: this.agentId,
+              module: 'type-safety-auditor',
+              file: filePath,
+              line: lineNum + 1,
+              description: `"as any" assertion in ${relPath}:${lineNum + 1}`,
+            });
+          }
+        }
+
+        // Check for missing return types on exported functions
+        if (/^export\s+(async\s+)?function\s+\w+\s*\([^)]*\)\s*\{/.test(line.trim())) {
+          // No return type annotation before {
+          missingReturnTypeCount++;
+          if (missingReturnTypeCount <= 3) {
+            findings.push({
+              id: `${this.agentId}-missing-return-type-${missingReturnTypeCount}`,
+              type: 'test-bug',
+              severity: 'low',
+              agentId: this.agentId,
+              module: 'type-safety-auditor',
+              file: filePath,
+              line: lineNum + 1,
+              description: `Exported function missing return type in ${relPath}:${lineNum + 1}`,
+            });
+          }
+        }
+      }
+    }
+
+    // Summary findings
+    if (anyCount > 5) {
+      findings.push({
+        id: `${this.agentId}-any-summary`,
+        type: 'test-bug',
+        severity: 'low',
+        agentId: this.agentId,
+        module: 'type-safety-auditor',
+        description: `${anyCount} total "any" type annotations found (showing first 5)`,
+      });
+    }
+
+    if (tsIgnoreCount > 3) {
+      findings.push({
+        id: `${this.agentId}-ts-ignore-summary`,
+        type: 'test-bug',
+        severity: 'low',
+        agentId: this.agentId,
+        module: 'type-safety-auditor',
+        description: `${tsIgnoreCount} total @ts-ignore comments found (showing first 3)`,
+      });
+    }
+
+    this.addEvidence({
+      type: 'log',
+      path: '',
+      description: `Scanned ${tsFiles.length} files: ${anyCount} any, ${tsIgnoreCount} @ts-ignore, ${asAnyCount} as any, ${missingReturnTypeCount} missing return types`,
+    });
+
+    return findings;
+  }
+}

package/agents/70-complexity-analyzer.ts

@@ -0,0 +1,179 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type { Finding } from '../core/types';
+import { BaseAgent } from './base-agent';
+
+/** Find all .ts files under a directory (excluding tests and node_modules). */
+function findTsFiles(dir: string, results: string[] = []): string[] {
+  if (!fs.existsSync(dir)) return results;
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory() && entry.name !== 'node_modules' && entry.name !== '.git' && entry.name !== 'dist') {
+      findTsFiles(fullPath, results);
+    } else if (entry.isFile() && entry.name.endsWith('.ts') && !entry.name.endsWith('.test.ts') && !entry.name.endsWith('.spec.ts') && !entry.name.endsWith('.d.ts')) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+/** Branch keywords for rough cyclomatic complexity. */
+const BRANCH_KEYWORDS = /\b(if|else\s+if|else|switch|case|for|while|do|catch|&&|\|\||\?\?)\b/g;
+
+interface FunctionInfo {
+  name: string;
+  startLine: number;
+  branchCount: number;
+}
+
+export class ComplexityAnalyzerAgent extends BaseAgent {
+  readonly agentId = 70;
+  readonly agentName = 'Complexity Analyzer';
+
+  protected async preFlight(): Promise<void> {
+    // File-based agent
+  }
+
+  protected async execute(): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    const projectRoot = this.config.projectRoot ?? process.cwd();
+    const srcDir = path.join(projectRoot, 'src');
+
+    if (!fs.existsSync(srcDir)) {
+      findings.push({
+        id: `${this.agentId}-no-src-dir`,
+        type: 'infra-issue',
+        severity: 'low',
+        agentId: this.agentId,
+        module: 'complexity-analyzer',
+        description: 'No src/ directory found in project root',
+      });
+      return findings;
+    }
+
+    const tsFiles = findTsFiles(srcDir);
+    let complexFunctionCount = 0;
+    let longFileCount = 0;
+
+    for (const filePath of tsFiles) {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const lines = content.split('\n');
+      const relPath = path.relative(projectRoot, filePath);
+
+      // Check file length
+      if (lines.length > 1000) {
+        findings.push({
+          id: `${this.agentId}-very-long-file-${longFileCount}`,
+          type: 'test-bug',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: 'complexity-analyzer',
+          file: filePath,
+          description: `File ${relPath} has ${lines.length} lines (>1000) — consider splitting`,
+        });
+        longFileCount++;
+      } else if (lines.length > 500) {
+        findings.push({
+          id: `${this.agentId}-long-file-${longFileCount}`,
+          type: 'test-bug',
+          severity: 'low',
+          agentId: this.agentId,
+          module: 'complexity-analyzer',
+          file: filePath,
+          description: `File ${relPath} has ${lines.length} lines (>500) — consider refactoring`,
+        });
+        longFileCount++;
+      }
+
+      // Analyze function complexity
+      const functions = this.extractFunctions(lines);
+      for (const fn of functions) {
+        if (fn.branchCount > 15) {
+          complexFunctionCount++;
+          if (complexFunctionCount <= 10) {
+            findings.push({
+              id: `${this.agentId}-complex-function-${complexFunctionCount}`,
+              type: 'test-bug',
+              severity: 'medium',
+              agentId: this.agentId,
+              module: 'complexity-analyzer',
+              file: filePath,
+              line: fn.startLine,
+              description: `Function "${fn.name}" in ${relPath}:${fn.startLine} has ${fn.branchCount} branches (>15) — high cyclomatic complexity`,
+              suggestedFix: 'Refactor into smaller functions with single responsibilities',
+            });
+          }
+        }
+      }
+    }
+
+    if (complexFunctionCount > 10) {
+      findings.push({
+        id: `${this.agentId}-complex-functions-summary`,
+        type: 'test-bug',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'complexity-analyzer',
+        description: `${complexFunctionCount} functions with high complexity found (showing first 10)`,
+      });
+    }
+
+    this.addEvidence({
+      type: 'log',
+      path: '',
+      description: `Scanned ${tsFiles.length} files: ${complexFunctionCount} complex functions, ${longFileCount} long files`,
+    });
+
+    return findings;
+  }
+
+  private extractFunctions(lines: string[]): FunctionInfo[] {
+    const functions: FunctionInfo[] = [];
+    let currentFunction: FunctionInfo | null = null;
+    let braceDepth = 0;
+    let functionBraceStart = 0;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      // Detect function start
+      const funcMatch = trimmed.match(/(?:async\s+)?(?:function\s+(\w+)|(\w+)\s*(?:=|:)\s*(?:async\s+)?(?:\([^)]*\)|[^=]*)=>|(\w+)\s*\([^)]*\)\s*(?::\s*[^{]+)?\s*\{)/);
+
+      if (funcMatch && !currentFunction) {
+        const name = funcMatch[1] ?? funcMatch[2] ?? funcMatch[3] ?? 'anonymous';
+        currentFunction = { name, startLine: i + 1, branchCount: 0 };
+        functionBraceStart = braceDepth;
+      }
+
+      // Count braces
+      for (const ch of line) {
+        if (ch === '{') braceDepth++;
+        if (ch === '}') braceDepth--;
+      }
+
+      // Count branches in current function
+      if (currentFunction) {
+        const matches = trimmed.match(BRANCH_KEYWORDS);
+        if (matches) {
+          currentFunction.branchCount += matches.length;
+        }
+      }
+
+      // Function ended
+      if (currentFunction && braceDepth <= functionBraceStart) {
+        functions.push(currentFunction);
+        currentFunction = null;
+      }
+    }
+
+    if (currentFunction) {
+      functions.push(currentFunction);
+    }
+
+    return functions;
+  }
+}

package/agents/__tests__/24-signup-onboarding-tester.test.ts

@@ -0,0 +1,274 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+// ---------------------------------------------------------------------------
+// Stub config helpers
+// ---------------------------------------------------------------------------
+
+function makeConfig(overrides: Partial<ValidatedConfig> = {}): ValidatedConfig {
+  return {
+    schemaVersion: 1,
+    name: 'test',
+    auth: {
+      loginUrl: 'http://localhost/login',
+      credentials: {
+        admin: { email: 'admin@test.com', password: 'secret' },
+      },
+    },
+    modules: [
+      { id: 'dashboard', route: '/dashboard', sidebarIcon: true },
+    ],
+    environments: {
+      alpha: { baseUrl: 'http://localhost:3000', seed: false },
+    },
+    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' },
+    agentClassification: { blocking: [], advisory: [24] },
+    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>(),
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Mock fetch
+// ---------------------------------------------------------------------------
+
+const fetchMock = vi.fn();
+vi.stubGlobal('fetch', fetchMock);
+
+// ---------------------------------------------------------------------------
+// Mock helpers
+// ---------------------------------------------------------------------------
+
+const loginMock = vi.fn().mockResolvedValue(undefined);
+
+vi.mock('../../helpers/navigation', () => ({
+  login: (...args: unknown[]) => loginMock(...args),
+  waitForSectionLoad: vi.fn().mockResolvedValue(undefined),
+  navigateToSection: vi.fn().mockResolvedValue(undefined),
+  switchPortal: vi.fn().mockResolvedValue(undefined),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock Playwright
+// ---------------------------------------------------------------------------
+
+interface MockLocator {
+  count: ReturnType<typeof vi.fn>;
+  first: ReturnType<typeof vi.fn>;
+  nth: ReturnType<typeof vi.fn>;
+  click: ReturnType<typeof vi.fn>;
+  fill: ReturnType<typeof vi.fn>;
+  innerText: ReturnType<typeof vi.fn>;
+}
+
+function makeMockLocator(countVal = 0): MockLocator {
+  const locator: MockLocator = {
+    count: vi.fn().mockResolvedValue(countVal),
+    first: vi.fn(),
+    nth: vi.fn(),
+    click: vi.fn().mockResolvedValue(undefined),
+    fill: vi.fn().mockResolvedValue(undefined),
+    innerText: vi.fn().mockResolvedValue('some text'),
+  };
+  locator.first.mockReturnValue(locator);
+  locator.nth.mockReturnValue(locator);
+  return locator;
+}
+
+interface MockPage {
+  close: ReturnType<typeof vi.fn>;
+  goto: ReturnType<typeof vi.fn>;
+  url: ReturnType<typeof vi.fn>;
+  locator: ReturnType<typeof vi.fn>;
+  waitForTimeout: ReturnType<typeof vi.fn>;
+}
+
+function makeMockPage(): MockPage {
+  const defaultLocator = makeMockLocator(0);
+  return {
+    close: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    url: vi.fn().mockReturnValue('http://localhost:3000/dashboard'),
+    locator: vi.fn().mockReturnValue(defaultLocator),
+    waitForTimeout: vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+let currentMockPage: MockPage;
+let mockBrowser: { newPage: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
+
+vi.mock('playwright', async () => ({
+  chromium: {
+    launch: vi.fn().mockImplementation(async () => mockBrowser),
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Dynamic import AFTER mocks are hoisted
+// ---------------------------------------------------------------------------
+
+const { SignupOnboardingTesterAgent } = await import('../24-signup-onboarding-tester');
+
+function createAgent(
+  config: ValidatedConfig = makeConfig(),
+  phase: Phase = 'alpha',
+): InstanceType<typeof SignupOnboardingTesterAgent> {
+  return new SignupOnboardingTesterAgent(config, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('SignupOnboardingTesterAgent', () => {
+  beforeEach(() => {
+    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
+    loginMock.mockReset().mockResolvedValue(undefined);
+
+    currentMockPage = makeMockPage();
+    mockBrowser = {
+      newPage: vi.fn().mockResolvedValue(currentMockPage),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+  });
+
+  // Identity
+  it('has agentId 24 and correct agentName', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(24);
+    expect(agent.agentName).toBe('Signup & Onboarding Tester');
+  });
+
+  // preFlight succeeds
+  it('resolves environment in preFlight without error', async () => {
+    const agent = createAgent();
+    const result = await agent.run();
+    expect(result.findings.every(f => !f.description.includes('preFlight'))).toBe(true);
+  });
+
+  // No credentials
+  it('produces medium finding when no credentials configured', async () => {
+    const config = makeConfig({
+      auth: { loginUrl: 'http://localhost/login', credentials: {} },
+    });
+    const agent = createAgent(config);
+    const result = await agent.run();
+
+    const noCredsFinding = result.findings.find(f => f.id.includes('no-credentials'));
+    expect(noCredsFinding).toBeDefined();
+    expect(noCredsFinding!.severity).toBe('medium');
+  });
+
+  // Registration page not found
+  it('produces medium finding when no registration page found', async () => {
+    // goto resolves but no registration form fields (count=0)
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const regFinding = result.findings.find(f => f.id.includes('no-register-page'));
+    expect(regFinding).toBeDefined();
+    expect(regFinding!.severity).toBe('medium');
+  });
+
+  // Registration page found with fields
+  it('detects registration form when email and password fields exist', async () => {
+    currentMockPage.locator.mockImplementation((sel: string) => {
+      if (sel.includes('email')) return makeMockLocator(1);
+      if (sel.includes('password')) return makeMockLocator(1);
+      if (sel.includes('name')) return makeMockLocator(1);
+      if (sel.includes('submit') || sel.includes('Register') || sel.includes('Sign up')) return makeMockLocator(1);
+      return makeMockLocator(0);
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    // Should NOT have a "no register page" finding
+    const regFinding = result.findings.find(f => f.id.includes('no-register-page'));
+    expect(regFinding).toBeUndefined();
+  });
+
+  // Login page missing inputs
+  it('produces high finding when login page missing email/password', async () => {
+    // All locators return 0 by default — means login page has no inputs
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const loginMissing = result.findings.find(f => f.id.includes('login-missing-inputs'));
+    expect(loginMissing).toBeDefined();
+    expect(loginMissing!.severity).toBe('high');
+  });
+
+  // Login flow stuck
+  it('produces medium finding when login stays on login page', async () => {
+    currentMockPage.url.mockReturnValue('http://localhost:3000/login');
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const stuckFinding = result.findings.find(f => f.id.includes('login-flow-stuck'));
+    expect(stuckFinding).toBeDefined();
+    expect(stuckFinding!.severity).toBe('medium');
+  });
+
+  // Onboarding detection
+  it('reports info finding about onboarding detection', async () => {
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const onboardFinding = result.findings.find(
+      f => f.id.includes('onboarding-detected') || f.id.includes('no-onboarding'),
+    );
+    expect(onboardFinding).toBeDefined();
+    expect(onboardFinding!.severity).toBe('info');
+  });
+
+  // Playwright crash
+  it('produces medium finding when Playwright crashes', async () => {
+    mockBrowser.newPage.mockRejectedValue(new Error('Browser crashed'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const pwFinding = result.findings.find(f => f.id.includes('playwright-failure'));
+    expect(pwFinding).toBeDefined();
+    expect(pwFinding!.severity).toBe('medium');
+  });
+
+  // Browser closed in finally
+  it('closes browser even when an error occurs', async () => {
+    mockBrowser.newPage.mockRejectedValue(new Error('Launch error'));
+
+    const agent = createAgent();
+    await agent.run();
+
+    expect(mockBrowser.close).toHaveBeenCalled();
+  });
+
+  // Login flow error
+  it('handles login flow navigation errors gracefully', async () => {
+    currentMockPage.goto.mockRejectedValue(new Error('Navigation error'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    // Should have a navigation-related finding but not crash
+    expect(result.status).toBeDefined();
+  });
+});