feat: add support for go command (#13)

Author: captainsafia

README.md

@@ -90,6 +90,25 @@ Skip confirmation prompt:
 grove remove feature/new-feature --yes
 ```
 
+### Navigate to a worktree
+
+Open a new shell session in a worktree directory:
+
+```bash
+grove go feature-branch
+```
+
+This spawns a new shell in the worktree directory. Exit the shell (Ctrl+D or `exit`) to return to your previous directory.
+
+You can also navigate by partial branch name for nested branches:
+
+```bash
+# If you have a worktree for feature/my-feature
+grove go my-feature
+```
+
+The `GROVE_WORKTREE` environment variable is set to the branch name while in the worktree shell.
+
 ### List all worktrees
 
 ```bash
@@ -196,6 +215,7 @@ grove self-update --pr 42
 
 - `grove init <git-url>` - Create a new worktree setup
 - `grove add <name> [options]` - Create a new worktree
+- `grove go <name>` - Navigate to a worktree
 - `grove remove <name> [options]` - Remove a worktree
 - `grove list [options]` - List all worktrees
 - `grove sync [options]` - Sync the bare clone with origin

site/index.html

@@ -253,6 +253,15 @@ <h4>Add a new worktree</h4>
                 <pre><code>grove add feature-branch --track origin/feature-branch</code></pre>
             </div>
 
+            <div class="command-group">
+                <h4>Navigate to a worktree</h4>
+                <p>Open a new shell session in a worktree directory:</p>
+                <pre><code>grove go feature-branch</code></pre>
+                <p>Navigate by partial branch name for nested branches:</p>
+                <pre><code>grove go my-feature</code></pre>
+                <p>Exit the shell (Ctrl+D or <code>exit</code>) to return to your previous directory.</p>
+            </div>
+
             <div class="command-group">
                 <h4>List worktrees</h4>
                 <p>Show all worktrees:</p>
@@ -320,6 +329,10 @@ <h3>Commands</h3>
                         <td>grove add &lt;branch&gt;</td>
                         <td>Create a new worktree for a branch</td>
                     </tr>
+                    <tr>
+                        <td>grove go &lt;name&gt;</td>
+                        <td>Navigate to a worktree</td>
+                    </tr>
                     <tr>
                         <td>grove list [options]</td>
                         <td>List all worktrees</td>

src/commands/go.ts

@@ -0,0 +1,64 @@
+import { Command } from "commander";
+import { spawn } from "child_process";
+import chalk from "chalk";
+import { WorktreeManager } from "../git/WorktreeManager";
+
+export function createGoCommand(): Command {
+  const command = new Command("go");
+
+  command
+    .description("Navigate to a worktree by branch name")
+    .argument("<name>", "Branch name or worktree name to navigate to")
+    .action(async (name: string) => {
+      try {
+        await runGo(name);
+      } catch (error) {
+        console.error(
+          chalk.red("Error:"),
+          error instanceof Error ? error.message : error,
+        );
+        process.exit(1);
+      }
+    });
+
+  return command;
+}
+
+async function runGo(name: string): Promise<void> {
+  const manager = new WorktreeManager();
+  await manager.initialize();
+
+  const worktree = await manager.findWorktreeByName(name);
+
+  if (!worktree) {
+    throw new Error(`Worktree '${name}' not found. Use 'grove list' to see available worktrees.`);
+  }
+
+  // Get the user's default shell
+  const shell = process.env.SHELL || "/bin/sh";
+
+  console.log(chalk.blue(`Entering worktree '${worktree.branch}' at ${worktree.path}`));
+  console.log();
+
+  // Spawn an interactive shell in the worktree directory
+  const child = spawn(shell, [], {
+    cwd: worktree.path,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      GROVE_WORKTREE: worktree.branch,
+    },
+  });
+
+  // Wait for the shell to exit
+  await new Promise<void>((resolve, reject) => {
+    child.on("close", (code) => {
+      if (code === 0 || code === null) {
+        resolve();
+      } else {
+        reject(new Error(`Shell exited with code ${code}`));
+      }
+    });
+    child.on("error", reject);
+  });
+}

src/git/WorktreeManager.ts

@@ -367,4 +367,31 @@ export class WorktreeManager {
       throw new Error(`Failed to sync branch '${branch}': ${error}`);
     }
   }
+
+  async findWorktreeByName(name: string): Promise<Worktree | undefined> {
+    const worktrees = await this.listWorktrees();
+
+    // First, try exact branch name match
+    let worktree = worktrees.find((wt) => wt.branch === name);
+    if (worktree) {
+      return worktree;
+    }
+
+    // Try matching by directory name (last part of the path)
+    worktree = worktrees.find((wt) => {
+      const dirName = path.basename(wt.path);
+      return dirName === name;
+    });
+    if (worktree) {
+      return worktree;
+    }
+
+    // Try partial branch name match (suffix matching for nested branches like feature/foo)
+    worktree = worktrees.find((wt) => wt.branch.endsWith(`/${name}`));
+    if (worktree) {
+      return worktree;
+    }
+
+    return undefined;
+  }
 }

src/index.ts

@@ -3,6 +3,7 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { createAddCommand } from './commands/add';
+import { createGoCommand } from './commands/go';
 import { createInitCommand } from './commands/init';
 import { createListCommand } from './commands/list';
 import { createPruneCommand } from './commands/prune';
@@ -22,6 +23,7 @@ program
 
 // Add all commands
 program.addCommand(createAddCommand());
+program.addCommand(createGoCommand());
 program.addCommand(createInitCommand());
 program.addCommand(createListCommand());
 program.addCommand(createPruneCommand());

test/unit/WorktreeManager.test.ts

@@ -219,4 +219,136 @@ describe("WorktreeManager", () => {
       );
     });
   });
+
+  describe("findWorktreeByName", () => {
+    test("should find worktree by exact branch name", async () => {
+      mockGit.raw.mockImplementation((args) => {
+        if (args[0] === "config") {
+          return Promise.resolve("false");
+        }
+        if (args[0] === "worktree" && args[1] === "list") {
+          return Promise.resolve(
+            "worktree /home/user/repo/main\n" +
+            "HEAD abc123\n" +
+            "branch refs/heads/main\n" +
+            "\n" +
+            "worktree /home/user/repo/feature-branch\n" +
+            "HEAD def456\n" +
+            "branch refs/heads/feature-branch\n"
+          );
+        }
+        return Promise.resolve("");
+      });
+      mockGit.status.mockImplementation(() =>
+        Promise.resolve({ isClean: () => true })
+      );
+
+      const result = await manager.findWorktreeByName("feature-branch");
+
+      expect(result).toBeDefined();
+      expect(result?.branch).toBe("feature-branch");
+      expect(result?.path).toBe("/home/user/repo/feature-branch");
+    });
+
+    test("should find worktree by directory name", async () => {
+      mockGit.raw.mockImplementation((args) => {
+        if (args[0] === "config") {
+          return Promise.resolve("false");
+        }
+        if (args[0] === "worktree" && args[1] === "list") {
+          return Promise.resolve(
+            "worktree /home/user/repo/my-worktree\n" +
+            "HEAD abc123\n" +
+            "branch refs/heads/feature/some-feature\n"
+          );
+        }
+        return Promise.resolve("");
+      });
+      mockGit.status.mockImplementation(() =>
+        Promise.resolve({ isClean: () => true })
+      );
+
+      const result = await manager.findWorktreeByName("my-worktree");
+
+      expect(result).toBeDefined();
+      expect(result?.branch).toBe("feature/some-feature");
+      expect(result?.path).toBe("/home/user/repo/my-worktree");
+    });
+
+    test("should find worktree by partial branch name suffix", async () => {
+      mockGit.raw.mockImplementation((args) => {
+        if (args[0] === "config") {
+          return Promise.resolve("false");
+        }
+        if (args[0] === "worktree" && args[1] === "list") {
+          return Promise.resolve(
+            "worktree /home/user/repo/feature/my-feature\n" +
+            "HEAD abc123\n" +
+            "branch refs/heads/feature/my-feature\n"
+          );
+        }
+        return Promise.resolve("");
+      });
+      mockGit.status.mockImplementation(() =>
+        Promise.resolve({ isClean: () => true })
+      );
+
+      const result = await manager.findWorktreeByName("my-feature");
+
+      expect(result).toBeDefined();
+      expect(result?.branch).toBe("feature/my-feature");
+    });
+
+    test("should return undefined when worktree not found", async () => {
+      mockGit.raw.mockImplementation((args) => {
+        if (args[0] === "config") {
+          return Promise.resolve("false");
+        }
+        if (args[0] === "worktree" && args[1] === "list") {
+          return Promise.resolve(
+            "worktree /home/user/repo/main\n" +
+            "HEAD abc123\n" +
+            "branch refs/heads/main\n"
+          );
+        }
+        return Promise.resolve("");
+      });
+      mockGit.status.mockImplementation(() =>
+        Promise.resolve({ isClean: () => true })
+      );
+
+      const result = await manager.findWorktreeByName("non-existent");
+
+      expect(result).toBeUndefined();
+    });
+
+    test("should prefer exact branch name match over directory name", async () => {
+      mockGit.raw.mockImplementation((args) => {
+        if (args[0] === "config") {
+          return Promise.resolve("false");
+        }
+        if (args[0] === "worktree" && args[1] === "list") {
+          return Promise.resolve(
+            "worktree /home/user/repo/feature-branch\n" +
+            "HEAD abc123\n" +
+            "branch refs/heads/other-branch\n" +
+            "\n" +
+            "worktree /home/user/repo/other-dir\n" +
+            "HEAD def456\n" +
+            "branch refs/heads/feature-branch\n"
+          );
+        }
+        return Promise.resolve("");
+      });
+      mockGit.status.mockImplementation(() =>
+        Promise.resolve({ isClean: () => true })
+      );
+
+      const result = await manager.findWorktreeByName("feature-branch");
+
+      expect(result).toBeDefined();
+      expect(result?.branch).toBe("feature-branch");
+      expect(result?.path).toBe("/home/user/repo/other-dir");
+    });
+  });
 });