agent-gauntlet 0.1.10 → 0.1.12

package/src/core/change-detector.ts

@@ -1,112 +1,130 @@
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
 
 const execAsync = promisify(exec);
 
 export interface ChangeDetectorOptions {
-  commit?: string; // If provided, get diff for this commit vs its parent
-  uncommitted?: boolean; // If true, only get uncommitted changes (staged + unstaged)
+	commit?: string; // If provided, get diff for this commit vs its parent
+	uncommitted?: boolean; // If true, only get uncommitted changes (staged + unstaged)
 }
 
 export class ChangeDetector {
-  constructor(
-    private baseBranch: string = 'origin/main',
-    private options: ChangeDetectorOptions = {}
-  ) {}
-
-  async getChangedFiles(): Promise<string[]> {
-    // If commit option is provided, use that
-    if (this.options.commit) {
-      return this.getCommitChangedFiles(this.options.commit);
-    }
-
-    // If uncommitted option is provided, only get uncommitted changes
-    if (this.options.uncommitted) {
-      return this.getUncommittedChangedFiles();
-    }
-
-    const isCI = process.env.CI === 'true' || process.env.GITHUB_ACTIONS === 'true';
-
-    if (isCI) {
-      return this.getCIChangedFiles();
-    } else {
-      return this.getLocalChangedFiles();
-    }
-  }
-
-  private async getCIChangedFiles(): Promise<string[]> {
-    // In GitHub Actions, GITHUB_BASE_REF is the target branch (e.g., main)
-    // GITHUB_SHA is the commit being built
-    const baseRef = process.env.GITHUB_BASE_REF || this.baseBranch;
-    const headRef = process.env.GITHUB_SHA || 'HEAD';
-    
-    // We might need to fetch first in some shallow clones, but assuming strictly for now
-    // git diff --name-only base...head
-    try {
-      const { stdout } = await execAsync(`git diff --name-only ${baseRef}...${headRef}`);
-      return this.parseOutput(stdout);
-    } catch (error) {
-      console.warn('Failed to detect changes via git diff in CI, falling back to HEAD^...HEAD', error);
-      // Fallback for push events where base ref might not be available
-      const { stdout } = await execAsync('git diff --name-only HEAD^...HEAD');
-      return this.parseOutput(stdout);
-    }
-  }
-
-  private async getLocalChangedFiles(): Promise<string[]> {
-    // 1. Committed changes relative to base branch
-    const { stdout: committed } = await execAsync(`git diff --name-only ${this.baseBranch}...HEAD`);
-    
-    // 2. Uncommitted changes (staged and unstaged)
-    const { stdout: uncommitted } = await execAsync('git diff --name-only HEAD');
-    
-    // 3. Untracked files
-    const { stdout: untracked } = await execAsync('git ls-files --others --exclude-standard');
-
-    const files = new Set([
-      ...this.parseOutput(committed),
-      ...this.parseOutput(uncommitted),
-      ...this.parseOutput(untracked)
-    ]);
-
-    return Array.from(files);
-  }
-
-  private async getCommitChangedFiles(commit: string): Promise<string[]> {
-    // Get diff for commit vs its parent
-    try {
-      const { stdout } = await execAsync(`git diff --name-only ${commit}^..${commit}`);
-      return this.parseOutput(stdout);
-    } catch (error) {
-      // If commit has no parent (initial commit), just get files in that commit
-      try {
-        const { stdout } = await execAsync(`git diff --name-only --root ${commit}`);
-        return this.parseOutput(stdout);
-      } catch {
-        throw new Error(`Failed to get changes for commit ${commit}`);
-      }
-    }
-  }
-
-  private async getUncommittedChangedFiles(): Promise<string[]> {
-    // Get uncommitted changes (staged + unstaged) and untracked files
-    const { stdout: staged } = await execAsync('git diff --name-only --cached');
-    const { stdout: unstaged } = await execAsync('git diff --name-only');
-    const { stdout: untracked } = await execAsync('git ls-files --others --exclude-standard');
-
-    const files = new Set([
-      ...this.parseOutput(staged),
-      ...this.parseOutput(unstaged),
-      ...this.parseOutput(untracked)
-    ]);
-
-    return Array.from(files);
-  }
-
-  private parseOutput(stdout: string): string[] {
-    return stdout
-      .split('\n')
-      .map(line => line.trim())
-      .filter(line => line.length > 0);
-  }
+	constructor(
+		private baseBranch: string = "origin/main",
+		private options: ChangeDetectorOptions = {},
+	) {}
+
+	async getChangedFiles(): Promise<string[]> {
+		// If commit option is provided, use that
+		if (this.options.commit) {
+			return this.getCommitChangedFiles(this.options.commit);
+		}
+
+		// If uncommitted option is provided, only get uncommitted changes
+		if (this.options.uncommitted) {
+			return this.getUncommittedChangedFiles();
+		}
+
+		const isCI =
+			process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true";
+
+		if (isCI) {
+			return this.getCIChangedFiles();
+		} else {
+			return this.getLocalChangedFiles();
+		}
+	}
+
+	private async getCIChangedFiles(): Promise<string[]> {
+		// In GitHub Actions, GITHUB_SHA is the commit being built
+		// Base branch priority is already resolved by caller
+		const baseRef = this.baseBranch;
+		const headRef = process.env.GITHUB_SHA || "HEAD";
+
+		// We might need to fetch first in some shallow clones, but assuming strictly for now
+		// git diff --name-only base...head
+		try {
+			const { stdout } = await execAsync(
+				`git diff --name-only ${baseRef}...${headRef}`,
+			);
+			return this.parseOutput(stdout);
+		} catch (error) {
+			console.warn(
+				"Failed to detect changes via git diff in CI, falling back to HEAD^...HEAD",
+				error,
+			);
+			// Fallback for push events where base ref might not be available
+			const { stdout } = await execAsync("git diff --name-only HEAD^...HEAD");
+			return this.parseOutput(stdout);
+		}
+	}
+
+	private async getLocalChangedFiles(): Promise<string[]> {
+		// 1. Committed changes relative to base branch
+		const { stdout: committed } = await execAsync(
+			`git diff --name-only ${this.baseBranch}...HEAD`,
+		);
+
+		// 2. Uncommitted changes (staged and unstaged)
+		const { stdout: uncommitted } = await execAsync(
+			"git diff --name-only HEAD",
+		);
+
+		// 3. Untracked files
+		const { stdout: untracked } = await execAsync(
+			"git ls-files --others --exclude-standard",
+		);
+
+		const files = new Set([
+			...this.parseOutput(committed),
+			...this.parseOutput(uncommitted),
+			...this.parseOutput(untracked),
+		]);
+
+		return Array.from(files);
+	}
+
+	private async getCommitChangedFiles(commit: string): Promise<string[]> {
+		// Get diff for commit vs its parent
+		try {
+			const { stdout } = await execAsync(
+				`git diff --name-only ${commit}^..${commit}`,
+			);
+			return this.parseOutput(stdout);
+		} catch (_error) {
+			// If commit has no parent (initial commit), just get files in that commit
+			try {
+				const { stdout } = await execAsync(
+					`git diff --name-only --root ${commit}`,
+				);
+				return this.parseOutput(stdout);
+			} catch {
+				throw new Error(`Failed to get changes for commit ${commit}`);
+			}
+		}
+	}
+
+	private async getUncommittedChangedFiles(): Promise<string[]> {
+		// Get uncommitted changes (staged + unstaged) and untracked files
+		const { stdout: staged } = await execAsync("git diff --name-only --cached");
+		const { stdout: unstaged } = await execAsync("git diff --name-only");
+		const { stdout: untracked } = await execAsync(
+			"git ls-files --others --exclude-standard",
+		);
+
+		const files = new Set([
+			...this.parseOutput(staged),
+			...this.parseOutput(unstaged),
+			...this.parseOutput(untracked),
+		]);
+
+		return Array.from(files);
+	}
+
+	private parseOutput(stdout: string): string[] {
+		return stdout
+			.split("\n")
+			.map((line) => line.trim())
+			.filter((line) => line.length > 0);
+	}
 }

package/src/core/entry-point.test.ts

@@ -1,63 +1,61 @@
-import { describe, it, expect } from 'bun:test';
-import { EntryPointExpander } from './entry-point.js';
-import { EntryPointConfig } from '../config/types.js';
-
-describe('EntryPointExpander', () => {
-  const expander = new EntryPointExpander();
-
-  it('should include root entry point if there are any changes', async () => {
-    const entryPoints: EntryPointConfig[] = [{ path: '.' }];
-    const changes = ['some/file.ts'];
-
-    const result = await expander.expand(entryPoints, changes);
-    
-    expect(result).toHaveLength(1);
-    expect(result[0].path).toBe('.');
-  });
-
-  it('should match fixed directory entry points', async () => {
-    const entryPoints: EntryPointConfig[] = [
-      { path: 'apps/api' },
-      { path: 'apps/web' }
-    ];
-    const changes = ['apps/api/src/index.ts'];
-
-    const result = await expander.expand(entryPoints, changes);
-    
-    // Result should have root (implicit or explicit fallback in code) + matched
-    // Looking at code: "if (changedFiles.length > 0) ... results.push({ path: '.', ... })"
-    // Wait, the code creates a default root config if one isn't provided in the list?
-    // Code: "const rootConfig = rootEntryPoint ?? { path: '.' }; results.push({ path: '.', config: rootConfig });"
-    // Yes, it always pushes root if changes > 0.
-
-    expect(result.some(r => r.path === 'apps/api')).toBe(true);
-    expect(result.some(r => r.path === 'apps/web')).toBe(false);
-  });
-
-  it('should match wildcard entry points', async () => {
-    const entryPoints: EntryPointConfig[] = [
-      { path: 'packages/*' }
-    ];
-    const changes = [
-      'packages/ui/button.ts',
-      'packages/utils/helper.ts',
-      'other/file.ts'
-    ];
-
-    const result = await expander.expand(entryPoints, changes);
-
-    const paths = result.map(r => r.path);
-    expect(paths).toContain('packages/ui');
-    expect(paths).toContain('packages/utils');
-    expect(paths).not.toContain('packages/other');
-  });
-
-  it('should handle no changes', async () => {
-    const entryPoints: EntryPointConfig[] = [{ path: '.' }];
-    const changes: string[] = [];
-
-    const result = await expander.expand(entryPoints, changes);
-    
-    expect(result).toHaveLength(0);
-  });
+import { describe, expect, it } from "bun:test";
+import type { EntryPointConfig } from "../config/types.js";
+import { EntryPointExpander } from "./entry-point.js";
+
+describe("EntryPointExpander", () => {
+	const expander = new EntryPointExpander();
+
+	it("should include root entry point if there are any changes", async () => {
+		const entryPoints: EntryPointConfig[] = [{ path: "." }];
+		const changes = ["some/file.ts"];
+
+		const result = await expander.expand(entryPoints, changes);
+
+		expect(result).toHaveLength(1);
+		expect(result[0].path).toBe(".");
+	});
+
+	it("should match fixed directory entry points", async () => {
+		const entryPoints: EntryPointConfig[] = [
+			{ path: "apps/api" },
+			{ path: "apps/web" },
+		];
+		const changes = ["apps/api/src/index.ts"];
+
+		const result = await expander.expand(entryPoints, changes);
+
+		// Result should have root (implicit or explicit fallback in code) + matched
+		// Looking at code: "if (changedFiles.length > 0) ... results.push({ path: '.', ... })"
+		// Wait, the code creates a default root config if one isn't provided in the list?
+		// Code: "const rootConfig = rootEntryPoint ?? { path: '.' }; results.push({ path: '.', config: rootConfig });"
+		// Yes, it always pushes root if changes > 0.
+
+		expect(result.some((r) => r.path === "apps/api")).toBe(true);
+		expect(result.some((r) => r.path === "apps/web")).toBe(false);
+	});
+
+	it("should match wildcard entry points", async () => {
+		const entryPoints: EntryPointConfig[] = [{ path: "packages/*" }];
+		const changes = [
+			"packages/ui/button.ts",
+			"packages/utils/helper.ts",
+			"other/file.ts",
+		];
+
+		const result = await expander.expand(entryPoints, changes);
+
+		const paths = result.map((r) => r.path);
+		expect(paths).toContain("packages/ui");
+		expect(paths).toContain("packages/utils");
+		expect(paths).not.toContain("packages/other");
+	});
+
+	it("should handle no changes", async () => {
+		const entryPoints: EntryPointConfig[] = [{ path: "." }];
+		const changes: string[] = [];
+
+		const result = await expander.expand(entryPoints, changes);
+
+		expect(result).toHaveLength(0);
+	});
 });

package/src/core/entry-point.ts

@@ -1,80 +1,126 @@
-import path from 'node:path';
-import { EntryPointConfig } from '../config/types.js';
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { EntryPointConfig } from "../config/types.js";
 
 export interface ExpandedEntryPoint {
-  path: string; // The specific directory (e.g., "engines/billing")
-  config: EntryPointConfig; // The config that generated this (e.g., "engines/*")
+	path: string; // The specific directory (e.g., "engines/billing")
+	config: EntryPointConfig; // The config that generated this (e.g., "engines/*")
 }
 
 export class EntryPointExpander {
-  constructor(private rootDir: string = process.cwd()) {}
-
-  async expand(entryPoints: EntryPointConfig[], changedFiles: string[]): Promise<ExpandedEntryPoint[]> {
-    const results: ExpandedEntryPoint[] = [];
-    const rootEntryPoint = entryPoints.find(ep => ep.path === '.');
-    
-    // Always include root entry point if configured and there are ANY changes
-    // Or should it only run if files match root patterns?
-    // Spec says: "A root entry point always exists and applies to repository-wide gates."
-    // Usually root gates run on any change or specific files in root.
-    // For simplicity, if root is configured, we'll include it if there are any changed files.
-    if (changedFiles.length > 0) {
-      const rootConfig = rootEntryPoint ?? { path: '.' };
-      results.push({ path: '.', config: rootConfig });
-    }
-
-    for (const ep of entryPoints) {
-      if (ep.path === '.') continue; // Handled above
-
-      if (ep.path.endsWith('*')) {
-        // Wildcard directory (e.g., "engines/*")
-        const parentDir = ep.path.slice(0, -2); // "engines"
-        const expandedPaths = await this.expandWildcard(parentDir, changedFiles);
-        
-        for (const subDir of expandedPaths) {
-          results.push({
-            path: subDir,
-            config: ep
-          });
-        }
-      } else {
-        // Fixed directory (e.g., "apps/api")
-        if (this.hasChangesInDir(ep.path, changedFiles)) {
-          results.push({
-            path: ep.path,
-            config: ep
-          });
-        }
-      }
-    }
-
-    return results;
-  }
-
-  private async expandWildcard(parentDir: string, changedFiles: string[]): Promise<string[]> {
-    const affectedSubDirs = new Set<string>();
-    
-    // Filter changes that are inside this parent directory
-    const relevantChanges = changedFiles.filter(f => f.startsWith(parentDir + '/'));
-    
-    for (const file of relevantChanges) {
-      // file: "engines/billing/src/foo.ts", parentDir: "engines"
-      // relPath: "billing/src/foo.ts"
-      const relPath = file.slice(parentDir.length + 1);
-      const subDirName = relPath.split('/')[0];
-      
-      if (subDirName) {
-        affectedSubDirs.add(path.join(parentDir, subDirName));
-      }
-    }
-
-    return Array.from(affectedSubDirs);
-  }
-
-  private hasChangesInDir(dirPath: string, changedFiles: string[]): boolean {
-    // Check if any changed file starts with the dirPath
-    // Need to ensure exact match or subdirectory (e.g. "app" should not match "apple")
-    const dirPrefix = dirPath.endsWith('/') ? dirPath : dirPath + '/';
-    return changedFiles.some(f => f === dirPath || f.startsWith(dirPrefix));
-  }
+	async expand(
+		entryPoints: EntryPointConfig[],
+		changedFiles: string[],
+	): Promise<ExpandedEntryPoint[]> {
+		const results: ExpandedEntryPoint[] = [];
+		const rootEntryPoint = entryPoints.find((ep) => ep.path === ".");
+
+		// Always include root entry point if configured and there are ANY changes
+		// Or should it only run if files match root patterns?
+		// Spec says: "A root entry point always exists and applies to repository-wide gates."
+		// Usually root gates run on any change or specific files in root.
+		// For simplicity, if root is configured, we'll include it if there are any changed files.
+		if (changedFiles.length > 0) {
+			const rootConfig = rootEntryPoint ?? { path: "." };
+			results.push({ path: ".", config: rootConfig });
+		}
+
+		for (const ep of entryPoints) {
+			if (ep.path === ".") continue; // Handled above
+
+			if (ep.path.endsWith("*")) {
+				// Wildcard directory (e.g., "engines/*")
+				const parentDir = ep.path.slice(0, -2); // "engines"
+				const expandedPaths = await this.expandWildcard(
+					parentDir,
+					changedFiles,
+				);
+
+				for (const subDir of expandedPaths) {
+					results.push({
+						path: subDir,
+						config: ep,
+					});
+				}
+			} else {
+				// Fixed directory (e.g., "apps/api")
+				if (this.hasChangesInDir(ep.path, changedFiles)) {
+					results.push({
+						path: ep.path,
+						config: ep,
+					});
+				}
+			}
+		}
+
+		return results;
+	}
+
+	async expandAll(
+		entryPoints: EntryPointConfig[],
+	): Promise<ExpandedEntryPoint[]> {
+		const results: ExpandedEntryPoint[] = [];
+
+		for (const ep of entryPoints) {
+			if (ep.path === ".") {
+				results.push({ path: ".", config: ep });
+				continue;
+			}
+
+			if (ep.path.endsWith("*")) {
+				const parentDir = ep.path.slice(0, -2);
+				const subDirs = await this.listSubDirectories(parentDir);
+				for (const subDir of subDirs) {
+					results.push({ path: subDir, config: ep });
+				}
+			} else {
+				results.push({ path: ep.path, config: ep });
+			}
+		}
+
+		return results;
+	}
+
+	private async expandWildcard(
+		parentDir: string,
+		changedFiles: string[],
+	): Promise<string[]> {
+		const affectedSubDirs = new Set<string>();
+
+		// Filter changes that are inside this parent directory
+		const relevantChanges = changedFiles.filter((f) =>
+			f.startsWith(`${parentDir}/`),
+		);
+
+		for (const file of relevantChanges) {
+			// file: "engines/billing/src/foo.ts", parentDir: "engines"
+			// relPath: "billing/src/foo.ts"
+			const relPath = file.slice(parentDir.length + 1);
+			const subDirName = relPath.split("/")[0];
+
+			if (subDirName) {
+				affectedSubDirs.add(path.join(parentDir, subDirName));
+			}
+		}
+
+		return Array.from(affectedSubDirs);
+	}
+
+	private async listSubDirectories(parentDir: string): Promise<string[]> {
+		try {
+			const dirents = await fs.readdir(parentDir, { withFileTypes: true });
+			return dirents
+				.filter((d) => d.isDirectory())
+				.map((d) => path.join(parentDir, d.name));
+		} catch {
+			return [];
+		}
+	}
+
+	private hasChangesInDir(dirPath: string, changedFiles: string[]): boolean {
+		// Check if any changed file starts with the dirPath
+		// Need to ensure exact match or subdirectory (e.g. "app" should not match "apple")
+		const dirPrefix = dirPath.endsWith("/") ? dirPath : `${dirPath}/`;
+		return changedFiles.some((f) => f === dirPath || f.startsWith(dirPrefix));
+	}
 }