vde-worktree 0.0.4 → 0.0.6

package/dist/index.mjs

@@ -5,10 +5,11 @@ import { access, appendFile, chmod, cp, mkdir, open, readFile, readdir, rename,
 import { homedir, hostname } from "node:os";
 import { dirname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
+import chalk, { Chalk } from "chalk";
 import { parseArgs } from "citty";
 import { execa } from "execa";
+import stringWidth from "string-width";
 import { getBorderCharacters, table } from "table";
-import chalk from "chalk";
 
 //#region src/core/constants.ts
 const SCHEMA_VERSION = 1;
@@ -1001,7 +1002,7 @@ const RESERVED_FZF_ARGS = new Set([
 	"height",
 	"border"
 ]);
-const sanitizeCandidate = (value) => value.replace(/[\t\r\n]+/g, " ").trim();
+const sanitizeCandidate = (value) => value.replace(/[\r\n]+/g, " ").trim();
 const buildFzfInput = (candidates) => {
 	return candidates.map((candidate) => sanitizeCandidate(candidate)).filter((candidate) => candidate.length > 0).join("\n");
 };
@@ -1152,11 +1153,149 @@ const loadPackageVersion = (requireFn) => {
 //#region src/cli/index.ts
 const EXIT_CODE_CANCELLED = 130;
 const optionNamesAllowOptionLikeValue = new Set(["fzfArg", "fzf-arg"]);
+const CD_FZF_EXTRA_ARGS = [
+	"--delimiter=	",
+	"--with-nth=1",
+	"--preview=printf '%b' {3}",
+	"--preview-window=right,60%,wrap",
+	"--ansi"
+];
 const COMPLETION_SHELLS = ["zsh", "fish"];
 const COMPLETION_FILE_BY_SHELL = {
 	zsh: "zsh/_vw",
 	fish: "fish/vw.fish"
 };
+const CATPPUCCIN_MOCHA = {
+	rosewater: "#f5e0dc",
+	mauve: "#cba6f7",
+	red: "#f38ba8",
+	peach: "#fab387",
+	yellow: "#f9e2af",
+	green: "#a6e3a1",
+	blue: "#89b4fa",
+	lavender: "#b4befe",
+	sapphire: "#74c7ec",
+	text: "#cdd6f4",
+	subtext0: "#a6adc8",
+	overlay0: "#6c7086"
+};
+const identityColor = (value) => value;
+const createCatppuccinTheme = ({ enabled }) => {
+	if (enabled !== true) return {
+		header: identityColor,
+		branch: identityColor,
+		branchCurrent: identityColor,
+		branchDetached: identityColor,
+		dirty: identityColor,
+		clean: identityColor,
+		merged: identityColor,
+		unmerged: identityColor,
+		unknown: identityColor,
+		base: identityColor,
+		locked: identityColor,
+		path: identityColor,
+		muted: identityColor,
+		value: identityColor,
+		previewLabel: identityColor,
+		previewSection: identityColor
+	};
+	const chalk = new Chalk({ level: 3 });
+	const color = (hex) => (value) => chalk.hex(hex)(value);
+	return {
+		header: color(CATPPUCCIN_MOCHA.rosewater),
+		branch: color(CATPPUCCIN_MOCHA.lavender),
+		branchCurrent: color(CATPPUCCIN_MOCHA.mauve),
+		branchDetached: color(CATPPUCCIN_MOCHA.peach),
+		dirty: color(CATPPUCCIN_MOCHA.peach),
+		clean: color(CATPPUCCIN_MOCHA.green),
+		merged: color(CATPPUCCIN_MOCHA.green),
+		unmerged: color(CATPPUCCIN_MOCHA.red),
+		unknown: color(CATPPUCCIN_MOCHA.yellow),
+		base: color(CATPPUCCIN_MOCHA.blue),
+		locked: color(CATPPUCCIN_MOCHA.red),
+		path: color(CATPPUCCIN_MOCHA.sapphire),
+		muted: color(CATPPUCCIN_MOCHA.overlay0),
+		value: color(CATPPUCCIN_MOCHA.text),
+		previewLabel: color(CATPPUCCIN_MOCHA.mauve),
+		previewSection: color(CATPPUCCIN_MOCHA.rosewater)
+	};
+};
+const shouldUseAnsiColors = ({ interactive }) => {
+	return interactive === true;
+};
+const colorizeCellContent = ({ cell, color }) => {
+	const matched = /^(\s*)(.*?)(\s*)$/.exec(cell);
+	if (matched === null) return cell;
+	const leftPadding = matched[1] ?? "";
+	const content = matched[2] ?? "";
+	const rightPadding = matched[3] ?? "";
+	if (content.length === 0) return cell;
+	return `${leftPadding}${color(content)}${rightPadding}`;
+};
+const colorizeListTableLine = ({ line, theme }) => {
+	if (line.startsWith("┌") || line.startsWith("├") || line.startsWith("└")) return theme.muted(line);
+	if (line.startsWith("│") !== true) return line;
+	const segments = line.split("│");
+	if (segments.length < 3) return line;
+	const cells = segments.slice(1, -1);
+	if (cells.length !== 5) return line;
+	const headers = cells.map((cell) => cell.trim());
+	if (headers[0] === "branch" && headers[1] === "dirty" && headers[2] === "merged" && headers[3] === "locked" && headers[4] === "path") {
+		const nextCells = cells.map((cell) => colorizeCellContent({
+			cell,
+			color: theme.header
+		}));
+		return [
+			segments[0],
+			...nextCells,
+			segments.at(-1) ?? ""
+		].join("│");
+	}
+	const branchCell = cells[0];
+	const dirtyCell = cells[1];
+	const mergedCell = cells[2];
+	const lockedCell = cells[3];
+	const pathCell = cells[4];
+	const branchColor = branchCell.includes("(detached)") === true ? theme.branchDetached : branchCell.trimStart().startsWith("*") ? theme.branchCurrent : theme.branch;
+	const dirtyTrimmed = dirtyCell.trim();
+	const dirtyColor = dirtyTrimmed === "dirty" ? theme.dirty : dirtyTrimmed === "clean" ? theme.clean : theme.value;
+	const mergedTrimmed = mergedCell.trim();
+	const mergedColor = mergedTrimmed === "merged" ? theme.merged : mergedTrimmed === "unmerged" ? theme.unmerged : mergedTrimmed === "-" ? theme.base : theme.unknown;
+	const lockedColor = lockedCell.trim() === "locked" ? theme.locked : theme.muted;
+	const nextCells = [
+		colorizeCellContent({
+			cell: branchCell,
+			color: branchColor
+		}),
+		colorizeCellContent({
+			cell: dirtyCell,
+			color: dirtyColor
+		}),
+		colorizeCellContent({
+			cell: mergedCell,
+			color: mergedColor
+		}),
+		colorizeCellContent({
+			cell: lockedCell,
+			color: lockedColor
+		}),
+		colorizeCellContent({
+			cell: pathCell,
+			color: theme.path
+		})
+	];
+	return [
+		segments[0],
+		...nextCells,
+		segments.at(-1) ?? ""
+	].join("│");
+};
+const colorizeListTable = ({ rendered, theme }) => {
+	return rendered.trimEnd().split("\n").map((line) => colorizeListTableLine({
+		line,
+		theme
+	})).join("\n");
+};
 const commandHelpEntries = [
 	{
 		name: "init",
@@ -1407,6 +1546,11 @@ const collectOptionValues = ({ args, optionNames }) => {
 	}
 	return values;
 };
+const mergeFzfArgs = ({ defaults, extras }) => {
+	const merged = [...defaults];
+	for (const arg of extras) if (merged.includes(arg) !== true) merged.push(arg);
+	return merged;
+};
 const toNumberOption = ({ value, optionName }) => {
 	if (value === void 0) return;
 	if (typeof value !== "string") throw createCliError("INVALID_ARGUMENT", { message: `${optionName} must be a number` });
@@ -1728,6 +1872,124 @@ const formatDisplayPath = (absolutePath) => {
 	if (absolutePath.startsWith(`${homeDirectory}${sep}`)) return `~${absolutePath.slice(homeDirectory.length)}`;
 	return absolutePath;
 };
+const encodeCdPreviewField = (value) => {
+	return value.replace(/\\/g, "\\\\").split("\x1B").join("\\033").replace(/\t/g, " ").replace(/\r\n?/g, "\n").replace(/\n/g, "\\n");
+};
+const formatMergedDisplayState = ({ mergedOverall, isBaseBranch, baseLabel = "base" }) => {
+	if (isBaseBranch) return baseLabel;
+	if (mergedOverall === true) return "merged";
+	if (mergedOverall === false) return "unmerged";
+	return "unknown";
+};
+const formatMergedColor = ({ mergedState, theme }) => {
+	const normalized = mergedState.toLowerCase();
+	if (normalized === "merged") return theme.merged(mergedState);
+	if (normalized === "unmerged") return theme.unmerged(mergedState);
+	if (normalized === "base") return theme.base(mergedState);
+	return theme.unknown(mergedState);
+};
+const padToDisplayWidth = ({ value, width }) => {
+	const visibleLength = stringWidth(value);
+	if (visibleLength >= width) return value;
+	return `${value}${" ".repeat(width - visibleLength)}`;
+};
+const buildCdBranchLabel = ({ worktree, currentWorktreeRoot }) => {
+	return `${worktree.path === currentWorktreeRoot ? "*" : " "} ${worktree.branch ?? "(detached)"}`;
+};
+const buildCdStateSummary = ({ worktree, isBaseBranch, theme }) => {
+	const dirtyLabel = worktree.dirty ? "DIRTY" : "CLEAN";
+	const mergedLabel = formatMergedDisplayState({
+		mergedOverall: worktree.merged.overall,
+		isBaseBranch
+	}).toUpperCase();
+	const lockLabel = worktree.locked.value ? "LOCK" : "OPEN";
+	const dirtyBadge = (worktree.dirty ? theme.unmerged : theme.clean)(padToDisplayWidth({
+		value: dirtyLabel,
+		width: 5
+	}));
+	const mergedBadge = formatMergedColor({
+		mergedState: padToDisplayWidth({
+			value: mergedLabel,
+			width: 8
+		}),
+		theme
+	});
+	const lockBadge = (worktree.locked.value ? theme.locked : theme.muted)(padToDisplayWidth({
+		value: lockLabel,
+		width: 4
+	}));
+	return `${dirtyBadge} ${theme.muted("|")} ${mergedBadge} ${theme.muted("|")} ${lockBadge}`;
+};
+const buildCdPreviewText = ({ worktree, baseBranch, theme }) => {
+	const isBaseBranch = typeof worktree.branch === "string" && baseBranch !== null && worktree.branch === baseBranch;
+	const branchLabel = worktree.branch === null ? theme.branchDetached("(detached)") : isBaseBranch ? theme.base(worktree.branch) : theme.branch(worktree.branch);
+	const pathLabel = theme.path(formatDisplayPath(worktree.path));
+	const dirtyValue = worktree.dirty ? theme.unmerged("[DIRTY]") : theme.merged("[CLEAN]");
+	const lockedValue = worktree.locked.value ? theme.locked("[LOCKED]") : theme.clean("[OPEN]");
+	const mergedValue = formatMergedColor({
+		mergedState: formatMergedDisplayState({
+			mergedOverall: worktree.merged.overall,
+			isBaseBranch
+		}).toUpperCase(),
+		theme
+	});
+	const remoteValue = worktree.upstream.remote === null ? theme.muted("none") : theme.value(worktree.upstream.remote ?? "none");
+	const aheadValue = worktree.upstream.ahead === null ? theme.unknown("UNKNOWN") : worktree.upstream.ahead > 0 ? theme.unmerged(String(worktree.upstream.ahead)) : theme.merged("0");
+	const behindValue = worktree.upstream.behind === null ? theme.unknown("UNKNOWN") : worktree.upstream.behind > 0 ? theme.unknown(String(worktree.upstream.behind)) : theme.merged("0");
+	const divider = theme.muted("----------------------------------------");
+	const lines = [
+		theme.previewSection("WORKTREE"),
+		divider,
+		`  ${theme.previewLabel("Branch ")}: ${branchLabel}`,
+		`  ${theme.previewLabel("Path   ")}: ${pathLabel}`,
+		"",
+		theme.previewSection("STATUS"),
+		divider,
+		`  ${theme.previewLabel("Dirty  ")}: ${dirtyValue}`,
+		`  ${theme.previewLabel("Locked ")}: ${lockedValue}`,
+		`  ${theme.previewLabel("Merged ")}: ${mergedValue}`,
+		`  ${theme.previewLabel("Remote ")}: ${remoteValue}`,
+		`  ${theme.previewLabel("Ahead  ")}: ${aheadValue}`,
+		`  ${theme.previewLabel("Behind ")}: ${behindValue}`
+	];
+	if (worktree.locked.value) {
+		lines.push("");
+		lines.push(theme.previewSection("LOCK"));
+		lines.push(divider);
+		if (typeof worktree.locked.reason === "string" && worktree.locked.reason.length > 0) lines.push(`  ${theme.previewLabel("Reason ")}: ${theme.value(worktree.locked.reason)}`);
+		if (typeof worktree.locked.owner === "string" && worktree.locked.owner.length > 0) lines.push(`  ${theme.previewLabel("Owner  ")}: ${theme.value(worktree.locked.owner)}`);
+	}
+	return lines.join("\n");
+};
+const buildCdCandidateLine = ({ worktree, baseBranch, theme, currentWorktreeRoot, branchColumnWidth }) => {
+	const isBaseBranch = typeof worktree.branch === "string" && baseBranch !== null && worktree.branch === baseBranch;
+	const branchLabelPadded = padToDisplayWidth({
+		value: buildCdBranchLabel({
+			worktree,
+			currentWorktreeRoot
+		}),
+		width: branchColumnWidth
+	});
+	const isCurrent = worktree.path === currentWorktreeRoot;
+	return [
+		`${worktree.branch === null ? theme.branchDetached(branchLabelPadded) : isCurrent ? theme.branchCurrent(branchLabelPadded) : isBaseBranch ? theme.base(branchLabelPadded) : theme.branch(branchLabelPadded)}  ${buildCdStateSummary({
+			worktree,
+			isBaseBranch,
+			theme
+		})}`,
+		worktree.path,
+		encodeCdPreviewField(buildCdPreviewText({
+			worktree,
+			baseBranch,
+			theme
+		}))
+	].join("	");
+};
+const resolveCdSelectionPath = (selectedLine) => {
+	const rawPath = selectedLine.split("	")[1];
+	if (typeof rawPath === "string" && rawPath.length > 0) return rawPath;
+	return selectedLine;
+};
 const containsBranch = ({ branch, worktrees }) => {
 	return worktrees.some((worktree) => worktree.branch === branch);
 };
@@ -2164,28 +2426,32 @@ const createCli = (options = {}) => {
 					})));
 					return EXIT_CODE.OK;
 				}
-				const rendered = table([[
-					"branch",
-					"dirty",
-					"merged",
-					"locked",
-					"path"
-				], ...snapshot.worktrees.map((worktree) => {
-					const mergedState = (worktree.branch !== null && snapshot.baseBranch !== null && worktree.branch === snapshot.baseBranch) === true ? "-" : worktree.merged.overall === true ? "merged" : worktree.merged.overall === false ? "unmerged" : "unknown";
-					return [
-						`${worktree.path === repoContext.currentWorktreeRoot ? "*" : " "} ${worktree.branch ?? "(detached)"}`,
-						worktree.dirty ? "dirty" : "clean",
-						mergedState,
-						worktree.locked.value ? "locked" : "-",
-						formatDisplayPath(worktree.path)
-					];
-				})], {
-					border: getBorderCharacters("norc"),
-					drawHorizontalLine: (lineIndex, rowCount) => {
-						return lineIndex === 0 || lineIndex === 1 || lineIndex === rowCount;
-					}
+				const theme = createCatppuccinTheme({ enabled: shouldUseAnsiColors({ interactive: runtime.isInteractive }) });
+				const colorized = colorizeListTable({
+					rendered: table([[
+						"branch",
+						"dirty",
+						"merged",
+						"locked",
+						"path"
+					], ...snapshot.worktrees.map((worktree) => {
+						const mergedState = (worktree.branch !== null && snapshot.baseBranch !== null && worktree.branch === snapshot.baseBranch) === true ? "-" : worktree.merged.overall === true ? "merged" : worktree.merged.overall === false ? "unmerged" : "unknown";
+						return [
+							`${worktree.path === repoContext.currentWorktreeRoot ? "*" : " "} ${worktree.branch ?? "(detached)"}`,
+							worktree.dirty ? "dirty" : "clean",
+							mergedState,
+							worktree.locked.value ? "locked" : "-",
+							formatDisplayPath(worktree.path)
+						];
+					})], {
+						border: getBorderCharacters("norc"),
+						drawHorizontalLine: (lineIndex, rowCount) => {
+							return lineIndex === 0 || lineIndex === 1 || lineIndex === rowCount;
+						}
+					}),
+					theme
 				});
-				for (const line of rendered.trimEnd().split("\n")) stdout(line);
+				for (const line of colorized.split("\n")) stdout(line);
 				return EXIT_CODE.OK;
 			}
 			if (command === "status") {
@@ -2581,7 +2847,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.overall === true).filter((worktree) => worktree.upstream.ahead === 0).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.byAncestry === true).map((worktree) => worktree.branch);
 					if (dryRun) return {
 						deleted: [],
 						candidates,
@@ -3292,15 +3558,33 @@ const createCli = (options = {}) => {
 					min: 0,
 					max: 0
 				});
-				const candidates = (await collectWorktreeSnapshot(repoRoot)).worktrees.map((worktree) => worktree.path);
+				const snapshot = await collectWorktreeSnapshot(repoRoot);
+				const theme = createCatppuccinTheme({ enabled: shouldUseAnsiColors({ interactive: runtime.isInteractive }) });
+				const branchColumnWidth = snapshot.worktrees.reduce((maxWidth, worktree) => {
+					const label = buildCdBranchLabel({
+						worktree,
+						currentWorktreeRoot: repoContext.currentWorktreeRoot
+					});
+					return Math.max(maxWidth, stringWidth(label));
+				}, 0);
+				const candidates = snapshot.worktrees.map((worktree) => buildCdCandidateLine({
+					worktree,
+					baseBranch: snapshot.baseBranch,
+					theme,
+					currentWorktreeRoot: repoContext.currentWorktreeRoot,
+					branchColumnWidth
+				}));
 				if (candidates.length === 0) throw createCliError("WORKTREE_NOT_FOUND", { message: "No worktree candidates found" });
 				const promptValue = readStringOption(parsedArgsRecord, "prompt");
 				const selection = await selectPathWithFzf$1({
 					candidates,
 					prompt: typeof promptValue === "string" && promptValue.length > 0 ? promptValue : "worktree> ",
-					fzfExtraArgs: collectOptionValues({
-						args: beforeDoubleDash,
-						optionNames: ["fzfArg", "fzf-arg"]
+					fzfExtraArgs: mergeFzfArgs({
+						defaults: CD_FZF_EXTRA_ARGS,
+						extras: collectOptionValues({
+							args: beforeDoubleDash,
+							optionNames: ["fzfArg", "fzf-arg"]
+						})
 					}),
 					cwd: repoRoot,
 					isInteractive: () => runtime.isInteractive || process.stderr.isTTY === true
@@ -3310,16 +3594,17 @@ const createCli = (options = {}) => {
 					throw error;
 				});
 				if (selection.status === "cancelled") return EXIT_CODE_CANCELLED;
+				const selectedPath = resolveCdSelectionPath(selection.path);
 				if (runtime.json) {
 					stdout(JSON.stringify(buildJsonSuccess({
 						command,
 						status: "ok",
 						repoRoot,
-						details: { path: selection.path }
+						details: { path: selectedPath }
 					})));
 					return EXIT_CODE.OK;
 				}
-				stdout(selection.path);
+				stdout(selectedPath);
 				return EXIT_CODE.OK;
 			}
 			throw createCliError("UNKNOWN_COMMAND", { message: `Unknown command: ${command}` });