@bastani/atomic 0.8.31-alpha.4 → 0.9.0-alpha.1

package/dist/builtin/subagents/src/runs/shared/worktree.ts

@@ -3,13 +3,11 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { APP_NAME, createGitEnvironment } from "@bastani/atomic";
-
 export interface WorktreeSetup {
 	cwd: string;
 	worktrees: WorktreeInfo[];
 	baseCommit: string;
 }
-
 interface WorktreeInfo {
 	path: string;
 	agentCwd: string;
@@ -18,7 +16,6 @@ interface WorktreeInfo {
 	nodeModulesLinked: boolean;
 	syntheticPaths: string[];
 }
-
 interface WorktreeDiff {
 	index: number;
 	agent: string;
@@ -29,28 +26,23 @@ interface WorktreeDiff {
 	deletions: number;
 	patchPath: string;
 }
-
 interface WorktreeTaskCwdConflict {
 	index: number;
 	agent: string;
 	cwd: string;
 }
-
 interface WorktreeSetupHookConfig {
 	hookPath: string;
 	timeoutMs?: number;
 }
-
 interface CreateWorktreesOptions {
 	agents?: string[];
 	setupHook?: WorktreeSetupHookConfig;
 }
-
 interface ResolvedWorktreeSetupHook {
 	hookPath: string;
 	timeoutMs: number;
 }
-
 interface WorktreeSetupHookInput {
 	version: 1;
 	repoRoot: string;
@@ -62,25 +54,20 @@ interface WorktreeSetupHookInput {
 	baseCommit: string;
 	agent?: string;
 }
-
 interface WorktreeSetupHookOutput {
 	syntheticPaths?: string[];
 }
-
 interface GitResult {
 	stdout: string;
 	stderr: string;
 	status: number | null;
 }
-
 interface RepoState {
 	toplevel: string;
 	cwdRelative: string;
 	baseCommit: string;
 }
-
 const DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS = 30000;
-
 function runGit(cwd: string, args: string[]): GitResult {
 	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8", env: createGitEnvironment() });
 	return {
@@ -89,7 +76,6 @@ function runGit(cwd: string, args: string[]): GitResult {
 		status: result.status,
 	};
 }
-
 function runGitChecked(cwd: string, args: string[]): string {
 	const result = runGit(cwd, args);
 	if (result.status !== 0) {
@@ -99,30 +85,24 @@ function runGitChecked(cwd: string, args: string[]): string {
 	}
 	return result.stdout;
 }
-
 function resolveRepoState(cwd: string): RepoState {
 	const cwdRelative = resolveRepoCwdRelative(cwd);
 	const toplevel = runGitChecked(cwd, ["rev-parse", "--show-toplevel"]).trim();
-
 	const status = runGitChecked(toplevel, ["status", "--porcelain"]);
 	if (status.trim().length > 0) {
 		throw new Error("worktree isolation requires a clean git working tree. Commit or stash changes first.");
 	}
-
 	const baseCommit = runGitChecked(toplevel, ["rev-parse", "HEAD"]).trim();
 	return { toplevel, cwdRelative, baseCommit };
 }
-
 function normalizeComparableCwd(cwd: string): string {
 	const resolved = path.resolve(cwd);
 	try {
 		return fs.realpathSync(resolved);
 	} catch {
-		// Use the unresolved absolute path when realpath resolution is unavailable.
 		return resolved;
 	}
 }
-
 export function findWorktreeTaskCwdConflict(
 	tasks: ReadonlyArray<{ agent: string; cwd?: string }>,
 	sharedCwd: string,
@@ -137,26 +117,21 @@ export function findWorktreeTaskCwdConflict(
 	}
 	return undefined;
 }
-
 export function formatWorktreeTaskCwdConflict(
 	conflict: WorktreeTaskCwdConflict,
 	sharedCwd: string,
 ): string {
 	return `worktree isolation uses the shared cwd (${sharedCwd}); task ${conflict.index + 1} (${conflict.agent}) sets cwd to ${conflict.cwd}. Remove task-level cwd overrides or disable worktree.`;
 }
-
 function safePatchAgentName(agent: string): string {
 	return agent.replace(/[^\w.-]/g, "_");
 }
-
 function buildWorktreeBranch(runId: string, index: number): string {
 	return `${APP_NAME}-parallel-${runId}-${index}`;
 }
-
 function buildWorktreePath(runId: string, index: number): string {
 	return path.join(os.tmpdir(), `${APP_NAME}-worktree-${runId}-${index}`);
 }
-
 function resolveRepoCwdRelative(cwd: string): string {
 	const repoCheck = runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
 	if (repoCheck.status !== 0 || repoCheck.stdout.trim() !== "true") {
@@ -168,13 +143,11 @@ function resolveRepoCwdRelative(cwd: string): string {
 		: "";
 	return normalizedPrefix === "." ? "" : normalizedPrefix;
 }
-
 export function resolveExpectedWorktreeAgentCwd(cwd: string, runId: string, index: number): string {
 	const cwdRelative = resolveRepoCwdRelative(cwd);
 	const worktreePath = buildWorktreePath(runId, index);
 	return cwdRelative ? path.join(worktreePath, cwdRelative) : worktreePath;
 }
-
 function linkNodeModulesIfPresent(toplevel: string, worktreePath: string): boolean {
 	const nodeModulesPath = path.join(toplevel, "node_modules");
 	const nodeModulesLinkPath = path.join(worktreePath, "node_modules");
@@ -183,11 +156,9 @@ function linkNodeModulesIfPresent(toplevel: string, worktreePath: string): boole
 		fs.symlinkSync(nodeModulesPath, nodeModulesLinkPath);
 		return true;
 	} catch {
-		// Symlink creation is optional (e.g., unsupported filesystems on CI runners).
 		return false;
 	}
 }
-
 function parseHookTimeout(timeoutMs: number | undefined): number {
 	if (timeoutMs === undefined) return DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS;
 	if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
@@ -195,7 +166,6 @@ function parseHookTimeout(timeoutMs: number | undefined): number {
 	}
 	return timeoutMs;
 }
-
 function resolveWorktreeSetupHook(
 	repoRoot: string,
 	config: WorktreeSetupHookConfig | undefined,
@@ -205,7 +175,6 @@ function resolveWorktreeSetupHook(
 	if (!hookPath) {
 		throw new Error("worktree setup hook path cannot be empty");
 	}
-
 	const expandedHookPath = hookPath.startsWith("~/") ? path.join(os.homedir(), hookPath.slice(2)) : hookPath;
 	let resolvedPath: string;
 	if (path.isAbsolute(expandedHookPath)) {
@@ -215,25 +184,21 @@ function resolveWorktreeSetupHook(
 	} else {
 		throw new Error("worktree setup hook must be an absolute path or a repo-relative path");
 	}
-
 	if (!fs.existsSync(resolvedPath)) {
 		throw new Error(`worktree setup hook not found: ${resolvedPath}`);
 	}
 	if (fs.statSync(resolvedPath).isDirectory()) {
 		throw new Error(`worktree setup hook must be a file, got directory: ${resolvedPath}`);
 	}
-
 	return {
 		hookPath: resolvedPath,
 		timeoutMs: parseHookTimeout(config.timeoutMs),
 	};
 }
-
 function normalizeSyntheticPath(worktreePath: string, rawPath: string): string {
 	const trimmed = rawPath.trim();
 	if (!trimmed) throw new Error("synthetic path cannot be empty");
 	if (path.isAbsolute(trimmed)) throw new Error(`synthetic path must be relative: ${rawPath}`);
-
 	const resolved = path.resolve(worktreePath, trimmed);
 	const relative = path.relative(worktreePath, resolved);
 	if (!relative || relative === ".") {
@@ -244,12 +209,10 @@ function normalizeSyntheticPath(worktreePath: string, rawPath: string): string {
 	}
 	return path.normalize(relative);
 }
-
 function hasTrackedEntries(worktreePath: string, relativePath: string): boolean {
 	const result = runGit(worktreePath, ["ls-files", "--", relativePath]);
 	return result.status === 0 && result.stdout.trim().length > 0;
 }
-
 function parseWorktreeSetupHookOutput(rawStdout: string): WorktreeSetupHookOutput {
 	const trimmed = rawStdout.trim();
 	if (!trimmed) {
@@ -267,7 +230,6 @@ function parseWorktreeSetupHookOutput(rawStdout: string): WorktreeSetupHookOutpu
 	}
 	return parsed as WorktreeSetupHookOutput;
 }
-
 function runWorktreeSetupHook(
 	hook: ResolvedWorktreeSetupHook,
 	input: WorktreeSetupHookInput,
@@ -279,7 +241,6 @@ function runWorktreeSetupHook(
 		timeout: hook.timeoutMs,
 		shell: false,
 	});
-
 	if (result.error) {
 		const code = "code" in result.error ? result.error.code : undefined;
 		if (code === "ETIMEDOUT") {
@@ -287,18 +248,15 @@ function runWorktreeSetupHook(
 		}
 		throw new Error(`worktree setup hook failed: ${result.error.message}`);
 	}
-
 	if (result.status !== 0) {
 		const details = result.stderr.trim() || result.stdout.trim() || "no output";
 		throw new Error(`worktree setup hook failed with exit code ${result.status}: ${details}`);
 	}
-
 	const output = parseWorktreeSetupHookOutput(result.stdout);
 	if (output.syntheticPaths === undefined) return [];
 	if (!Array.isArray(output.syntheticPaths)) {
 		throw new Error("worktree setup hook output field 'syntheticPaths' must be an array of relative paths");
 	}
-
 	const uniquePaths = new Set<string>();
 	for (const candidate of output.syntheticPaths) {
 		if (typeof candidate !== "string") {
@@ -312,7 +270,6 @@ function runWorktreeSetupHook(
 	}
 	return [...uniquePaths];
 }
-
 function createSingleWorktree(
 	toplevel: string,
 	cwdRelative: string,
@@ -329,12 +286,10 @@ function createSingleWorktree(
 		const message = add.stderr.trim() || add.stdout.trim() || `failed to create worktree ${worktreePath}`;
 		throw new Error(message);
 	}
-
 	const agentCwd = cwdRelative ? path.join(worktreePath, cwdRelative) : worktreePath;
 	try {
 		const nodeModulesLinked = linkNodeModulesIfPresent(toplevel, worktreePath);
 		const syntheticPaths = nodeModulesLinked ? ["node_modules"] : [];
-
 		if (setupHook) {
 			const hookSyntheticPaths = runWorktreeSetupHook(setupHook, {
 				version: 1,
@@ -349,7 +304,6 @@ function createSingleWorktree(
 			});
 			syntheticPaths.push(...hookSyntheticPaths);
 		}
-
 		return {
 			path: worktreePath,
 			agentCwd,
@@ -360,22 +314,18 @@ function createSingleWorktree(
 		};
 	} catch (error) {
 		try { runGitChecked(toplevel, ["worktree", "remove", "--force", worktreePath]); } catch {
-			// Best-effort rollback; preserve the original setup failure.
 		}
 		try { runGitChecked(toplevel, ["branch", "-D", branch]); } catch {
-			// Best-effort rollback; preserve the original setup failure.
 		}
 		throw error;
 	}
 }
-
 function removeSyntheticPath(worktree: WorktreeInfo, syntheticPath: string): void {
 	const resolved = path.resolve(worktree.path, syntheticPath);
 	const relative = path.relative(worktree.path, resolved);
 	if (!relative || relative === "." || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
 		return;
 	}
-
 	let stat: fs.Stats;
 	try {
 		stat = fs.lstatSync(resolved);
@@ -384,7 +334,6 @@ function removeSyntheticPath(worktree: WorktreeInfo, syntheticPath: string): voi
 		if (code === "ENOENT") return;
 		throw error;
 	}
-
 	if (stat.isSymbolicLink()) {
 		fs.unlinkSync(resolved);
 		return;
@@ -395,7 +344,6 @@ function removeSyntheticPath(worktree: WorktreeInfo, syntheticPath: string): voi
 	}
 	fs.rmSync(resolved, { force: true });
 }
-
 function removeSyntheticPathsBeforeDiff(worktree: WorktreeInfo): void {
 	if (worktree.syntheticPaths.length === 0) return;
 	const seen = new Set<string>();
@@ -405,7 +353,6 @@ function removeSyntheticPathsBeforeDiff(worktree: WorktreeInfo): void {
 		removeSyntheticPath(worktree, syntheticPath);
 	}
 }
-
 function emptyDiff(index: number, agent: string, branch: string, patchPath: string): WorktreeDiff {
 	return {
 		index,
@@ -418,7 +365,6 @@ function emptyDiff(index: number, agent: string, branch: string, patchPath: stri
 		patchPath,
 	};
 }
-
 function parseNumstat(numstat: string): { filesChanged: number; insertions: number; deletions: number } {
 	const lines = numstat
 		.split("\n")
@@ -427,7 +373,6 @@ function parseNumstat(numstat: string): { filesChanged: number; insertions: numb
 	let filesChanged = 0;
 	let insertions = 0;
 	let deletions = 0;
-
 	for (const line of lines) {
 		const [rawInsertions, rawDeletions] = line.split("\t");
 		if (rawInsertions === undefined || rawDeletions === undefined) continue;
@@ -435,10 +380,8 @@ function parseNumstat(numstat: string): { filesChanged: number; insertions: numb
 		if (/^\d+$/.test(rawInsertions)) insertions += parseInt(rawInsertions, 10);
 		if (/^\d+$/.test(rawDeletions)) deletions += parseInt(rawDeletions, 10);
 	}
-
 	return { filesChanged, insertions, deletions };
 }
-
 function captureWorktreeDiff(
 	setup: WorktreeSetup,
 	worktree: WorktreeInfo,
@@ -451,11 +394,9 @@ function captureWorktreeDiff(
 	const patch = runGitChecked(worktree.path, ["diff", "--cached", setup.baseCommit]);
 	const numstat = runGitChecked(worktree.path, ["diff", "--cached", "--numstat", setup.baseCommit]);
 	fs.writeFileSync(patchPath, patch, "utf-8");
-
 	if (!patch.trim()) {
 		return emptyDiff(worktree.index, agent, worktree.branch, patchPath);
 	}
-
 	const parsed = parseNumstat(numstat);
 	return {
 		index: worktree.index,
@@ -468,33 +409,25 @@ function captureWorktreeDiff(
 		patchPath,
 	};
 }
-
 function writeEmptyPatch(patchPath: string): void {
 	try {
 		fs.writeFileSync(patchPath, "", "utf-8");
 	} catch {
-		// Diff artifact writing is best-effort in error paths.
 	}
 }
-
 function cleanupSingleWorktree(repoCwd: string, worktree: WorktreeInfo): void {
 	try { runGitChecked(repoCwd, ["worktree", "remove", "--force", worktree.path]); } catch {
-		// Cleanup is best-effort to avoid masking caller errors.
 	}
 	try { runGitChecked(repoCwd, ["branch", "-D", worktree.branch]); } catch {
-		// Cleanup is best-effort to avoid masking caller errors.
 	}
 }
-
 function hasWorktreeChanges(diff: WorktreeDiff): boolean {
 	return diff.filesChanged > 0 || diff.insertions > 0 || diff.deletions > 0 || diff.diffStat.trim().length > 0;
 }
-
 export function createWorktrees(cwd: string, runId: string, count: number, options?: CreateWorktreesOptions): WorktreeSetup {
 	const repo = resolveRepoState(cwd);
 	const setupHook = resolveWorktreeSetupHook(repo.toplevel, options?.setupHook);
 	const worktrees: WorktreeInfo[] = [];
-
 	try {
 		for (let index = 0; index < count; index++) {
 			worktrees.push(createSingleWorktree(
@@ -515,22 +448,18 @@ export function createWorktrees(cwd: string, runId: string, count: number, optio
 		});
 		throw error;
 	}
-
 	return {
 		cwd: repo.toplevel,
 		worktrees,
 		baseCommit: repo.baseCommit,
 	};
 }
-
 export function diffWorktrees(setup: WorktreeSetup, agents: string[], diffsDir: string): WorktreeDiff[] {
 	try {
 		fs.mkdirSync(diffsDir, { recursive: true });
 	} catch {
-		// Returning no diffs is safer than failing the whole command on artifact-dir issues.
 		return [];
 	}
-
 	const diffs: WorktreeDiff[] = [];
 	for (let index = 0; index < setup.worktrees.length; index++) {
 		const worktree = setup.worktrees[index]!;
@@ -539,28 +468,22 @@ export function diffWorktrees(setup: WorktreeSetup, agents: string[], diffsDir:
 		try {
 			diffs.push(captureWorktreeDiff(setup, worktree, agent, patchPath));
 		} catch {
-			// Preserve execution flow; failed diff capture maps to an empty per-task patch.
 			writeEmptyPatch(patchPath);
 			diffs.push(emptyDiff(index, agent, worktree.branch, patchPath));
 		}
 	}
-
 	return diffs;
 }
-
 export function cleanupWorktrees(setup: WorktreeSetup): void {
 	for (let index = setup.worktrees.length - 1; index >= 0; index--) {
 		cleanupSingleWorktree(setup.cwd, setup.worktrees[index]!);
 	}
 	try { runGitChecked(setup.cwd, ["worktree", "prune"]); } catch {
-		// Pruning is best-effort cleanup.
 	}
 }
-
 export function formatWorktreeDiffSummary(diffs: WorktreeDiff[]): string {
 	const changed = diffs.filter(hasWorktreeChanges);
 	if (changed.length === 0) return "";
-
 	const lines: string[] = ["=== Worktree Changes ===", ""];
 	for (const diff of changed) {
 		lines.push(
@@ -571,7 +494,6 @@ export function formatWorktreeDiffSummary(diffs: WorktreeDiff[]): string {
 		}
 		lines.push("");
 	}
-
 	const patchesDir = path.dirname(changed[0]!.patchPath);
 	lines.push(`Full patches: ${patchesDir}`);
 	return lines.join("\n").trimEnd();