pi-subagents 0.12.2 → 0.12.4

package/worktree.ts

@@ -15,6 +15,7 @@ export interface WorktreeInfo {
 	branch: string;
 	index: number;
 	nodeModulesLinked: boolean;
+	syntheticPaths: string[];
 }
 
 export interface WorktreeDiff {
@@ -34,6 +35,37 @@ export interface WorktreeTaskCwdConflict {
 	cwd: string;
 }
 
+export interface WorktreeSetupHookConfig {
+	hookPath: string;
+	timeoutMs?: number;
+}
+
+export interface CreateWorktreesOptions {
+	agents?: string[];
+	setupHook?: WorktreeSetupHookConfig;
+}
+
+interface ResolvedWorktreeSetupHook {
+	hookPath: string;
+	timeoutMs: number;
+}
+
+interface WorktreeSetupHookInput {
+	version: 1;
+	repoRoot: string;
+	worktreePath: string;
+	agentCwd: string;
+	branch: string;
+	index: number;
+	runId: string;
+	baseCommit: string;
+	agent?: string;
+}
+
+interface WorktreeSetupHookOutput {
+	syntheticPaths?: string[];
+}
+
 interface GitResult {
 	stdout: string;
 	stderr: string;
@@ -46,6 +78,8 @@ interface RepoState {
 	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" });
 	return {
@@ -139,7 +173,140 @@ function linkNodeModulesIfPresent(toplevel: string, worktreePath: string): boole
 	}
 }
 
-function createSingleWorktree(toplevel: string, cwdRelative: string, runId: string, index: number): WorktreeInfo {
+function parseHookTimeout(timeoutMs: number | undefined): number {
+	if (timeoutMs === undefined) return DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS;
+	if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
+		throw new Error("worktree setup hook timeout must be an integer greater than 0");
+	}
+	return timeoutMs;
+}
+
+function resolveWorktreeSetupHook(
+	repoRoot: string,
+	config: WorktreeSetupHookConfig | undefined,
+): ResolvedWorktreeSetupHook | undefined {
+	if (!config) return undefined;
+	const hookPath = config.hookPath.trim();
+	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)) {
+		resolvedPath = expandedHookPath;
+	} else if (expandedHookPath.includes("/") || expandedHookPath.includes("\\")) {
+		resolvedPath = path.resolve(repoRoot, expandedHookPath);
+	} 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 === ".") {
+		throw new Error(`synthetic path cannot target the worktree root: ${rawPath}`);
+	}
+	if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+		throw new Error(`synthetic path escapes the worktree root: ${rawPath}`);
+	}
+	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) {
+		throw new Error("worktree setup hook returned empty stdout; expected JSON object");
+	}
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(trimmed);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`worktree setup hook returned invalid JSON: ${message}`);
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+		throw new Error("worktree setup hook stdout must be a JSON object");
+	}
+	return parsed as WorktreeSetupHookOutput;
+}
+
+function runWorktreeSetupHook(
+	hook: ResolvedWorktreeSetupHook,
+	input: WorktreeSetupHookInput,
+): string[] {
+	const result = spawnSync(hook.hookPath, [], {
+		cwd: input.worktreePath,
+		encoding: "utf-8",
+		input: JSON.stringify(input),
+		timeout: hook.timeoutMs,
+		shell: false,
+	});
+
+	if (result.error) {
+		const code = "code" in result.error ? result.error.code : undefined;
+		if (code === "ETIMEDOUT") {
+			throw new Error(`worktree setup hook timed out after ${hook.timeoutMs}ms`);
+		}
+		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") {
+			throw new Error("worktree setup hook output field 'syntheticPaths' must contain only strings");
+		}
+		const normalizedPath = normalizeSyntheticPath(input.worktreePath, candidate);
+		if (hasTrackedEntries(input.worktreePath, normalizedPath)) {
+			throw new Error(`worktree setup hook cannot mark tracked paths as synthetic: ${normalizedPath}`);
+		}
+		uniquePaths.add(normalizedPath);
+	}
+	return [...uniquePaths];
+}
+
+function createSingleWorktree(
+	toplevel: string,
+	cwdRelative: string,
+	runId: string,
+	index: number,
+	baseCommit: string,
+	setupHook: ResolvedWorktreeSetupHook | undefined,
+	agent: string | undefined,
+): WorktreeInfo {
 	const branch = buildWorktreeBranch(runId, index);
 	const worktreePath = buildWorktreePath(runId, index);
 	const add = runGit(toplevel, ["worktree", "add", worktreePath, "-b", branch, "HEAD"]);
@@ -148,29 +315,76 @@ function createSingleWorktree(toplevel: string, cwdRelative: string, runId: stri
 		throw new Error(message);
 	}
 
-	return {
-		path: worktreePath,
-		agentCwd: cwdRelative ? path.join(worktreePath, cwdRelative) : worktreePath,
-		branch,
-		index,
-		nodeModulesLinked: linkNodeModulesIfPresent(toplevel, worktreePath),
-	};
+	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,
+				repoRoot: toplevel,
+				worktreePath,
+				agentCwd,
+				branch,
+				index,
+				runId,
+				baseCommit,
+				agent,
+			});
+			syntheticPaths.push(...hookSyntheticPaths);
+		}
+
+		return {
+			path: worktreePath,
+			agentCwd,
+			branch,
+			index,
+			nodeModulesLinked,
+			syntheticPaths,
+		};
+	} catch (error) {
+		try { runGitChecked(toplevel, ["worktree", "remove", "--force", worktreePath]); } catch {}
+		try { runGitChecked(toplevel, ["branch", "-D", branch]); } catch {}
+		throw error;
+	}
 }
 
-function removeSyntheticNodeModulesSymlink(worktree: WorktreeInfo): void {
-	if (!worktree.nodeModulesLinked) return;
+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;
+	}
 
-	const nodeModulesPath = path.join(worktree.path, "node_modules");
 	let stat: fs.Stats;
 	try {
-		stat = fs.lstatSync(nodeModulesPath);
+		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()) return;
-	fs.unlinkSync(nodeModulesPath);
+
+	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 {
@@ -212,7 +426,7 @@ function captureWorktreeDiff(
 	agent: string,
 	patchPath: string,
 ): WorktreeDiff {
-	removeSyntheticNodeModulesSymlink(worktree);
+	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]);
@@ -251,13 +465,22 @@ 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): WorktreeSetup {
+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(repo.toplevel, repo.cwdRelative, runId, index));
+			worktrees.push(createSingleWorktree(
+				repo.toplevel,
+				repo.cwdRelative,
+				runId,
+				index,
+				repo.baseCommit,
+				setupHook,
+				options?.agents?.[index],
+			));
 		}
 	} catch (error) {
 		cleanupWorktrees({