vde-worktree 0.0.9 → 0.0.10

package/dist/index.mjs

@@ -41,6 +41,8 @@ const COMMAND_NAMES = {
 	GONE: "gone",
 	GET: "get",
 	EXTRACT: "extract",
+	ABSORB: "absorb",
+	UNABSORB: "unabsorb",
 	USE: "use",
 	EXEC: "exec",
 	INVOKE: "invoke",
@@ -60,6 +62,8 @@ const WRITE_COMMANDS = new Set([
 	COMMAND_NAMES.GONE,
 	COMMAND_NAMES.GET,
 	COMMAND_NAMES.EXTRACT,
+	COMMAND_NAMES.ABSORB,
+	COMMAND_NAMES.UNABSORB,
 	COMMAND_NAMES.USE,
 	COMMAND_NAMES.LOCK,
 	COMMAND_NAMES.UNLOCK
@@ -1383,6 +1387,30 @@ const commandHelpEntries = [
 			"--from <path>"
 		]
 	},
+	{
+		name: "absorb",
+		usage: "vw absorb <branch> [--from <worktree-name>] [--keep-stash] [--allow-agent --allow-unsafe]",
+		summary: "Bring non-primary worktree changes (including uncommitted) into primary worktree.",
+		details: ["Stashes source worktree changes, checks out target branch in primary, then applies stash.", "Non-TTY execution requires --allow-agent and --allow-unsafe."],
+		options: [
+			"--from <worktree-name>",
+			"--keep-stash",
+			"--allow-agent",
+			"--allow-unsafe"
+		]
+	},
+	{
+		name: "unabsorb",
+		usage: "vw unabsorb <branch> [--to <worktree-name>] [--keep-stash] [--allow-agent --allow-unsafe]",
+		summary: "Push primary worktree changes (including uncommitted) into non-primary worktree.",
+		details: ["Stashes primary worktree changes, applies them in target non-primary worktree, then optionally drops stash.", "Non-TTY execution requires --allow-agent and --allow-unsafe."],
+		options: [
+			"--to <worktree-name>",
+			"--keep-stash",
+			"--allow-agent",
+			"--allow-unsafe"
+		]
+	},
 	{
 		name: "use",
 		usage: "vw use <branch> [--allow-shared] [--allow-agent --allow-unsafe]",
@@ -1878,6 +1906,212 @@ const ensureBranchIsNotPrimary = ({ branch, baseBranch }) => {
 		}
 	});
 };
+const toManagedWorktreeName = ({ repoRoot, worktreePath }) => {
+	const relativePath = relative(getWorktreeRootPath(repoRoot), worktreePath);
+	if (relativePath.length === 0 || relativePath === "." || relativePath === ".." || relativePath.startsWith(`..${sep}`)) return null;
+	return relativePath.split(sep).join("/");
+};
+const resolveManagedWorktreePathFromName = ({ repoRoot, optionName, worktreeName }) => {
+	const normalized = worktreeName.trim();
+	if (normalized.length === 0) throw createCliError("INVALID_ARGUMENT", {
+		message: `${optionName} requires non-empty worktree name`,
+		details: {
+			optionName,
+			worktreeName
+		}
+	});
+	if (normalized === ".worktree" || normalized.startsWith(".worktree/") || normalized.startsWith(".worktree\\")) throw createCliError("INVALID_ARGUMENT", {
+		message: `${optionName} expects vw-managed worktree name (without .worktree/ prefix)`,
+		details: {
+			optionName,
+			worktreeName
+		}
+	});
+	const worktreeRoot = getWorktreeRootPath(repoRoot);
+	let resolvedPath;
+	try {
+		resolvedPath = resolveRepoRelativePath({
+			repoRoot: worktreeRoot,
+			relativePath: normalized
+		});
+	} catch (error) {
+		throw createCliError("INVALID_ARGUMENT", {
+			message: `${optionName} expects vw-managed worktree name`,
+			details: {
+				optionName,
+				worktreeName
+			},
+			cause: error
+		});
+	}
+	if (resolvedPath === worktreeRoot) throw createCliError("INVALID_ARGUMENT", {
+		message: `${optionName} expects vw-managed worktree name`,
+		details: {
+			optionName,
+			worktreeName
+		}
+	});
+	return resolvedPath;
+};
+const resolveManagedNonPrimaryWorktreeByBranch = ({ repoRoot, branch, worktrees, optionName, worktreeName, role }) => {
+	const managedCandidates = worktrees.filter((worktree) => {
+		return worktree.branch === branch && worktree.path !== repoRoot && toManagedWorktreeName({
+			repoRoot,
+			worktreePath: worktree.path
+		}) !== null;
+	});
+	if (typeof worktreeName === "string") {
+		const resolvedPath = resolveManagedWorktreePathFromName({
+			repoRoot,
+			optionName,
+			worktreeName
+		});
+		const selected = managedCandidates.find((worktree) => worktree.path === resolvedPath);
+		if (selected === void 0) throw createCliError("WORKTREE_NOT_FOUND", {
+			message: `${role} worktree not found for branch '${branch}' and name '${worktreeName}'`,
+			details: {
+				branch,
+				worktreeName,
+				optionName,
+				role
+			}
+		});
+		return selected;
+	}
+	if (managedCandidates.length === 0) throw createCliError("WORKTREE_NOT_FOUND", {
+		message: `No managed ${role} worktree found for branch: ${branch}`,
+		details: {
+			branch,
+			role
+		}
+	});
+	if (managedCandidates.length > 1) throw createCliError("INVALID_ARGUMENT", {
+		message: `Multiple managed ${role} worktrees found; use ${optionName} <worktree-name>`,
+		details: {
+			branch,
+			role,
+			optionName,
+			candidates: managedCandidates.map((worktree) => {
+				return toManagedWorktreeName({
+					repoRoot,
+					worktreePath: worktree.path
+				}) ?? worktree.path;
+			})
+		}
+	});
+	return managedCandidates[0];
+};
+const createStashEntry = async ({ cwd, message }) => {
+	await runGitCommand({
+		cwd,
+		args: [
+			"stash",
+			"push",
+			"-u",
+			"-m",
+			message
+		]
+	});
+	const stashTop = await runGitCommand({
+		cwd,
+		args: [
+			"rev-parse",
+			"--verify",
+			"-q",
+			"stash@{0}"
+		],
+		reject: false
+	});
+	const stashOid = stashTop.stdout.trim();
+	if (stashTop.exitCode === 0 && stashOid.length > 0) return stashOid;
+	throw createCliError("INTERNAL_ERROR", {
+		message: "Failed to resolve created stash entry",
+		details: {
+			cwd,
+			message
+		}
+	});
+};
+const restoreStashedChanges = async ({ cwd, stashOid }) => {
+	if ((await runGitCommand({
+		cwd,
+		args: [
+			"stash",
+			"apply",
+			stashOid
+		],
+		reject: false
+	})).exitCode !== 0) throw createCliError("STASH_APPLY_FAILED", {
+		message: "Failed to auto-restore stashed changes after pre-hook failure",
+		details: {
+			cwd,
+			stashOid
+		}
+	});
+	await dropStashByOid({
+		cwd,
+		stashOid
+	});
+};
+const runPreHookWithAutoRestore = async ({ name, context, restore }) => {
+	try {
+		await runPreHook({
+			name,
+			context
+		});
+	} catch (error) {
+		if (restore !== void 0) try {
+			await restore();
+		} catch (restoreError) {
+			const hookError = ensureCliError(error);
+			const restoreCliError = ensureCliError(restoreError);
+			throw createCliError(hookError.code, {
+				message: `${hookError.message} (auto-restore failed)`,
+				details: {
+					...hookError.details,
+					autoRestoreFailed: true,
+					autoRestoreError: {
+						code: restoreCliError.code,
+						message: restoreCliError.message,
+						details: restoreCliError.details
+					}
+				},
+				cause: error
+			});
+		}
+		throw error;
+	}
+};
+const resolveStashRefByOid = async ({ cwd, stashOid }) => {
+	const lines = (await runGitCommand({
+		cwd,
+		args: [
+			"stash",
+			"list",
+			"--format=%gd%x09%H"
+		]
+	})).stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+	for (const line of lines) {
+		const [ref, oid] = line.split("	");
+		if (typeof ref === "string" && typeof oid === "string" && ref.length > 0 && oid === stashOid) return ref;
+	}
+	return null;
+};
+const dropStashByOid = async ({ cwd, stashOid }) => {
+	const stashRef = await resolveStashRefByOid({
+		cwd,
+		stashOid
+	});
+	if (stashRef === null) return;
+	await runGitCommand({
+		cwd,
+		args: [
+			"stash",
+			"drop",
+			stashRef
+		]
+	});
+};
 const formatDisplayPath = (absolutePath) => {
 	const homeDirectory = homedir();
 	if (homeDirectory.length === 0) return absolutePath;
@@ -2201,13 +2435,22 @@ const createCli = (options = {}) => {
 		},
 		from: {
 			type: "string",
-			valueHint: "path",
-			description: "Path used by extract --from"
+			valueHint: "value",
+			description: "For extract: filesystem path. For absorb: managed worktree name without .worktree/ prefix."
+		},
+		to: {
+			type: "string",
+			valueHint: "worktree-name",
+			description: "Worktree name used by unabsorb --to"
 		},
 		stash: {
 			type: "boolean",
 			description: "Allow stash for extract"
 		},
+		keepStash: {
+			type: "boolean",
+			description: "Keep stash entry after absorb/unabsorb"
+		},
 		fallback: {
 			type: "boolean",
 			description: "Enable fallback behavior (disable with --no-fallback)",
@@ -3089,29 +3332,11 @@ const createCli = (options = {}) => {
 						reject: false
 					})).stdout.trim().length > 0;
 					if (dirty && parsedArgs.stash !== true) throw createCliError("DIRTY_WORKTREE", { message: "extract requires clean worktree unless --stash is specified" });
-					let stashRef = null;
-					if (dirty && parsedArgs.stash === true) {
-						await runGitCommand({
-							cwd: repoRoot,
-							args: [
-								"stash",
-								"push",
-								"-u",
-								"-m",
-								`vde-worktree extract ${branch}`
-							]
-						});
-						const stashTop = await runGitCommand({
-							cwd: repoRoot,
-							args: [
-								"stash",
-								"list",
-								"--max-count=1",
-								"--format=%gd"
-							]
-						});
-						stashRef = stashTop.stdout.trim().length > 0 ? stashTop.stdout.trim() : null;
-					}
+					let stashOid = null;
+					if (dirty && parsedArgs.stash === true) stashOid = await createStashEntry({
+						cwd: repoRoot,
+						message: `vde-worktree extract ${branch}`
+					});
 					const hookContext = createHookContext({
 						runtime,
 						repoRoot,
@@ -3120,9 +3345,15 @@ const createCli = (options = {}) => {
 						worktreePath: targetPath,
 						stderr
 					});
-					await runPreHook({
+					await runPreHookWithAutoRestore({
 						name: "extract",
-						context: hookContext
+						context: hookContext,
+						restore: stashOid !== null ? async () => {
+							await restoreStashedChanges({
+								cwd: repoRoot,
+								stashOid
+							});
+						} : void 0
 					});
 					await runGitCommand({
 						cwd: repoRoot,
@@ -3137,30 +3368,26 @@ const createCli = (options = {}) => {
 							branch
 						]
 					});
-					if (stashRef !== null) {
+					if (stashOid !== null) {
 						if ((await runGitCommand({
 							cwd: targetPath,
 							args: [
 								"stash",
 								"apply",
-								stashRef
+								stashOid
 							],
 							reject: false
 						})).exitCode !== 0) throw createCliError("STASH_APPLY_FAILED", {
 							message: "Failed to apply stash to extracted worktree",
 							details: {
-								stashRef,
+								stashOid,
 								branch,
 								path: targetPath
 							}
 						});
-						await runGitCommand({
+						await dropStashByOid({
 							cwd: repoRoot,
-							args: [
-								"stash",
-								"drop",
-								stashRef
-							]
+							stashOid
 						});
 					}
 					await runPostHook({
@@ -3184,6 +3411,260 @@ const createCli = (options = {}) => {
 				stdout(result.path);
 				return EXIT_CODE.OK;
 			}
+			if (command === "absorb") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 1,
+					max: 1
+				});
+				const branch = commandArgs[0];
+				const fromWorktreeName = typeof parsedArgs.from === "string" ? parsedArgs.from : void 0;
+				const keepStash = parsedArgs.keepStash === true;
+				if (runtime.isInteractive !== true) {
+					if (parsedArgs.allowAgent !== true) throw createCliError("UNSAFE_FLAG_REQUIRED", { message: "UNSAFE_FLAG_REQUIRED: absorb in non-TTY requires --allow-agent" });
+					ensureUnsafeForNonTty({
+						runtime,
+						reason: "absorb in non-TTY mode requires --allow-unsafe"
+					});
+				}
+				const result = await runWriteOperation(async () => {
+					if ((await runGitCommand({
+						cwd: repoRoot,
+						args: ["status", "--porcelain"],
+						reject: false
+					})).stdout.trim().length > 0) throw createCliError("DIRTY_WORKTREE", {
+						message: "absorb requires clean primary worktree",
+						details: { repoRoot }
+					});
+					const sourceWorktree = resolveManagedNonPrimaryWorktreeByBranch({
+						repoRoot,
+						branch,
+						worktrees: (await collectWorktreeSnapshot(repoRoot)).worktrees,
+						optionName: "--from",
+						worktreeName: fromWorktreeName,
+						role: "source"
+					});
+					const sourceDirty = (await runGitCommand({
+						cwd: sourceWorktree.path,
+						args: ["status", "--porcelain"],
+						reject: false
+					})).stdout.trim().length > 0;
+					let stashOid = null;
+					if (sourceDirty) stashOid = await createStashEntry({
+						cwd: sourceWorktree.path,
+						message: `vde-worktree absorb ${branch}`
+					});
+					const hookContext = createHookContext({
+						runtime,
+						repoRoot,
+						action: "absorb",
+						branch,
+						worktreePath: repoRoot,
+						stderr,
+						extraEnv: { WT_SOURCE_WORKTREE_PATH: sourceWorktree.path }
+					});
+					await runPreHookWithAutoRestore({
+						name: "absorb",
+						context: hookContext,
+						restore: stashOid !== null ? async () => {
+							await restoreStashedChanges({
+								cwd: sourceWorktree.path,
+								stashOid
+							});
+						} : void 0
+					});
+					await runGitCommand({
+						cwd: repoRoot,
+						args: [
+							"checkout",
+							"--ignore-other-worktrees",
+							branch
+						]
+					});
+					if (stashOid !== null) {
+						if ((await runGitCommand({
+							cwd: repoRoot,
+							args: [
+								"stash",
+								"apply",
+								stashOid
+							],
+							reject: false
+						})).exitCode !== 0) throw createCliError("STASH_APPLY_FAILED", {
+							message: "Failed to apply stash to primary worktree",
+							details: {
+								stashOid,
+								branch,
+								sourcePath: sourceWorktree.path,
+								path: repoRoot
+							}
+						});
+						if (!keepStash) await dropStashByOid({
+							cwd: repoRoot,
+							stashOid
+						});
+					}
+					await runPostHook({
+						name: "absorb",
+						context: hookContext
+					});
+					const stashOutputRef = keepStash && stashOid !== null ? await resolveStashRefByOid({
+						cwd: repoRoot,
+						stashOid
+					}) ?? stashOid : null;
+					return {
+						branch,
+						path: repoRoot,
+						sourcePath: sourceWorktree.path,
+						stashed: sourceDirty,
+						stashRef: stashOutputRef
+					};
+				});
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "ok",
+						repoRoot,
+						details: result
+					})));
+					return EXIT_CODE.OK;
+				}
+				stdout(result.path);
+				return EXIT_CODE.OK;
+			}
+			if (command === "unabsorb") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 1,
+					max: 1
+				});
+				const branch = commandArgs[0];
+				const targetWorktreeName = typeof parsedArgs.to === "string" ? parsedArgs.to : void 0;
+				const keepStash = parsedArgs.keepStash === true;
+				if (runtime.isInteractive !== true) {
+					if (parsedArgs.allowAgent !== true) throw createCliError("UNSAFE_FLAG_REQUIRED", { message: "UNSAFE_FLAG_REQUIRED: unabsorb in non-TTY requires --allow-agent" });
+					ensureUnsafeForNonTty({
+						runtime,
+						reason: "unabsorb in non-TTY mode requires --allow-unsafe"
+					});
+				}
+				const result = await runWriteOperation(async () => {
+					const currentBranch = (await runGitCommand({
+						cwd: repoRoot,
+						args: ["branch", "--show-current"],
+						reject: false
+					})).stdout.trim();
+					if (currentBranch !== branch) throw createCliError("INVALID_ARGUMENT", {
+						message: "unabsorb requires primary worktree to be on the target branch",
+						details: {
+							branch,
+							currentBranch
+						}
+					});
+					if ((await runGitCommand({
+						cwd: repoRoot,
+						args: ["status", "--porcelain"],
+						reject: false
+					})).stdout.trim().length === 0) throw createCliError("DIRTY_WORKTREE", {
+						message: "unabsorb requires dirty primary worktree",
+						details: { repoRoot }
+					});
+					const targetWorktree = resolveManagedNonPrimaryWorktreeByBranch({
+						repoRoot,
+						branch,
+						worktrees: (await collectWorktreeSnapshot(repoRoot)).worktrees,
+						optionName: "--to",
+						worktreeName: targetWorktreeName,
+						role: "target"
+					});
+					if ((await runGitCommand({
+						cwd: targetWorktree.path,
+						args: ["status", "--porcelain"],
+						reject: false
+					})).stdout.trim().length > 0) throw createCliError("DIRTY_WORKTREE", {
+						message: "unabsorb requires clean target worktree",
+						details: {
+							branch,
+							path: targetWorktree.path
+						}
+					});
+					const stashOid = await createStashEntry({
+						cwd: repoRoot,
+						message: `vde-worktree unabsorb ${branch}`
+					});
+					const hookContext = createHookContext({
+						runtime,
+						repoRoot,
+						action: "unabsorb",
+						branch,
+						worktreePath: targetWorktree.path,
+						stderr,
+						extraEnv: {
+							WT_SOURCE_WORKTREE_PATH: repoRoot,
+							WT_TARGET_WORKTREE_PATH: targetWorktree.path
+						}
+					});
+					await runPreHookWithAutoRestore({
+						name: "unabsorb",
+						context: hookContext,
+						restore: async () => {
+							await restoreStashedChanges({
+								cwd: repoRoot,
+								stashOid
+							});
+						}
+					});
+					if ((await runGitCommand({
+						cwd: targetWorktree.path,
+						args: [
+							"stash",
+							"apply",
+							stashOid
+						],
+						reject: false
+					})).exitCode !== 0) throw createCliError("STASH_APPLY_FAILED", {
+						message: "Failed to apply stash to target worktree",
+						details: {
+							stashOid,
+							branch,
+							sourcePath: repoRoot,
+							targetPath: targetWorktree.path
+						}
+					});
+					if (!keepStash) await dropStashByOid({
+						cwd: repoRoot,
+						stashOid
+					});
+					await runPostHook({
+						name: "unabsorb",
+						context: hookContext
+					});
+					const stashOutputRef = keepStash ? await resolveStashRefByOid({
+						cwd: repoRoot,
+						stashOid
+					}) ?? stashOid : null;
+					return {
+						branch,
+						path: targetWorktree.path,
+						sourcePath: repoRoot,
+						stashed: true,
+						stashRef: stashOutputRef
+					};
+				});
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "ok",
+						repoRoot,
+						details: result
+					})));
+					return EXIT_CODE.OK;
+				}
+				stdout(result.path);
+				return EXIT_CODE.OK;
+			}
 			if (command === "use") {
 				ensureArgumentCount({
 					command,