agent-gauntlet 0.1.10 → 0.1.12

package/src/commands/check.test.ts

@@ -1,25 +1,29 @@
-import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
-import { Command } from 'commander';
-import { registerCheckCommand } from './check.js';
+import { beforeEach, describe, expect, it } from "bun:test";
+import { Command } from "commander";
+import { registerCheckCommand } from "./check.js";
 
-describe('Check Command', () => {
-  let program: Command;
+describe("Check Command", () => {
+	let program: Command;
 
-  beforeEach(() => {
-    program = new Command();
-    registerCheckCommand(program);
-  });
+	beforeEach(() => {
+		program = new Command();
+		registerCheckCommand(program);
+	});
 
-  it('should register the check command', () => {
-    const checkCmd = program.commands.find(cmd => cmd.name() === 'check');
-    expect(checkCmd).toBeDefined();
-    expect(checkCmd?.description()).toBe('Run only applicable checks for detected changes');
-  });
+	it("should register the check command", () => {
+		const checkCmd = program.commands.find((cmd) => cmd.name() === "check");
+		expect(checkCmd).toBeDefined();
+		expect(checkCmd?.description()).toBe(
+			"Run only applicable checks for detected changes",
+		);
+	});
 
-  it('should have correct options', () => {
-    const checkCmd = program.commands.find(cmd => cmd.name() === 'check');
-    expect(checkCmd?.options.some(opt => opt.long === '--gate')).toBe(true);
-    expect(checkCmd?.options.some(opt => opt.long === '--commit')).toBe(true);
-    expect(checkCmd?.options.some(opt => opt.long === '--uncommitted')).toBe(true);
-  });
+	it("should have correct options", () => {
+		const checkCmd = program.commands.find((cmd) => cmd.name() === "check");
+		expect(checkCmd?.options.some((opt) => opt.long === "--gate")).toBe(true);
+		expect(checkCmd?.options.some((opt) => opt.long === "--commit")).toBe(true);
+		expect(checkCmd?.options.some((opt) => opt.long === "--uncommitted")).toBe(
+			true,
+		);
+	});
 });

package/src/commands/check.ts

@@ -1,72 +1,99 @@
-import type { Command } from 'commander';
-import chalk from 'chalk';
-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 { Logger } from '../output/logger.js';
-import { ConsoleReporter } from '../output/console.js';
-import { rotateLogs } from './shared.js';
+import chalk from "chalk";
+import type { Command } from "commander";
+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 { Logger } from "../output/logger.js";
+import { rotateLogs } from "./shared.js";
 
 export function registerCheckCommand(program: Command): void {
-  program
-    .command('check')
-    .description('Run only applicable checks for detected changes')
-    .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) => {
-      try {
-        const config = await loadConfig();
+	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) => {
+			try {
+				const config = await loadConfig();
 
-        // Rotate logs before starting
-        await rotateLogs(config.project.log_dir);
+				// Rotate logs before starting
+				await rotateLogs(config.project.log_dir);
 
-        const changeDetector = new ChangeDetector(config.project.base_branch, {
-          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.'));
-          process.exit(0);
-        }
-        
-        console.log(chalk.dim(`Found ${changes.length} changed files.`));
+				// Determine effective base branch
+				// Priority: CLI override > CI env var > config
+				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;
 
-        const entryPoints = await expander.expand(config.project.entry_points, changes);
-        let jobs = jobGen.generateJobs(entryPoints);
+				const changeDetector = new ChangeDetector(effectiveBaseBranch, {
+					commit: options.commit,
+					uncommitted: options.uncommitted,
+				});
+				const expander = new EntryPointExpander();
+				const jobGen = new JobGenerator(config);
 
-        // Filter to only checks
-        jobs = jobs.filter(j => j.type === 'check');
+				console.log(chalk.dim("Detecting changes..."));
+				const changes = await changeDetector.getChangedFiles();
 
-        if (options.gate) {
-          jobs = jobs.filter(j => j.name === options.gate);
-        }
+				if (changes.length === 0) {
+					console.log(chalk.green("No changes detected."));
+					process.exit(0);
+				}
 
-        if (jobs.length === 0) {
-          console.log(chalk.yellow('No applicable checks for these changes.'));
-          process.exit(0);
-        }
+				console.log(chalk.dim(`Found ${changes.length} changed files.`));
 
-        console.log(chalk.dim(`Running ${jobs.length} check(s)...`));
+				const entryPoints = await expander.expand(
+					config.project.entry_points,
+					changes,
+				);
+				let jobs = jobGen.generateJobs(entryPoints);
 
-        const logger = new Logger(config.project.log_dir);
-        const reporter = new ConsoleReporter();
-        const runner = new Runner(config, logger, reporter);
+				// Filter to only checks
+				jobs = jobs.filter((j) => j.type === "check");
 
-        const success = await runner.run(jobs);
-        process.exit(success ? 0 : 1);
+				if (options.gate) {
+					jobs = jobs.filter((j) => j.name === options.gate);
+				}
 
-      } catch (error: any) {
-        console.error(chalk.red('Error:'), error.message);
-        process.exit(1);
-      }
-    });
+				if (jobs.length === 0) {
+					console.log(chalk.yellow("No applicable checks for these changes."));
+					process.exit(0);
+				}
+
+				console.log(chalk.dim(`Running ${jobs.length} check(s)...`));
+
+				const logger = new Logger(config.project.log_dir);
+				const reporter = new ConsoleReporter();
+				const runner = new Runner(
+					config,
+					logger,
+					reporter,
+					undefined,
+					undefined,
+					effectiveBaseBranch,
+				);
+
+				const success = await runner.run(jobs);
+				process.exit(success ? 0 : 1);
+			} catch (error: unknown) {
+				const err = error as { message?: string };
+				console.error(chalk.red("Error:"), err.message);
+				process.exit(1);
+			}
+		});
 }

package/src/commands/ci/index.ts

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

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

@@ -0,0 +1,78 @@
+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 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 id = `${check.name}-${ep.path.replace(/\//g, "-")}`;
+
+						matrixJobs.push({
+							id,
+							name: check.name,
+							entry_point: ep.path,
+							working_directory: checkDef.working_directory || ep.path,
+							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/detect.test.ts

@@ -1,37 +1,43 @@
-import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
-import { Command } from 'commander';
-import { registerDetectCommand } from './detect.js';
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { Command } from "commander";
+import { registerDetectCommand } from "./detect.js";
 
-describe('Detect Command', () => {
-  let program: Command;
-  const originalConsoleLog = console.log;
-  const originalConsoleError = console.error;
-  let logs: string[];
-  let errors: string[];
+describe("Detect Command", () => {
+	let program: Command;
+	const originalConsoleLog = console.log;
+	const originalConsoleError = console.error;
+	let logs: string[];
+	let errors: string[];
 
-  beforeEach(() => {
-    program = new Command();
-    registerDetectCommand(program);
-    logs = [];
-    errors = [];
-    console.log = (...args: any[]) => {
-      logs.push(args.join(' '));
-    };
-    console.error = (...args: any[]) => {
-      errors.push(args.join(' '));
-    };
-  });
+	beforeEach(() => {
+		program = new Command();
+		registerDetectCommand(program);
+		logs = [];
+		errors = [];
+		console.log = (...args: unknown[]) => {
+			logs.push(args.join(" "));
+		};
+		console.error = (...args: unknown[]) => {
+			errors.push(args.join(" "));
+		};
+	});
 
-  afterEach(() => {
-    console.log = originalConsoleLog;
-    console.error = originalConsoleError;
-  });
+	afterEach(() => {
+		console.log = originalConsoleLog;
+		console.error = originalConsoleError;
+	});
 
-  it('should register the detect command', () => {
-    const detectCmd = program.commands.find(cmd => cmd.name() === 'detect');
-    expect(detectCmd).toBeDefined();
-    expect(detectCmd?.description()).toBe('Show what gates would run for detected changes (without executing them)');
-    expect(detectCmd?.options.some(opt => opt.long === '--commit')).toBe(true);
-    expect(detectCmd?.options.some(opt => opt.long === '--uncommitted')).toBe(true);
-  });
+	it("should register the detect command", () => {
+		const detectCmd = program.commands.find((cmd) => cmd.name() === "detect");
+		expect(detectCmd).toBeDefined();
+		expect(detectCmd?.description()).toBe(
+			"Show what gates would run for detected changes (without executing them)",
+		);
+		expect(detectCmd?.options.some((opt) => opt.long === "--commit")).toBe(
+			true,
+		);
+		expect(detectCmd?.options.some((opt) => opt.long === "--uncommitted")).toBe(
+			true,
+		);
+	});
 });

package/src/commands/detect.ts

@@ -1,69 +1,97 @@
-import type { Command } from 'commander';
-import chalk from 'chalk';
-import { loadConfig } from '../config/loader.js';
-import { ChangeDetector } from '../core/change-detector.js';
-import { EntryPointExpander } from '../core/entry-point.js';
-import { JobGenerator, type Job } from '../core/job.js';
+import chalk from "chalk";
+import type { Command } from "commander";
+import { loadConfig } from "../config/loader.js";
+import { ChangeDetector } from "../core/change-detector.js";
+import { EntryPointExpander } from "../core/entry-point.js";
+import { type Job, JobGenerator } from "../core/job.js";
 
 export function registerDetectCommand(program: Command): void {
-  program
-    .command('detect')
-    .description('Show what gates would run for detected changes (without executing them)')
-    .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) => {
-      try {
-        const config = await loadConfig();
-        const changeDetector = new ChangeDetector(config.project.base_branch, {
-          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.'));
-          return;
-        }
-        
-        console.log(chalk.dim(`Found ${changes.length} changed files:`));
-        changes.forEach(file => console.log(chalk.dim(`  - ${file}`)));
-        console.log();
+	program
+		.command("detect")
+		.description(
+			"Show what gates would run for detected changes (without executing them)",
+		)
+		.option(
+			"-b, --base-branch <branch>",
+			"Override base branch for change detection",
+		)
+		.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) => {
+			try {
+				const config = await loadConfig();
 
-        const entryPoints = await expander.expand(config.project.entry_points, changes);
-        const jobs = jobGen.generateJobs(entryPoints);
+				// Determine effective base branch
+				// Priority: CLI override > CI env var > config
+				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;
 
-        if (jobs.length === 0) {
-          console.log(chalk.yellow('No applicable gates for these changes.'));
-          return;
-        }
+				const changeDetector = new ChangeDetector(effectiveBaseBranch, {
+					commit: options.commit,
+					uncommitted: options.uncommitted,
+				});
+				const expander = new EntryPointExpander();
+				const jobGen = new JobGenerator(config);
 
-        console.log(chalk.bold(`Would run ${jobs.length} gate(s):\n`));
-        
-        // Group jobs by entry point for better display
-        const jobsByEntryPoint = new Map<string, Job[]>();
-        for (const job of jobs) {
-          if (!jobsByEntryPoint.has(job.entryPoint)) {
-            jobsByEntryPoint.set(job.entryPoint, []);
-          }
-          jobsByEntryPoint.get(job.entryPoint)!.push(job);
-        }
+				console.log(chalk.dim("Detecting changes..."));
+				const changes = await changeDetector.getChangedFiles();
 
-        for (const [entryPoint, entryJobs] of jobsByEntryPoint.entries()) {
-          console.log(chalk.cyan(`Entry point: ${entryPoint}`));
-          for (const job of entryJobs) {
-            const typeLabel = job.type === 'check' ? chalk.yellow('check') : chalk.blue('review');
-            console.log(`  ${typeLabel} ${chalk.bold(job.name)}`);
-          }
-          console.log();
-        }
+				if (changes.length === 0) {
+					console.log(chalk.green("No changes detected."));
+					return;
+				}
 
-      } catch (error: any) {
-        console.error(chalk.red('Error:'), error.message);
-        process.exit(1);
-      }
-    });
+				console.log(chalk.dim(`Found ${changes.length} changed files:`));
+				changes.forEach((file) => {
+					console.log(chalk.dim(`  - ${file}`));
+				});
+				console.log();
+
+				const entryPoints = await expander.expand(
+					config.project.entry_points,
+					changes,
+				);
+				const jobs = jobGen.generateJobs(entryPoints);
+
+				if (jobs.length === 0) {
+					console.log(chalk.yellow("No applicable gates for these changes."));
+					return;
+				}
+
+				console.log(chalk.bold(`Would run ${jobs.length} gate(s):\n`));
+
+				// Group jobs by entry point for better display
+				const jobsByEntryPoint = new Map<string, Job[]>();
+				for (const job of jobs) {
+					if (!jobsByEntryPoint.has(job.entryPoint)) {
+						jobsByEntryPoint.set(job.entryPoint, []);
+					}
+					jobsByEntryPoint.get(job.entryPoint)?.push(job);
+				}
+
+				for (const [entryPoint, entryJobs] of jobsByEntryPoint.entries()) {
+					console.log(chalk.cyan(`Entry point: ${entryPoint}`));
+					for (const job of entryJobs) {
+						const typeLabel =
+							job.type === "check"
+								? chalk.yellow("check")
+								: chalk.blue("review");
+						console.log(`  ${typeLabel} ${chalk.bold(job.name)}`);
+					}
+					console.log();
+				}
+			} catch (error: unknown) {
+				const err = error as { message?: string };
+				console.error(chalk.red("Error:"), err.message);
+				process.exit(1);
+			}
+		});
 }