@avi770/testteam 1.2.0

package/agents/11-fixer.ts

@@ -0,0 +1,253 @@
+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

@@ -0,0 +1,444 @@
+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
+    }
+  }
+}