@avi770/testteam 1.2.0

package/agents/09-healer.ts

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

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