feat: add worktree management UI and operations (#1216)

Author: jonathanlab

apps/code/src/main/services/context-menu/schemas.ts

@@ -112,6 +112,15 @@ export const confirmDeleteArchivedTaskOutput = z.object({
   confirmed: z.boolean(),
 });
 
+export const confirmDeleteWorktreeInput = z.object({
+  worktreePath: z.string(),
+  linkedTaskCount: z.number(),
+});
+
+export const confirmDeleteWorktreeOutput = z.object({
+  confirmed: z.boolean(),
+});
+
 export type ConfirmDeleteTaskInput = z.infer<typeof confirmDeleteTaskInput>;
 export type ConfirmDeleteTaskResult = z.infer<typeof confirmDeleteTaskOutput>;
 export type ConfirmDeleteArchivedTaskInput = z.infer<
@@ -120,6 +129,12 @@ export type ConfirmDeleteArchivedTaskInput = z.infer<
 export type ConfirmDeleteArchivedTaskResult = z.infer<
   typeof confirmDeleteArchivedTaskOutput
 >;
+export type ConfirmDeleteWorktreeInput = z.infer<
+  typeof confirmDeleteWorktreeInput
+>;
+export type ConfirmDeleteWorktreeResult = z.infer<
+  typeof confirmDeleteWorktreeOutput
+>;
 
 export type TaskContextMenuResult = z.infer<typeof taskContextMenuOutput>;
 export type ArchivedTaskContextMenuResult = z.infer<

apps/code/src/main/services/context-menu/service.ts

@@ -82,6 +82,25 @@ export class ContextMenuService {
     return { confirmed };
   }
 
+  async confirmDeleteWorktree({
+    worktreePath,
+    linkedTaskCount,
+  }: {
+    worktreePath: string;
+    linkedTaskCount: number;
+  }): Promise<{ confirmed: boolean }> {
+    const confirmed = await this.confirm({
+      title: "Delete Worktree",
+      message: `Delete worktree at ${worktreePath}?`,
+      detail:
+        linkedTaskCount > 0
+          ? `This will remove ${linkedTaskCount} linked task${linkedTaskCount === 1 ? "" : "s"} and delete the worktree.`
+          : "This will delete the worktree from disk.",
+      confirmLabel: "Delete",
+    });
+    return { confirmed };
+  }
+
   async showTaskContextMenu(
     input: TaskContextMenuInput,
   ): Promise<TaskContextMenuResult> {

apps/code/src/main/services/workspace/schemas.ts

@@ -190,6 +190,32 @@ export const getWorktreeTasksInput = z.object({
 
 export const getWorktreeTasksOutput = z.array(localTaskSchema);
 
+export const listGitWorktreesInput = z.object({
+  mainRepoPath: z.string(),
+});
+
+export const gitWorktreeEntrySchema = z.object({
+  worktreePath: z.string(),
+  head: z.string(),
+  branch: z.string().nullable(),
+  taskIds: z.array(z.string()),
+});
+
+export const listGitWorktreesOutput = z.array(gitWorktreeEntrySchema);
+
+export const getWorktreeSizeInput = z.object({
+  worktreePath: z.string(),
+});
+
+export const getWorktreeSizeOutput = z.object({
+  sizeBytes: z.number(),
+});
+
+export const deleteWorktreeInput = z.object({
+  worktreePath: z.string(),
+  mainRepoPath: z.string(),
+});
+
 export const togglePinInput = z.object({
   taskId: z.string(),
 });
@@ -245,6 +271,9 @@ export type IsWorkspaceRunningInput = z.infer<typeof isWorkspaceRunningInput>;
 export type GetWorkspaceTerminalsInput = z.infer<
   typeof getWorkspaceTerminalsInput
 >;
+export type ListGitWorktreesInput = z.infer<typeof listGitWorktreesInput>;
+export type GetWorktreeSizeInput = z.infer<typeof getWorktreeSizeInput>;
+export type DeleteWorktreeInput = z.infer<typeof deleteWorktreeInput>;
 
 export type WorkspaceTerminalCreatedPayload = z.infer<
   typeof workspaceTerminalCreatedPayload

apps/code/src/main/services/workspace/service.ts

@@ -1,11 +1,14 @@
+import { execFile } from "node:child_process";
 import * as fs from "node:fs";
 import * as fsPromises from "node:fs/promises";
 import path from "node:path";
+import { promisify } from "node:util";
 import { createGitClient } from "@posthog/git/client";
 import {
   getCurrentBranch,
   getDefaultBranch,
   hasTrackedFiles,
+  listWorktrees,
 } from "@posthog/git/queries";
 import { CreateOrSwitchBranchSaga } from "@posthog/git/sagas/branch";
 import { DetachHeadSaga } from "@posthog/git/sagas/head";
@@ -44,6 +47,8 @@ import type {
 import { ScriptRunner } from "./scriptRunner";
 import { buildWorkspaceEnv } from "./workspaceEnv";
 
+const execFileAsync = promisify(execFile);
+
 type TaskAssociation =
   | { taskId: string; folderId: string; mode: "local" }
   | { taskId: string; folderId: string | null; mode: "cloud" }
@@ -1197,6 +1202,70 @@ export class WorkspaceService extends TypedEventEmitter<WorkspaceServiceEvents>
     return result;
   }
 
+  async listGitWorktrees(mainRepoPath: string): Promise<
+    Array<{
+      worktreePath: string;
+      head: string;
+      branch: string | null;
+      taskIds: string[];
+    }>
+  > {
+    const worktreeBasePath = getWorktreeLocation();
+    const rawWorktrees = await listWorktrees(mainRepoPath);
+
+    const twigWorktrees = rawWorktrees.filter((wt) => {
+      const isMainRepo = path.resolve(wt.path) === path.resolve(mainRepoPath);
+      const isUnderTwig = path
+        .resolve(wt.path)
+        .startsWith(path.resolve(worktreeBasePath));
+      return !isMainRepo && isUnderTwig;
+    });
+
+    return twigWorktrees.map((wt) => {
+      const taskIds = this.getWorktreeTasks(wt.path).map((t) => t.taskId);
+      return {
+        worktreePath: wt.path,
+        head: wt.head,
+        branch: wt.branch,
+        taskIds,
+      };
+    });
+  }
+
+  async getWorktreeSize(worktreePath: string): Promise<{ sizeBytes: number }> {
+    try {
+      const { stdout } = await execFileAsync("du", ["-s", worktreePath]);
+      const [sizeStr] = stdout.trim().split("\t");
+      const sizeBytes = sizeStr ? parseInt(sizeStr, 10) * 512 : 0;
+      return { sizeBytes };
+    } catch (error) {
+      log.warn(`Failed to get size for ${worktreePath}:`, error);
+      return { sizeBytes: 0 };
+    }
+  }
+
+  async deleteWorktree(
+    mainRepoPath: string,
+    worktreePath: string,
+  ): Promise<void> {
+    const worktree = this.worktreeRepo.findByPath(worktreePath);
+    if (worktree) {
+      const workspace = this.workspaceRepo.findById(worktree.workspaceId);
+      if (workspace) {
+        await this.deleteWorkspace(workspace.taskId, mainRepoPath);
+        return;
+      }
+    }
+
+    const worktreeBasePath = getWorktreeLocation();
+    const manager = new WorktreeManager({ mainRepoPath, worktreeBasePath });
+    await manager.deleteWorktree(worktreePath);
+
+    if (worktree) {
+      this.worktreeRepo.deleteByWorkspaceId(worktree.workspaceId);
+    }
+  }
+
   private async cleanupWorktree(
     taskId: string,
     mainRepoPath: string,

apps/code/src/main/trpc/routers/context-menu.ts

@@ -7,6 +7,8 @@ import {
   confirmDeleteArchivedTaskOutput,
   confirmDeleteTaskInput,
   confirmDeleteTaskOutput,
+  confirmDeleteWorktreeInput,
+  confirmDeleteWorktreeOutput,
   fileContextMenuInput,
   fileContextMenuOutput,
   folderContextMenuInput,
@@ -34,6 +36,11 @@ export const contextMenuRouter = router({
     .output(confirmDeleteArchivedTaskOutput)
     .mutation(({ input }) => getService().confirmDeleteArchivedTask(input)),
 
+  confirmDeleteWorktree: publicProcedure
+    .input(confirmDeleteWorktreeInput)
+    .output(confirmDeleteWorktreeOutput)
+    .mutation(({ input }) => getService().confirmDeleteWorktree(input)),
+
   showTaskContextMenu: publicProcedure
     .input(taskContextMenuInput)
     .output(taskContextMenuOutput)

apps/code/src/main/trpc/routers/workspace.ts

@@ -5,6 +5,7 @@ import {
   createWorkspaceInput,
   createWorkspaceOutput,
   deleteWorkspaceInput,
+  deleteWorktreeInput,
   getAllTaskTimestampsOutput,
   getAllWorkspacesOutput,
   getLocalTasksInput,
@@ -16,10 +17,14 @@ import {
   getWorkspaceInfoOutput,
   getWorkspaceTerminalsInput,
   getWorkspaceTerminalsOutput,
+  getWorktreeSizeInput,
+  getWorktreeSizeOutput,
   getWorktreeTasksInput,
   getWorktreeTasksOutput,
   isWorkspaceRunningInput,
   isWorkspaceRunningOutput,
+  listGitWorktreesInput,
+  listGitWorktreesOutput,
   markActivityInput,
   markViewedInput,
   runStartScriptsInput,
@@ -111,6 +116,22 @@ export const workspaceRouter = router({
     .output(getWorktreeTasksOutput)
     .query(({ input }) => getService().getWorktreeTasks(input.worktreePath)),
 
+  listGitWorktrees: publicProcedure
+    .input(listGitWorktreesInput)
+    .output(listGitWorktreesOutput)
+    .query(({ input }) => getService().listGitWorktrees(input.mainRepoPath)),
+
+  getWorktreeSize: publicProcedure
+    .input(getWorktreeSizeInput)
+    .output(getWorktreeSizeOutput)
+    .query(({ input }) => getService().getWorktreeSize(input.worktreePath)),
+
+  deleteWorktree: publicProcedure
+    .input(deleteWorktreeInput)
+    .mutation(({ input }) =>
+      getService().deleteWorktree(input.mainRepoPath, input.worktreePath),
+    ),
+
   togglePin: publicProcedure
     .input(togglePinInput)
     .output(togglePinOutput)

apps/code/src/renderer/features/settings/components/SettingsDialog.tsx

@@ -14,6 +14,7 @@ import {
   Plugs,
   PlugsConnected,
   TrafficSignal,
+  TreeStructure,
   User,
   Wrench,
 } from "@phosphor-icons/react";
@@ -31,6 +32,7 @@ import { ShortcutsSettings } from "./sections/ShortcutsSettings";
 import { SignalSourcesSettings } from "./sections/SignalSourcesSettings";
 import { UpdatesSettings } from "./sections/UpdatesSettings";
 import { WorkspacesSettings } from "./sections/WorkspacesSettings";
+import { WorktreesSettings } from "./sections/worktrees/WorktreesSettings";
 
 interface SidebarItem {
   id: SettingsCategory;
@@ -43,6 +45,7 @@ const SIDEBAR_ITEMS: SidebarItem[] = [
   { id: "general", label: "General", icon: <GearSix size={16} /> },
   { id: "account", label: "Account", icon: <User size={16} /> },
   { id: "workspaces", label: "Workspaces", icon: <Folder size={16} /> },
+  { id: "worktrees", label: "Worktrees", icon: <TreeStructure size={16} /> },
   {
     id: "personalization",
     label: "Personalization",
@@ -69,6 +72,7 @@ const CATEGORY_TITLES: Record<SettingsCategory, string> = {
   general: "General",
   account: "Account",
   workspaces: "Workspaces",
+  worktrees: "Worktrees",
   personalization: "Personalization",
   "claude-code": "Claude Code",
   "mcp-servers": "MCP Servers",
@@ -83,6 +87,7 @@ const CATEGORY_COMPONENTS: Record<SettingsCategory, React.ComponentType> = {
   general: GeneralSettings,
   account: AccountSettings,
   workspaces: WorkspacesSettings,
+  worktrees: WorktreesSettings,
   personalization: PersonalizationSettings,
   "claude-code": ClaudeCodeSettings,
   "mcp-servers": McpServersSettings,

apps/code/src/renderer/features/settings/components/sections/worktrees/WorktreeGroupSection.tsx

@@ -0,0 +1,56 @@
+import { Flex, Text } from "@radix-ui/themes";
+import type { Task } from "@shared/types";
+import type { WorktreeEntry } from "./WorktreeRow";
+import { WorktreeRow } from "./WorktreeRow";
+
+export interface WorktreeGroup {
+  folderPath: string;
+  worktrees: WorktreeEntry[];
+}
+
+function getFolderName(folderPath: string): string {
+  const parts = folderPath.split("/");
+  return parts[parts.length - 1] || folderPath;
+}
+
+interface WorktreeGroupSectionProps {
+  group: WorktreeGroup;
+  taskMap: Map<string, Task>;
+  deletingWorktrees: Set<string>;
+  onDelete: (
+    worktreePath: string,
+    allTaskIds: string[],
+    existingTaskIds: string[],
+    folderPath: string,
+  ) => void;
+}
+
+export function WorktreeGroupSection({
+  group,
+  taskMap,
+  deletingWorktrees,
+  onDelete,
+}: WorktreeGroupSectionProps) {
+  const folderName = getFolderName(group.folderPath);
+
+  return (
+    <Flex direction="column">
+      <Text size="1" color="gray" mb="2">
+        {folderName}
+      </Text>
+      <Flex direction="column">
+        {group.worktrees.map((worktree, index) => (
+          <WorktreeRow
+            key={worktree.worktreePath}
+            worktree={worktree}
+            folderPath={group.folderPath}
+            taskMap={taskMap}
+            isDeleting={deletingWorktrees.has(worktree.worktreePath)}
+            onDelete={onDelete}
+            isLast={index === group.worktrees.length - 1}
+          />
+        ))}
+      </Flex>
+    </Flex>
+  );
+}