bsmnt 0.1.2 → 0.2.0

package/packages/cli/src/commands/worktree.js

@@ -1,805 +0,0 @@
-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`));
-	}
-}