agent-gauntlet 0.10.0 → 0.11.0

package/src/index.ts

@@ -1,47 +0,0 @@
-#!/usr/bin/env bun
-import { Command } from "commander";
-import packageJson from "../package.json" with { type: "json" };
-import {
-	registerCheckCommand,
-	registerCICommand,
-	registerCleanCommand,
-	registerDetectCommand,
-	registerHealthCommand,
-	registerHelpCommand,
-	registerInitCommand,
-	registerListCommand,
-	registerReviewCommand,
-	registerRunCommand,
-	registerStopHookCommand,
-	registerValidateCommand,
-	registerWaitCICommand,
-} from "./commands/index.js";
-
-const program = new Command();
-
-program
-	.name("agent-gauntlet")
-	.description("AI-assisted quality gates")
-	.version(packageJson.version);
-
-// Register all commands
-registerRunCommand(program);
-registerCheckCommand(program);
-registerCICommand(program);
-registerCleanCommand(program);
-registerReviewCommand(program);
-registerDetectCommand(program);
-registerListCommand(program);
-registerHealthCommand(program);
-registerInitCommand(program);
-registerValidateCommand(program);
-registerStopHookCommand(program);
-registerWaitCICommand(program);
-registerHelpCommand(program);
-
-// Default action: help
-if (process.argv.length < 3) {
-	process.argv.push("help");
-}
-
-program.parse(process.argv);

package/src/output/app-logger.ts

@@ -1,214 +0,0 @@
-import fs from "node:fs";
-import fsPromises from "node:fs/promises";
-import path from "node:path";
-import {
-	configure,
-	getLogger,
-	type LogRecord,
-	type Logger as LogTapeLogger,
-} from "@logtape/logtape";
-import { createConsoleSink } from "./sinks/console-sink.js";
-
-/**
- * Logger modes that determine sink configuration:
- * - "interactive": Console output to stderr (file capture via console-log.ts)
- * - "stop-hook": NO console output (JSON protocol on stdout must be clean)
- * - "ci": Console output to stderr
- */
-export type LoggerMode = "interactive" | "stop-hook" | "ci";
-
-/**
- * Log level options.
- */
-export type LogLevel = "debug" | "info" | "warning" | "error";
-
-/**
- * App logger configuration options.
- */
-export interface AppLoggerConfig {
-	mode: LoggerMode;
-	logDir?: string;
-	level?: LogLevel;
-	debugLog?: {
-		enabled: boolean;
-		maxSizeMb?: number;
-	};
-}
-
-// Global state for cleanup (file descriptor for debug log, configuration flag)
-let debugLogFd: number | null = null;
-let isConfigured = false;
-
-/**
- * Safely serialize a value, handling circular references.
- */
-function safeStringify(value: unknown): string {
-	try {
-		return JSON.stringify(value);
-	} catch {
-		return "[Unserializable]";
-	}
-}
-
-/**
- * Create a debug log sink that writes to .debug.log file.
- * Format matches existing DebugLogger: [ISO_TIMESTAMP] message
- */
-function createDebugLogSink(logDir: string): (record: LogRecord) => void {
-	const debugLogPath = path.join(logDir, ".debug.log");
-
-	// Open file for append
-	debugLogFd = fs.openSync(
-		debugLogPath,
-		fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_APPEND,
-	);
-
-	return (record: LogRecord) => {
-		if (debugLogFd === null) return;
-
-		const timestamp = new Date(record.timestamp).toISOString();
-		const level = record.level.toUpperCase();
-		const category = record.category.join(".");
-		const message = record.message
-			.map((part) => (typeof part === "string" ? part : safeStringify(part)))
-			.join("");
-
-		const line = `[${timestamp}] ${level} [${category}] ${message}\n`;
-
-		try {
-			fs.writeSync(debugLogFd, line);
-		} catch {
-			// Suppress write errors
-		}
-	};
-}
-
-/**
- * Initialize the application logger with LogTape.
- *
- * IMPORTANT: In stop-hook mode, NO console output is generated.
- * stdout must remain clean for the JSON protocol response.
- * File logging is handled separately by console-log.ts which captures stderr.
- *
- * @param config - Logger configuration
- * @returns Promise that resolves when logger is configured
- */
-export async function initLogger(config: AppLoggerConfig): Promise<void> {
-	// Reset if already configured
-	if (isConfigured) {
-		await resetLogger();
-	}
-
-	const { mode, level = "info", logDir, debugLog } = config;
-
-	// Ensure log directory exists if we need it for debug log
-	if (logDir && debugLog?.enabled) {
-		await fsPromises.mkdir(logDir, { recursive: true });
-	}
-
-	// Build sink configuration
-	const sinks: Record<string, (record: LogRecord) => void> = {};
-	const activeSinks: string[] = [];
-
-	// Console sink (only for interactive and ci modes)
-	// Outputs to stderr, which gets captured by console-log.ts
-	if (mode !== "stop-hook") {
-		sinks.console = createConsoleSink();
-		activeSinks.push("console");
-	}
-
-	// Debug log sink (writes directly to .debug.log)
-	if (logDir && debugLog?.enabled) {
-		sinks.debugLog = createDebugLogSink(logDir);
-		activeSinks.push("debugLog");
-	}
-
-	// Configure LogTape (reset: true needed if LogTape was previously configured)
-	// IMPORTANT: Configure the meta logger to suppress its default stdout output.
-	// Without this, LogTape writes "LogTape loggers are configured..." to stdout,
-	// which breaks the stop-hook JSON protocol.
-	try {
-		await configure({
-			sinks,
-			loggers: [
-				{
-					category: ["gauntlet"],
-					lowestLevel: level,
-					sinks: activeSinks,
-				},
-				{
-					// Suppress LogTape's internal meta logger (writes to stdout by default)
-					category: ["logtape", "meta"],
-					lowestLevel: "fatal",
-					sinks: [],
-				},
-			],
-			reset: true,
-		});
-		isConfigured = true;
-	} catch (error) {
-		// Close debug log fd if initialization fails to prevent leaks
-		if (debugLogFd !== null) {
-			try {
-				fs.closeSync(debugLogFd);
-			} catch {
-				// Ignore close errors
-			}
-			debugLogFd = null;
-		}
-		throw error;
-	}
-}
-
-/**
- * Reset the logger configuration and close file handles.
- */
-export async function resetLogger(): Promise<void> {
-	if (debugLogFd !== null) {
-		try {
-			fs.closeSync(debugLogFd);
-		} catch {
-			// Ignore close errors
-		}
-		debugLogFd = null;
-	}
-
-	// Reset LogTape configuration (reset: true required after initial configure)
-	// Also suppress meta logger to avoid stdout pollution
-	await configure({
-		sinks: {},
-		loggers: [
-			{
-				category: ["logtape", "meta"],
-				lowestLevel: "fatal",
-				sinks: [],
-			},
-		],
-		reset: true,
-	});
-	isConfigured = false;
-}
-
-/**
- * Get the root application logger.
- */
-export function getAppLogger(): LogTapeLogger {
-	return getLogger(["gauntlet"]);
-}
-
-/**
- * Get a child logger for a specific category.
- * Categories are hierarchical, e.g., ["gauntlet", "runner"] or ["gauntlet", "gate", "check"]
- *
- * @param category - The category path (after "gauntlet" prefix)
- */
-export function getCategoryLogger(...category: string[]): LogTapeLogger {
-	return getLogger(["gauntlet", ...category]);
-}
-
-/**
- * Check if the logger has been configured.
- */
-export function isLoggerConfigured(): boolean {
-	return isConfigured;
-}

package/src/output/console-log.ts

@@ -1,168 +0,0 @@
-import fs from "node:fs";
-import fsPromises from "node:fs/promises";
-import path from "node:path";
-import { inspect } from "node:util";
-
-// biome-ignore lint/suspicious/noControlCharactersInRegex: Required for ANSI escape code stripping
-const ANSI_REGEX = /\x1b\[[0-9;]*m/g;
-
-function stripAnsi(text: string): string {
-	return text.replace(ANSI_REGEX, "");
-}
-
-function formatArgs(args: unknown[]): string {
-	return args
-		.map((a) => (typeof a === "string" ? a : inspect(a, { depth: 4 })))
-		.join(" ");
-}
-
-function openLogFileExclusive(
-	logDir: string,
-	runNum: number,
-): { fd: number; logPath: string } {
-	const logPath = path.join(logDir, `console.${runNum}.log`);
-	try {
-		const fd = fs.openSync(
-			logPath,
-			fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL,
-		);
-		return { fd, logPath };
-	} catch (e: unknown) {
-		const error = e as { code?: string };
-		if (error.code === "EEXIST") {
-			// If file exists, something is wrong with our numbering logic
-			// Log warning and try incrementing as fallback
-			console.error(`Warning: console.${runNum}.log already exists`);
-			return openLogFileFallback(logDir, runNum + 1);
-		}
-		throw e;
-	}
-}
-
-function openLogFileFallback(
-	logDir: string,
-	startNum: number,
-): { fd: number; logPath: string } {
-	let runNum = startNum;
-	for (let attempts = 0; attempts < 100; attempts++) {
-		const logPath = path.join(logDir, `console.${runNum}.log`);
-		try {
-			const fd = fs.openSync(
-				logPath,
-				fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL,
-			);
-			return { fd, logPath };
-		} catch (e: unknown) {
-			const error = e as { code?: string };
-			if (error.code === "EEXIST") {
-				runNum++;
-				continue;
-			}
-			throw e;
-		}
-	}
-	throw new Error("Failed to create console log file after 100 attempts");
-}
-
-export interface ConsoleLogHandle {
-	/** Restore original console functions */
-	restore: () => void;
-	/** Write directly to the log file without terminal output */
-	writeToLogOnly: (text: string) => void;
-}
-
-/**
- * Start console logging with unified run numbering.
- * @param logDir The directory to write logs to
- * @param runNumber The run number from Logger (ensures console.N.log matches check.N.log)
- */
-export async function startConsoleLog(
-	logDir: string,
-	runNumber: number,
-): Promise<ConsoleLogHandle> {
-	await fsPromises.mkdir(logDir, { recursive: true });
-	const { fd } = openLogFileExclusive(logDir, runNumber);
-
-	try {
-		const originalLog = console.log;
-		const originalError = console.error;
-		const originalWarn = console.warn;
-		const originalStdoutWrite = process.stdout.write.bind(process.stdout);
-		const originalStderrWrite = process.stderr.write.bind(process.stderr);
-
-		let isClosed = false;
-
-		function writeToLog(text: string): void {
-			if (isClosed) return;
-			try {
-				fs.writeSync(fd, stripAnsi(text));
-			} catch {
-				// Suppress logging failures to prevent crashing the application
-			}
-		}
-
-		// Only patch console methods in bun (bun's console.log bypasses stdout.write)
-		// In Node.js, console.log goes through stdout.write, so patching both would cause double logging
-		const isBun = typeof globalThis.Bun !== "undefined";
-		if (isBun) {
-			console.log = (...args: unknown[]) => {
-				writeToLog(`${formatArgs(args)}\n`);
-				originalLog(...args);
-			};
-
-			console.error = (...args: unknown[]) => {
-				writeToLog(`${formatArgs(args)}\n`);
-				originalError(...args);
-			};
-
-			console.warn = (...args: unknown[]) => {
-				writeToLog(`${formatArgs(args)}\n`);
-				originalWarn(...args);
-			};
-		}
-
-		process.stdout.write = ((
-			chunk: string | Uint8Array,
-			...args: unknown[]
-		): boolean => {
-			const text =
-				typeof chunk === "string" ? chunk : Buffer.from(chunk).toString();
-			writeToLog(text);
-			return originalStdoutWrite(chunk, ...(args as []));
-		}) as typeof process.stdout.write;
-
-		process.stderr.write = ((
-			chunk: string | Uint8Array,
-			...args: unknown[]
-		): boolean => {
-			const text =
-				typeof chunk === "string" ? chunk : Buffer.from(chunk).toString();
-			writeToLog(text);
-			return originalStderrWrite(chunk, ...(args as []));
-		}) as typeof process.stderr.write;
-
-		return {
-			restore: () => {
-				isClosed = true;
-				if (isBun) {
-					console.log = originalLog;
-					console.error = originalError;
-					console.warn = originalWarn;
-				}
-				process.stdout.write = originalStdoutWrite;
-				process.stderr.write = originalStderrWrite;
-				try {
-					fs.closeSync(fd);
-				} catch {
-					// Ignore close errors
-				}
-			},
-			writeToLogOnly: (text: string) => {
-				writeToLog(text);
-			},
-		};
-	} catch (error) {
-		fs.closeSync(fd);
-		throw error;
-	}
-}