@bastani/atomic 0.8.31-alpha.5 → 0.9.0-alpha.2

package/dist/builtin/workflows/src/runs/shared/worktree-diff.ts

@@ -0,0 +1,165 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { runGitChecked } from "./worktree-git.js";
+import type { WorktreeDiff, WorktreeInfo, WorktreeSetup } from "./worktree-types.js";
+
+function safePatchAgentName(agent: string): string {
+	return agent.replace(/[^\w.-]/g, "_");
+}
+
+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);
+	} catch (error) {
+		const code = error && typeof error === "object" && "code" in error ? (error as { code?: unknown }).code : undefined;
+		if (code === "ENOENT") return;
+		throw error;
+	}
+
+	if (stat.isSymbolicLink()) {
+		fs.unlinkSync(resolved);
+		return;
+	}
+	if (stat.isDirectory()) {
+		fs.rmSync(resolved, { recursive: true, force: true });
+		return;
+	}
+	fs.rmSync(resolved, { force: true });
+}
+
+function removeSyntheticPathsBeforeDiff(worktree: WorktreeInfo): void {
+	if (worktree.syntheticPaths.length === 0) return;
+	const seen = new Set<string>();
+	for (const syntheticPath of worktree.syntheticPaths) {
+		if (seen.has(syntheticPath)) continue;
+		seen.add(syntheticPath);
+		removeSyntheticPath(worktree, syntheticPath);
+	}
+}
+
+function emptyDiff(index: number, agent: string, branch: string, patchPath: string): WorktreeDiff {
+	return {
+		index,
+		agent,
+		branch,
+		diffStat: "",
+		filesChanged: 0,
+		insertions: 0,
+		deletions: 0,
+		patchPath,
+	};
+}
+
+function parseNumstat(numstat: string): { filesChanged: number; insertions: number; deletions: number } {
+	const lines = numstat
+		.split("\n")
+		.map((line) => line.trim())
+		.filter(Boolean);
+	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;
+		filesChanged++;
+		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,
+	agent: string,
+	patchPath: string,
+): WorktreeDiff {
+	removeSyntheticPathsBeforeDiff(worktree);
+	runGitChecked(worktree.path, ["add", "-A"]);
+	const diffStat = runGitChecked(worktree.path, ["diff", "--cached", "--stat", setup.baseCommit]).trim();
+	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,
+		agent,
+		branch: worktree.branch,
+		diffStat,
+		filesChanged: parsed.filesChanged,
+		insertions: parsed.insertions,
+		deletions: parsed.deletions,
+		patchPath,
+	};
+}
+
+function writeEmptyPatch(patchPath: string): void {
+	try {
+		fs.writeFileSync(patchPath, "", "utf-8");
+	} catch {
+		// Diff artifact writing is best-effort in error paths.
+	}
+}
+
+function hasWorktreeChanges(diff: WorktreeDiff): boolean {
+	return diff.filesChanged > 0 || diff.insertions > 0 || diff.deletions > 0 || diff.diffStat.trim().length > 0;
+}
+
+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]!;
+		const agent = agents[index] ?? `task-${index + 1}`;
+		const patchPath = path.join(diffsDir, `task-${index}-${safePatchAgentName(agent)}.patch`);
+		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 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(
+			`--- Task ${diff.index + 1} (${diff.agent}): ${diff.filesChanged} files changed, +${diff.insertions} -${diff.deletions} ---`,
+		);
+		if (diff.diffStat.trim().length > 0) {
+			lines.push(diff.diffStat);
+		}
+		lines.push("");
+	}
+
+	const patchesDir = path.dirname(changed[0]!.patchPath);
+	lines.push(`Full patches: ${patchesDir}`);
+	return lines.join("\n").trimEnd();
+}

package/dist/builtin/workflows/src/runs/shared/worktree-git.ts

@@ -0,0 +1,220 @@
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createGitEnvironment } from "@bastani/atomic";
+import type { GitResult, GitWorktreeSetupOptions, GitWorktreeSetupResult } from "./worktree-types.js";
+
+const DISABLED_GIT_HOOKS_PATH = process.platform === "win32" ? "NUL" : "/dev/null";
+
+export function runGit(cwd: string, args: string[]): GitResult {
+	const result = spawnSync("git", [
+		"-c",
+		`core.hooksPath=${DISABLED_GIT_HOOKS_PATH}`,
+		"-c",
+		"core.fsmonitor=false",
+		...args,
+	], {
+		cwd,
+		encoding: "utf-8",
+		env: createGitEnvironment({ GIT_OPTIONAL_LOCKS: "0" }),
+		timeout: 5000,
+	});
+	return {
+		stdout: result.stdout ?? "",
+		stderr: result.stderr ?? "",
+		status: result.status,
+		...(result.error === undefined ? {} : { error: result.error }),
+	};
+}
+
+export function runGitChecked(cwd: string, args: string[]): string {
+	const result = runGit(cwd, args);
+	if (result.status !== 0) {
+		const command = `git -C ${cwd} ${args.join(" ")}`;
+		const message = result.stderr.trim() || result.stdout.trim() || `${command} failed`;
+		throw new Error(message);
+	}
+	return result.stdout;
+}
+
+export function gitFailureMessage(result: GitResult): string {
+	if (result.error !== undefined) return result.error.message;
+	return result.stderr.trim() || result.stdout.trim() || `git exited with status ${result.status}`;
+}
+
+function quoteShellArg(value: string): string {
+	if (process.platform === "win32") return `"${value.replace(/"/g, "\"\"")}"`;
+	return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+function worktreeRecoveryCommand(repositoryRoot: string, worktreeDir: string): string {
+	return `git -C ${quoteShellArg(repositoryRoot)} worktree remove --force ${quoteShellArg(worktreeDir)}`;
+}
+
+function hasGrandparent(value: string): boolean {
+	const parent = path.dirname(value);
+	if (parent === value) return false;
+	const grandparent = path.dirname(parent);
+	return grandparent !== parent;
+}
+
+function pathAncestors(value: string): string[] {
+	const ancestors: string[] = [];
+	let current = value;
+	while (true) {
+		ancestors.push(current);
+		const parent = path.dirname(current);
+		if (parent === current) return ancestors;
+		current = parent;
+	}
+}
+
+function shouldPreserveLogicalPath(logicalPath: string): boolean {
+	return pathAncestors(logicalPath).some((ancestor) => {
+		try {
+			return fs.lstatSync(ancestor).isSymbolicLink() && hasGrandparent(ancestor);
+		} catch {
+			return false;
+		}
+	});
+}
+
+function canonicalizePreservingSymlinks(value: string): string {
+	const logicalPath = path.resolve(value);
+	const preserveLogicalPath = shouldPreserveLogicalPath(logicalPath);
+	try {
+		const canonical = fs.realpathSync.native(logicalPath);
+		return preserveLogicalPath && canonical !== logicalPath ? logicalPath : canonical;
+	} catch {
+		return logicalPath;
+	}
+}
+
+function resolveGitWorktreePath(value: string, repoRoot: string): string {
+	const trimmed = value.trim();
+	if (!trimmed) throw new Error("gitWorktreeDir cannot be empty");
+	if (trimmed.includes("\0")) {
+		throw new Error("gitWorktreeDir contains an unusable null byte; provide a valid path or omit gitWorktreeDir.");
+	}
+	return canonicalizePreservingSymlinks(path.isAbsolute(trimmed) ? trimmed : path.resolve(repoRoot, trimmed));
+}
+
+function comparableRealPath(value: string): string {
+	const realpath = fs.realpathSync.native(value).replace(/\\/g, "/");
+	return process.platform === "win32" ? realpath.toLowerCase() : realpath;
+}
+
+function gitPathFromOutput(value: string, cwd: string): string | undefined {
+	const trimmed = value.trim();
+	if (!trimmed) return undefined;
+	return path.isAbsolute(trimmed) ? path.resolve(trimmed) : path.resolve(cwd, trimmed);
+}
+
+function pathExistsSync(value: string): boolean {
+	try {
+		fs.statSync(value);
+		return true;
+	} catch (error) {
+		const code = error && typeof error === "object" && "code" in error ? (error as { code?: unknown }).code : undefined;
+		if (code === "ENOENT" || code === "ENOTDIR") return false;
+		throw error;
+	}
+}
+
+function repositoryRootForGitWorktree(cwd: string): string {
+	const result = runGit(cwd, ["rev-parse", "--show-toplevel"]);
+	if (result.status !== 0) {
+		throw new Error(`gitWorktreeDir requires the workflow to be invoked from inside a Git repository. Start from a Git checkout or omit gitWorktreeDir. Git reported: ${gitFailureMessage(result)}`);
+	}
+	return result.stdout.trim();
+}
+
+function gitTopLevel(cwd: string): string | undefined {
+	const result = runGit(cwd, ["rev-parse", "--show-toplevel"]);
+	if (result.status !== 0) return undefined;
+	return gitPathFromOutput(result.stdout, cwd);
+}
+
+function gitCommonDirForWorktree(cwd: string): string {
+	const result = runGit(cwd, ["rev-parse", "--git-common-dir"]);
+	if (result.status !== 0) throw new Error(gitFailureMessage(result));
+	const gitPath = gitPathFromOutput(result.stdout, cwd);
+	if (gitPath === undefined) throw new Error("git rev-parse --git-common-dir returned an empty path");
+	return gitPath;
+}
+
+function dirnameForEachRelativeComponent(base: string, relativePath: string): string | undefined {
+	if (relativePath === "") return base;
+	let current = base;
+	for (const component of relativePath.split(/[\\/]+/).filter(Boolean)) {
+		if (component === ".") continue;
+		if (component === "..") return undefined;
+		current = path.dirname(current);
+	}
+	return current;
+}
+
+function cwdWithinGitRepository(cwd: string, repoRoot: string): { relativeCwd: string; logicalRepoRoot: string } {
+	const sourceCwd = fs.realpathSync.native(cwd);
+	const sourceRepoRoot = fs.realpathSync.native(repoRoot);
+	const relativeCwd = path.relative(sourceRepoRoot, sourceCwd);
+	const safeRelativeCwd = relativeCwd === "" || relativeCwd.startsWith("..") || path.isAbsolute(relativeCwd) ? "" : relativeCwd;
+	const logicalCwd = canonicalizePreservingSymlinks(cwd);
+	return {
+		relativeCwd: safeRelativeCwd,
+		logicalRepoRoot: dirnameForEachRelativeComponent(logicalCwd, safeRelativeCwd) ?? repoRoot,
+	};
+}
+
+function workspaceCwdForGitWorktreeRoot(worktreeRoot: string, relativeCwd: string): string {
+	return relativeCwd === "" ? worktreeRoot : path.join(worktreeRoot, relativeCwd);
+}
+
+function validateExistingGitWorktreeRoot(worktreeRoot: string, repoRoot: string): void {
+	const topLevel = gitTopLevel(worktreeRoot);
+	if (topLevel === undefined) {
+		throw new Error(`gitWorktreeDir already exists but is not a Git worktree: ${worktreeRoot}`);
+	}
+	if (comparableRealPath(worktreeRoot) !== comparableRealPath(topLevel)) {
+		throw new Error(`gitWorktreeDir already exists but is not a Git worktree root: ${worktreeRoot}. Git top-level checkout is ${topLevel}`);
+	}
+	if (comparableRealPath(gitCommonDirForWorktree(repoRoot)) !== comparableRealPath(gitCommonDirForWorktree(topLevel))) {
+		throw new Error(`gitWorktreeDir already exists but does not belong to the invoking Git repository: ${worktreeRoot}`);
+	}
+}
+
+export function setupGitWorktree(options: GitWorktreeSetupOptions): GitWorktreeSetupResult {
+	const repoRoot = repositoryRootForGitWorktree(options.cwd);
+	const { relativeCwd, logicalRepoRoot } = cwdWithinGitRepository(options.cwd, repoRoot);
+	const worktreeRoot = resolveGitWorktreePath(options.gitWorktreeDir, logicalRepoRoot);
+	if (pathExistsSync(worktreeRoot)) {
+		validateExistingGitWorktreeRoot(worktreeRoot, repoRoot);
+		return {
+			worktreeRoot,
+			cwd: workspaceCwdForGitWorktreeRoot(worktreeRoot, relativeCwd),
+			repositoryRoot: repoRoot,
+			created: false,
+		};
+	}
+
+	try {
+		fs.mkdirSync(path.dirname(worktreeRoot), { recursive: true });
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to create parent directory for requested gitWorktreeDir ${worktreeRoot}: ${message}`);
+	}
+	const baseRef = options.baseBranch?.trim() || "HEAD";
+	const result = runGit(repoRoot, ["worktree", "add", "--detach", worktreeRoot, baseRef]);
+	if (result.status !== 0) {
+		throw new Error([
+			`Failed to create git worktree at requested gitWorktreeDir ${worktreeRoot} from ${baseRef}. Git reported: ${gitFailureMessage(result)}`,
+			`If another process just created this same-repository worktree, rerun the workflow to resume it. If this is an orphaned worktree from an interrupted run, recover or remove it with: ${worktreeRecoveryCommand(repoRoot, worktreeRoot)}`,
+		].join("\n"));
+	}
+	return {
+		worktreeRoot,
+		cwd: workspaceCwdForGitWorktreeRoot(worktreeRoot, relativeCwd),
+		repositoryRoot: repoRoot,
+		created: true,
+	};
+}