vde-worktree 0.0.10 → 0.0.12

package/dist/index.mjs

@@ -601,6 +601,143 @@ const readNumberFromEnvOrDefault = ({ rawValue, defaultValue }) => {
 	return rawValue;
 };
 
+//#endregion
+//#region src/core/worktree-merge-lifecycle.ts
+const lifecycleFilePath = (repoRoot, branch) => {
+	return join(getStateDirectoryPath(repoRoot), "branches", `${branchToWorktreeId(branch)}.json`);
+};
+const hasStateDirectory = async (repoRoot) => {
+	try {
+		await access(getStateDirectoryPath(repoRoot), constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const parseLifecycle = (content) => {
+	try {
+		const parsed = JSON.parse(content);
+		if (parsed.schemaVersion !== 1 || typeof parsed.branch !== "string" || typeof parsed.worktreeId !== "string" || typeof parsed.baseBranch !== "string" || typeof parsed.createdHead !== "string" || parsed.createdHead.length === 0 || typeof parsed.createdAt !== "string" || typeof parsed.updatedAt !== "string") return {
+			valid: false,
+			record: null
+		};
+		return {
+			valid: true,
+			record: parsed
+		};
+	} catch {
+		return {
+			valid: false,
+			record: null
+		};
+	}
+};
+const writeJsonAtomically$1 = async ({ filePath, payload }) => {
+	await mkdir(dirname(filePath), { recursive: true });
+	const tmpPath = `${filePath}.tmp-${String(process.pid)}-${String(Date.now())}`;
+	await writeFile(tmpPath, `${JSON.stringify(payload)}\n`, "utf8");
+	await rename(tmpPath, filePath);
+};
+const readWorktreeMergeLifecycle = async ({ repoRoot, branch }) => {
+	const path = lifecycleFilePath(repoRoot, branch);
+	try {
+		await access(path, constants.F_OK);
+	} catch {
+		return {
+			path,
+			exists: false,
+			valid: true,
+			record: null
+		};
+	}
+	try {
+		return {
+			path,
+			exists: true,
+			...parseLifecycle(await readFile(path, "utf8"))
+		};
+	} catch {
+		return {
+			path,
+			exists: true,
+			valid: false,
+			record: null
+		};
+	}
+};
+const upsertWorktreeMergeLifecycle = async ({ repoRoot, branch, baseBranch, createdHead }) => {
+	if (await hasStateDirectory(repoRoot) !== true) {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		return {
+			schemaVersion: 1,
+			branch,
+			worktreeId: branchToWorktreeId(branch),
+			baseBranch,
+			createdHead,
+			createdAt: now,
+			updatedAt: now
+		};
+	}
+	const current = await readWorktreeMergeLifecycle({
+		repoRoot,
+		branch
+	});
+	if (current.valid && current.record !== null && current.record.baseBranch === baseBranch) return current.record;
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const next = {
+		schemaVersion: 1,
+		branch,
+		worktreeId: branchToWorktreeId(branch),
+		baseBranch,
+		createdHead: current.record?.createdHead ?? createdHead,
+		createdAt: current.record?.createdAt ?? now,
+		updatedAt: now
+	};
+	await writeJsonAtomically$1({
+		filePath: current.path,
+		payload: next
+	});
+	return next;
+};
+const moveWorktreeMergeLifecycle = async ({ repoRoot, fromBranch, toBranch, baseBranch, createdHead }) => {
+	if (await hasStateDirectory(repoRoot) !== true) {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		return {
+			schemaVersion: 1,
+			branch: toBranch,
+			worktreeId: branchToWorktreeId(toBranch),
+			baseBranch,
+			createdHead,
+			createdAt: now,
+			updatedAt: now
+		};
+	}
+	const source = await readWorktreeMergeLifecycle({
+		repoRoot,
+		branch: fromBranch
+	});
+	const targetPath = lifecycleFilePath(repoRoot, toBranch);
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const next = {
+		schemaVersion: 1,
+		branch: toBranch,
+		worktreeId: branchToWorktreeId(toBranch),
+		baseBranch,
+		createdHead: source.record?.createdHead ?? createdHead,
+		createdAt: source.record?.createdAt ?? now,
+		updatedAt: now
+	};
+	await writeJsonAtomically$1({
+		filePath: targetPath,
+		payload: next
+	});
+	if (source.path !== targetPath) await rm(source.path, { force: true });
+	return next;
+};
+const deleteWorktreeMergeLifecycle = async ({ repoRoot, branch }) => {
+	await rm(lifecycleFilePath(repoRoot, branch), { force: true });
+};
+
 //#endregion
 //#region src/core/worktree-lock.ts
 const parseLock = (content) => {
@@ -707,8 +844,9 @@ const parseMergedResult = (raw) => {
 		return null;
 	}
 };
-const resolveMergedByPr = async ({ repoRoot, branch, enabled = true, runGh = defaultRunGh }) => {
+const resolveMergedByPr = async ({ repoRoot, branch, baseBranch, enabled = true, runGh = defaultRunGh }) => {
 	if (enabled !== true) return null;
+	if (baseBranch === null) return null;
 	try {
 		const result = await runGh({
 			cwd: repoRoot,
@@ -719,6 +857,8 @@ const resolveMergedByPr = async ({ repoRoot, branch, enabled = true, runGh = def
 				"merged",
 				"--head",
 				branch,
+				"--base",
+				baseBranch,
 				"--limit",
 				"1",
 				"--json",
@@ -878,7 +1018,7 @@ const resolveLockState = async ({ repoRoot, branch }) => {
 		};
 	}
 };
-const resolveMergedState = async ({ repoRoot, branch, baseBranch, enableGh }) => {
+const resolveMergedState = async ({ repoRoot, branch, head, baseBranch, enableGh }) => {
 	if (branch === null) return {
 		byAncestry: null,
 		byPR: null,
@@ -902,21 +1042,35 @@ const resolveMergedState = async ({ repoRoot, branch, baseBranch, enableGh }) =>
 	const byPR = await resolveMergedByPr({
 		repoRoot,
 		branch,
+		baseBranch,
 		enabled: enableGh
 	});
+	let byLifecycle = null;
+	if (baseBranch !== null) {
+		const lifecycle = await upsertWorktreeMergeLifecycle({
+			repoRoot,
+			branch,
+			baseBranch,
+			createdHead: head
+		});
+		if (byAncestry === true) byLifecycle = lifecycle.createdHead !== head;
+		else if (byAncestry === false) byLifecycle = false;
+	}
 	return {
 		byAncestry,
 		byPR,
 		overall: resolveMergedOverall({
 			byAncestry,
-			byPR
+			byPR,
+			byLifecycle
 		})
 	};
 };
-const resolveMergedOverall = ({ byAncestry, byPR }) => {
-	if (byPR === true) return true;
-	if (byPR === false) return false;
-	return byAncestry;
+const resolveMergedOverall = ({ byAncestry, byPR, byLifecycle }) => {
+	if (byPR === true || byLifecycle === true) return true;
+	if (byAncestry === false) return false;
+	if (byPR === false || byLifecycle === false) return false;
+	return null;
 };
 const resolveUpstreamState = async (worktreePath) => {
 	const upstreamRef = await runGitCommand({
@@ -968,6 +1122,7 @@ const enrichWorktree = async ({ repoRoot, worktree, baseBranch, enableGh }) => {
 		resolveMergedState({
 			repoRoot,
 			branch: worktree.branch,
+			head: worktree.head,
 			baseBranch,
 			enableGh
 		}),
@@ -1690,6 +1845,22 @@ const resolveBaseBranch = async (repoRoot) => {
 	for (const candidate of ["main", "master"]) if (await doesGitRefExist(repoRoot, `refs/heads/${candidate}`)) return candidate;
 	throw createCliError("INVALID_ARGUMENT", { message: "Unable to resolve base branch. Configure vde-worktree.baseBranch." });
 };
+const resolveBranchHead = async ({ repoRoot, branch }) => {
+	const resolved = await runGitCommand({
+		cwd: repoRoot,
+		args: [
+			"rev-parse",
+			"--verify",
+			branch
+		],
+		reject: false
+	});
+	if (resolved.exitCode !== 0 || resolved.stdout.trim().length === 0) throw createCliError("INVALID_ARGUMENT", {
+		message: `Failed to resolve branch head: ${branch}`,
+		details: { branch }
+	});
+	return resolved.stdout.trim();
+};
 const ensureTargetPathWritable = async (targetPath) => {
 	try {
 		await access(targetPath, constants.F_OK);
@@ -2818,6 +2989,15 @@ const createCli = (options = {}) => {
 							baseBranch
 						]
 					});
+					await upsertWorktreeMergeLifecycle({
+						repoRoot,
+						branch,
+						baseBranch,
+						createdHead: await resolveBranchHead({
+							repoRoot,
+							branch
+						})
+					});
 					await runPostHook({
 						name: "new",
 						context: hookContext
@@ -2848,12 +3028,27 @@ const createCli = (options = {}) => {
 				});
 				const branch = commandArgs[0];
 				const result = await runWriteOperation(async () => {
-					const existing = (await collectWorktreeSnapshot(repoRoot)).worktrees.find((worktree) => worktree.branch === branch);
-					if (existing !== void 0) return {
-						status: "existing",
-						branch,
-						path: existing.path
-					};
+					const snapshot = await collectWorktreeSnapshot(repoRoot);
+					const existing = snapshot.worktrees.find((worktree) => worktree.branch === branch);
+					if (existing !== void 0) {
+						if (snapshot.baseBranch !== null) {
+							const branchHead = await resolveBranchHead({
+								repoRoot,
+								branch
+							});
+							await upsertWorktreeMergeLifecycle({
+								repoRoot,
+								branch,
+								baseBranch: snapshot.baseBranch,
+								createdHead: branchHead
+							});
+						}
+						return {
+							status: "existing",
+							branch,
+							path: existing.path
+						};
+					}
 					const targetPath = branchToWorktreePath(repoRoot, branch);
 					await ensureTargetPathWritable(targetPath);
 					const hookContext = createHookContext({
@@ -2868,6 +3063,7 @@ const createCli = (options = {}) => {
 						name: "switch",
 						context: hookContext
 					});
+					let lifecycleBaseBranch = snapshot.baseBranch;
 					if (await doesGitRefExist(repoRoot, `refs/heads/${branch}`)) await runGitCommand({
 						cwd: repoRoot,
 						args: [
@@ -2877,17 +3073,33 @@ const createCli = (options = {}) => {
 							branch
 						]
 					});
-					else await runGitCommand({
-						cwd: repoRoot,
-						args: [
-							"worktree",
-							"add",
-							"-b",
+					else {
+						const baseBranch = await resolveBaseBranch(repoRoot);
+						lifecycleBaseBranch = baseBranch;
+						await runGitCommand({
+							cwd: repoRoot,
+							args: [
+								"worktree",
+								"add",
+								"-b",
+								branch,
+								targetPath,
+								baseBranch
+							]
+						});
+					}
+					if (lifecycleBaseBranch !== null) {
+						const branchHead = await resolveBranchHead({
+							repoRoot,
+							branch
+						});
+						await upsertWorktreeMergeLifecycle({
+							repoRoot,
 							branch,
-							targetPath,
-							await resolveBaseBranch(repoRoot)
-						]
-					});
+							baseBranch: lifecycleBaseBranch,
+							createdHead: branchHead
+						});
+					}
 					await runPostHook({
 						name: "switch",
 						context: hookContext
@@ -2987,6 +3199,19 @@ const createCli = (options = {}) => {
 							newPath
 						]
 					});
+					if (snapshot.baseBranch !== null) {
+						const branchHead = await resolveBranchHead({
+							repoRoot,
+							branch: newBranch
+						});
+						await moveWorktreeMergeLifecycle({
+							repoRoot,
+							fromBranch: oldBranch,
+							toBranch: newBranch,
+							baseBranch: snapshot.baseBranch,
+							createdHead: branchHead
+						});
+					}
 					await runPostHook({
 						name: "mv",
 						context: hookContext
@@ -3076,6 +3301,10 @@ const createCli = (options = {}) => {
 						repoRoot,
 						branch: target.branch
 					});
+					await deleteWorktreeMergeLifecycle({
+						repoRoot,
+						branch: target.branch
+					});
 					await runPostHook({
 						name: "del",
 						context: hookContext
@@ -3107,7 +3336,7 @@ const createCli = (options = {}) => {
 				if (parsedArgs.apply === true && parsedArgs.dryRun === true) throw createCliError("INVALID_ARGUMENT", { message: "Cannot use --apply and --dry-run together" });
 				const dryRun = parsedArgs.apply !== true;
 				const execute = async () => {
-					const candidates = (await collectWorktreeSnapshot(repoRoot)).worktrees.filter((worktree) => worktree.branch !== null).filter((worktree) => worktree.path !== repoRoot).filter((worktree) => worktree.dirty === false).filter((worktree) => worktree.locked.value === false).filter((worktree) => worktree.merged.byAncestry === true).map((worktree) => worktree.branch);
+					const candidates = (await collectWorktreeSnapshot(repoRoot)).worktrees.filter((worktree) => worktree.branch !== null).filter((worktree) => worktree.path !== repoRoot).filter((worktree) => worktree.dirty === false).filter((worktree) => worktree.locked.value === false).filter((worktree) => worktree.merged.overall === true).map((worktree) => worktree.branch);
 					if (dryRun) return {
 						deleted: [],
 						candidates,
@@ -3150,6 +3379,10 @@ const createCli = (options = {}) => {
 							repoRoot,
 							branch
 						});
+						await deleteWorktreeMergeLifecycle({
+							repoRoot,
+							branch
+						});
 						deleted.push(branch);
 					}
 					await runPostHook({
@@ -3239,8 +3472,19 @@ const createCli = (options = {}) => {
 							`${remote}/${branch}`
 						]
 					});
-					const existing = (await collectWorktreeSnapshot(repoRoot)).worktrees.find((worktree) => worktree.branch === branch);
+					const snapshot = await collectWorktreeSnapshot(repoRoot);
+					const lifecycleBaseBranch = snapshot.baseBranch;
+					const existing = snapshot.worktrees.find((worktree) => worktree.branch === branch);
 					if (existing !== void 0) {
+						if (lifecycleBaseBranch !== null) await upsertWorktreeMergeLifecycle({
+							repoRoot,
+							branch,
+							baseBranch: lifecycleBaseBranch,
+							createdHead: await resolveBranchHead({
+								repoRoot,
+								branch
+							})
+						});
 						await runPostHook({
 							name: "get",
 							context: hookContext
@@ -3262,6 +3506,15 @@ const createCli = (options = {}) => {
 							branch
 						]
 					});
+					if (lifecycleBaseBranch !== null) await upsertWorktreeMergeLifecycle({
+						repoRoot,
+						branch,
+						baseBranch: lifecycleBaseBranch,
+						createdHead: await resolveBranchHead({
+							repoRoot,
+							branch
+						})
+					});
 					await runPostHook({
 						name: "get",
 						context: hookContext
@@ -3368,6 +3621,15 @@ const createCli = (options = {}) => {
 							branch
 						]
 					});
+					await upsertWorktreeMergeLifecycle({
+						repoRoot,
+						branch,
+						baseBranch,
+						createdHead: await resolveBranchHead({
+							repoRoot,
+							branch
+						})
+					});
 					if (stashOid !== null) {
 						if ((await runGitCommand({
 							cwd: targetPath,