@avi770/testteam 3.0.0 → 3.2.0

package/agents/09-healer.ts

@@ -1,228 +0,0 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { BaseAgent } from './base-agent';
-import { validateCodeQuality } from '../helpers/quality-gate';
-import type { Finding } from '../core/types';
-
-/** Maximum number of fix attempts per finding before escalation. */
-const MAX_ATTEMPTS = 3;
-
-/** Describes the root-cause category of a test-bug finding. */
-type FixStrategy = 'selector' | 'timing' | 'data' | 'unknown';
-
-/** Per-finding attempt tracking (kept in-memory for a single run). */
-interface AttemptRecord {
-  findingId: string;
-  attempts: number;
-}
-
-/**
- * Classifies a test-bug finding into one of three fix strategies based on
- * keywords in the description.
- *
- * - selector: element-locator problems (element not found, stale selector, …)
- * - timing:   race-condition / timeout problems
- * - data:     seed / fixture / data mismatch problems
- * - unknown:  fallback when no keyword matches
- */
-export function classifyFixStrategy(finding: Finding): FixStrategy {
-  const lower = finding.description.toLowerCase();
-
-  if (
-    lower.includes('selector') ||
-    lower.includes('element not found') ||
-    lower.includes('locator') ||
-    lower.includes('stale') ||
-    lower.includes('no such element')
-  ) {
-    return 'selector';
-  }
-
-  if (
-    lower.includes('timeout') ||
-    lower.includes('timing') ||
-    lower.includes('race') ||
-    lower.includes('wait') ||
-    lower.includes('timed out')
-  ) {
-    return 'timing';
-  }
-
-  if (
-    lower.includes('seed') ||
-    lower.includes('fixture') ||
-    lower.includes('data') ||
-    lower.includes('expected value') ||
-    lower.includes('mismatch')
-  ) {
-    return 'data';
-  }
-
-  return 'unknown';
-}
-
-/**
- * Generates a suggested fix string given a FixStrategy and the original
- * finding.  The generated suggestion intentionally uses plain English so it
- * can be reviewed by a developer or fed to a downstream AI patch agent.
- */
-export function generateFixSuggestion(finding: Finding, strategy: FixStrategy): string {
-  switch (strategy) {
-    case 'selector':
-      return (
-        `[Healer] Selector fix for "${finding.module}": ` +
-        `Update the element selector/locator — the target element may have changed its ` +
-        `data-testid, class, or role attribute. ` +
-        `Suggested action: inspect the current DOM and replace the stale selector with ` +
-        `a stable data-testid attribute (e.g. data-testid="<component>-<action>").`
-      );
-
-    case 'timing':
-      return (
-        `[Healer] Timing fix for "${finding.module}": ` +
-        `Add an explicit wait before the failing assertion. ` +
-        `Suggested action: replace hard sleeps with \`waitFor\` / \`waitForSelector\` ` +
-        `or increase the relevant timeout in the test configuration.`
-      );
-
-    case 'data':
-      return (
-        `[Healer] Data fix for "${finding.module}": ` +
-        `Update the test seed or fixture so the expected values match the current schema. ` +
-        `Suggested action: re-run \`pnpm seed:test\` to refresh test data, or update ` +
-        `the fixture file to reflect the current data model.`
-      );
-
-    default:
-      return (
-        `[Healer] Unknown strategy for "${finding.module}": ` +
-        `Manual investigation required — no known fix pattern matched the description.`
-      );
-  }
-}
-
-export class HealerAgent extends BaseAgent {
-  readonly agentId = 9;
-  readonly agentName = 'Healer';
-
-  /** Attempt tracking for the current run (finding id → attempt count). */
-  private readonly attemptMap = new Map<string, AttemptRecord>();
-
-  /** Set to true when there are no findings to process — makes execute() a no-op. */
-  private noFindings = false;
-
-  protected async preFlight(): Promise<void> {
-    const testBugsDir = path.join(this.runDir, 'findings', 'test-bugs');
-    let entries: string[];
-    try {
-      entries = await fs.readdir(testBugsDir);
-    } 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;
-    }
-  }
-
-  protected async execute(): Promise<Finding[]> {
-    if (this.noFindings) {
-      return [];
-    }
-
-    const testBugsDir = path.join(this.runDir, 'findings', 'test-bugs');
-
-    let entries: string[];
-    try {
-      entries = await fs.readdir(testBugsDir);
-    } catch {
-      return [];
-    }
-
-    const jsonFiles = entries.filter((e) => e.endsWith('.json'));
-    const unresolvedFindings: Finding[] = [];
-
-    for (const filename of jsonFiles) {
-      const filePath = path.join(testBugsDir, filename);
-      let finding: Finding;
-      try {
-        const raw = await fs.readFile(filePath, 'utf-8');
-        finding = JSON.parse(raw) as Finding;
-      } catch {
-        continue;
-      }
-
-      const record = this.getOrCreateAttemptRecord(finding.id);
-
-      if (record.attempts >= MAX_ATTEMPTS) {
-        unresolvedFindings.push({
-          ...finding,
-          suggestedFix:
-            `[Healer] Escalated after ${MAX_ATTEMPTS} attempts — requires manual investigation.`,
-        });
-        continue;
-      }
-
-      record.attempts += 1;
-
-      const strategy = classifyFixStrategy(finding);
-      const suggestion = generateFixSuggestion(finding, strategy);
-
-      // Run quality gate on any embedded test code in suggestedFix (if present)
-      const qualityViolations = validateCodeQuality(suggestion, `healer-fix-${finding.id}.ts`);
-      const hasErrors = qualityViolations.some((v) => v.severity === 'error');
-
-      if (hasErrors) {
-        // The fix suggestion itself has quality errors — escalate
-        unresolvedFindings.push({
-          ...finding,
-          suggestedFix:
-            `[Healer] Generated fix failed quality gate (attempt ${record.attempts}/${MAX_ATTEMPTS}): ` +
-            qualityViolations.map((v) => v.message).join('; '),
-        });
-        continue;
-      }
-
-      const resolvedFinding: Finding = {
-        ...finding,
-        suggestedFix: suggestion,
-      };
-
-      this.addEvidence({
-        type: 'log',
-        path: filePath,
-        description: `Healer processed test-bug "${finding.id}" with strategy "${strategy}" (attempt ${record.attempts})`,
-      });
-
-      // Write updated finding back to disk
-      await fs.writeFile(filePath, JSON.stringify(resolvedFinding, null, 2), 'utf-8');
-    }
-
-    return unresolvedFindings;
-  }
-
-  private getOrCreateAttemptRecord(findingId: string): AttemptRecord {
-    const existing = this.attemptMap.get(findingId);
-    if (existing) return existing;
-    const record: AttemptRecord = { findingId, attempts: 0 };
-    this.attemptMap.set(findingId, record);
-    return record;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-interface NodeError extends Error {
-  code: string;
-}
-
-function isNodeError(err: unknown): err is NodeError {
-  return err instanceof Error && 'code' in err;
-}

package/agents/10-reporter.ts

@@ -1,266 +0,0 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { BaseAgent } from './base-agent';
-import { readAgentResult } from '../core/evidence';
-import type { AgentResult, Finding, FindingSeverity, Phase } from '../core/types';
-
-/** Agent IDs whose results are pulled into the consolidated report. */
-const KNOWN_AGENT_IDS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23] as const;
-
-/** Release-gate recommendation. */
-export type ReleaseRecommendation = 'GO' | 'CONDITIONAL GO' | 'NO-GO';
-
-/** Phase-level aggregation used in the report. */
-interface PhaseSummary {
-  phase: Phase;
-  passCount: number;
-  failCount: number;
-  findings: Finding[];
-}
-
-/**
- * Determines the release recommendation based on the severity of all findings
- * across every agent result.
- *
- * - NO-GO:          any critical finding
- * - CONDITIONAL GO: 0 critical findings, at least one high finding
- * - GO:             0 critical and 0 high findings
- */
-export function determineRecommendation(results: AgentResult[]): ReleaseRecommendation {
-  const allFindings = results.flatMap((r) => r.findings);
-  const hasCritical = allFindings.some((f) => f.severity === 'critical');
-  const hasHigh = allFindings.some((f) => f.severity === 'high');
-
-  if (hasCritical) return 'NO-GO';
-  if (hasHigh) return 'CONDITIONAL GO';
-  return 'GO';
-}
-
-/**
- * Aggregates agent results by phase.
- */
-function aggregateByPhase(results: AgentResult[]): Map<Phase, PhaseSummary> {
-  const map = new Map<Phase, PhaseSummary>();
-
-  for (const result of results) {
-    const phase = result.phase;
-    const existing = map.get(phase) ?? {
-      phase,
-      passCount: 0,
-      failCount: 0,
-      findings: [],
-    };
-
-    if (result.status === 'passed') {
-      existing.passCount += 1;
-    } else {
-      existing.failCount += 1;
-    }
-    existing.findings.push(...result.findings);
-    map.set(phase, existing);
-  }
-
-  return map;
-}
-
-function severityEmoji(severity: FindingSeverity): string {
-  switch (severity) {
-    case 'critical': return 'CRITICAL';
-    case 'high': return 'HIGH';
-    case 'medium': return 'MEDIUM';
-    case 'low': return 'LOW';
-    case 'info': return 'INFO';
-  }
-}
-
-function formatFindingLine(f: Finding): string {
-  const loc = f.file ? ` (${f.file}${f.line ? `:${f.line}` : ''})` : '';
-  return `- [${severityEmoji(f.severity)}] Agent ${f.agentId} | ${f.module}${loc}: ${f.description}`;
-}
-
-/**
- * Extracts a summary string from the agent result with the given ID, or returns
- * a placeholder when that result is not present in the collection.
- */
-function agentSummaryLine(results: AgentResult[], agentId: number, label: string): string {
-  const result = results.find((r) => r.agentId === agentId);
-  if (!result) return `${label}: not run`;
-  return `${label}: ${result.summary}`;
-}
-
-/**
- * Builds the full markdown report string from the collected agent results.
- */
-export function buildMarkdownReport(
-  results: AgentResult[],
-  runId: string,
-  recommendation: ReleaseRecommendation,
-): string {
-  const phaseMap = aggregateByPhase(results);
-  const phases: Phase[] = ['alpha', 'beta', 'uat', 'release'];
-
-  const lines: string[] = [];
-
-  lines.push(`# TestTeam — Release Report`);
-  lines.push(`**Run ID:** ${runId}`);
-  lines.push(`**Generated:** ${new Date().toISOString()}`);
-  lines.push(`**Recommendation:** ${recommendation}`);
-  lines.push('');
-
-  // Phase summaries
-  lines.push('## Phase Summaries');
-  for (const phase of phases) {
-    const summary = phaseMap.get(phase);
-    if (!summary) {
-      lines.push(`### ${phase.toUpperCase()}`);
-      lines.push('No agents ran in this phase.');
-      lines.push('');
-      continue;
-    }
-    lines.push(`### ${phase.toUpperCase()}`);
-    lines.push(`- Pass: ${summary.passCount}`);
-    lines.push(`- Fail: ${summary.failCount}`);
-    lines.push(`- Total findings: ${summary.findings.length}`);
-    lines.push('');
-  }
-
-  // Specialist summaries
-  lines.push('## Specialist Summaries');
-  lines.push(agentSummaryLine(results, 4, 'Coverage (Agent 4)'));
-  lines.push(agentSummaryLine(results, 7, 'Security (Agent 7)'));
-  lines.push(agentSummaryLine(results, 8, 'Accessibility (Agent 8)'));
-  lines.push(agentSummaryLine(results, 13, 'Performance (Agent 13)'));
-  lines.push(agentSummaryLine(results, 14, 'Data Integrity (Agent 14)'));
-  lines.push('');
-
-  // All findings by severity
-  const allFindings = results.flatMap((r) => r.findings);
-  const severities: FindingSeverity[] = ['critical', 'high', 'medium', 'low'];
-
-  lines.push('## Findings by Severity');
-  for (const sev of severities) {
-    const group = allFindings.filter((f) => f.severity === sev);
-    if (group.length === 0) continue;
-    lines.push(`### ${sev.toUpperCase()} (${group.length})`);
-    for (const f of group) {
-      lines.push(formatFindingLine(f));
-    }
-    lines.push('');
-  }
-
-  if (allFindings.length === 0) {
-    lines.push('No findings — all agents passed.');
-    lines.push('');
-  }
-
-  lines.push(`---`);
-  lines.push(`_Generated by TestTeam Reporter (Agent 10)_`);
-
-  return lines.join('\n');
-}
-
-export class ReporterAgent extends BaseAgent {
-  readonly agentId = 10;
-  readonly agentName = 'Reporter';
-
-  /** When true, execute() returns a single informational finding instead of a full report. */
-  private noPriorResults = false;
-
-  protected async preFlight(): Promise<void> {
-    const agentResultsDir = path.join(this.runDir, 'agent-results');
-    let entries: string[];
-    try {
-      entries = await fs.readdir(agentResultsDir);
-    } catch (err: unknown) {
-      if (isNodeError(err) && err.code === 'ENOENT') {
-        // Directory missing — gracefully degrade instead of throwing
-        this.noPriorResults = true;
-        return;
-      }
-      throw err;
-    }
-
-    const jsonFiles = entries.filter((e) => e.endsWith('.json'));
-    if (jsonFiles.length === 0) {
-      // Empty directory — gracefully degrade instead of throwing
-      this.noPriorResults = true;
-    }
-  }
-
-  protected async execute(): Promise<Finding[]> {
-    if (this.noPriorResults) {
-      return [{
-        id: `${this.agentId}-no-results`,
-        type: 'infra-issue',
-        severity: 'low',
-        agentId: this.agentId,
-        module: 'reporter',
-        description: 'No agent results to report — agent-results directory is empty or missing',
-      }];
-    }
-
-    // Read all available agent results
-    const results: AgentResult[] = [];
-    for (const agentId of KNOWN_AGENT_IDS) {
-      const result = await readAgentResult(this.runDir, agentId);
-      if (result) {
-        results.push(result);
-      }
-    }
-
-    // Also read any extra result files not in the known-IDs list
-    const agentResultsDir = path.join(this.runDir, 'agent-results');
-    try {
-      const entries = await fs.readdir(agentResultsDir);
-      for (const entry of entries) {
-        if (!entry.endsWith('.json')) continue;
-        const idStr = entry.replace('.json', '');
-        const id = parseInt(idStr, 10);
-        if (isNaN(id) || KNOWN_AGENT_IDS.includes(id as typeof KNOWN_AGENT_IDS[number])) continue;
-        const raw = await fs.readFile(path.join(agentResultsDir, entry), 'utf-8');
-        results.push(JSON.parse(raw) as AgentResult);
-      }
-    } catch {
-      // Ignore read errors for extra files
-    }
-
-    const recommendation = determineRecommendation(results);
-
-    // Use run directory name as run ID
-    const runId = path.basename(this.runDir);
-    const date = new Date().toISOString().slice(0, 10);
-    const reportFilename = `${date}-${runId}.md`;
-
-    const reportsDir = path.join(
-      path.dirname(path.dirname(this.runDir)), // go up from .run/<runId> to project root
-      'testteam',
-      'reports',
-    );
-    await fs.mkdir(reportsDir, { recursive: true });
-
-    const reportPath = path.join(reportsDir, reportFilename);
-    const markdownContent = buildMarkdownReport(results, runId, recommendation);
-    await fs.writeFile(reportPath, markdownContent, 'utf-8');
-
-    this.addEvidence({
-      type: 'report',
-      path: reportPath,
-      description: `Consolidated release report — recommendation: ${recommendation}`,
-    });
-
-    // Reporter does not generate new findings — it only aggregates
-    return [];
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-interface NodeError extends Error {
-  code: string;
-}
-
-function isNodeError(err: unknown): err is NodeError {
-  return err instanceof Error && 'code' in err;
-}