@avi770/testteam 3.0.0 → 3.2.0

package/agents/11-fixer.ts

@@ -1,253 +0,0 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { execFile } from 'child_process';
-import { BaseAgent } from './base-agent';
-import { classifyFinding, shouldAutoCommit, shouldRequireHumanReview } from '../core/fix-loop';
-import { validateCodeQuality } from '../helpers/quality-gate';
-import type { Finding, FindingType } from '../core/types';
-
-/** Maximum number of quality-gate retry attempts per finding. */
-const MAX_ATTEMPTS = 3;
-
-/** The date-stamped fix branch name prefix. */
-const FIX_BRANCH_PREFIX = 'fix/testteam-';
-
-/** Extended finding with resolution metadata. */
-export interface ResolvedFinding extends Finding {
-  autoCommit: boolean;
-  requiresHumanReview: boolean;
-  resolutionStatus: 'resolved' | 'escalated' | 'pending-review';
-  attemptCount: number;
-}
-
-function execFilePromise(
-  file: string,
-  args: string[],
-): Promise<{ stdout: string; stderr: string }> {
-  return new Promise((resolve, reject) => {
-    execFile(file, args, { shell: true }, (error, stdout, stderr) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve({ stdout: stdout ?? '', stderr: stderr ?? '' });
-    });
-  });
-}
-
-async function getCurrentBranch(): Promise<string> {
-  const result = await execFilePromise('git', ['rev-parse', '--abbrev-ref', 'HEAD']);
-  return result.stdout.trim();
-}
-
-async function isOnFixBranch(): Promise<boolean> {
-  try {
-    const branch = await getCurrentBranch();
-    return branch.startsWith('fix/') || branch.startsWith('hotfix/');
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Generates a code patch suggestion for a code-bug finding.
- * Returns a plain-English description (not actual source code) so it can be
- * reviewed by a developer or fed to a downstream AI patch agent.
- */
-export function generatePatchSuggestion(finding: Finding, findingType: FindingType): string {
-  switch (findingType) {
-    case 'code-bug-cosmetic':
-      return (
-        `[Fixer] Cosmetic patch for "${finding.module}": ` +
-        `${finding.suggestedFix ?? 'Review and apply the minimal style or copy change indicated by the finding description.'}`
-      );
-
-    case 'code-bug-security':
-      return (
-        `[Fixer] Security patch for "${finding.module}": ` +
-        `${finding.suggestedFix ?? 'Apply the security hardening indicated by the finding. ' +
-        'Validate input, sanitise output, and ensure no sensitive data is exposed. ' +
-        'Human review is mandatory before merging.'}`
-      );
-
-    case 'code-bug-logic':
-      return (
-        `[Fixer] Logic patch for "${finding.module}": ` +
-        `${finding.suggestedFix ?? 'Review the business logic at the indicated file/line. ' +
-        'Ensure edge cases and error paths are handled correctly. ' +
-        'Human review is mandatory before merging.'}`
-      );
-
-    default:
-      return (
-        `[Fixer] Patch for "${finding.module}": ` +
-        `${finding.suggestedFix ?? 'Manual investigation required.'}`
-      );
-  }
-}
-
-export class FixerAgent extends BaseAgent {
-  readonly agentId = 11;
-  readonly agentName = 'Fixer';
-
-  /** Set to true when there are no findings to process — makes execute() a no-op. */
-  private noFindings = false;
-
-  protected async preFlight(): Promise<void> {
-    const codeBugsDir = path.join(this.runDir, 'findings', 'code-bugs');
-    let entries: string[];
-    try {
-      entries = await fs.readdir(codeBugsDir);
-    } catch (err: unknown) {
-      if (isNodeError(err) && err.code === 'ENOENT') {
-        this.noFindings = true;
-        return;
-      }
-      throw err;
-    }
-
-    const jsonFiles = entries.filter((e) => e.endsWith('.json'));
-    if (jsonFiles.length === 0) {
-      this.noFindings = true;
-      return;
-    }
-
-    // Verify we are on a fix branch, or that git is available so we can create one
-    try {
-      await execFilePromise('git', ['--version']);
-    } catch {
-      throw new Error('[Fixer] preFlight failed: git is not available — cannot create fix branch');
-    }
-  }
-
-  protected async execute(): Promise<Finding[]> {
-    if (this.noFindings) {
-      return [];
-    }
-
-    const codeBugsDir = path.join(this.runDir, 'findings', 'code-bugs');
-
-    let entries: string[];
-    try {
-      entries = await fs.readdir(codeBugsDir);
-    } catch {
-      return [];
-    }
-
-    const jsonFiles = entries.filter((e) => e.endsWith('.json'));
-    const resultFindings: Finding[] = [];
-
-    // Ensure we are on a fix branch before processing findings
-    await this.ensureFixBranch();
-
-    for (const filename of jsonFiles) {
-      const filePath = path.join(codeBugsDir, filename);
-      let finding: Finding;
-      try {
-        const raw = await fs.readFile(filePath, 'utf-8');
-        finding = JSON.parse(raw) as Finding;
-      } catch {
-        continue;
-      }
-
-      const resolved = await this.processFinding(finding, filePath);
-      resultFindings.push(resolved);
-    }
-
-    return resultFindings;
-  }
-
-  private async processFinding(finding: Finding, filePath: string): Promise<ResolvedFinding> {
-    // Use classifyFinding to determine canonical type (changedFiles is empty — no source changes)
-    const findingType = classifyFinding(finding, []);
-    const autoCommit = shouldAutoCommit(findingType, this.phase);
-    const requiresHumanReview = shouldRequireHumanReview(findingType, this.phase);
-
-    let patchSuggestion = generatePatchSuggestion(finding, findingType);
-    let attemptCount = 0;
-    let qualityPassed = false;
-
-    while (attemptCount < MAX_ATTEMPTS) {
-      attemptCount += 1;
-      const violations = validateCodeQuality(patchSuggestion, `fixer-patch-${finding.id}.ts`);
-      const hasErrors = violations.some((v) => v.severity === 'error');
-
-      if (!hasErrors) {
-        qualityPassed = true;
-        break;
-      }
-
-      // Attempt to refine the patch suggestion by appending quality feedback
-      if (attemptCount < MAX_ATTEMPTS) {
-        patchSuggestion =
-          `${patchSuggestion}\n` +
-          `// Quality gate feedback (attempt ${attemptCount}): ` +
-          violations.map((v) => v.message).join('; ');
-      }
-    }
-
-    const resolutionStatus: ResolvedFinding['resolutionStatus'] = !qualityPassed
-      ? 'escalated'
-      : requiresHumanReview
-        ? 'pending-review'
-        : 'resolved';
-
-    const resolvedFinding: ResolvedFinding = {
-      ...finding,
-      suggestedFix: qualityPassed
-        ? patchSuggestion
-        : `[Fixer] Escalated after ${MAX_ATTEMPTS} attempts — quality gate could not be satisfied.`,
-      autoCommit,
-      requiresHumanReview,
-      resolutionStatus,
-      attemptCount,
-    };
-
-    this.addEvidence({
-      type: 'log',
-      path: filePath,
-      description:
-        `Fixer processed "${finding.id}" type="${findingType}" ` +
-        `autoCommit=${autoCommit} humanReview=${requiresHumanReview} ` +
-        `status=${resolutionStatus} attempts=${attemptCount}`,
-    });
-
-    // Write updated finding back to disk
-    await fs.writeFile(filePath, JSON.stringify(resolvedFinding, null, 2), 'utf-8');
-
-    return resolvedFinding;
-  }
-
-  private async ensureFixBranch(): Promise<void> {
-    try {
-      const onFix = await isOnFixBranch();
-      if (onFix) return;
-
-      const date = new Date().toISOString().slice(0, 10); // YYYY-MM-DD
-      const branchName = `${FIX_BRANCH_PREFIX}${date}`;
-
-      await execFilePromise('git', ['checkout', '-b', branchName]);
-
-      this.addEvidence({
-        type: 'log',
-        path: this.runDir,
-        description: `Fixer created fix branch: ${branchName}`,
-      });
-    } catch {
-      // If branch creation fails (e.g. branch already exists or git issue) we continue —
-      // the findings are still processed and the branch state is best-effort.
-    }
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-interface NodeError extends Error {
-  code: string;
-}
-
-function isNodeError(err: unknown): err is NodeError {
-  return err instanceof Error && 'code' in err;
-}

package/agents/12-ux-inspector.ts

@@ -1,444 +0,0 @@
-import { stat, readdir } from 'node:fs/promises';
-import type { Browser, Page } from 'playwright';
-import type { Finding } from '../core/types';
-import { BaseAgent } from './base-agent';
-
-async function fileExists(p: string): Promise<boolean> {
-  try { await stat(p); return true; } catch { return false; }
-}
-import { login, navigateToSection } from '../helpers/navigation';
-import { captureScreenshot } from '../helpers/screenshot';
-
-/** Selectors that indicate an ErrorBoundary rendered in the application. */
-const ERROR_BOUNDARY_SELECTORS = [
-  '[data-testid="error-boundary"]',
-  '[data-testid="error-fallback"]',
-  '.error-boundary',
-  '[role="alert"]',
-] as const;
-
-/** Selectors that indicate an empty-state placeholder is rendered. */
-const EMPTY_STATE_SELECTORS = [
-  '[data-testid="empty-state"]',
-  '.empty-state',
-  '[aria-label="No data"]',
-  '[data-testid="no-results"]',
-] as const;
-
-/** Selectors for inline form validation messages. */
-const VALIDATION_MESSAGE_SELECTORS = [
-  '[data-testid="field-error"]',
-  '.field-error',
-  '[aria-live="polite"]',
-  '[role="alert"]',
-  '.form-error',
-] as const;
-
-export class UxInspectorAgent extends BaseAgent {
-  readonly agentId = 12;
-  readonly agentName = 'UX Inspector';
-
-  protected async preFlight(): Promise<void> {
-    const runDirExists = await fileExists(this.runDir);
-    if (!runDirExists) {
-      throw new Error(
-        `Run directory does not exist: ${this.runDir}. ` +
-          'Browser Crawler (Agent 5) must run first to populate screenshots.',
-      );
-    }
-
-    const files = await readdir(this.runDir);
-    const screenshotFiles = files.filter((f) => f.endsWith('.png'));
-
-    if (screenshotFiles.length === 0) {
-      // Advisory agent — missing screenshots is informational, not a gate blocker.
-      // preFlight will succeed; execute() will handle the absence gracefully.
-    }
-  }
-
-  protected async execute(): Promise<Finding[]> {
-    const findings: Finding[] = [];
-
-    const env =
-      this.config.environments['beta'] ??
-      this.config.environments['alpha'] ??
-      Object.values(this.config.environments)[0];
-
-    if (!env) {
-      findings.push({
-        id: '12-no-env',
-        type: 'infra-issue',
-        severity: 'critical',
-        agentId: this.agentId,
-        module: 'ux-inspector',
-        description: 'No environment configured — cannot determine base URL',
-      });
-      return findings;
-    }
-
-    const rawLoginUrl = this.config.auth.loginUrl ?? '/login';
-    const loginUrl = rawLoginUrl.startsWith('http') ? rawLoginUrl : `${env.baseUrl}${rawLoginUrl}`;
-    const credentials =
-      this.config.auth.credentials?.['admin'] ??
-      Object.values(this.config.auth.credentials ?? {})[0];
-
-    if (!credentials) {
-      findings.push({
-        id: '12-no-credentials',
-        type: 'infra-issue',
-        severity: 'critical',
-        agentId: this.agentId,
-        module: 'ux-inspector',
-        description: 'No credentials configured in auth.credentials — cannot log in',
-      });
-      return findings;
-    }
-
-    const { chromium } = await import('playwright');
-
-    let browser: Browser | null = null;
-    let page: Page | null = null;
-
-    try {
-      browser = await chromium.launch({ headless: true });
-      page = await browser.newPage();
-
-      await login(page, credentials, loginUrl);
-
-      for (const module of this.config.modules) {
-        const moduleFindings = await this.inspectModule(page, module.id);
-        findings.push(...moduleFindings);
-      }
-    } finally {
-      if (page) await page.close().catch(() => undefined);
-      if (browser) await browser.close().catch(() => undefined);
-    }
-
-    return findings;
-  }
-
-  private async inspectModule(
-    page: Page,
-    moduleId: string,
-  ): Promise<Finding[]> {
-    const findings: Finding[] = [];
-
-    // Navigate to module
-    try {
-      await navigateToSection(page, moduleId, this.config);
-    } catch (navErr) {
-      findings.push({
-        id: `12-nav-${moduleId}`,
-        type: 'infra-issue',
-        severity: 'high',
-        agentId: this.agentId,
-        module: moduleId,
-        description: `Navigation to module "${moduleId}" failed: ${navErr instanceof Error ? navErr.message : String(navErr)}`,
-      });
-      return findings;
-    }
-
-    // Check loading states: spinners/skeletons should eventually disappear
-    const loadingVisible = await this.checkLoadingStatesStuck(page);
-    if (loadingVisible) {
-      const screenshotPath = await captureScreenshot(
-        page,
-        `ux-loading-stuck-${moduleId}`,
-        this.runDir,
-      );
-      this.addEvidence({
-        type: 'screenshot',
-        path: screenshotPath,
-        description: `Loading spinner/skeleton stuck in module "${moduleId}"`,
-      });
-      findings.push({
-        id: `12-loading-stuck-${moduleId}`,
-        type: 'code-bug-cosmetic',
-        severity: 'medium',
-        agentId: this.agentId,
-        module: moduleId,
-        description: `Loading indicator remains visible after navigation settled in module "${moduleId}"`,
-        screenshot: screenshotPath,
-        suggestedFix: 'Ensure loading state is cleared when data resolves or errors occur',
-      });
-    }
-
-    // Simulate API error: intercept routes returning 500, then reload
-    await this.checkErrorBoundaryOnApiError(page, moduleId, findings);
-
-    // Re-navigate after route interception test
-    try {
-      await page.unroute('**/*');
-      await navigateToSection(page, moduleId, this.config);
-    } catch {
-      // Best-effort re-navigation; continue to next checks
-    }
-
-    // Check for empty states
-    await this.checkEmptyStates(page, moduleId, findings);
-
-    // Check form validation inline messages
-    await this.checkFormValidation(page, moduleId, findings);
-
-    // Check for truncated text
-    await this.checkTruncatedText(page, moduleId, findings);
-
-    return findings;
-  }
-
-  private async checkLoadingStatesStuck(page: Page): Promise<boolean> {
-    try {
-      const loadingSelectors = [
-        '[data-testid="loading-spinner"]',
-        '[data-testid="skeleton"]',
-        '.loading-spinner',
-        '.skeleton',
-        '[aria-label="Loading"]',
-      ];
-
-      for (const selector of loadingSelectors) {
-        const isVisible = await page.isVisible(selector).catch(() => false);
-        if (isVisible) {
-          return true;
-        }
-      }
-      return false;
-    } catch {
-      return false;
-    }
-  }
-
-  private async checkErrorBoundaryOnApiError(
-    page: Page,
-    moduleId: string,
-    findings: Finding[],
-  ): Promise<void> {
-    try {
-      // Intercept all API calls and return 500
-      await page.route('**/api/**', (route) => {
-        return route.fulfill({
-          status: 500,
-          contentType: 'application/json',
-          body: JSON.stringify({ error: 'Internal Server Error' }),
-        });
-      });
-
-      // Reload to trigger the intercepted error
-      await page.reload({ waitUntil: 'domcontentloaded' }).catch(() => undefined);
-
-      // Wait briefly for React to render error boundary
-      await page.waitForTimeout(1000).catch(() => undefined);
-
-      let errorBoundaryFound = false;
-      for (const selector of ERROR_BOUNDARY_SELECTORS) {
-        const visible = await page.isVisible(selector).catch(() => false);
-        if (visible) {
-          errorBoundaryFound = true;
-          break;
-        }
-      }
-
-      if (!errorBoundaryFound) {
-        const screenshotPath = await captureScreenshot(
-          page,
-          `ux-error-boundary-missing-${moduleId}`,
-          this.runDir,
-        );
-        this.addEvidence({
-          type: 'screenshot',
-          path: screenshotPath,
-          description: `No ErrorBoundary rendered during API error in module "${moduleId}"`,
-        });
-        findings.push({
-          id: `12-error-boundary-${moduleId}`,
-          type: 'code-bug-logic',
-          severity: 'high',
-          agentId: this.agentId,
-          module: moduleId,
-          description: `Module "${moduleId}" does not render an ErrorBoundary when API returns 500`,
-          screenshot: screenshotPath,
-          suggestedFix:
-            'Wrap module content with a React ErrorBoundary component that renders a user-friendly fallback',
-        });
-      }
-
-      // Remove interception after test
-      await page.unroute('**/api/**');
-    } catch {
-      // Route interception not supported or failed — skip this check
-      await page.unroute('**/api/**').catch(() => undefined);
-    }
-  }
-
-  private async checkEmptyStates(
-    page: Page,
-    moduleId: string,
-    findings: Finding[],
-  ): Promise<void> {
-    try {
-      // Look for data containers that are empty (no rows, no items)
-      const hasDataRows = await page
-        .evaluate(() => {
-          const tables = document.querySelectorAll('table tbody tr');
-          const listItems = document.querySelectorAll('[data-testid="list-item"]');
-          const cards = document.querySelectorAll('[data-testid="card"]');
-          return tables.length > 0 || listItems.length > 0 || cards.length > 0;
-        })
-        .catch(() => true); // If evaluation fails, assume data present
-
-      if (!hasDataRows) {
-        // Check if an empty state indicator is shown
-        let emptyStateShown = false;
-        for (const selector of EMPTY_STATE_SELECTORS) {
-          const visible = await page.isVisible(selector).catch(() => false);
-          if (visible) {
-            emptyStateShown = true;
-            break;
-          }
-        }
-
-        if (!emptyStateShown) {
-          const screenshotPath = await captureScreenshot(
-            page,
-            `ux-empty-state-missing-${moduleId}`,
-            this.runDir,
-          );
-          this.addEvidence({
-            type: 'screenshot',
-            path: screenshotPath,
-            description: `No empty-state placeholder in module "${moduleId}" when data is absent`,
-          });
-          findings.push({
-            id: `12-empty-state-${moduleId}`,
-            type: 'code-bug-cosmetic',
-            severity: 'low',
-            agentId: this.agentId,
-            module: moduleId,
-            description: `Module "${moduleId}" shows no empty-state message when there are no data rows`,
-            screenshot: screenshotPath,
-            suggestedFix:
-              'Add an empty-state component (e.g. <EmptyState />) when list/table has zero records',
-          });
-        }
-      }
-    } catch {
-      // Best-effort check
-    }
-  }
-
-  private async checkFormValidation(
-    page: Page,
-    moduleId: string,
-    findings: Finding[],
-  ): Promise<void> {
-    try {
-      // Look for a form with required fields and attempt to submit it empty
-      const hasForm = await page.isVisible('form').catch(() => false);
-      if (!hasForm) return;
-
-      const hasRequiredField = await page
-        .evaluate(() => document.querySelectorAll('input[required], select[required], textarea[required]').length > 0)
-        .catch(() => false);
-
-      if (!hasRequiredField) return;
-
-      // Submit the form without filling any fields
-      const submitButton = page.locator('button[type="submit"]').first();
-      const submitVisible = await submitButton.isVisible().catch(() => false);
-      if (!submitVisible) return;
-
-      await submitButton.click().catch(() => undefined);
-
-      // Wait briefly for validation to appear
-      await page.waitForTimeout(500).catch(() => undefined);
-
-      let validationShown = false;
-      for (const selector of VALIDATION_MESSAGE_SELECTORS) {
-        const visible = await page.isVisible(selector).catch(() => false);
-        if (visible) {
-          validationShown = true;
-          break;
-        }
-      }
-
-      if (!validationShown) {
-        const screenshotPath = await captureScreenshot(
-          page,
-          `ux-form-validation-missing-${moduleId}`,
-          this.runDir,
-        );
-        this.addEvidence({
-          type: 'screenshot',
-          path: screenshotPath,
-          description: `No inline validation messages in form in module "${moduleId}"`,
-        });
-        findings.push({
-          id: `12-form-validation-${moduleId}`,
-          type: 'code-bug-cosmetic',
-          severity: 'medium',
-          agentId: this.agentId,
-          module: moduleId,
-          description: `Form in module "${moduleId}" does not show inline validation messages on empty submit`,
-          screenshot: screenshotPath,
-          suggestedFix:
-            'Display inline validation errors next to each required field on form submit',
-        });
-      }
-    } catch {
-      // Best-effort check
-    }
-  }
-
-  private async checkTruncatedText(
-    page: Page,
-    moduleId: string,
-    findings: Finding[],
-  ): Promise<void> {
-    try {
-      const truncatedCount = await page
-        .evaluate(() => {
-          const all = Array.from(document.querySelectorAll('*'));
-          let count = 0;
-          for (const el of all) {
-            const style = window.getComputedStyle(el);
-            if (
-              style.overflow === 'hidden' &&
-              el.scrollWidth > el.clientWidth &&
-              el.textContent !== null &&
-              el.textContent.trim().length > 0
-            ) {
-              count++;
-            }
-          }
-          return count;
-        })
-        .catch(() => 0);
-
-      if (truncatedCount > 0) {
-        const screenshotPath = await captureScreenshot(
-          page,
-          `ux-truncated-text-${moduleId}`,
-          this.runDir,
-        );
-        this.addEvidence({
-          type: 'screenshot',
-          path: screenshotPath,
-          description: `${truncatedCount} truncated text element(s) detected in module "${moduleId}"`,
-        });
-        findings.push({
-          id: `12-truncated-text-${moduleId}`,
-          type: 'code-bug-cosmetic',
-          severity: 'low',
-          agentId: this.agentId,
-          module: moduleId,
-          description: `${truncatedCount} element(s) with overflow:hidden are truncating visible text in module "${moduleId}"`,
-          screenshot: screenshotPath,
-          suggestedFix:
-            'Use text-overflow:ellipsis with title attribute, or expand container width to fit content',
-        });
-      }
-    } catch {
-      // Best-effort check
-    }
-  }
-}