agent-gauntlet 0.10.0 → 0.11.0

package/src/core/runner.ts

@@ -1,290 +0,0 @@
-import type {
-	LoadedCheckGateConfig,
-	LoadedConfig,
-	LoadedReviewGateConfig,
-} from "../config/types.js";
-import { CheckGateExecutor } from "../gates/check.js";
-import type { GateResult } from "../gates/result.js";
-import { ReviewGateExecutor } from "../gates/review.js";
-import type { ConsoleReporter } from "../output/console.js";
-import type { Logger } from "../output/logger.js";
-import type { DebugLogger } from "../utils/debug-log.js";
-import type { PreviousViolation } from "../utils/log-parser.js";
-import { sanitizeJobId } from "../utils/sanitizer.js";
-import type { Job } from "./job.js";
-
-/**
- * Iteration statistics for RUN_END logging.
- */
-export interface IterationStats {
-	/** Number of violations marked as fixed */
-	fixed: number;
-	/** Number of violations marked as skipped */
-	skipped: number;
-	/** Number of remaining active violations (failures) */
-	failed: number;
-}
-
-/**
- * Structured result from Runner.run() for proper status mapping.
- */
-export interface RunnerOutcome {
-	/** Whether all gates passed */
-	allPassed: boolean;
-	/** Whether any violations were skipped (for passed_with_warnings) */
-	anySkipped: boolean;
-	/** Whether retry limit was exceeded */
-	retryLimitExceeded: boolean;
-	/** Whether any gates had errors */
-	anyErrors: boolean;
-	/** Iteration statistics for debug logging */
-	stats: IterationStats;
-	/** Individual gate results */
-	gateResults: GateResult[];
-}
-
-/**
- * Calculate iteration statistics from gate results.
- * Aggregates fixed, skipped, and failed counts from all results and subResults.
- * For CHECK gates that don't set errorCount, count failed/error status as 1 failure.
- */
-function calculateStats(results: GateResult[]): IterationStats {
-	let fixed = 0;
-	let skipped = 0;
-	let failed = 0;
-
-	for (const result of results) {
-		// Count from top-level result
-		if (result.fixedCount) fixed += result.fixedCount;
-		if (result.skipped) skipped += result.skipped.length;
-
-		// For failed gates, use errorCount if set, otherwise count as 1 failure
-		// This handles CHECK gates which only set status but not errorCount
-		if (result.errorCount) {
-			failed += result.errorCount;
-		} else if (result.status === "fail" || result.status === "error") {
-			failed += 1;
-		}
-
-		// Count from subResults (review gates)
-		if (result.subResults) {
-			for (const sub of result.subResults) {
-				if (sub.fixedCount) fixed += sub.fixedCount;
-				if (sub.skipped) skipped += sub.skipped.length;
-
-				if (sub.errorCount) {
-					failed += sub.errorCount;
-				} else if (sub.status === "fail" || sub.status === "error") {
-					failed += 1;
-				}
-			}
-		}
-	}
-
-	return { fixed, skipped, failed };
-}
-
-export class Runner {
-	private checkExecutor = new CheckGateExecutor();
-	private reviewExecutor = new ReviewGateExecutor();
-	private results: GateResult[] = [];
-	private shouldStop = false;
-
-	constructor(
-		private config: LoadedConfig,
-		private logger: Logger,
-		private reporter: ConsoleReporter,
-		private previousFailuresMap?: Map<string, Map<string, PreviousViolation[]>>,
-		private changeOptions?: { commit?: string; uncommitted?: boolean },
-		private baseBranchOverride?: string,
-		private passedSlotsMap?: Map<
-			string,
-			Map<number, { adapter: string; passIteration: number }>
-		>,
-		private debugLogger?: DebugLogger,
-		private isRerun?: boolean,
-	) {}
-
-	async run(jobs: Job[]): Promise<RunnerOutcome> {
-		// Note: logger.init() is called by the caller (run-executor, check, review)
-		// before startConsoleLog to ensure unified numbering
-
-		// Enforce retry limit before executing gates
-		const maxRetries = this.config.project.max_retries ?? 3;
-		const currentRunNumber = this.logger.getRunNumber();
-		const maxAllowedRuns = maxRetries + 1;
-
-		if (currentRunNumber > maxAllowedRuns) {
-			console.error(
-				`Retry limit exceeded: run ${currentRunNumber} exceeds max allowed ${maxAllowedRuns} (max_retries: ${maxRetries}). Human input required on what to do next.`,
-			);
-			process.exitCode = 1;
-			return {
-				allPassed: false,
-				anySkipped: false,
-				retryLimitExceeded: true,
-				anyErrors: false,
-				stats: { fixed: 0, skipped: 0, failed: 0 },
-				gateResults: [],
-			};
-		}
-
-		const parallelEnabled = this.config.project.allow_parallel;
-		const parallelJobs = parallelEnabled
-			? jobs.filter((j) => j.gateConfig.parallel)
-			: [];
-		const sequentialJobs = parallelEnabled
-			? jobs.filter((j) => !j.gateConfig.parallel)
-			: jobs;
-
-		// Start parallel jobs
-		const parallelPromises = parallelJobs.map((job) => this.executeJob(job));
-
-		// Start sequential jobs
-		const sequentialPromise = (async () => {
-			for (const job of sequentialJobs) {
-				if (this.shouldStop) break;
-				await this.executeJob(job);
-			}
-		})();
-
-		await Promise.all([...parallelPromises, sequentialPromise]);
-
-		const allPassed = this.results.every((r) => r.status === "pass");
-		const anySkipped = this.results.some(
-			(r) => r.skipped && r.skipped.length > 0,
-		);
-		const anyErrors = this.results.some((r) => r.status === "error");
-		const retryLimitExceeded =
-			!allPassed && currentRunNumber === maxAllowedRuns;
-
-		// Calculate statistics from results
-		const stats = calculateStats(this.results);
-
-		// If on the final allowed run and gates failed, report "Retry limit exceeded"
-		if (retryLimitExceeded) {
-			await this.reporter.printSummary(
-				this.results,
-				this.config.project.log_dir,
-				"Retry limit exceeded",
-			);
-			return {
-				allPassed: false,
-				anySkipped,
-				retryLimitExceeded: true,
-				anyErrors,
-				stats,
-				gateResults: this.results,
-			};
-		}
-
-		await this.reporter.printSummary(this.results, this.config.project.log_dir);
-
-		return {
-			allPassed,
-			anySkipped,
-			retryLimitExceeded: false,
-			anyErrors,
-			stats,
-			gateResults: this.results,
-		};
-	}
-
-	private async executeJob(job: Job): Promise<void> {
-		if (this.shouldStop) return;
-
-		this.reporter.onJobStart(job);
-
-		let result: GateResult;
-
-		const effectiveBaseBranch =
-			this.baseBranchOverride || this.config.project.base_branch;
-
-		try {
-			if (job.type === "check") {
-				const logPath = await this.logger.getLogPath(job.id);
-				const jobLogger = await this.logger.createJobLogger(job.id);
-				result = await this.checkExecutor.execute(
-					job.id,
-					job.gateConfig as LoadedCheckGateConfig,
-					job.workingDirectory,
-					jobLogger,
-					{ baseBranch: effectiveBaseBranch, isRerun: this.isRerun },
-				);
-				result.logPath = logPath;
-			} else {
-				// Use sanitized Job ID for lookup because that's what log-parser uses (based on filenames)
-				const safeJobId = sanitizeJobId(job.id);
-				result = await this.reviewExecutor.execute(
-					job.id,
-					job.gateConfig as LoadedReviewGateConfig,
-					job.entryPoint,
-					this.logger.createLoggerFactory(job.id),
-					effectiveBaseBranch,
-					this.previousFailuresMap?.get(safeJobId),
-					this.changeOptions,
-					this.config.project.rerun_new_issue_threshold,
-					this.passedSlotsMap?.get(safeJobId),
-					this.config.project.log_dir,
-					this.config.project.cli?.adapters,
-				);
-			}
-		} catch (err) {
-			console.error("[ERROR] Execution failed for", job.id, ":", err);
-			result = {
-				jobId: job.id,
-				status: "error",
-				duration: 0,
-				message: err instanceof Error ? err.message : String(err),
-			};
-		}
-
-		this.results.push(result);
-		this.reporter.onJobComplete(job, result);
-		await this.logGateResults(job.id, result);
-
-		this.checkFailFast(job, result);
-	}
-
-	private checkFailFast(job: Job, result: GateResult): void {
-		if (result.status === "pass") return;
-		if (job.type !== "check") return;
-
-		// We know it's a check gate, so cast to check config to access fail_fast safely
-		const config = job.gateConfig as LoadedCheckGateConfig;
-		if (config.fail_fast) {
-			this.shouldStop = true;
-		}
-	}
-
-	/**
-	 * Log gate results to the debug log.
-	 * For review gates with subResults, logs one entry per reviewer.
-	 * For check gates, logs a single entry.
-	 */
-	private async logGateResults(
-		jobId: string,
-		result: GateResult,
-	): Promise<void> {
-		if (!this.debugLogger) return;
-
-		if (result.subResults && result.subResults.length > 0) {
-			for (const sub of result.subResults) {
-				const cli = sub.nameSuffix.match(/\((.+?)@\d+\)/)?.[1];
-				await this.debugLogger.logGateResult(
-					jobId,
-					sub.status,
-					sub.duration ?? result.duration,
-					{ violations: sub.errorCount, cli },
-				);
-			}
-		} else {
-			await this.debugLogger.logGateResult(
-				jobId,
-				result.status,
-				result.duration,
-				{ violations: result.errorCount },
-			);
-		}
-	}
-}

package/src/gates/check.ts

@@ -1,118 +0,0 @@
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-import type { LoadedCheckGateConfig } from "../config/types.js";
-import { resolveCheckCommand } from "./resolve-check-command.js";
-import type { GateResult } from "./result.js";
-
-const execAsync = promisify(exec);
-const MAX_BUFFER_BYTES = 10 * 1024 * 1024;
-
-export class CheckGateExecutor {
-	async execute(
-		jobId: string,
-		config: LoadedCheckGateConfig,
-		workingDirectory: string,
-		logger: (output: string) => Promise<void>,
-		options?: { baseBranch?: string; isRerun?: boolean },
-	): Promise<GateResult> {
-		const startTime = Date.now();
-
-		const command = resolveCheckCommand(config, options);
-
-		try {
-			await logger(
-				`[${new Date().toISOString()}] Starting check: ${config.name}\n`,
-			);
-			await logger(`Executing command: ${command}\n`);
-			await logger(`Working directory: ${workingDirectory}\n\n`);
-
-			const { stdout, stderr } = await execAsync(command, {
-				cwd: workingDirectory,
-				timeout: config.timeout ? config.timeout * 1000 : undefined,
-				maxBuffer: MAX_BUFFER_BYTES,
-			});
-
-			if (stdout) await logger(stdout);
-			if (stderr) await logger(`\nSTDERR:\n${stderr}`);
-
-			const result: GateResult = {
-				jobId,
-				status: "pass",
-				duration: Date.now() - startTime,
-				message: "Command exited with code 0",
-			};
-
-			await logger(`Result: ${result.status} - ${result.message}\n`);
-			return result;
-		} catch (error: unknown) {
-			const err = error as {
-				stdout?: string;
-				stderr?: string;
-				message?: string;
-				signal?: string;
-				code?: number;
-			};
-			if (err.stdout) await logger(err.stdout);
-			if (err.stderr) await logger(`\nSTDERR:\n${err.stderr}`);
-
-			await logger(`\nCommand failed: ${err.message}`);
-
-			// If it's a timeout
-			if (err.signal === "SIGTERM" && config.timeout) {
-				const result: GateResult = {
-					jobId,
-					status: "fail",
-					duration: Date.now() - startTime,
-					message: `Timed out after ${config.timeout}s`,
-					fixInstructions: config.fixInstructionsContent,
-					fixWithSkill: config.fixWithSkill,
-				};
-				await logger(`Result: ${result.status} - ${result.message}\n`);
-				await this.logFixInfo(config, logger);
-				return result;
-			}
-
-			// If it's a non-zero exit code
-			if (typeof err.code === "number") {
-				const result: GateResult = {
-					jobId,
-					status: "fail",
-					duration: Date.now() - startTime,
-					message: `Exited with code ${err.code}`,
-					fixInstructions: config.fixInstructionsContent,
-					fixWithSkill: config.fixWithSkill,
-				};
-				await logger(`Result: ${result.status} - ${result.message}\n`);
-				await this.logFixInfo(config, logger);
-				return result;
-			}
-
-			// Other errors
-			const result: GateResult = {
-				jobId,
-				status: "error",
-				duration: Date.now() - startTime,
-				message: err.message || "Unknown error",
-				fixInstructions: config.fixInstructionsContent,
-				fixWithSkill: config.fixWithSkill,
-			};
-			await logger(`Result: ${result.status} - ${result.message}\n`);
-			await this.logFixInfo(config, logger);
-			return result;
-		}
-	}
-
-	private async logFixInfo(
-		config: LoadedCheckGateConfig,
-		logger: (output: string) => Promise<void>,
-	): Promise<void> {
-		if (config.fixInstructionsContent) {
-			await logger(
-				`\n--- Fix Instructions ---\n${config.fixInstructionsContent}\n`,
-			);
-		}
-		if (config.fixWithSkill) {
-			await logger(`\n--- Fix Skill: ${config.fixWithSkill} ---\n`);
-		}
-	}
-}

package/src/gates/resolve-check-command.ts

@@ -1,21 +0,0 @@
-import type { LoadedCheckGateConfig } from "../config/types.js";
-
-/**
- * Resolves which command to execute for a check gate, selecting rerun_command
- * when in rerun mode and performing variable substitution.
- */
-export function resolveCheckCommand(
-	config: Pick<LoadedCheckGateConfig, "command" | "rerun_command">,
-	options?: { baseBranch?: string; isRerun?: boolean },
-): string {
-	const rawCommand =
-		options?.isRerun && config.rerun_command
-			? config.rerun_command
-			: config.command;
-	let result = rawCommand;
-	const baseBranch = options?.baseBranch;
-	if (baseBranch) {
-		result = result.replace(/\$\{BASE_BRANCH\}/g, () => baseBranch);
-	}
-	return result;
-}

package/src/gates/result.ts

@@ -1,54 +0,0 @@
-export type GateStatus = "pass" | "fail" | "error";
-
-export interface PreviousViolation {
-	file: string;
-	line: number | string;
-	issue: string;
-	fix?: string;
-	priority?: "critical" | "high" | "medium" | "low";
-	status?: "new" | "fixed" | "skipped";
-	result?: string | null;
-}
-
-export interface ReviewFullJsonOutput {
-	adapter: string;
-	timestamp: string;
-	status: "pass" | "fail" | "error" | "skipped_prior_pass";
-	rawOutput: string;
-	violations: PreviousViolation[];
-	passIteration?: number; // Only present when status is "skipped_prior_pass"
-}
-
-export interface GateResult {
-	jobId: string;
-	status: GateStatus;
-	duration: number; // ms
-	message?: string; // summary message
-	logPath?: string; // path to full log
-	logPaths?: string[]; // paths to multiple logs (e.g. per-agent logs)
-	fixInstructions?: string; // Markdown content for fixing failures
-	fixWithSkill?: string; // CLI skill name for fixing failures
-	errorCount?: number; // Number of active failures/violations
-	fixedCount?: number; // Number of violations marked as fixed
-	skipped?: Array<{
-		file: string;
-		line: number | string;
-		issue: string;
-		result?: string | null;
-	}>;
-	subResults?: Array<{
-		nameSuffix: string;
-		status: GateStatus;
-		duration?: number; // per-reviewer timing in ms
-		message: string;
-		logPath?: string;
-		errorCount?: number;
-		fixedCount?: number;
-		skipped?: Array<{
-			file: string;
-			line: number | string;
-			issue: string;
-			result?: string | null;
-		}>;
-	}>;
-}