feat: add worktree management surface

Author: pallyoung

packages/server/src/__tests__/worktree-commands.test.ts

@@ -33,6 +33,7 @@ describe("Worktree Commands", () => {
   let eventBus: EventBus;
   let db: ReturnType<typeof openDatabase>;
   let workspaceId: string;
+  let tempPaths: string[];
 
   beforeEach(async () => {
     repoDir = join(
@@ -51,6 +52,7 @@ describe("Worktree Commands", () => {
     runMigrations(db);
     eventBus = new EventBus();
     workspaceMgr = new WorkspaceManager({ db, eventBus });
+    tempPaths = [];
 
     const workspace = await workspaceMgr.open({ path: repoDir });
     workspaceId = workspace.id;
@@ -71,6 +73,7 @@ describe("Worktree Commands", () => {
   afterEach(async () => {
     await rm(repoDir, { recursive: true, force: true });
     await rm(otherRepoDir, { recursive: true, force: true });
+    await Promise.all(tempPaths.map((tempPath) => rm(tempPath, { recursive: true, force: true })));
   });
 
   it("returns status for a worktree belonging to the workspace repo", async () => {
@@ -118,4 +121,83 @@ describe("Worktree Commands", () => {
     expect(result.ok).toBe(false);
     expect(result.error?.code).toBe("worktree_not_found");
   });
+
+  it("emits worktreeChanged after create and remove", async () => {
+    const createdPath = join(
+      tmpdir(),
+      `worktree-command-created-${Date.now()}-${Math.random().toString(36).slice(2)}`
+    );
+    const linkedPath = join(
+      tmpdir(),
+      `worktree-command-linked-${Date.now()}-${Math.random().toString(36).slice(2)}`
+    );
+    tempPaths.push(createdPath, linkedPath);
+
+    await execFileAsync("git", ["branch", "feature/existing-worktree"], { cwd: repoDir });
+    await execFileAsync("git", ["worktree", "add", linkedPath, "feature/existing-worktree"], {
+      cwd: repoDir,
+    });
+    const linkedWorkspace = await workspaceMgr.open({ path: linkedPath });
+    await execFileAsync("git", ["branch", "feature/worktree-manager"], { cwd: repoDir });
+
+    const emitted: Array<{ workspaceId: string; worktreeChanged?: boolean }> = [];
+    eventBus.on("git.state.changed", (event) => emitted.push(event));
+
+    const createResult = await dispatch(
+      {
+        kind: "command",
+        id: "worktree-create-event",
+        op: "worktree.create",
+        args: {
+          workspaceId,
+          branch: "feature/worktree-manager",
+          path: createdPath,
+        },
+      },
+      ctx
+    );
+
+    expect(createResult.ok).toBe(true);
+    expect(emitted).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          workspaceId,
+          worktreeChanged: true,
+        }),
+        expect.objectContaining({
+          workspaceId: linkedWorkspace.id,
+          worktreeChanged: true,
+        }),
+      ])
+    );
+
+    emitted.length = 0;
+
+    const removeResult = await dispatch(
+      {
+        kind: "command",
+        id: "worktree-remove-event",
+        op: "worktree.remove",
+        args: {
+          workspaceId,
+          worktreePath: createdPath,
+        },
+      },
+      ctx
+    );
+
+    expect(removeResult.ok).toBe(true);
+    expect(emitted).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          workspaceId,
+          worktreeChanged: true,
+        }),
+        expect.objectContaining({
+          workspaceId: linkedWorkspace.id,
+          worktreeChanged: true,
+        }),
+      ])
+    );
+  });
 });

packages/server/src/commands/git-events.ts

@@ -0,0 +1,19 @@
+import type { CommandContext } from "../ws/dispatch.js";
+
+export function emitGitStateChanged(
+  ctx: CommandContext,
+  workspaceId: string,
+  options?: {
+    treeChanged?: boolean;
+    branchChanged?: boolean;
+    worktreeChanged?: boolean;
+  }
+) {
+  ctx.eventBus.emit({
+    type: "git.state.changed",
+    workspaceId,
+    treeChanged: options?.treeChanged,
+    branchChanged: options?.branchChanged,
+    worktreeChanged: options?.worktreeChanged,
+  });
+}

packages/server/src/commands/git.ts

@@ -20,24 +20,7 @@ import {
 import { getFileDiff } from "../git/diff.js";
 import type { CommandContext } from "../ws/dispatch.js";
 import { registerCommand } from "../ws/dispatch.js";
-
-function emitGitStateChanged(
-  ctx: CommandContext,
-  workspaceId: string,
-  options?: {
-    treeChanged?: boolean;
-    branchChanged?: boolean;
-    worktreeChanged?: boolean;
-  }
-) {
-  ctx.eventBus.emit({
-    type: "git.state.changed",
-    workspaceId,
-    treeChanged: options?.treeChanged,
-    branchChanged: options?.branchChanged,
-    worktreeChanged: options?.worktreeChanged,
-  });
-}
+import { emitGitStateChanged } from "./git-events.js";
 
 const gitHttpAuthSchema = z.object({
   username: z.string(),

packages/server/src/commands/worktree.ts

@@ -5,14 +5,42 @@
 import { z } from "zod";
 import {
   createWorktree,
+  getGitCommonDirPath,
   getWorktreeDiff,
   getWorktreeStatus,
   getWorktreeTree,
   listWorktrees,
   removeWorktree,
   resolveWorktreePath,
 } from "../git/worktree.js";
+import type { CommandContext } from "../ws/dispatch.js";
 import { registerCommand } from "../ws/dispatch.js";
+import { emitGitStateChanged } from "./git-events.js";
+
+async function findRelatedWorkspaceIds(
+  ctx: CommandContext,
+  workspacePath: string
+): Promise<string[]> {
+  const targetCommonDir = await getGitCommonDirPath(workspacePath);
+  const relatedWorkspaceIds = await Promise.all(
+    ctx.workspaceMgr.list().map(async (workspace) => {
+      try {
+        const commonDir = await getGitCommonDirPath(workspace.path);
+        return commonDir === targetCommonDir ? workspace.id : null;
+      } catch {
+        return null;
+      }
+    })
+  );
+
+  return relatedWorkspaceIds.filter((workspaceId): workspaceId is string => Boolean(workspaceId));
+}
+
+function emitWorktreeChangedForWorkspaceIds(ctx: CommandContext, workspaceIds: string[]) {
+  for (const workspaceId of workspaceIds) {
+    emitGitStateChanged(ctx, workspaceId, { worktreeChanged: true });
+  }
+}
 
 // worktree.list
 registerCommand("worktree.list", z.object({ workspaceId: z.string() }), async (args, ctx) => {
@@ -85,7 +113,11 @@ registerCommand(
     if (!workspace) {
       throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
     }
-    return { worktree: await createWorktree(workspace.path, args.branch, args.path) };
+
+    const relatedWorkspaceIds = await findRelatedWorkspaceIds(ctx, workspace.path);
+    const worktree = await createWorktree(workspace.path, args.branch, args.path);
+    emitWorktreeChangedForWorkspaceIds(ctx, relatedWorkspaceIds);
+    return { worktree };
   }
 );
 
@@ -103,8 +135,10 @@ registerCommand(
       throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
     }
 
+    const relatedWorkspaceIds = await findRelatedWorkspaceIds(ctx, workspace.path);
     const worktreePath = await resolveWorktreePath(workspace.path, args.worktreePath);
     await removeWorktree(workspace.path, worktreePath, args.force);
+    emitWorktreeChangedForWorkspaceIds(ctx, relatedWorkspaceIds);
     return {};
   }
 );

packages/server/src/git/worktree.ts

@@ -13,6 +13,11 @@ function normalizeWorktreePath(worktreePath: string): string {
   return path.resolve(worktreePath);
 }
 
+export async function getGitCommonDirPath(repoPath: string): Promise<string> {
+  const { stdout } = await runGit(repoPath, ["rev-parse", "--git-common-dir"]);
+  return normalizeWorktreePath(path.resolve(repoPath, stdout.trim()));
+}
+
 export async function resolveWorktreePath(repoPath: string, worktreePath: string): Promise<string> {
   const normalizedRequested = normalizeWorktreePath(worktreePath);
   const worktrees = await listWorktrees(repoPath);
@@ -171,12 +176,13 @@ export async function getWorktreeTree(worktreePath: string): Promise<FileNode[]>
 export async function createWorktree(
   repoPath: string,
   branch: string,
-  path: string
+  worktreePath: string
 ): Promise<WorktreeInfo> {
-  await runGit(repoPath, ["worktree", "add", path, branch]);
+  await runGit(repoPath, ["worktree", "add", worktreePath, branch]);
 
   const worktrees = await listWorktrees(repoPath);
-  const created = worktrees.find((wt) => wt.path === path);
+  const normalizedRequested = normalizeWorktreePath(worktreePath);
+  const created = worktrees.find((wt) => normalizeWorktreePath(wt.path) === normalizedRequested);
 
   if (!created) {
     throw new Error("Failed to find created worktree");