bsmnt 0.0.0

package/src/commands/worktree.js

@@ -0,0 +1,805 @@
+import { execSync } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import fs from "fs-extra";
+import ora from "ora";
+import pc from "picocolors";
+import prompts from "prompts";
+
+const WORKTREE_BASE = path.join(os.homedir(), ".claude", "worktrees");
+
+/**
+ * Check if we're inside a git repository
+ */
+function isGitRepo() {
+	try {
+		execSync("git rev-parse --is-inside-work-tree", { stdio: "pipe" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Get the project name from git root directory
+ */
+function getProjectName() {
+	const gitRoot = execSync("git rev-parse --show-toplevel", {
+		encoding: "utf-8",
+	}).trim();
+	return path.basename(gitRoot);
+}
+
+/**
+ * Get the git root directory
+ */
+function _getGitRoot() {
+	return execSync("git rev-parse --show-toplevel", {
+		encoding: "utf-8",
+	}).trim();
+}
+
+/**
+ * Convert branch name to directory-safe name (feature/auth -> feature-auth)
+ */
+function sanitizeBranchName(branchName) {
+	return branchName.replace(/\//g, "-");
+}
+
+/**
+ * Get the worktree path for a branch
+ */
+function getWorktreePath(projectName, branchName) {
+	const safeName = sanitizeBranchName(branchName);
+	return path.join(WORKTREE_BASE, projectName, safeName);
+}
+
+/**
+ * Get all existing branches
+ */
+function _getExistingBranches() {
+	try {
+		const output = execSync('git branch --format="%(refname:short)"', {
+			encoding: "utf-8",
+		});
+		return output.trim().split("\n").filter(Boolean);
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Check if a branch exists
+ */
+function branchExists(branchName) {
+	try {
+		execSync(`git show-ref --verify --quiet refs/heads/${branchName}`, {
+			stdio: "pipe",
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Detect package manager and install dependencies
+ */
+async function detectAndInstallDeps(worktreePath) {
+	const spinner = ora(pc.dim("Detecting dependencies...")).start();
+
+	// Node.js projects
+	if (fs.existsSync(path.join(worktreePath, "package.json"))) {
+		if (
+			fs.existsSync(path.join(worktreePath, "bun.lock")) ||
+			fs.existsSync(path.join(worktreePath, "bun.lockb"))
+		) {
+			spinner.text = pc.dim("Installing dependencies with bun...");
+			try {
+				execSync("bun install", { cwd: worktreePath, stdio: "pipe" });
+				spinner.succeed(pc.green("Dependencies installed with bun"));
+			} catch {
+				spinner.warn(pc.yellow("bun install failed"));
+			}
+			return;
+		}
+
+		if (fs.existsSync(path.join(worktreePath, "pnpm-lock.yaml"))) {
+			spinner.text = pc.dim("Installing dependencies with pnpm...");
+			try {
+				execSync("pnpm install", { cwd: worktreePath, stdio: "pipe" });
+				spinner.succeed(pc.green("Dependencies installed with pnpm"));
+			} catch {
+				spinner.warn(pc.yellow("pnpm install failed"));
+			}
+			return;
+		}
+
+		if (fs.existsSync(path.join(worktreePath, "yarn.lock"))) {
+			spinner.text = pc.dim("Installing dependencies with yarn...");
+			try {
+				execSync("yarn install", { cwd: worktreePath, stdio: "pipe" });
+				spinner.succeed(pc.green("Dependencies installed with yarn"));
+			} catch {
+				spinner.warn(pc.yellow("yarn install failed"));
+			}
+			return;
+		}
+
+		spinner.text = pc.dim("Installing dependencies with npm...");
+		try {
+			execSync("npm install", { cwd: worktreePath, stdio: "pipe" });
+			spinner.succeed(pc.green("Dependencies installed with npm"));
+		} catch {
+			spinner.warn(pc.yellow("npm install failed"));
+		}
+		return;
+	}
+
+	// Rust projects
+	if (fs.existsSync(path.join(worktreePath, "Cargo.toml"))) {
+		spinner.text = pc.dim("Building Rust project...");
+		try {
+			execSync("cargo build", { cwd: worktreePath, stdio: "pipe" });
+			spinner.succeed(pc.green("Rust project built"));
+		} catch {
+			spinner.warn(pc.yellow("cargo build failed"));
+		}
+		return;
+	}
+
+	// Python projects
+	if (fs.existsSync(path.join(worktreePath, "requirements.txt"))) {
+		spinner.text = pc.dim("Installing Python dependencies...");
+		try {
+			execSync("pip install -r requirements.txt", {
+				cwd: worktreePath,
+				stdio: "pipe",
+			});
+			spinner.succeed(pc.green("Python dependencies installed"));
+		} catch {
+			spinner.warn(pc.yellow("pip install failed"));
+		}
+		return;
+	}
+
+	if (fs.existsSync(path.join(worktreePath, "pyproject.toml"))) {
+		const pyprojectContent = fs.readFileSync(
+			path.join(worktreePath, "pyproject.toml"),
+			"utf-8",
+		);
+		if (pyprojectContent.includes("[tool.poetry]")) {
+			spinner.text = pc.dim("Installing with poetry...");
+			try {
+				execSync("poetry install", { cwd: worktreePath, stdio: "pipe" });
+				spinner.succeed(pc.green("Poetry dependencies installed"));
+			} catch {
+				spinner.warn(pc.yellow("poetry install failed"));
+			}
+		} else {
+			spinner.text = pc.dim("Installing with pip...");
+			try {
+				execSync("pip install -e .", { cwd: worktreePath, stdio: "pipe" });
+				spinner.succeed(pc.green("Python package installed"));
+			} catch {
+				spinner.warn(pc.yellow("pip install failed"));
+			}
+		}
+		return;
+	}
+
+	// Go projects
+	if (fs.existsSync(path.join(worktreePath, "go.mod"))) {
+		spinner.text = pc.dim("Downloading Go modules...");
+		try {
+			execSync("go mod download", { cwd: worktreePath, stdio: "pipe" });
+			spinner.succeed(pc.green("Go modules downloaded"));
+		} catch {
+			spinner.warn(pc.yellow("go mod download failed"));
+		}
+		return;
+	}
+
+	spinner.info(pc.dim("No recognized dependency files found"));
+}
+
+/**
+ * Get list of worktrees for the current project
+ */
+function getWorktrees(projectName) {
+	const projectWorktreeDir = path.join(WORKTREE_BASE, projectName);
+
+	if (!fs.existsSync(projectWorktreeDir)) {
+		return [];
+	}
+
+	const worktrees = [];
+	const dirs = fs.readdirSync(projectWorktreeDir, { withFileTypes: true });
+
+	for (const dir of dirs) {
+		if (dir.isDirectory()) {
+			const worktreePath = path.join(projectWorktreeDir, dir.name);
+			const gitFile = path.join(worktreePath, ".git");
+
+			let branchName = "unknown";
+			if (fs.existsSync(gitFile)) {
+				try {
+					const gitContent = fs.readFileSync(gitFile, "utf-8");
+					const gitDirMatch = gitContent.match(/gitdir: (.+)/);
+					if (gitDirMatch) {
+						const headFile = path.join(gitDirMatch[1].trim(), "HEAD");
+						if (fs.existsSync(headFile)) {
+							const headContent = fs.readFileSync(headFile, "utf-8");
+							branchName = headContent.replace("ref: refs/heads/", "").trim();
+						}
+					}
+				} catch {
+					// ignore
+				}
+			}
+
+			worktrees.push({
+				name: dir.name,
+				path: worktreePath,
+				branch: branchName,
+			});
+		}
+	}
+
+	return worktrees;
+}
+
+/**
+ * Create a single worktree (helper function)
+ * Returns { success: boolean, path: string, branch: string, error?: string }
+ */
+async function createSingleWorktree(
+	projectName,
+	branchName,
+	installDeps = true,
+) {
+	const worktreePath = getWorktreePath(projectName, branchName);
+
+	// Check if worktree path already exists
+	if (fs.existsSync(worktreePath)) {
+		return {
+			success: false,
+			path: worktreePath,
+			branch: branchName,
+			error: "Worktree already exists",
+		};
+	}
+
+	// Create parent directory
+	fs.ensureDirSync(path.dirname(worktreePath));
+
+	const spinner = ora(`Creating worktree '${branchName}'...`).start();
+
+	try {
+		// Check if branch already exists
+		if (branchExists(branchName)) {
+			spinner.text = pc.dim(`Using existing branch '${branchName}'...`);
+			execSync(`git worktree add "${worktreePath}" "${branchName}"`, {
+				stdio: "pipe",
+			});
+		} else {
+			spinner.text = pc.dim(`Creating new branch '${branchName}'...`);
+			execSync(`git worktree add "${worktreePath}" -b "${branchName}"`, {
+				stdio: "pipe",
+			});
+		}
+		spinner.succeed(pc.green(`Worktree created: ${pc.cyan(branchName)}`));
+	} catch (e) {
+		spinner.fail(
+			pc.red(`Failed to create worktree '${branchName}': ${e.message}`),
+		);
+		return {
+			success: false,
+			path: worktreePath,
+			branch: branchName,
+			error: e.message,
+		};
+	}
+
+	// Install dependencies
+	if (installDeps) {
+		await detectAndInstallDeps(worktreePath);
+	}
+
+	return { success: true, path: worktreePath, branch: branchName };
+}
+
+/**
+ * Create new worktree(s)
+ */
+async function cmdCreate(options = {}) {
+	const projectName = getProjectName();
+
+	// If branch is provided via flag, create worktree(s)
+	// Supports comma-separated branches: -b=feature/auth,feature/dashboard
+	if (options.branch) {
+		const branches = options.branch
+			.split(",")
+			.map((b) => b.trim())
+			.filter(Boolean);
+
+		if (branches.length === 1) {
+			// Single worktree
+			const result = await createSingleWorktree(projectName, branches[0]);
+			if (result.success) {
+				console.log(`\n${pc.bold(pc.green("✅ Worktree ready!"))}`);
+				console.log(`  ${pc.bold("Path:")}   ${result.path}`);
+				console.log(`  ${pc.bold("Branch:")} ${result.branch}`);
+				console.log(`\n${pc.bold("To switch to this worktree, run:")}`);
+				console.log(pc.cyan(`  cd ${result.path}`));
+				console.log();
+			}
+			return;
+		}
+
+		// Multiple worktrees via flag
+		const results = [];
+		for (const branchName of branches) {
+			const result = await createSingleWorktree(projectName, branchName, false);
+			results.push(result);
+		}
+
+		// Install dependencies for all successful worktrees
+		const successful = results.filter((r) => r.success);
+		if (successful.length > 0) {
+			console.log(`\n${pc.dim("Installing dependencies...")}`);
+			for (const result of successful) {
+				await detectAndInstallDeps(result.path);
+			}
+		}
+
+		// Summary
+		const failed = results.filter((r) => !r.success);
+
+		console.log(
+			`\n${pc.bold(pc.green(`✅ ${successful.length} worktree${successful.length !== 1 ? "s" : ""} created!`))}`,
+		);
+
+		if (successful.length > 0) {
+			console.log(`\n${pc.bold("Created worktrees:")}`);
+			for (const result of successful) {
+				console.log(`  ${pc.green("●")} ${pc.bold(result.branch)}`);
+				console.log(`    ${pc.cyan(result.path)}`);
+			}
+		}
+
+		if (failed.length > 0) {
+			console.log(`\n${pc.bold(pc.red(`Failed (${failed.length}):`))}`);
+			for (const result of failed) {
+				console.log(`  ${pc.red("●")} ${result.branch}: ${result.error}`);
+			}
+		}
+
+		console.log();
+		return;
+	}
+
+	// Ask how many worktrees to create
+	const { count } = await prompts({
+		type: "number",
+		name: "count",
+		message: "How many worktrees to create?",
+		initial: 1,
+		min: 1,
+		max: 10,
+		validate: (value) => {
+			if (value < 1) return "Must create at least 1 worktree";
+			if (value > 10) return "Maximum 10 worktrees at once";
+			return true;
+		},
+	});
+
+	if (count === undefined) {
+		console.log(pc.yellow("\n⚠ Operation cancelled.\n"));
+		return;
+	}
+
+	// Collect branch names
+	const branches = [];
+	for (let i = 0; i < count; i++) {
+		const { branch } = await prompts({
+			type: "text",
+			name: "branch",
+			message: count > 1 ? `Branch name (${i + 1}/${count}):` : "Branch name:",
+			initial: "feature/",
+			validate: (value) => {
+				if (!value.trim()) return "Branch name is required";
+				if (value.includes(" ")) return "Branch name cannot contain spaces";
+				if (branches.includes(value)) return "Branch name already entered";
+				return true;
+			},
+		});
+
+		if (!branch) {
+			console.log(pc.yellow("\n⚠ Operation cancelled.\n"));
+			return;
+		}
+		branches.push(branch);
+	}
+
+	console.log();
+
+	// Create all worktrees (without installing deps yet for speed)
+	const results = [];
+	for (const branchName of branches) {
+		const result = await createSingleWorktree(projectName, branchName, false);
+		results.push(result);
+	}
+
+	// Install dependencies for all successful worktrees
+	const successful = results.filter((r) => r.success);
+	if (successful.length > 0) {
+		console.log(`\n${pc.dim("Installing dependencies...")}`);
+		for (const result of successful) {
+			await detectAndInstallDeps(result.path);
+		}
+	}
+
+	// Summary
+	const failed = results.filter((r) => !r.success);
+
+	console.log(
+		`\n${pc.bold(pc.green(`✅ ${successful.length} worktree${successful.length !== 1 ? "s" : ""} created!`))}`,
+	);
+
+	if (successful.length > 0) {
+		console.log(`\n${pc.bold("Created worktrees:")}`);
+		for (const result of successful) {
+			console.log(`  ${pc.green("●")} ${pc.bold(result.branch)}`);
+			console.log(`    ${pc.cyan(result.path)}`);
+		}
+	}
+
+	if (failed.length > 0) {
+		console.log(`\n${pc.bold(pc.red(`Failed (${failed.length}):`))}`);
+		for (const result of failed) {
+			console.log(`  ${pc.red("●")} ${result.branch}: ${result.error}`);
+		}
+	}
+
+	if (successful.length === 1) {
+		console.log(`\n${pc.bold("To switch to this worktree, run:")}`);
+		console.log(pc.cyan(`  cd ${successful[0].path}`));
+	} else if (successful.length > 1) {
+		console.log(`\n${pc.bold("To switch to a worktree, run:")}`);
+		console.log(pc.cyan(`  cd <worktree-path>`));
+	}
+
+	console.log();
+}
+
+/**
+ * List all worktrees for current project
+ */
+async function cmdList() {
+	const projectName = getProjectName();
+	const worktrees = getWorktrees(projectName);
+
+	console.log(`\n${pc.bold(`Worktrees for '${pc.cyan(projectName)}':`)}\n`);
+
+	if (worktrees.length === 0) {
+		console.log(pc.dim("  No worktrees found\n"));
+		return;
+	}
+
+	for (const wt of worktrees) {
+		console.log(`  ${pc.green("●")} ${pc.bold(wt.branch)}`);
+		console.log(`    ${pc.blue(wt.path)}`);
+	}
+	console.log();
+}
+
+/**
+ * Switch to a worktree (show cd command)
+ */
+async function cmdSwitch(options = {}) {
+	const projectName = getProjectName();
+	const worktrees = getWorktrees(projectName);
+
+	if (worktrees.length === 0) {
+		console.log(
+			pc.yellow(
+				"\n⚠ No worktrees found. Create one first with: basement -w create\n",
+			),
+		);
+		return;
+	}
+
+	let selectedWorktree = options.branch;
+
+	if (!selectedWorktree) {
+		const { selected } = await prompts({
+			type: "select",
+			name: "selected",
+			message: "Switch to worktree:",
+			choices: worktrees.map((wt) => ({
+				title: wt.branch,
+				description: wt.path,
+				value: wt.branch,
+			})),
+		});
+
+		if (!selected) {
+			console.log(pc.yellow("\n⚠ Operation cancelled.\n"));
+			return;
+		}
+		selectedWorktree = selected;
+	}
+
+	const worktree = worktrees.find((wt) => wt.branch === selectedWorktree);
+
+	if (!worktree) {
+		console.log(pc.red(`\n✗ Worktree not found: ${selectedWorktree}\n`));
+		return;
+	}
+
+	console.log(`\n${pc.bold("To switch to this worktree, run:")}`);
+	console.log(pc.cyan(`  cd ${worktree.path}`));
+	console.log();
+}
+
+/**
+ * Remove a worktree
+ */
+async function cmdRemove(options = {}) {
+	const projectName = getProjectName();
+	const worktrees = getWorktrees(projectName);
+
+	if (worktrees.length === 0) {
+		console.log(pc.yellow("\n⚠ No worktrees found.\n"));
+		return;
+	}
+
+	let selectedWorktree = options.branch;
+
+	if (!selectedWorktree) {
+		const { selected } = await prompts({
+			type: "select",
+			name: "selected",
+			message: "Remove worktree:",
+			choices: worktrees.map((wt) => ({
+				title: wt.branch,
+				description: wt.path,
+				value: wt.branch,
+			})),
+		});
+
+		if (!selected) {
+			console.log(pc.yellow("\n⚠ Operation cancelled.\n"));
+			return;
+		}
+		selectedWorktree = selected;
+	}
+
+	const worktree = worktrees.find((wt) => wt.branch === selectedWorktree);
+
+	if (!worktree) {
+		console.log(pc.red(`\n✗ Worktree not found: ${selectedWorktree}\n`));
+		return;
+	}
+
+	// Confirm removal
+	if (!options.force) {
+		const { confirm } = await prompts({
+			type: "confirm",
+			name: "confirm",
+			message: `Remove worktree at ${pc.cyan(worktree.path)}?`,
+			initial: false,
+		});
+
+		if (!confirm) {
+			console.log(pc.yellow("\n⚠ Operation cancelled.\n"));
+			return;
+		}
+	}
+
+	// Ask about branch deletion
+	let deleteBranch = options.deleteBranch;
+	if (deleteBranch === undefined) {
+		const { shouldDelete } = await prompts({
+			type: "confirm",
+			name: "shouldDelete",
+			message: `Also delete branch '${worktree.branch}'?`,
+			initial: false,
+		});
+		deleteBranch = shouldDelete;
+	}
+
+	const spinner = ora("Removing worktree...").start();
+
+	try {
+		execSync(`git worktree remove "${worktree.path}" --force`, {
+			stdio: "pipe",
+		});
+		spinner.succeed(pc.green(`Worktree removed: ${worktree.path}`));
+	} catch {
+		spinner.warn(
+			pc.yellow("git worktree remove failed, removing directory manually..."),
+		);
+		try {
+			fs.removeSync(worktree.path);
+			spinner.succeed(pc.green(`Directory removed: ${worktree.path}`));
+		} catch (e) {
+			spinner.fail(pc.red(`Failed to remove: ${e.message}`));
+			return;
+		}
+	}
+
+	// Delete the branch if requested
+	if (deleteBranch) {
+		const branchSpinner = ora(
+			`Deleting branch '${worktree.branch}'...`,
+		).start();
+		try {
+			execSync(`git branch -D "${worktree.branch}"`, { stdio: "pipe" });
+			branchSpinner.succeed(pc.green(`Branch deleted: ${worktree.branch}`));
+		} catch {
+			branchSpinner.warn(
+				pc.yellow(
+					"Could not delete branch (may be checked out elsewhere or already deleted)",
+				),
+			);
+		}
+	}
+
+	console.log();
+}
+
+/**
+ * Prune stale worktrees
+ */
+async function cmdPrune() {
+	const projectName = getProjectName();
+
+	const spinner = ora("Pruning stale worktree references...").start();
+
+	try {
+		execSync("git worktree prune", { stdio: "pipe" });
+		spinner.succeed(pc.green("Git worktree references pruned"));
+	} catch (e) {
+		spinner.warn(pc.yellow(`git worktree prune warning: ${e.message}`));
+	}
+
+	const projectWorktreeDir = path.join(WORKTREE_BASE, projectName);
+
+	if (!fs.existsSync(projectWorktreeDir)) {
+		console.log(pc.green("\n✓ No worktrees to clean up\n"));
+		return;
+	}
+
+	const checkSpinner = ora(
+		"Checking for orphaned worktree directories...",
+	).start();
+
+	let pruned = 0;
+	const dirs = fs.readdirSync(projectWorktreeDir, { withFileTypes: true });
+
+	for (const dir of dirs) {
+		if (dir.isDirectory()) {
+			const worktreePath = path.join(projectWorktreeDir, dir.name);
+			const gitFile = path.join(worktreePath, ".git");
+
+			let isValid = false;
+
+			if (fs.existsSync(gitFile)) {
+				try {
+					const gitContent = fs.readFileSync(gitFile, "utf-8");
+					const gitDirMatch = gitContent.match(/gitdir: (.+)/);
+					if (gitDirMatch && fs.existsSync(gitDirMatch[1].trim())) {
+						isValid = true;
+					}
+				} catch {
+					// invalid
+				}
+			}
+
+			if (!isValid) {
+				console.log(pc.yellow(`  Removing orphaned: ${worktreePath}`));
+				fs.removeSync(worktreePath);
+				pruned++;
+			}
+		}
+	}
+
+	// Remove empty project directory
+	const remaining = fs.readdirSync(projectWorktreeDir);
+	if (remaining.length === 0) {
+		fs.rmdirSync(projectWorktreeDir);
+	}
+
+	if (pruned === 0) {
+		checkSpinner.succeed(pc.green("No orphaned directories found"));
+	} else {
+		checkSpinner.succeed(
+			pc.green(
+				`Pruned ${pruned} orphaned director${pruned === 1 ? "y" : "ies"}`,
+			),
+		);
+	}
+
+	console.log();
+}
+
+/**
+ * Main worktree command
+ */
+export async function worktreeCommand(options = {}) {
+	// Verify we're in a git repo
+	if (!isGitRepo()) {
+		console.log(pc.red("\n✗ Not in a git repository\n"));
+		process.exit(1);
+	}
+
+	// Ensure worktree base directory exists
+	fs.ensureDirSync(WORKTREE_BASE);
+
+	let action = options.action;
+
+	// If action specified via flag, use it directly
+	if (!action) {
+		const { selectedAction } = await prompts({
+			type: "select",
+			name: "selectedAction",
+			message: "What would you like to do?",
+			choices: [
+				{
+					title: "Create worktree",
+					description: "Create a new worktree with a branch",
+					value: "create",
+				},
+				{
+					title: "List worktrees",
+					description: "Show all worktrees for this project",
+					value: "list",
+				},
+				{
+					title: "Switch worktree",
+					description: "Get cd command to switch to a worktree",
+					value: "switch",
+				},
+				{
+					title: "Remove worktree",
+					description: "Remove a worktree and optionally its branch",
+					value: "remove",
+				},
+				{
+					title: "Prune worktrees",
+					description: "Clean up stale worktrees and orphaned directories",
+					value: "prune",
+				},
+			],
+		});
+
+		if (!selectedAction) {
+			console.log(pc.yellow("\n⚠ Operation cancelled.\n"));
+			return;
+		}
+
+		action = selectedAction;
+	}
+
+	switch (action) {
+		case "create":
+			await cmdCreate(options);
+			break;
+		case "list":
+			await cmdList();
+			break;
+		case "switch":
+			await cmdSwitch(options);
+			break;
+		case "remove":
+			await cmdRemove(options);
+			break;
+		case "prune":
+			await cmdPrune();
+			break;
+		default:
+			console.log(pc.red(`\n✗ Unknown action: ${action}\n`));
+	}
+}