@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.3

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

@@ -1,116 +0,0 @@
-import { lstatSync, realpathSync } from "node:fs";
-import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
-import type { GitWorktreeSetupResult } from "./worktree-types.js";
-
-function relativePathWithin(root: string, candidate: string): string | undefined {
-	const path = relative(root, candidate);
-	return path === ".." || path.startsWith(`..${sep}`) || isAbsolute(path) ? undefined : path;
-}
-
-function existingRealPathThroughAncestor(path: string, description: string): string {
-	let existing = resolve(path);
-	const missing: string[] = [];
-	while (true) {
-		try {
-			return resolve(realpathSync.native(existing), ...missing);
-		} catch (error) {
-			let existingEntry: ReturnType<typeof lstatSync> | undefined;
-			try {
-				existingEntry = lstatSync(existing);
-			} catch {
-				// Missing components are resolved through their nearest existing ancestor.
-			}
-			const code =
-				error && typeof error === "object" && "code" in error
-					? String((error as { readonly code?: unknown }).code)
-					: undefined;
-			const parent = dirname(existing);
-			if (
-				existingEntry?.isSymbolicLink() === true ||
-				(code !== "ENOENT" && code !== "ENOTDIR") ||
-				parent === existing
-			) {
-				const message = error instanceof Error ? error.message : String(error);
-				throw new Error(`atomic-workflows: cannot resolve ${description} ${path}: ${message}`);
-			}
-			missing.unshift(existing.slice(parent.length + (parent.endsWith(sep) ? 0 : 1)));
-			existing = parent;
-		}
-	}
-}
-
-function existingRealPath(path: string, description: string): string {
-	try {
-		return realpathSync.native(path);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`atomic-workflows: cannot resolve ${description} ${path}: ${message}`);
-	}
-}
-
-export function resolveWorktreeStageCwd(cwd: string | undefined, setup: GitWorktreeSetupResult): string | undefined {
-	const worktreeRoot = existingRealPath(setup.worktreeRoot, "gitWorktreeDir");
-	const repositoryRoot = existingRealPath(setup.repositoryRoot, "invoking checkout");
-	if (cwd === undefined || cwd.length === 0) return undefined;
-
-	const absoluteInput = isAbsolute(cwd);
-	const candidate = absoluteInput ? cwd : resolve(setup.cwd, cwd);
-	if (!absoluteInput && relativePathWithin(setup.worktreeRoot, candidate) === undefined) {
-		throw new Error(
-			`atomic-workflows: relative cwd ${cwd} escapes gitWorktreeDir ${setup.worktreeRoot}; choose a cwd inside the worktree.`,
-		);
-	}
-	const candidateRealPath = existingRealPath(candidate, "cwd");
-	const worktreeRelative = relativePathWithin(worktreeRoot, candidateRealPath);
-	if (worktreeRelative !== undefined) return resolve(setup.worktreeRoot, worktreeRelative);
-	if (!isAbsolute(cwd)) {
-		throw new Error(
-			`atomic-workflows: relative cwd ${cwd} escapes gitWorktreeDir ${setup.worktreeRoot}; choose a path that remains inside the selected worktree.`,
-		);
-	}
-	if (relativePathWithin(setup.worktreeRoot, candidate) !== undefined) {
-		throw new Error(
-			`atomic-workflows: cwd ${cwd} resolves outside gitWorktreeDir ${setup.worktreeRoot}; remove the escaping symlink or choose a cwd inside the worktree.`,
-		);
-	}
-
-	const repositoryRelative = absoluteInput ? relativePathWithin(repositoryRoot, candidateRealPath) : undefined;
-	if (repositoryRelative === undefined) {
-		throw new Error(
-			`atomic-workflows: cwd ${cwd} is outside gitWorktreeDir ${setup.worktreeRoot}; use a cwd inside the invoking repository so Atomic can remap it, or omit cwd.`,
-		);
-	}
-	const mappedCwd = resolve(setup.worktreeRoot, repositoryRelative);
-	const mappedRealPath = existingRealPath(mappedCwd, "remapped worktree cwd");
-	if (relativePathWithin(worktreeRoot, mappedRealPath) === undefined) {
-		throw new Error(
-			`atomic-workflows: cwd ${cwd} remaps through a path that resolves outside gitWorktreeDir ${setup.worktreeRoot}; remove the escaping symlink or omit cwd.`,
-		);
-	}
-	return mappedCwd;
-}
-
-export function resolveContainedRelativePath(
-	root: string,
-	baseDir: string,
-	relativePath: string,
-	description: string,
-): string {
-	if (isAbsolute(relativePath) || relativePath.split(/[\\/]+/).includes("..")) {
-		throw new Error(
-			`atomic-workflows: relative output ${relativePath} escapes ${description} ${root}; use a path without parent traversal.`,
-		);
-	}
-	const candidate = resolve(baseDir, relativePath);
-	if (relativePathWithin(resolve(root), candidate) === undefined) {
-		throw new Error(`atomic-workflows: relative output ${relativePath} escapes ${description} ${root}.`);
-	}
-	const realRoot = existingRealPath(root, description);
-	const realCandidate = existingRealPathThroughAncestor(candidate, "relative output");
-	if (relativePathWithin(realRoot, realCandidate) === undefined) {
-		throw new Error(
-			`atomic-workflows: relative output ${relativePath} resolves outside ${description} ${root} through a symlink.`,
-		);
-	}
-	return candidate;
-}

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

@@ -1,172 +0,0 @@
-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-generation.ts

@@ -1,57 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-export interface GitWorktreeGenerationAnchor {
-	assertCurrent(): void;
-	dispose(): void;
-}
-
-function sameFileIdentity(left: fs.BigIntStats, right: fs.BigIntStats): boolean {
-	return left.dev === right.dev && left.ino === right.ino;
-}
-
-function openMainCheckoutAnchor(gitDir: string): GitWorktreeGenerationAnchor {
-	let disposed = false;
-	return {
-		assertCurrent() {
-			if (disposed) throw new Error(`cached .git identity anchor is already disposed: ${gitDir}`);
-			if (!fs.lstatSync(gitDir).isDirectory()) {
-				throw new Error(`cached main-checkout .git directory is no longer current: ${gitDir}`);
-			}
-		},
-		dispose() {
-			disposed = true;
-		},
-	};
-}
-
-export function openGitWorktreeGenerationAnchor(worktreeRoot: string): GitWorktreeGenerationAnchor {
-	const gitFile = path.join(worktreeRoot, ".git");
-	if (fs.lstatSync(gitFile).isDirectory()) return openMainCheckoutAnchor(gitFile);
-	const descriptor = fs.openSync(gitFile, "r");
-	let disposed = false;
-
-	const anchor: GitWorktreeGenerationAnchor = {
-		assertCurrent() {
-			if (disposed) throw new Error(`cached .git identity anchor is already disposed: ${gitFile}`);
-			const held = fs.fstatSync(descriptor, { bigint: true });
-			const current = fs.lstatSync(gitFile, { bigint: true });
-			if (!current.isFile() || !sameFileIdentity(held, current)) {
-				throw new Error(`cached .git identity anchor no longer matches the selected checkout: ${gitFile}`);
-			}
-		},
-		dispose() {
-			if (disposed) return;
-			disposed = true;
-			fs.closeSync(descriptor);
-		},
-	};
-
-	try {
-		anchor.assertCurrent();
-		return anchor;
-	} catch (error) {
-		anchor.dispose();
-		throw error;
-	}
-}

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

@@ -1,107 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { createChildProcessEnvironment, createGitEnvironment } from "@bastani/atomic";
-import type { GitResult } from "./worktree-types.js";
-
-const DISABLED_GIT_HOOKS_PATH = process.platform === "win32" ? "NUL" : "/dev/null";
-const GIT_COMMAND_TIMEOUT_MS = 60_000;
-const GIT_READ_ONLY_PROBE_TIMEOUT_ATTEMPTS = 2;
-export type GitRunner = (cwd: string, args: readonly string[]) => GitResult;
-let gitRunnerOverride: GitRunner | undefined;
-
-function gitCommandArgs(args: readonly string[]): string[] {
-	return ["-c", `core.hooksPath=${DISABLED_GIT_HOOKS_PATH}`, "-c", "core.fsmonitor=false", ...args];
-}
-function gitCommandArgv(args: readonly string[]): string[] {
-	return ["git", ...gitCommandArgs(args)];
-}
-function withDiagnostics(result: GitResult, cwd: string, args: readonly string[]): GitResult {
-	return {
-		...result,
-		argv: result.argv ?? gitCommandArgv(args),
-		cwd: result.cwd ?? cwd,
-		timeoutMs: result.timeoutMs ?? GIT_COMMAND_TIMEOUT_MS,
-	};
-}
-function spawnGit(cwd: string, args: readonly string[], plain: boolean): GitResult {
-	const startedAt = Date.now();
-	const result = spawnSync("git", plain ? args : gitCommandArgs(args), {
-		cwd,
-		encoding: "utf-8",
-		env: createGitEnvironment(
-			{ GIT_OPTIONAL_LOCKS: "0", GIT_TERMINAL_PROMPT: "0", GCM_INTERACTIVE: "never" },
-			createChildProcessEnvironment(),
-		),
-		timeout: GIT_COMMAND_TIMEOUT_MS,
-	});
-	return {
-		stdout: result.stdout ?? "",
-		stderr: result.stderr ?? "",
-		status: result.status ?? null,
-		signal: result.signal ?? null,
-		elapsedMs: Math.max(0, Date.now() - startedAt),
-		...(result.error === undefined ? {} : { error: result.error }),
-	};
-}
-export function withGitRunnerForTest<T>(runner: GitRunner, callback: () => T): T {
-	const previous = gitRunnerOverride;
-	gitRunnerOverride = runner;
-	try {
-		return callback();
-	} finally {
-		gitRunnerOverride = previous;
-	}
-}
-export function runGit(cwd: string, args: readonly string[]): GitResult {
-	return withDiagnostics((gitRunnerOverride ?? ((dir, values) => spawnGit(dir, values, false)))(cwd, args), cwd, args);
-}
-/** Run Git without command-line config overrides; used only for shared config. */
-export function runGitPlain(cwd: string, args: readonly string[]): GitResult {
-	const result = (gitRunnerOverride ?? ((dir, values) => spawnGit(dir, values, true)))(cwd, args);
-	return { ...withDiagnostics(result, cwd, args), argv: result.argv ?? ["git", ...args] };
-}
-export function runGitChecked(cwd: string, args: readonly string[]): string {
-	const result = runGit(cwd, args);
-	if (result.status !== 0) throw new Error(gitFailureMessage(result));
-	return result.stdout;
-}
-function gitErrorCode(error: Error): string | undefined {
-	return "code" in error ? String((error as Error & { readonly code?: unknown }).code) : undefined;
-}
-export function isGitTimeoutResult(result: GitResult): boolean {
-	if (result.error === undefined) return false;
-	const code = gitErrorCode(result.error)?.toUpperCase();
-	const message = result.error.message.toLowerCase();
-	return code === "ETIMEDOUT" || message.includes("etimedout") || message.includes("timed out");
-}
-function formatArg(value: string): string {
-	return /^[A-Za-z0-9_./:@%+=,\\-]+$/.test(value) ? value : JSON.stringify(value);
-}
-function diagnosticSuffix(result: GitResult): string {
-	const details: string[] = [];
-	if (result.argv?.length) details.push(`command: ${result.argv.map(formatArg).join(" ")}`);
-	if (result.cwd !== undefined) details.push(`cwd: ${result.cwd}`);
-	if (result.timeoutMs !== undefined) details.push(`timeout: ${result.timeoutMs}ms`);
-	if (result.elapsedMs !== undefined) details.push(`elapsed: ${result.elapsedMs}ms`);
-	details.push(`status: ${result.status === null ? "null" : result.status}`);
-	if (result.signal !== undefined) details.push(`signal: ${result.signal ?? "null"}`);
-	if (result.attempts !== undefined && result.attempts > 1) details.push(`attempts: ${result.attempts}`);
-	return ` (${details.join("; ")})`;
-}
-export function gitFailureMessage(result: GitResult): string {
-	if (result.error !== undefined) {
-		const code = gitErrorCode(result.error);
-		if (isGitTimeoutResult(result))
-			return `git command timed out after ${result.timeoutMs ?? GIT_COMMAND_TIMEOUT_MS}ms${code === undefined ? "" : ` (${code})`}: ${result.error.message}${diagnosticSuffix(result)}`;
-		return `${code === undefined ? result.error.message : `${code}: ${result.error.message}`}${diagnosticSuffix(result)}`;
-	}
-	return `${result.stderr.trim() || result.stdout.trim() || `git exited with status ${result.status}`}${diagnosticSuffix(result)}`;
-}
-export function runGitReadOnlyProbe(cwd: string, args: readonly string[]): GitResult {
-	let attempts = 1;
-	let result = runGit(cwd, args);
-	while (attempts < GIT_READ_ONLY_PROBE_TIMEOUT_ATTEMPTS && result.status !== 0 && isGitTimeoutResult(result)) {
-		attempts += 1;
-		result = runGit(cwd, args);
-	}
-	return attempts > 1 ? { ...result, attempts } : result;
-}