agent-gauntlet 0.1.9 → 0.1.11

package/src/index.ts

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

package/src/output/console.ts

@@ -1,201 +1,256 @@
-import chalk from 'chalk';
-import fs from 'node:fs/promises';
-import { GateResult } from '../gates/result.js';
-import { Job } from '../core/job.js';
+import fs from "node:fs/promises";
+import chalk from "chalk";
+import type { Job } from "../core/job.js";
+import type { GateResult } from "../gates/result.js";
 
 export class ConsoleReporter {
-  onJobStart(job: Job) {
-    console.log(chalk.blue(`[START] ${job.id}`));
-  }
-
-  onJobComplete(job: Job, result: GateResult) {
-    const duration = (result.duration / 1000).toFixed(2) + 's';
-    const message = result.message ?? '';
-    
-    if (result.status === 'pass') {
-      console.log(chalk.green(`[PASS]  ${job.id} (${duration})`));
-    } else if (result.status === 'fail') {
-      console.log(chalk.red(`[FAIL]  ${job.id} (${duration}) - ${message}`));
-    } else {
-      console.log(chalk.magenta(`[ERROR] ${job.id} (${duration}) - ${message}`));
-    }
-  }
-
-  async printSummary(results: GateResult[]) {
-    console.log('\n' + chalk.bold('--- Gauntlet Summary ---'));
-    
-    const passed = results.filter(r => r.status === 'pass');
-    const failed = results.filter(r => r.status === 'fail');
-    const errored = results.filter(r => r.status === 'error');
-
-    console.log(`Total: ${results.length}`);
-    console.log(chalk.green(`Passed: ${passed.length}`));
-    if (failed.length > 0) console.log(chalk.red(`Failed: ${failed.length}`));
-    if (errored.length > 0) console.log(chalk.magenta(`Errored: ${errored.length}`));
-
-    if (failed.length > 0 || errored.length > 0) {
-      console.log('\n' + chalk.bold('=== Failure Details ===\n'));
-      
-      for (const result of [...failed, ...errored]) {
-        const details = await this.extractFailureDetails(result);
-        this.printFailureDetails(result, details);
-      }
-    }
-  }
-
-  private async extractFailureDetails(result: GateResult): Promise<string[]> {
-    if (!result.logPath) {
-      return [result.message ?? 'Unknown error'];
-    }
-
-    try {
-      const logContent = await fs.readFile(result.logPath, 'utf-8');
-      return this.parseLogContent(logContent, result.jobId);
-    } catch (error) {
-      return [result.message ?? 'Unknown error', `(Could not read log file: ${result.logPath})`];
-    }
-  }
-
-  private parseLogContent(logContent: string, jobId: string): string[] {
-    const lines = logContent.split('\n');
-    const details: string[] = [];
-
-    // Check if this is a review log
-    if (jobId.startsWith('review:')) {
-      // Look for parsed violations section (formatted output)
-      const violationsStart = logContent.indexOf('--- Parsed Result ---');
-      if (violationsStart !== -1) {
-        const violationsSection = logContent.substring(violationsStart);
-        const sectionLines = violationsSection.split('\n');
-        
-        for (let i = 0; i < sectionLines.length; i++) {
-          const line = sectionLines[i];
-          // Match numbered violation lines: "1. file:line - issue" (line can be a number or '?')
-          const violationMatch = line.match(/^\d+\.\s+(.+?):(\d+|\?)\s+-\s+(.+)$/);
-          if (violationMatch) {
-            const file = violationMatch[1];
-            const lineNum = violationMatch[2];
-            const issue = violationMatch[3];
-            details.push(`  ${chalk.cyan(file)}:${chalk.yellow(lineNum)} - ${issue}`);
-            
-            // Check next line for "Fix:" suggestion
-            if (i + 1 < sectionLines.length) {
-              const nextLine = sectionLines[i + 1].trim();
-              if (nextLine.startsWith('Fix:')) {
-                const fix = nextLine.substring(4).trim();
-                details.push(`    ${chalk.dim('Fix:')} ${fix}`);
-                i++; // Skip the fix line
-              }
-            }
-          }
-        }
-      }
-
-      // If no parsed violations, look for JSON violations (handles both minified and pretty-printed)
-      if (details.length === 0) {
-        // Find the first '{' and last '}' to extract JSON object
-        const jsonStart = logContent.indexOf('{');
-        const jsonEnd = logContent.lastIndexOf('}');
-        if (jsonStart !== -1 && jsonEnd !== -1 && jsonEnd > jsonStart) {
-          try {
-            const jsonStr = logContent.substring(jsonStart, jsonEnd + 1);
-            const json = JSON.parse(jsonStr);
-            if (json.status === 'fail' && json.violations && Array.isArray(json.violations)) {
-              json.violations.forEach((v: any) => {
-                const file = v.file || 'unknown';
-                const line = v.line || '?';
-                const issue = v.issue || 'Unknown issue';
-                details.push(`  ${chalk.cyan(file)}:${chalk.yellow(line)} - ${issue}`);
-                if (v.fix) {
-                  details.push(`    ${chalk.dim('Fix:')} ${v.fix}`);
-                }
-              });
-            }
-          } catch {
-            // JSON parse failed, fall through to other parsing
-          }
-        }
-      }
-
-      // If still no details, look for error messages
-      if (details.length === 0) {
-        // Try to find the actual error message (first non-empty line after "Error:")
-        const errorIndex = logContent.indexOf('Error:');
-        if (errorIndex !== -1) {
-          const afterError = logContent.substring(errorIndex + 6).trim();
-          const firstErrorLine = afterError.split('\n')[0].trim();
-          if (firstErrorLine && !firstErrorLine.startsWith('Usage:') && !firstErrorLine.startsWith('Commands:')) {
-            details.push(`  ${firstErrorLine}`);
-          }
-        }
-        
-        // Also check for "Result: error" lines
-        if (details.length === 0) {
-          const resultMatch = logContent.match(/Result:\s*error(?:\s*-\s*(.+?))?(?:\n|$)/);
-          if (resultMatch && resultMatch[1]) {
-            details.push(`  ${resultMatch[1]}`);
-          }
-        }
-      }
-    } else {
-      // This is a check log
-      // Look for STDERR section
-      const stderrStart = logContent.indexOf('STDERR:');
-      if (stderrStart !== -1) {
-        const stderrSection = logContent.substring(stderrStart + 7).trim();
-        const stderrLines = stderrSection.split('\n').filter(line => {
-          // Skip empty lines and command output markers
-          return line.trim() && 
-                 !line.includes('STDOUT:') && 
-                 !line.includes('Command failed:') &&
-                 !line.includes('Result:');
-        });
-        if (stderrLines.length > 0) {
-          details.push(...stderrLines.slice(0, 10).map(line => `  ${line.trim()}`));
-        }
-      }
-
-      // If no STDERR, look for error messages
-      if (details.length === 0) {
-        const errorMatch = logContent.match(/Command failed:\s*(.+?)(?:\n|$)/);
-        if (errorMatch) {
-          details.push(`  ${errorMatch[1]}`);
-        } else {
-          // Look for any line with "Result: fail" or "Result: error"
-          const resultMatch = logContent.match(/Result:\s*(fail|error)\s*-\s*(.+?)(?:\n|$)/);
-          if (resultMatch) {
-            details.push(`  ${resultMatch[2]}`);
-          }
-        }
-      }
-    }
-
-    // If we still have no details, use the message from the result
-    if (details.length === 0) {
-      details.push('  (See log file for details)');
-    }
-
-    return details;
-  }
-
-  private printFailureDetails(result: GateResult, details: string[]) {
-    const statusColor = result.status === 'error' ? chalk.magenta : chalk.red;
-    const statusLabel = result.status === 'error' ? 'ERROR' : 'FAIL';
-    
-    console.log(statusColor(`[${statusLabel}] ${result.jobId}`));
-    if (result.message) {
-      console.log(chalk.dim(`  Summary: ${result.message}`));
-    }
-    
-    if (details.length > 0) {
-      console.log(chalk.dim('  Details:'));
-      details.forEach(detail => console.log(detail));
-    }
-    
-    if (result.logPath) {
-      console.log(chalk.dim(`  Log: ${result.logPath}`));
-    }
-    
-    console.log(''); // Empty line between failures
-  }
+	onJobStart(job: Job) {
+		console.log(chalk.blue(`[START] ${job.id}`));
+	}
+
+	onJobComplete(job: Job, result: GateResult) {
+		const duration = `${(result.duration / 1000).toFixed(2)}s`;
+		const message = result.message ?? "";
+
+		if (result.status === "pass") {
+			console.log(chalk.green(`[PASS]  ${job.id} (${duration})`));
+		} else if (result.status === "fail") {
+			console.log(chalk.red(`[FAIL]  ${job.id} (${duration}) - ${message}`));
+		} else {
+			console.log(
+				chalk.magenta(`[ERROR] ${job.id} (${duration}) - ${message}`),
+			);
+		}
+	}
+
+	async printSummary(results: GateResult[]) {
+		console.log(`\n${chalk.bold("--- Gauntlet Summary ---")}`);
+
+		const passed = results.filter((r) => r.status === "pass");
+		const failed = results.filter((r) => r.status === "fail");
+		const errored = results.filter((r) => r.status === "error");
+
+		console.log(`Total: ${results.length}`);
+		console.log(chalk.green(`Passed: ${passed.length}`));
+		if (failed.length > 0) console.log(chalk.red(`Failed: ${failed.length}`));
+		if (errored.length > 0)
+			console.log(chalk.magenta(`Errored: ${errored.length}`));
+
+		if (failed.length > 0 || errored.length > 0) {
+			console.log(`\n${chalk.bold("=== Failure Details ===\n")}`);
+
+			for (const result of [...failed, ...errored]) {
+				const details = await this.extractFailureDetails(result);
+				this.printFailureDetails(result, details);
+			}
+		}
+	}
+
+	/** @internal Public for testing */
+	async extractFailureDetails(result: GateResult): Promise<string[]> {
+		const logPaths =
+			result.logPaths || (result.logPath ? [result.logPath] : []);
+
+		if (logPaths.length === 0) {
+			return [result.message ?? "Unknown error"];
+		}
+
+		const allDetails: string[] = [];
+		for (const logPath of logPaths) {
+			try {
+				const logContent = await fs.readFile(logPath, "utf-8");
+				const details = this.parseLogContent(logContent, result.jobId);
+				allDetails.push(...details);
+			} catch (_error: unknown) {
+				allDetails.push(`(Could not read log file: ${logPath})`);
+			}
+		}
+
+		return allDetails.length > 0
+			? allDetails
+			: [result.message ?? "Unknown error"];
+	}
+
+	private parseLogContent(logContent: string, jobId: string): string[] {
+		const _lines = logContent.split("\n");
+		const details: string[] = [];
+
+		// Check if this is a review log
+		if (jobId.startsWith("review:")) {
+			// Look for parsed violations section (formatted output)
+			// Use regex to be flexible about adapter name in parentheses
+			// Matches: "--- Parsed Result ---" or "--- Parsed Result (adapter) ---"
+			const parsedResultRegex = /---\s*Parsed Result(?:\s+\(([^)]+)\))?\s*---/;
+			const match = logContent.match(parsedResultRegex);
+
+			if (match && match.index !== undefined) {
+				const violationsStart = match.index;
+				const violationsSection = logContent.substring(violationsStart);
+				const sectionLines = violationsSection.split("\n");
+
+				for (let i = 0; i < sectionLines.length; i++) {
+					const line = sectionLines[i];
+					// Match numbered violation lines: "1. file:line - issue" (line can be a number or '?')
+					const violationMatch = line.match(
+						/^\d+\.\s+(.+?):(\d+|\?)\s+-\s+(.+)$/,
+					);
+					if (violationMatch) {
+						const file = violationMatch[1];
+						const lineNum = violationMatch[2];
+						const issue = violationMatch[3];
+						details.push(
+							`  ${chalk.cyan(file)}:${chalk.yellow(lineNum)} - ${issue}`,
+						);
+
+						// Check next line for "Fix:" suggestion
+						if (i + 1 < sectionLines.length) {
+							const nextLine = sectionLines[i + 1].trim();
+							if (nextLine.startsWith("Fix:")) {
+								const fix = nextLine.substring(4).trim();
+								details.push(`    ${chalk.dim("Fix:")} ${fix}`);
+								i++; // Skip the fix line
+							}
+						}
+					}
+				}
+			}
+
+			// If no parsed violations, look for JSON violations (handles both minified and pretty-printed)
+			if (details.length === 0) {
+				// Find the first '{' and last '}' to extract JSON object
+				const jsonStart = logContent.indexOf("{");
+				const jsonEnd = logContent.lastIndexOf("}");
+				if (jsonStart !== -1 && jsonEnd !== -1 && jsonEnd > jsonStart) {
+					try {
+						const jsonStr = logContent.substring(jsonStart, jsonEnd + 1);
+						const json = JSON.parse(jsonStr);
+						if (
+							json.status === "fail" &&
+							json.violations &&
+							Array.isArray(json.violations)
+						) {
+							json.violations.forEach(
+								(v: {
+									file?: string;
+									line?: number | string;
+									issue?: string;
+									fix?: string;
+								}) => {
+									const file = v.file || "unknown";
+									const line = v.line || "?";
+									const issue = v.issue || "Unknown issue";
+									details.push(
+										`  ${chalk.cyan(file)}:${chalk.yellow(line)} - ${issue}`,
+									);
+									if (v.fix) {
+										details.push(`    ${chalk.dim("Fix:")} ${v.fix}`);
+									}
+								},
+							);
+						}
+					} catch {
+						// JSON parse failed, fall through to other parsing
+					}
+				}
+			}
+
+			// If still no details, look for error messages
+			if (details.length === 0) {
+				// Try to find the actual error message (first non-empty line after "Error:")
+				const errorIndex = logContent.indexOf("Error:");
+				if (errorIndex !== -1) {
+					const afterError = logContent.substring(errorIndex + 6).trim();
+					const firstErrorLine = afterError.split("\n")[0].trim();
+					if (
+						firstErrorLine &&
+						!firstErrorLine.startsWith("Usage:") &&
+						!firstErrorLine.startsWith("Commands:")
+					) {
+						details.push(`  ${firstErrorLine}`);
+					}
+				}
+
+				// Also check for "Result: error" lines
+				if (details.length === 0) {
+					const resultMatch = logContent.match(
+						/Result:\s*error(?:\s*-\s*(.+?))?(?:\n|$)/,
+					);
+					if (resultMatch?.[1]) {
+						details.push(`  ${resultMatch[1]}`);
+					}
+				}
+			}
+		} else {
+			// This is a check log
+			// Look for STDERR section
+			const stderrStart = logContent.indexOf("STDERR:");
+			if (stderrStart !== -1) {
+				const stderrSection = logContent.substring(stderrStart + 7).trim();
+				const stderrLines = stderrSection.split("\n").filter((line) => {
+					// Skip empty lines and command output markers
+					return (
+						line.trim() &&
+						!line.includes("STDOUT:") &&
+						!line.includes("Command failed:") &&
+						!line.includes("Result:")
+					);
+				});
+				if (stderrLines.length > 0) {
+					details.push(
+						...stderrLines.slice(0, 10).map((line) => `  ${line.trim()}`),
+					);
+				}
+			}
+
+			// If no STDERR, look for error messages
+			if (details.length === 0) {
+				const errorMatch = logContent.match(/Command failed:\s*(.+?)(?:\n|$)/);
+				if (errorMatch) {
+					details.push(`  ${errorMatch[1]}`);
+				} else {
+					// Look for any line with "Result: fail" or "Result: error"
+					const resultMatch = logContent.match(
+						/Result:\s*(fail|error)\s*-\s*(.+?)(?:\n|$)/,
+					);
+					if (resultMatch) {
+						details.push(`  ${resultMatch[2]}`);
+					}
+				}
+			}
+		}
+
+		// If we still have no details, use the message from the result
+		if (details.length === 0) {
+			details.push("  (See log file for details)");
+		}
+
+		return details;
+	}
+
+	private printFailureDetails(result: GateResult, details: string[]) {
+		const statusColor = result.status === "error" ? chalk.magenta : chalk.red;
+		const statusLabel = result.status === "error" ? "ERROR" : "FAIL";
+
+		console.log(statusColor(`[${statusLabel}] ${result.jobId}`));
+		if (result.message) {
+			console.log(chalk.dim(`  Summary: ${result.message}`));
+		}
+
+		if (details.length > 0) {
+			console.log(chalk.dim("  Details:"));
+			details.forEach((detail) => {
+				console.log(detail);
+			});
+		}
+
+		if (result.logPaths && result.logPaths.length > 0) {
+			result.logPaths.forEach((p) => {
+				console.log(chalk.dim(`  Log: ${p}`));
+			});
+		} else if (result.logPath) {
+			console.log(chalk.dim(`  Log: ${result.logPath}`));
+		}
+
+		console.log(""); // Empty line between failures
+	}
 }

package/src/output/logger.ts

@@ -1,66 +1,80 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { sanitizeJobId } from '../utils/sanitizer.js';
+import fs from "node:fs/promises";
+import path from "node:path";
+import { sanitizeJobId } from "../utils/sanitizer.js";
 
 function formatTimestamp(): string {
-  return new Date().toISOString();
+	return new Date().toISOString();
 }
 
 export class Logger {
-  private initializedFiles: Set<string> = new Set();
+	private initializedFiles: Set<string> = new Set();
 
-  constructor(private logDir: string) {}
+	constructor(private logDir: string) {}
 
-  async init() {
-    await fs.mkdir(this.logDir, { recursive: true });
-  }
+	async init() {
+		await fs.mkdir(this.logDir, { recursive: true });
+	}
 
-  async close() {
-    // No-op - using append mode
-  }
+	async close() {
+		// No-op - using append mode
+	}
 
-  getLogPath(jobId: string, adapterName?: string): string {
-    const safeName = sanitizeJobId(jobId);
-    if (adapterName) {
-      return path.join(this.logDir, `${safeName}_${adapterName}.log`);
-    }
-    return path.join(this.logDir, `${safeName}.log`);
-  }
+	getLogPath(jobId: string, adapterName?: string): string {
+		const safeName = sanitizeJobId(jobId);
+		if (adapterName) {
+			return path.join(this.logDir, `${safeName}_${adapterName}.log`);
+		}
+		return path.join(this.logDir, `${safeName}.log`);
+	}
 
-  private async initFile(logPath: string): Promise<void> {
-    if (!this.initializedFiles.has(logPath)) {
-      await fs.writeFile(logPath, '');
-      this.initializedFiles.add(logPath);
-    }
-  }
+	private async initFile(logPath: string): Promise<void> {
+		if (!this.initializedFiles.has(logPath)) {
+			await fs.writeFile(logPath, "");
+			this.initializedFiles.add(logPath);
+		}
+	}
 
-  async createJobLogger(jobId: string): Promise<(text: string) => Promise<void>> {
-    const logPath = this.getLogPath(jobId);
-    await this.initFile(logPath);
+	async createJobLogger(
+		jobId: string,
+	): Promise<(text: string) => Promise<void>> {
+		const logPath = this.getLogPath(jobId);
+		await this.initFile(logPath);
 
-    return async (text: string) => {
-      const timestamp = formatTimestamp();
-      const lines = text.split('\n');
-      if (lines.length > 0) {
-        lines[0] = `[${timestamp}] ${lines[0]}`;
-      }
-      await fs.appendFile(logPath, lines.join('\n') + (text.endsWith('\n') ? '' : '\n'));
-    };
-  }
+		return async (text: string) => {
+			const timestamp = formatTimestamp();
+			const lines = text.split("\n");
+			if (lines.length > 0) {
+				lines[0] = `[${timestamp}] ${lines[0]}`;
+			}
+			await fs.appendFile(
+				logPath,
+				lines.join("\n") + (text.endsWith("\n") ? "" : "\n"),
+			);
+		};
+	}
 
-  createLoggerFactory(jobId: string): (adapterName?: string) => Promise<(text: string) => Promise<void>> {
-    return async (adapterName?: string) => {
-      const logPath = this.getLogPath(jobId, adapterName);
-      await this.initFile(logPath);
+	createLoggerFactory(
+		jobId: string,
+	): (
+		adapterName?: string,
+	) => Promise<{ logger: (text: string) => Promise<void>; logPath: string }> {
+		return async (adapterName?: string) => {
+			const logPath = this.getLogPath(jobId, adapterName);
+			await this.initFile(logPath);
 
-      return async (text: string) => {
-        const timestamp = formatTimestamp();
-        const lines = text.split('\n');
-        if (lines.length > 0) {
-          lines[0] = `[${timestamp}] ${lines[0]}`;
-        }
-        await fs.appendFile(logPath, lines.join('\n') + (text.endsWith('\n') ? '' : '\n'));
-      };
-    };
-  }
+			const logger = async (text: string) => {
+				const timestamp = formatTimestamp();
+				const lines = text.split("\n");
+				if (lines.length > 0) {
+					lines[0] = `[${timestamp}] ${lines[0]}`;
+				}
+				await fs.appendFile(
+					logPath,
+					lines.join("\n") + (text.endsWith("\n") ? "" : "\n"),
+				);
+			};
+
+			return { logger, logPath };
+		};
+	}
 }