@avi770/testteam 3.0.0 → 3.2.0

package/core/config.ts

@@ -1,178 +0,0 @@
-export interface WorkflowStep {
-  action: 'navigate' | 'click' | 'fill-form' | 'wait' | 'verify';
-  target: string;
-  verify?: string;
-  data?: string;
-  timeout?: number;
-  contains?: string;
-}
-
-export interface ModuleConfig {
-  id: string;
-  route: string;
-  sidebarIcon: boolean;
-}
-
-export interface CredentialEntry {
-  email: string;
-  password: string;
-}
-
-export interface RoleEntry {
-  name: string;
-  email: string;
-}
-
-export interface AuthConfig {
-  loginUrl?: string;
-  credentials?: Record<string, CredentialEntry>;
-  roles?: RoleEntry[];
-}
-
-export interface EnvironmentConfig {
-  baseUrl: string;
-  seed?: boolean;
-}
-
-export interface PortalConfig {
-  name: string;
-  queryParam: string | null;
-}
-
-export interface IntegrationConfig {
-  name: string;
-  [key: string]: unknown;
-}
-
-export interface WorkerConfig {
-  name: string;
-  [key: string]: unknown;
-}
-
-export interface WorkflowConfig {
-  name: string;
-  steps: WorkflowStep[];
-}
-
-export interface AccuracyConfig {
-  enabled: boolean;
-  decimalPrecision: number;
-  currencySymbol: string;
-  timezone: string;
-}
-
-export interface TenancyConfig {
-  enabled: boolean;
-  isolationField: string;
-  testFirms: string[];
-}
-
-export interface CostBudgetConfig {
-  maxPerRun: number;
-  maxPerAgent: number;
-  alertThreshold: number;
-  onExceeded: 'abort' | 'alert-continue' | 'skip-remaining';
-}
-
-export interface AgentClassificationConfig {
-  blocking: number[];
-  advisory: number[];
-}
-
-export interface CoverageThresholds {
-  lines: number;
-  functions: number;
-  branches: number;
-  statements: number;
-}
-
-export interface LighthouseThresholds {
-  accessibility: number;
-  performance: number;
-  bestPractices: number;
-  seo: number;
-}
-
-export interface ThresholdsConfig {
-  unitCoverage: CoverageThresholds;
-  lighthouse: LighthouseThresholds;
-  apiResponseTime: number;
-  bundleSizeLimit: number;
-  maxConsoleErrors: number;
-}
-
-export interface TestTeamConfig {
-  schemaVersion: number;
-  name: string;
-  /** Absolute path to the target project root (where package.json, prisma/, apps/ live) */
-  projectRoot?: string;
-  auth: AuthConfig;
-  modules: ModuleConfig[];
-  environments: Record<string, EnvironmentConfig>;
-  portals: PortalConfig[];
-  breakpoints: number[];
-  integrations: IntegrationConfig[];
-  workers: WorkerConfig[];
-  workflows: WorkflowConfig[];
-  accuracy: AccuracyConfig;
-  tenancy: TenancyConfig;
-  costBudget: CostBudgetConfig;
-  agentClassification: AgentClassificationConfig;
-  thresholds: ThresholdsConfig;
-  disabledAgents: number[];
-}
-
-export interface ValidatedConfig extends TestTeamConfig {
-  disabledAgentSet: Set<number>;
-}
-
-export function validateConfig(raw: TestTeamConfig): ValidatedConfig {
-  if (raw.schemaVersion === undefined || raw.schemaVersion === null) {
-    throw new Error('schemaVersion is required');
-  }
-
-  if (!raw.name) {
-    throw new Error('name is required');
-  }
-
-  if (raw.modules !== undefined && !Array.isArray(raw.modules)) {
-    throw new Error('modules must be an array');
-  }
-
-  if (raw.modules !== undefined && Array.isArray(raw.modules) && raw.modules.length === 0) {
-    throw new Error('modules must contain at least one module');
-  }
-
-  if (!raw.auth) {
-    throw new Error('auth is required');
-  }
-
-  const disabledAgentSet = new Set<number>(raw.disabledAgents ?? []);
-
-  // Warn on empty credential passwords and empty emails
-  if (raw.auth.credentials) {
-    const entries = Object.entries(raw.auth.credentials);
-    let allPasswordsEmpty = entries.length > 0;
-
-    for (const [role, entry] of entries) {
-      if (entry.password === '') {
-        console.warn(`[TestTeam] Warning: credential "${role}" has an empty password. Set a real password in your config.`);
-      } else {
-        allPasswordsEmpty = false;
-      }
-
-      if (entry.email === '') {
-        console.warn(`[TestTeam] Warning: credential "${role}" has an empty email. Set TF_${role.toUpperCase()}_EMAIL in your environment.`);
-      }
-    }
-
-    if (allPasswordsEmpty && entries.length > 0) {
-      throw new Error('All credentials have empty passwords. At least one credential must have a non-empty password.');
-    }
-  }
-
-  return {
-    ...raw,
-    disabledAgentSet,
-  };
-}

package/core/cost-tracker.ts

@@ -1,59 +0,0 @@
-export interface CostBudget {
-  maxPerRun: number;
-  maxPerAgent: number;
-  alertThreshold: number;
-  onExceeded: 'abort' | 'alert-continue' | 'skip-remaining';
-}
-
-export interface BudgetCheckResult {
-  status: 'ok' | 'alert' | 'exceeded';
-  totalCost: number;
-  budgetRemaining: number;
-}
-
-export class CostTracker {
-  private readonly budget: CostBudget;
-  private readonly agentCosts: Map<string, number> = new Map();
-
-  constructor(budget: CostBudget) {
-    this.budget = budget;
-  }
-
-  trackCost(agentId: string, amount: number): void {
-    const current = this.agentCosts.get(agentId) ?? 0;
-    this.agentCosts.set(agentId, current + amount);
-  }
-
-  getTotalCost(): number {
-    let total = 0;
-    for (const cost of this.agentCosts.values()) {
-      total += cost;
-    }
-    return total;
-  }
-
-  getAgentCost(agentId: string): number {
-    return this.agentCosts.get(agentId) ?? 0;
-  }
-
-  checkBudget(): BudgetCheckResult {
-    const totalCost = this.getTotalCost();
-    const budgetRemaining = this.budget.maxPerRun - totalCost;
-    const alertLimit = this.budget.maxPerRun * this.budget.alertThreshold;
-
-    let status: 'ok' | 'alert' | 'exceeded';
-    if (totalCost >= this.budget.maxPerRun) {
-      status = 'exceeded';
-    } else if (totalCost >= alertLimit) {
-      status = 'alert';
-    } else {
-      status = 'ok';
-    }
-
-    return { status, totalCost, budgetRemaining };
-  }
-
-  isAgentOverBudget(agentId: string): boolean {
-    return this.getAgentCost(agentId) >= this.budget.maxPerAgent;
-  }
-}

package/core/evidence.ts

@@ -1,132 +0,0 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import type { AgentResult, Finding, FindingType, Phase } from './types';
-
-const SUBDIRS = [
-  'agent-results',
-  'findings/test-bugs',
-  'findings/code-bugs',
-  'evidence/screenshots',
-  'evidence/logs',
-  'evidence/reports',
-];
-
-/**
- * Creates the canonical `.run/{runId}/` directory structure.
- * Safe to call multiple times — uses `{ recursive: true }`.
- */
-export async function initRunDirectory(runDir: string): Promise<void> {
-  for (const subdir of SUBDIRS) {
-    await fs.mkdir(path.join(runDir, subdir), { recursive: true });
-  }
-}
-
-/**
- * Writes an AgentResult as JSON to `agent-results/{agentId}.json`.
- * Creates the parent directory lazily if it does not yet exist.
- */
-export async function writeAgentResult(
-  runDir: string,
-  agentId: number,
-  result: AgentResult,
-): Promise<void> {
-  const dir = path.join(runDir, 'agent-results');
-  await fs.mkdir(dir, { recursive: true });
-  await fs.writeFile(path.join(dir, `${agentId}.json`), JSON.stringify(result, null, 2), 'utf-8');
-}
-
-/**
- * Reads an AgentResult from `agent-results/{agentId}.json`.
- * Returns `null` when the file does not exist.
- */
-export async function readAgentResult(
-  runDir: string,
-  agentId: number,
-): Promise<AgentResult | null> {
-  const filePath = path.join(runDir, 'agent-results', `${agentId}.json`);
-  try {
-    const raw = await fs.readFile(filePath, 'utf-8');
-    return JSON.parse(raw) as AgentResult;
-  } catch (err: unknown) {
-    if (isNodeError(err) && err.code === 'ENOENT') {
-      return null;
-    }
-    throw err;
-  }
-}
-
-/**
- * Determines the findings subdirectory for a given FindingType.
- *
- * - `test-bug`            → `findings/test-bugs/`
- * - `code-bug-*`          → `findings/code-bugs/`
- * - `infra-issue`         → `findings/code-bugs/`
- */
-function findingSubdir(type: FindingType): string {
-  if (type === 'test-bug') {
-    return 'findings/test-bugs';
-  }
-  return 'findings/code-bugs';
-}
-
-/**
- * Writes a Finding as JSON to the appropriate subdirectory.
- * Creates the target directory lazily if it does not yet exist.
- */
-export async function writeFinding(runDir: string, finding: Finding): Promise<void> {
-  const dir = path.join(runDir, findingSubdir(finding.type));
-  await fs.mkdir(dir, { recursive: true });
-  await fs.writeFile(
-    path.join(dir, `${finding.id}.json`),
-    JSON.stringify(finding, null, 2),
-    'utf-8',
-  );
-}
-
-/**
- * Moves all files currently in `agent-results/` to
- * `archive/attempt-{attempt}/` and empties the source directory.
- * Is a no-op when `agent-results/` is empty or does not exist.
- */
-export async function archivePhaseResults(
-  runDir: string,
-  phase: Phase,
-  attempt: number,
-): Promise<void> {
-  const sourceDir = path.join(runDir, 'agent-results');
-
-  let entries: string[];
-  try {
-    entries = await fs.readdir(sourceDir);
-  } catch (err: unknown) {
-    if (isNodeError(err) && err.code === 'ENOENT') {
-      return;
-    }
-    throw err;
-  }
-
-  if (entries.length === 0) {
-    return;
-  }
-
-  const destDir = path.join(runDir, 'archive', `${phase}-attempt-${attempt}`);
-  await fs.mkdir(destDir, { recursive: true });
-
-  await Promise.all(
-    entries.map((entry) =>
-      fs.rename(path.join(sourceDir, entry), path.join(destDir, entry)),
-    ),
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-interface NodeError extends Error {
-  code: string;
-}
-
-function isNodeError(err: unknown): err is NodeError {
-  return err instanceof Error && 'code' in err;
-}

package/core/fix-loop.ts

@@ -1,85 +0,0 @@
-import type { Finding, FindingType, Phase } from './types';
-
-const SECURITY_KEYWORDS = ['xss', 'injection', 'csrf', 'auth-bypass', 'exposure'] as const;
-const COSMETIC_KEYWORDS = ['css', 'aria', 'i18n', 'link', 'alt-text'] as const;
-
-function isInTestFile(filePath: string): boolean {
-  return filePath.includes('/tests/');
-}
-
-function hasKeyword(description: string, keywords: readonly string[]): boolean {
-  const lower = description.toLowerCase();
-  return keywords.some((keyword) => lower.includes(keyword));
-}
-
-/**
- * Classifies a finding based on its file location and description keywords.
- *
- * Priority order:
- * 1. Test file with unchanged source → test-bug
- * 2. Security keyword in description → code-bug-security
- * 3. Cosmetic keyword in description → code-bug-cosmetic
- * 4. Fallback → code-bug-logic
- */
-export function classifyFinding(finding: Finding, changedFiles: string[]): FindingType {
-  const filePath = finding.file ?? '';
-
-  if (filePath !== '' && isInTestFile(filePath) && !changedFiles.includes(filePath)) {
-    return 'test-bug';
-  }
-
-  if (hasKeyword(finding.description, SECURITY_KEYWORDS)) {
-    return 'code-bug-security';
-  }
-
-  if (hasKeyword(finding.description, COSMETIC_KEYWORDS)) {
-    return 'code-bug-cosmetic';
-  }
-
-  return 'code-bug-logic';
-}
-
-/**
- * Determines whether a finding should be automatically committed without human intervention.
- *
- * UAT phase never auto-commits regardless of finding type.
- * Test bugs always auto-commit (routed to the Healer agent).
- * Cosmetic bugs auto-commit in alpha and beta only.
- * Logic and security bugs never auto-commit (require human gates).
- */
-export function shouldAutoCommit(findingType: FindingType, phase: Phase): boolean {
-  // Test bugs always auto-commit — routed to the Healer agent regardless of phase
-  if (findingType === 'test-bug') {
-    return true;
-  }
-
-  // UAT requires human review for all non-test-bug finding types
-  if (phase === 'uat') {
-    return false;
-  }
-
-  if (findingType === 'code-bug-cosmetic') {
-    return phase === 'alpha' || phase === 'beta';
-  }
-
-  return false;
-}
-
-/**
- * Determines whether a finding requires human review before any action is taken.
- *
- * Security and logic bugs always require human review.
- * UAT phase requires human review for all finding types.
- * Cosmetic bugs and test bugs in alpha/beta do not require human review.
- */
-export function shouldRequireHumanReview(findingType: FindingType, phase: Phase): boolean {
-  if (findingType === 'code-bug-security' || findingType === 'code-bug-logic') {
-    return true;
-  }
-
-  if (phase === 'uat') {
-    return true;
-  }
-
-  return false;
-}

package/core/health-check.ts

@@ -1,54 +0,0 @@
-export interface HealthCheck {
-  name: string;
-  check: () => Promise<boolean>;
-  required: boolean;
-}
-
-export interface HealthCheckResult {
-  name: string;
-  passed: boolean;
-  required: boolean;
-  error?: string;
-  durationMs: number;
-}
-
-export interface HealthCheckSummary {
-  canProceed: boolean;
-  results: HealthCheckResult[];
-  warnings: string[];
-}
-
-export async function runHealthChecks({
-  checks,
-}: {
-  checks: HealthCheck[];
-}): Promise<HealthCheckSummary> {
-  const results: HealthCheckResult[] = [];
-  const warnings: string[] = [];
-
-  for (const { name, check, required } of checks) {
-    const start = Date.now();
-    let passed = false;
-    let error: string | undefined;
-
-    try {
-      passed = await check();
-    } catch (err) {
-      passed = false;
-      error = err instanceof Error ? err.message : String(err);
-    }
-
-    const durationMs = Date.now() - start;
-    results.push({ name, passed, required, error, durationMs });
-
-    if (!passed && !required) {
-      warnings.push(`Optional check '${name}' failed`);
-    }
-  }
-
-  const canProceed = results
-    .filter((r) => r.required)
-    .every((r) => r.passed);
-
-  return { canProceed, results, warnings };
-}