feat: add support for add and remove commands

captainsafia · captainsafia · commit 3fed99a1b73a · 2025-12-14T16:15:38.000-08:00
diff --git a/src/commands/add.ts b/src/commands/add.ts
@@ -0,0 +1,82 @@
+import { Command } from "commander";
+import * as path from "path";
+import chalk from "chalk";
+import { WorktreeManager } from "../git/WorktreeManager";
+
+interface AddCommandOptions {
+  branch?: boolean;
+  track?: string;
+}
+
+export function createAddCommand(): Command {
+  const command = new Command("add");
+
+  command
+    .description("Create a new worktree")
+    .argument("<name>", "Branch name or new branch name (with -b)")
+    .option("-b, --branch", "Create a new branch", false)
+    .option(
+      "-t, --track <remote-branch>",
+      "Set up tracking for the specified remote branch",
+    )
+    .action(async (name: string, options: AddCommandOptions) => {
+      try {
+        await runAdd(name, options);
+      } catch (error) {
+        console.error(
+          chalk.red("Error:"),
+          error instanceof Error ? error.message : error,
+        );
+        process.exit(1);
+      }
+    });
+
+  return command;
+}
+
+async function runAdd(name: string, options: AddCommandOptions): Promise<void> {
+  const manager = new WorktreeManager();
+  await manager.initialize();
+
+  // Determine the worktree path based on the branch name
+  // Convert branch name like "feature/my-feature" to a path like "../feature/my-feature"
+  const worktreePath = getWorktreePath(name);
+
+  console.log(chalk.blue(`Creating worktree for '${name}'...`));
+
+  if (options.branch) {
+    // Create a new branch and worktree
+    await manager.addWorktree(worktreePath, name, {
+      createBranch: true,
+      track: options.track,
+    });
+    console.log(
+      chalk.green("✓ Created new branch and worktree:"),
+      chalk.bold(name),
+    );
+  } else {
+    // Create worktree from existing branch
+    await manager.addWorktree(worktreePath, name, {
+      createBranch: false,
+      track: options.track,
+    });
+    console.log(chalk.green("✓ Created worktree:"), chalk.bold(name));
+  }
+
+  console.log(chalk.gray("  Path:"), worktreePath);
+  console.log();
+  console.log(chalk.yellow("To switch to this worktree:"));
+  console.log(chalk.gray(`  cd ${worktreePath}`));
+}
+
+function getWorktreePath(branchName: string): string {
+  // Get the current working directory
+  const cwd = process.cwd();
+  const parentDir = path.dirname(cwd);
+
+  // Use the branch name as the directory name
+  // Replace slashes with the OS path separator for nested branches
+  const dirName = branchName.replace(/\//g, path.sep);
+
+  return path.join(parentDir, dirName);
+}
diff --git a/src/commands/remove.ts b/src/commands/remove.ts
@@ -0,0 +1,114 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { WorktreeManager } from "../git/WorktreeManager";
+
+interface RemoveCommandOptions {
+  force: boolean;
+  yes: boolean;
+}
+
+export function createRemoveCommand(): Command {
+  const command = new Command("remove");
+
+  command
+    .description("Remove a worktree")
+    .argument("<name>", "Branch name or path of the worktree to remove")
+    .option(
+      "--force",
+      "Remove the worktree even if it has uncommitted changes",
+      false,
+    )
+    .option("-y, --yes", "Skip confirmation prompt", false)
+    .action(async (name: string, options: RemoveCommandOptions) => {
+      try {
+        await runRemove(name, options);
+      } catch (error) {
+        console.error(
+          chalk.red("Error:"),
+          error instanceof Error ? error.message : error,
+        );
+        process.exit(1);
+      }
+    });
+
+  return command;
+}
+
+async function runRemove(
+  name: string,
+  options: RemoveCommandOptions,
+): Promise<void> {
+  const manager = new WorktreeManager();
+  await manager.initialize();
+
+  // Find the worktree by branch name or path
+  const worktrees = await manager.listWorktrees();
+  const worktree = worktrees.find(
+    (wt) =>
+      wt.branch === name ||
+      wt.path === name ||
+      wt.path.endsWith(`/${name}`) ||
+      wt.path.endsWith(`\\${name}`),
+  );
+
+  if (!worktree) {
+    throw new Error(
+      `Worktree '${name}' not found. Use 'grove list' to see available worktrees.`,
+    );
+  }
+
+  if (worktree.isMain) {
+    throw new Error(
+      `Cannot remove the main worktree (${worktree.branch}). This is the primary worktree.`,
+    );
+  }
+
+  if (worktree.isLocked) {
+    throw new Error(
+      `Worktree '${worktree.branch}' is locked. Unlock it first with 'git worktree unlock'.`,
+    );
+  }
+
+  // Warn about dirty worktrees
+  if (worktree.isDirty && !options.force) {
+    console.log(chalk.yellow("Warning: This worktree has uncommitted changes."));
+    console.log(
+      chalk.yellow("Use --force to remove it anyway, or commit/stash your changes first."),
+    );
+    console.log();
+  }
+
+  // Show worktree info
+  console.log(chalk.blue("Worktree to remove:"));
+  console.log(chalk.gray("  Path:"), worktree.path);
+  console.log(chalk.gray("  Branch:"), worktree.branch);
+  if (worktree.isDirty) {
+    console.log(chalk.yellow("  Status: dirty (uncommitted changes)"));
+  }
+  console.log();
+
+  // Confirm removal
+  if (!options.yes) {
+    const answers = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "proceed",
+        message: `Are you sure you want to remove the worktree for '${worktree.branch}'?`,
+        default: false,
+      },
+    ]);
+
+    if (!answers.proceed) {
+      console.log(chalk.blue("Operation cancelled."));
+      return;
+    }
+  }
+
+  // Remove the worktree
+  await manager.removeWorktree(worktree.path, options.force);
+  console.log(
+    chalk.green("✓ Removed worktree:"),
+    chalk.bold(worktree.branch),
+  );
+}
diff --git a/src/git/WorktreeManager.ts b/src/git/WorktreeManager.ts
@@ -255,4 +255,44 @@ export class WorktreeManager {
       throw new Error(`Failed to clone repository: ${error}`);
     }
   }
+
+  async addWorktree(
+    worktreePath: string,
+    branchName: string,
+    options: { createBranch?: boolean; track?: string } = {},
+  ): Promise<void> {
+    try {
+      const args = ["worktree", "add"];
+
+      if (options.createBranch) {
+        args.push("-b", branchName);
+        if (options.track) {
+          args.push("--track", options.track);
+        }
+        args.push(worktreePath);
+        if (options.track) {
+          args.push(options.track);
+        }
+      } else {
+        args.push(worktreePath, branchName);
+      }
+
+      await this.git.raw(args);
+    } catch (error) {
+      throw new Error(`Failed to add worktree: ${error}`);
+    }
+  }
+
+  async removeWorktree(worktreePath: string, force: boolean = false): Promise<void> {
+    try {
+      const args = ["worktree", "remove"];
+      if (force) {
+        args.push("--force");
+      }
+      args.push(worktreePath);
+      await this.git.raw(args);
+    } catch (error) {
+      throw new Error(`Failed to remove worktree: ${error}`);
+    }
+  }
 }
diff --git a/src/index.ts b/src/index.ts
@@ -2,9 +2,11 @@
 
 import { Command } from 'commander';
 import chalk from 'chalk';
+import { createAddCommand } from './commands/add';
 import { createInitCommand } from './commands/init';
 import { createListCommand } from './commands/list';
 import { createPruneCommand } from './commands/prune';
+import { createRemoveCommand } from './commands/remove';
 
 const program = new Command();
 
@@ -14,9 +16,11 @@ program
   .version(require('../package.json').version);
 
 // Add all commands
+program.addCommand(createAddCommand());
 program.addCommand(createInitCommand());
 program.addCommand(createListCommand());
 program.addCommand(createPruneCommand());
+program.addCommand(createRemoveCommand());
 
 // Handle unknown commands
 program.on('command:*', () => {
