agent-gauntlet 0.10.0 → 0.11.0

package/src/commands/check.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 registerCheckCommand(program: Command): void {
-	program
-		.command("check")
-		.description("Run only applicable checks for detected changes")
-		.option(
-			"-b, --base-branch <branch>",
-			"Override base branch for change detection",
-		)
-		.option("-g, --gate <name>", "Run specific check 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("check", 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 checks
-				jobs = jobs.filter((j) => j.type === "check");
-
-				if (options.gate) {
-					jobs = jobs.filter((j) => j.name === options.gate);
-				}
-
-				if (jobs.length === 0) {
-					console.log(chalk.yellow("No applicable checks 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} check(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/ci/index.ts

@@ -1,15 +0,0 @@
-import type { Command } from "commander";
-import { initCI } from "./init.js";
-import { listJobs } from "./list-jobs.js";
-
-export function registerCICommand(program: Command): void {
-	const ci = program.command("ci").description("Manage CI integration");
-
-	ci.command("init")
-		.description("Initialize CI workflow and configuration")
-		.action(initCI);
-
-	ci.command("list-jobs")
-		.description("List CI jobs (used by workflow)")
-		.action(listJobs);
-}

package/src/commands/ci/init.ts

@@ -1,96 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import chalk from "chalk";
-import YAML from "yaml";
-import { loadCIConfig } from "../../config/ci-loader.js";
-import type { CIConfig } from "../../config/types.js";
-import workflowTemplate from "../../templates/workflow.yml" with {
-	type: "text",
-};
-
-export async function initCI(): Promise<void> {
-	const workflowDir = path.join(process.cwd(), ".github", "workflows");
-	const workflowPath = path.join(workflowDir, "gauntlet.yml");
-	const gauntletDir = path.join(process.cwd(), ".gauntlet");
-	const ciConfigPath = path.join(gauntletDir, "ci.yml");
-
-	// 1. Ensure .gauntlet/ci.yml exists
-	if (!(await fileExists(ciConfigPath))) {
-		console.log(chalk.yellow("Creating starter .gauntlet/ci.yml..."));
-		await fs.mkdir(gauntletDir, { recursive: true });
-		const starterContent = `# CI Configuration for Agent Gauntlet
-# Define runtimes, services, and which checks to run in CI.
-
-runtimes:
-  # ruby:
-  #   version: "3.3"
-  #   bundler_cache: true
-
-services:
-  # postgres:
-  #   image: postgres:16
-  #   ports: ["5432:5432"]
-
-setup:
-  # - name: Global Setup
-  #   run: echo "Setting up..."
-
-checks:
-  # - name: linter
-  #   requires_runtimes: [ruby]
-`;
-		await fs.writeFile(ciConfigPath, starterContent);
-	} else {
-		console.log(chalk.dim("Found existing .gauntlet/ci.yml"));
-	}
-
-	// 2. Load CI config to get services
-	let ciConfig: CIConfig | undefined;
-	try {
-		ciConfig = await loadCIConfig();
-	} catch (_e) {
-		console.warn(
-			chalk.yellow(
-				"Could not load CI config to inject services. Workflow will have no services defined.",
-			),
-		);
-	}
-
-	// 3. Generate workflow file
-	console.log(chalk.dim(`Generating ${workflowPath}...`));
-	await fs.mkdir(workflowDir, { recursive: true });
-
-	let templateContent = workflowTemplate;
-
-	// Inject services
-	if (ciConfig?.services && Object.keys(ciConfig.services).length > 0) {
-		const servicesYaml = YAML.stringify({ services: ciConfig.services });
-		// Indent services
-		const indentedServices = servicesYaml
-			.split("\n")
-			.map((line) => (line.trim() ? `    ${line}` : line))
-			.join("\n");
-
-		templateContent = templateContent.replace(
-			"    # Services will be injected here by agent-gauntlet",
-			indentedServices,
-		);
-	} else {
-		templateContent = templateContent.replace(
-			"    # Services will be injected here by agent-gauntlet\n",
-			"",
-		);
-	}
-
-	await fs.writeFile(workflowPath, templateContent);
-	console.log(chalk.green("Successfully generated GitHub Actions workflow!"));
-}
-
-async function fileExists(path: string): Promise<boolean> {
-	try {
-		const stat = await fs.stat(path);
-		return stat.isFile();
-	} catch {
-		return false;
-	}
-}

package/src/commands/ci/list-jobs.ts

@@ -1,90 +0,0 @@
-import { loadCIConfig } from "../../config/ci-loader.js";
-import { loadConfig } from "../../config/loader.js";
-import type { CISetupStep } from "../../config/types.js";
-import { EntryPointExpander } from "../../core/entry-point.js";
-
-export async function listJobs(): Promise<void> {
-	try {
-		const config = await loadConfig();
-		const ciConfig = await loadCIConfig();
-		const expander = new EntryPointExpander();
-		const expandedEntryPoints = await expander.expandAll(
-			config.project.entry_points,
-		);
-
-		const matrixJobs = [];
-		const seenJobs = new Set<string>();
-
-		const globalSetup = formatSetup(ciConfig.setup || undefined);
-
-		if (ciConfig.checks) {
-			for (const ep of expandedEntryPoints) {
-				// Get checks enabled for this entry point
-				const allowedChecks = new Set(ep.config.checks || []);
-
-				for (const check of ciConfig.checks) {
-					if (allowedChecks.has(check.name)) {
-						// Check definition from .gauntlet/checks/*.yml
-						const checkDef = config.checks[check.name];
-						if (!checkDef) {
-							console.warn(
-								`Warning: Check '${check.name}' found in CI config but not defined in checks/*.yml`,
-							);
-							continue;
-						}
-
-						const workingDirectory = checkDef.working_directory || ep.path;
-						// Dedupe by check name + working directory only - if two entry points
-						// both trigger e.g. "test" with working_directory: ".", run it once
-						const jobKey = `${check.name}:${workingDirectory}`;
-
-						// Skip if we've already created a job for this exact entry point/check combination
-						if (seenJobs.has(jobKey)) {
-							continue;
-						}
-						seenJobs.add(jobKey);
-
-						const id = `${check.name}-${ep.path.replace(/\//g, "-")}`;
-
-						matrixJobs.push({
-							id,
-							name: check.name,
-							entry_point: ep.path,
-							working_directory: workingDirectory,
-							command: checkDef.command,
-							runtimes: check.requires_runtimes || [],
-							services: check.requires_services || [],
-							setup: formatSetup(check.setup || undefined),
-							global_setup: globalSetup,
-						});
-					}
-				}
-			}
-		}
-
-		const output = {
-			matrix: matrixJobs,
-			services: ciConfig.services || {},
-			runtimes: ciConfig.runtimes || {},
-		};
-
-		console.log(JSON.stringify(output));
-	} catch (e) {
-		console.error("Error generating CI jobs:", e);
-		process.exit(1);
-	}
-}
-
-const formatSetup = (steps: CISetupStep[] | null | undefined): string => {
-	if (!steps || steps.length === 0) return "";
-	return steps
-		.map((s) => {
-			const cmd = s.working_directory
-				? `(cd "${s.working_directory}" && ${s.run})`
-				: s.run;
-			return `echo "::group::${s.name}"
-${cmd}
-echo "::endgroup::"`;
-		})
-		.join("\n");
-};

package/src/commands/clean.ts

@@ -1,54 +0,0 @@
-import chalk from "chalk";
-import type { Command } from "commander";
-import { loadGlobalConfig } from "../config/global.js";
-import { loadConfig } from "../config/loader.js";
-import {
-	getDebugLogger,
-	initDebugLogger,
-	mergeDebugLogConfig,
-} from "../utils/debug-log.js";
-import { acquireLock, cleanLogs, releaseLock } from "./shared.js";
-
-export function registerCleanCommand(program: Command): void {
-	program
-		.command("clean")
-		.description("Archive logs")
-		.action(async () => {
-			let config: Awaited<ReturnType<typeof loadConfig>> | undefined;
-			let lockAcquired = false;
-			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);
-
-				// Acquire lock BEFORE logging - prevents clean from running during active gauntlet run
-				await acquireLock(config.project.log_dir);
-				lockAcquired = true;
-
-				// Log the command invocation (only after lock acquired)
-				const debugLogger = getDebugLogger();
-				await debugLogger?.logCommand("clean", []);
-				await debugLogger?.logClean("manual", "user_request");
-
-				await cleanLogs(
-					config.project.log_dir,
-					config.project.max_previous_logs,
-				);
-				await releaseLock(config.project.log_dir);
-				console.log(chalk.green("Logs archived successfully."));
-			} catch (error: unknown) {
-				if (config && lockAcquired) {
-					await releaseLock(config.project.log_dir);
-				}
-				const err = error as { message?: string };
-				console.error(chalk.red("Error:"), err.message);
-				process.exit(1);
-			}
-		});
-}