@avi770/testteam 1.2.0

package/core/evidence.ts

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

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

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