agent-gauntlet 0.10.0 → 0.11.0

package/src/commands/list.ts

@@ -1,33 +0,0 @@
-import chalk from "chalk";
-import type { Command } from "commander";
-import { loadConfig } from "../config/loader.js";
-
-export function registerListCommand(program: Command): void {
-	program
-		.command("list")
-		.description("List configured gates")
-		.action(async () => {
-			try {
-				const config = await loadConfig();
-				console.log(chalk.bold("Check Gates:"));
-				Object.values(config.checks).forEach((c) => {
-					console.log(` - ${c.name}`);
-				});
-
-				console.log(chalk.bold("\nReview Gates:"));
-				Object.values(config.reviews).forEach((r) => {
-					console.log(` - ${r.name} (Tools: ${r.cli_preference?.join(", ")})`);
-				});
-
-				console.log(chalk.bold("\nEntry Points:"));
-				config.project.entry_points.forEach((ep) => {
-					console.log(` - ${ep.path}`);
-					if (ep.checks) console.log(`   Checks: ${ep.checks.join(", ")}`);
-					if (ep.reviews) console.log(`   Reviews: ${ep.reviews.join(", ")}`);
-				});
-			} catch (error: unknown) {
-				const err = error as { message?: string };
-				console.error(chalk.red("Error:"), err.message);
-			}
-		});
-}

package/src/commands/review.ts

@@ -1,311 +0,0 @@
-import chalk from "chalk";
-import type { Command } from "commander";
-import { loadGlobalConfig } from "../config/global.js";
-import { loadConfig } from "../config/loader.js";
-import { ChangeDetector } from "../core/change-detector.js";
-import { EntryPointExpander } from "../core/entry-point.js";
-import { JobGenerator } from "../core/job.js";
-import { Runner } from "../core/runner.js";
-import { ConsoleReporter } from "../output/console.js";
-import {
-	type ConsoleLogHandle,
-	startConsoleLog,
-} from "../output/console-log.js";
-import { Logger } from "../output/logger.js";
-import {
-	getDebugLogger,
-	initDebugLogger,
-	mergeDebugLogConfig,
-} from "../utils/debug-log.js";
-import {
-	readExecutionState,
-	resolveFixBase,
-	writeExecutionState,
-} from "../utils/execution-state.js";
-import {
-	findPreviousFailures,
-	type PassedSlot,
-	type PreviousViolation,
-} from "../utils/log-parser.js";
-import {
-	acquireLock,
-	cleanLogs,
-	hasExistingLogs,
-	performAutoClean,
-	releaseLock,
-	shouldAutoClean,
-} from "./shared.js";
-
-export function registerReviewCommand(program: Command): void {
-	program
-		.command("review")
-		.description("Run only applicable reviews for detected changes")
-		.option(
-			"-b, --base-branch <branch>",
-			"Override base branch for change detection",
-		)
-		.option("-g, --gate <name>", "Run specific review gate only")
-		.option("-c, --commit <sha>", "Use diff for a specific commit")
-		.option(
-			"-u, --uncommitted",
-			"Use diff for current uncommitted changes (staged and unstaged)",
-		)
-		.action(async (options) => {
-			let config: Awaited<ReturnType<typeof loadConfig>> | undefined;
-			let lockAcquired = false;
-			let restoreConsole: ConsoleLogHandle | undefined;
-			try {
-				config = await loadConfig();
-
-				// Initialize debug logger
-				const globalConfig = await loadGlobalConfig();
-				const debugLogConfig = mergeDebugLogConfig(
-					config.project.debug_log,
-					globalConfig.debug_log,
-				);
-				initDebugLogger(config.project.log_dir, debugLogConfig);
-
-				// Log the command invocation
-				const debugLogger = getDebugLogger();
-				const args = [
-					options.baseBranch ? `-b ${options.baseBranch}` : "",
-					options.gate ? `-g ${options.gate}` : "",
-					options.commit ? `-c ${options.commit}` : "",
-					options.uncommitted ? "-u" : "",
-				].filter(Boolean);
-				await debugLogger?.logCommand("review", args);
-
-				// Determine effective base branch first (needed for auto-clean)
-				const effectiveBaseBranch =
-					options.baseBranch ||
-					(process.env.GITHUB_BASE_REF &&
-					(process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true")
-						? process.env.GITHUB_BASE_REF
-						: null) ||
-					config.project.base_branch;
-
-				// Auto-clean on context change (branch changed, commit merged)
-				const autoCleanResult = await shouldAutoClean(
-					config.project.log_dir,
-					effectiveBaseBranch,
-				);
-				if (autoCleanResult.clean) {
-					console.log(
-						chalk.dim(`Auto-cleaning logs (${autoCleanResult.reason})...`),
-					);
-					await debugLogger?.logClean(
-						"auto",
-						autoCleanResult.reason || "unknown",
-					);
-					await performAutoClean(config.project.log_dir, autoCleanResult);
-				}
-
-				// Detect rerun mode after auto-clean (clean may have removed logs)
-				const logsExist = await hasExistingLogs(config.project.log_dir);
-				const isRerun = logsExist && !options.commit;
-
-				// Acquire lock BEFORE starting console log (prevents orphaned log files)
-				await acquireLock(config.project.log_dir);
-				lockAcquired = true;
-
-				// Initialize Logger early to get unified run number for console log
-				const logger = new Logger(config.project.log_dir);
-				await logger.init();
-				const runNumber = logger.getRunNumber();
-
-				restoreConsole = await startConsoleLog(
-					config.project.log_dir,
-					runNumber,
-				);
-
-				let failuresMap:
-					| Map<string, Map<string, PreviousViolation[]>>
-					| undefined;
-				let changeOptions:
-					| { commit?: string; uncommitted?: boolean; fixBase?: string }
-					| undefined;
-
-				let passedSlotsMap: Map<string, Map<number, PassedSlot>> | undefined;
-
-				if (isRerun) {
-					console.log(
-						chalk.dim(
-							"Existing logs detected — running in verification mode...",
-						),
-					);
-					const { failures: previousFailures, passedSlots } =
-						await findPreviousFailures(
-							config.project.log_dir,
-							options.gate,
-							true,
-						);
-
-					failuresMap = new Map();
-					for (const gateFailure of previousFailures) {
-						const adapterMap = new Map<string, PreviousViolation[]>();
-						for (const af of gateFailure.adapterFailures) {
-							const key = af.reviewIndex
-								? String(af.reviewIndex)
-								: af.adapterName;
-							adapterMap.set(key, af.violations);
-						}
-						failuresMap.set(gateFailure.jobId, adapterMap);
-					}
-
-					passedSlotsMap = passedSlots;
-
-					if (previousFailures.length > 0) {
-						const totalViolations = previousFailures.reduce(
-							(sum, gf) =>
-								sum +
-								gf.adapterFailures.reduce(
-									(s, af) => s + af.violations.length,
-									0,
-								),
-							0,
-						);
-						console.log(
-							chalk.yellow(
-								`Found ${previousFailures.length} gate(s) with ${totalViolations} previous violation(s)`,
-							),
-						);
-					}
-
-					changeOptions = { uncommitted: true };
-					// Use working_tree_ref from execution state for rerun diff scoping
-					const executionState = await readExecutionState(
-						config.project.log_dir,
-					);
-					if (executionState?.working_tree_ref) {
-						changeOptions.fixBase = executionState.working_tree_ref;
-					}
-				} else if (!logsExist) {
-					// Post-clean run: check if execution state has a working_tree_ref to use as fixBase
-					const executionState = await readExecutionState(
-						config.project.log_dir,
-					);
-					if (executionState) {
-						const resolved = await resolveFixBase(
-							executionState,
-							effectiveBaseBranch,
-						);
-						if (resolved.warning) {
-							console.log(chalk.yellow(`Warning: ${resolved.warning}`));
-						}
-						if (resolved.fixBase) {
-							changeOptions = { fixBase: resolved.fixBase };
-						}
-					}
-				}
-
-				// Allow explicit commit or uncommitted options to override fixBase
-				if (options.commit || options.uncommitted) {
-					changeOptions = {
-						commit: options.commit,
-						uncommitted: options.uncommitted,
-						fixBase: changeOptions?.fixBase,
-					};
-				}
-
-				const changeDetector = new ChangeDetector(
-					effectiveBaseBranch,
-					changeOptions || {
-						commit: options.commit,
-						uncommitted: options.uncommitted,
-					},
-				);
-				const expander = new EntryPointExpander();
-				const jobGen = new JobGenerator(config);
-
-				console.log(chalk.dim("Detecting changes..."));
-				const changes = await changeDetector.getChangedFiles();
-
-				if (changes.length === 0) {
-					console.log(chalk.green("No changes detected."));
-					await writeExecutionState(config.project.log_dir);
-					await releaseLock(config.project.log_dir);
-					restoreConsole?.restore();
-					process.exit(0);
-				}
-
-				console.log(chalk.dim(`Found ${changes.length} changed files.`));
-
-				const entryPoints = await expander.expand(
-					config.project.entry_points,
-					changes,
-				);
-				let jobs = jobGen.generateJobs(entryPoints);
-
-				// Filter to only reviews
-				jobs = jobs.filter((j) => j.type === "review");
-
-				if (options.gate) {
-					jobs = jobs.filter((j) => j.name === options.gate);
-				}
-
-				if (jobs.length === 0) {
-					console.log(chalk.yellow("No applicable reviews for these changes."));
-					await writeExecutionState(config.project.log_dir);
-					await releaseLock(config.project.log_dir);
-					restoreConsole?.restore();
-					process.exit(0);
-				}
-
-				console.log(chalk.dim(`Running ${jobs.length} review(s)...`));
-
-				// Log run start
-				const runMode = isRerun ? "verification" : "full";
-				await debugLogger?.logRunStart(runMode, changes.length, jobs.length);
-
-				const reporter = new ConsoleReporter();
-				const runner = new Runner(
-					config,
-					logger,
-					reporter,
-					failuresMap,
-					changeOptions,
-					effectiveBaseBranch,
-					passedSlotsMap,
-					debugLogger ?? undefined,
-					isRerun,
-				);
-
-				const success = await runner.run(jobs);
-
-				// Log run end
-				await debugLogger?.logRunEnd(
-					success ? "pass" : "fail",
-					0,
-					0,
-					0,
-					logger.getRunNumber(),
-				);
-
-				// Write execution state before releasing lock (for interval checks)
-				// This now captures working_tree_ref which is used for rerun diff scoping
-				await writeExecutionState(config.project.log_dir);
-
-				if (success) {
-					await debugLogger?.logClean("auto", "all_passed");
-					await cleanLogs(config.project.log_dir);
-				}
-				await releaseLock(config.project.log_dir);
-				restoreConsole?.restore();
-				process.exit(success ? 0 : 1);
-			} catch (error: unknown) {
-				// Write execution state even on error (if lock was acquired)
-				if (config && lockAcquired) {
-					try {
-						await writeExecutionState(config.project.log_dir);
-					} catch {
-						// Ignore errors writing state during error handling
-					}
-					await releaseLock(config.project.log_dir);
-				}
-				const err = error as { message?: string };
-				console.error(chalk.red("Error:"), err.message);
-				restoreConsole?.restore();
-				process.exit(1);
-			}
-		});
-}

package/src/commands/run.ts

@@ -1,29 +0,0 @@
-import type { Command } from "commander";
-import { executeRun } from "../core/run-executor.js";
-import { isSuccessStatus } from "../types/gauntlet-status.js";
-
-export function registerRunCommand(program: Command): void {
-	program
-		.command("run")
-		.description("Run gates for detected changes")
-		.option(
-			"-b, --base-branch <branch>",
-			"Override base branch for change detection",
-		)
-		.option("-g, --gate <name>", "Run specific gate only")
-		.option("-c, --commit <sha>", "Use diff for a specific commit")
-		.option(
-			"-u, --uncommitted",
-			"Use diff for current uncommitted changes (staged and unstaged)",
-		)
-		.action(async (options) => {
-			const result = await executeRun({
-				baseBranch: options.baseBranch,
-				gate: options.gate,
-				commit: options.commit,
-				uncommitted: options.uncommitted,
-			});
-
-			process.exit(isSuccessStatus(result.status) ? 0 : 1);
-		});
-}

package/src/commands/shared.ts

@@ -1,267 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import {
-	getDebugLogBackupFilename,
-	getDebugLogFilename,
-} from "../utils/debug-log.js";
-import {
-	deleteExecutionState,
-	getCurrentBranch,
-	getExecutionStateFilename,
-	isCommitInBranch,
-	readExecutionState,
-} from "../utils/execution-state.js";
-
-const LOCK_FILENAME = ".gauntlet-run.lock";
-const SESSION_REF_FILENAME = ".session_ref";
-
-export interface AutoCleanResult {
-	clean: boolean;
-	reason?: string;
-	resetState?: boolean;
-}
-
-/**
- * Check if logs should be auto-cleaned based on execution context changes.
- * Returns { clean: true, reason, resetState } if context has changed.
- * Returns { clean: false } if context is unchanged or state file doesn't exist.
- * When resetState is true, the execution state should be deleted (not just logs).
- */
-export async function shouldAutoClean(
-	logDir: string,
-	baseBranch: string,
-): Promise<AutoCleanResult> {
-	const state = await readExecutionState(logDir);
-
-	// No state file = no auto-clean needed
-	if (!state) {
-		return { clean: false };
-	}
-
-	// Check if branch changed
-	try {
-		const currentBranch = await getCurrentBranch();
-		if (currentBranch !== state.branch) {
-			return { clean: true, reason: "branch changed", resetState: true };
-		}
-	} catch {
-		// If we can't get the current branch, don't auto-clean
-		return { clean: false };
-	}
-
-	// Check if commit was merged into base branch
-	try {
-		const isMerged = await isCommitInBranch(state.commit, baseBranch);
-		if (isMerged) {
-			return { clean: true, reason: "commit merged", resetState: true };
-		}
-	} catch {
-		// If we can't check merge status, don't auto-clean
-	}
-
-	return { clean: false };
-}
-
-/**
- * Perform auto-clean with state reset if needed.
- */
-export async function performAutoClean(
-	logDir: string,
-	result: AutoCleanResult,
-	maxPreviousLogs = 3,
-): Promise<void> {
-	await cleanLogs(logDir, maxPreviousLogs);
-
-	// Delete execution state if context changed (branch changed or commit merged)
-	if (result.resetState) {
-		await deleteExecutionState(logDir);
-	}
-}
-
-/**
- * Get the lock filename constant.
- * Useful for checking lock status from other modules.
- */
-export function getLockFilename(): string {
-	return LOCK_FILENAME;
-}
-
-export async function exists(filePath: string): Promise<boolean> {
-	try {
-		await fs.stat(filePath);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-export async function acquireLock(logDir: string): Promise<void> {
-	await fs.mkdir(logDir, { recursive: true });
-	const lockPath = path.resolve(logDir, LOCK_FILENAME);
-	try {
-		await fs.writeFile(lockPath, String(process.pid), { flag: "wx" });
-	} catch (err: unknown) {
-		if (
-			typeof err === "object" &&
-			err !== null &&
-			"code" in err &&
-			(err as { code: string }).code === "EEXIST"
-		) {
-			console.error(
-				`Error: A gauntlet run is already in progress (lock file: ${lockPath}).`,
-			);
-			console.error(
-				"If no run is actually in progress, delete the lock file manually.",
-			);
-			process.exit(1);
-		}
-		throw err;
-	}
-}
-
-export async function releaseLock(logDir: string): Promise<void> {
-	const lockPath = path.resolve(logDir, LOCK_FILENAME);
-	try {
-		await fs.rm(lockPath, { force: true });
-	} catch {
-		// no-op if missing
-	}
-}
-
-export async function hasExistingLogs(logDir: string): Promise<boolean> {
-	try {
-		const entries = await fs.readdir(logDir);
-		return entries.some(
-			(f) =>
-				(f.endsWith(".log") || f.endsWith(".json")) &&
-				f !== "previous" &&
-				!f.startsWith("console.") &&
-				!f.startsWith("."),
-		);
-	} catch {
-		return false;
-	}
-}
-
-/**
- * Get the set of persistent files that should never be moved during clean.
- */
-/**
- * Marker file used by stop-hook to detect nested invocations.
- * Must match STOP_HOOK_MARKER_FILE in stop-hook.ts.
- */
-const STOP_HOOK_MARKER_FILE = ".stop-hook-active";
-
-function getPersistentFiles(): Set<string> {
-	return new Set([
-		getExecutionStateFilename(),
-		getDebugLogFilename(),
-		getDebugLogBackupFilename(),
-		LOCK_FILENAME,
-		SESSION_REF_FILENAME, // Will be deleted, not moved
-		STOP_HOOK_MARKER_FILE, // Cleaned up by stop-hook finally block, not cleanLogs
-	]);
-}
-
-/**
- * Check if there are current logs to archive.
- * Returns true if there are .log or .json files in the log directory root.
- * Excludes persistent files (.execution_state, .debug.log, etc.)
- */
-async function hasCurrentLogs(logDir: string): Promise<boolean> {
-	try {
-		const files = await fs.readdir(logDir);
-		const persistentFiles = getPersistentFiles();
-		return files.some(
-			(f) =>
-				(f.endsWith(".log") || f.endsWith(".json")) &&
-				f !== "previous" &&
-				!persistentFiles.has(f),
-		);
-	} catch {
-		return false;
-	}
-}
-
-/** Get current log files (excludes previous dirs and persistent files). */
-function getCurrentLogFiles(files: string[]): string[] {
-	const persistentFiles = getPersistentFiles();
-	return files.filter(
-		(file) => !file.startsWith("previous") && !persistentFiles.has(file),
-	);
-}
-
-/** Delete current logs without archiving (maxPreviousLogs === 0). */
-async function deleteCurrentLogs(logDir: string): Promise<void> {
-	const files = await fs.readdir(logDir);
-	await Promise.all(
-		getCurrentLogFiles(files).map((file) =>
-			fs.rm(path.join(logDir, file), { recursive: true, force: true }),
-		),
-	);
-}
-
-/** Rotate existing previous/ directories to make room for a new archive. */
-async function rotatePreviousDirs(
-	logDir: string,
-	maxPreviousLogs: number,
-): Promise<void> {
-	const oldestSuffix = maxPreviousLogs - 1;
-	const oldestDir =
-		oldestSuffix === 0 ? "previous" : `previous.${oldestSuffix}`;
-	const oldestPath = path.join(logDir, oldestDir);
-	if (await exists(oldestPath)) {
-		await fs.rm(oldestPath, { recursive: true, force: true });
-	}
-
-	for (let i = oldestSuffix - 1; i >= 0; i--) {
-		const fromName = i === 0 ? "previous" : `previous.${i}`;
-		const toName = `previous.${i + 1}`;
-		const fromPath = path.join(logDir, fromName);
-		const toPath = path.join(logDir, toName);
-		if (await exists(fromPath)) {
-			await fs.rename(fromPath, toPath);
-		}
-	}
-}
-
-export async function cleanLogs(
-	logDir: string,
-	maxPreviousLogs = 3,
-): Promise<void> {
-	try {
-		if (!(await exists(logDir))) return;
-		if (!(await hasCurrentLogs(logDir))) return;
-
-		if (maxPreviousLogs === 0) {
-			await deleteCurrentLogs(logDir);
-			return;
-		}
-
-		await rotatePreviousDirs(logDir, maxPreviousLogs);
-
-		const previousDir = path.join(logDir, "previous");
-		await fs.mkdir(previousDir, { recursive: true });
-
-		const files = await fs.readdir(logDir);
-		await Promise.all(
-			getCurrentLogFiles(files).map((file) =>
-				fs.rename(path.join(logDir, file), path.join(previousDir, file)),
-			),
-		);
-
-		// Delete legacy .session_ref if it exists (migration cleanup)
-		try {
-			await fs.rm(path.join(logDir, SESSION_REF_FILENAME), { force: true });
-		} catch {
-			// Ignore errors
-		}
-	} catch (error) {
-		console.warn(
-			"Failed to clean logs in",
-			logDir,
-			":",
-			error instanceof Error ? error.message : error,
-		);
-	}
-}