Create a worktree for each opened branch

apps/desktop/package.json

@@ -45,6 +45,7 @@
 		"dotenv": "^17.2.3",
 		"electron-router-dom": "^2.1.0",
 		"electron-store": "^11.0.2",
+		"execa": "^9.6.0",
 		"fast-glob": "^3.3.3",
 		"framer-motion": "^12.23.24",
 		"http-proxy": "^1.18.1",
@@ -61,6 +62,7 @@
 		"react-resizable-panels": "^3.0.6",
 		"react-router-dom": "^7.8.2",
 		"react-syntax-highlighter": "^16.1.0",
+		"simple-git": "^3.30.0",
 		"superjson": "^2.2.5",
 		"tailwind-merge": "^2.6.0",
 		"trpc-electron": "^0.1.2",

apps/desktop/src/lib/trpc/routers/projects/projects.ts

@@ -1,90 +1,74 @@
 import { dialog } from "electron";
 import type { BrowserWindow } from "electron";
 import { basename } from "node:path";
-import { z } from "zod";
+import { nanoid } from "nanoid";
 import { publicProcedure, router } from "../..";
 import { db } from "../../../../main/lib/db";
-import type { RecentProject } from "../../../../main/lib/db/schemas";
+import type { Project } from "../../../../main/lib/db/schemas";
+import { getGitRoot } from "../workspaces/utils/git";
 
-/**
- * Projects router
- * Handles project selection, recents management, and workspace creation
- */
 export const createProjectsRouter = (window: BrowserWindow) => {
 	return router({
-		/**
-		 * Open a new project via folder picker
-		 * Adds to recents and returns path for UI to handle
-		 */
-		openProject: publicProcedure.mutation(async () => {
+		getRecents: publicProcedure.query((): Project[] => {
+			return db.data.projects
+				.slice()
+				.sort((a, b) => b.lastOpenedAt - a.lastOpenedAt);
+		}),
+
+		openNew: publicProcedure.mutation(async () => {
 			const result = await dialog.showOpenDialog(window, {
 				properties: ["openDirectory"],
 				title: "Open Project",
 			});
 
 			if (result.canceled || result.filePaths.length === 0) {
-				return { success: false as const };
+				return { success: false };
 			}
 
-			const path = result.filePaths[0];
-			const name = basename(path);
+			const selectedPath = result.filePaths[0];
 
-			await db.update((data) => {
-				const existingIndex = data.recentProjects.findIndex(
-					(p) => p.path === path,
-				);
-				if (existingIndex !== -1) {
-					data.recentProjects[existingIndex].lastOpenedAt = Date.now();
-				} else {
-					data.recentProjects.push({
-						path,
-						name,
-						lastOpenedAt: Date.now(),
-					});
-				}
-			});
+			let mainRepoPath: string;
+			try {
+				mainRepoPath = await getGitRoot(selectedPath);
+			} catch (_error) {
+				return {
+					success: false,
+					error: "Selected folder is not in a git repository",
+				};
+			}
 
-			return {
-				success: true as const,
-				path,
-				name,
-			};
-		}),
-		openRecent: publicProcedure
-			.input(z.object({ path: z.string() }))
-			.mutation(async ({ input }) => {
-				const { path } = input;
-				const name = basename(path);
+			const name = basename(mainRepoPath);
 
+			let project = db.data.projects.find(
+				(p) => p.mainRepoPath === mainRepoPath,
+			);
+
+			if (project) {
 				await db.update((data) => {
-					const recent = data.recentProjects.find((p) => p.path === path);
-					if (recent) {
-						recent.lastOpenedAt = Date.now();
+					const p = data.projects.find((p) => p.id === project?.id);
+					if (p) {
+						p.lastOpenedAt = Date.now();
 					}
 				});
-
-				return {
-					success: true as const,
-					path,
+			} else {
+				project = {
+					id: nanoid(),
+					mainRepoPath,
 					name,
+					lastOpenedAt: Date.now(),
+					createdAt: Date.now(),
 				};
-			}),
-		getRecents: publicProcedure.query((): RecentProject[] => {
-			return db.data.recentProjects
-				.slice()
-				.sort((a, b) => b.lastOpenedAt - a.lastOpenedAt);
-		}),
-		removeRecent: publicProcedure
-			.input(z.object({ path: z.string() }))
-			.mutation(async ({ input }) => {
+
 				await db.update((data) => {
-					data.recentProjects = data.recentProjects.filter(
-						(p) => p.path !== input.path,
-					);
+					data.projects.push(project!);
 				});
+			}
 
-				return { success: true };
-			}),
+			return {
+				success: true as const,
+				project,
+			};
+		}),
 	});
 };
 

apps/desktop/src/lib/trpc/routers/workspaces/utils/git.ts

@@ -0,0 +1,91 @@
+import simpleGit from "simple-git";
+import { join } from "node:path";
+import { mkdir } from "node:fs/promises";
+
+export function generateBranchName(): string {
+	const adjectives = [
+		"azure",
+		"crimson",
+		"emerald",
+		"golden",
+		"indigo",
+		"jade",
+		"lavender",
+		"magenta",
+		"navy",
+		"olive",
+		"pearl",
+		"rose",
+		"silver",
+		"teal",
+		"violet",
+	];
+
+	const nouns = [
+		"cloud",
+		"forest",
+		"mountain",
+		"ocean",
+		"river",
+		"storm",
+		"sunset",
+		"thunder",
+		"wave",
+		"wind",
+		"meadow",
+		"canyon",
+		"glacier",
+		"valley",
+		"peak",
+	];
+
+	const adjective = adjectives[Math.floor(Math.random() * adjectives.length)];
+	const noun = nouns[Math.floor(Math.random() * nouns.length)];
+	const number = Math.floor(Math.random() * 100);
+
+	return `${adjective}-${noun}-${number}`;
+}
+
+export async function createWorktree(
+	mainRepoPath: string,
+	branch: string,
+	worktreePath: string,
+): Promise<void> {
+	try {
+		const parentDir = join(worktreePath, "..");
+		await mkdir(parentDir, { recursive: true });
+
+		const git = simpleGit(mainRepoPath);
+		await git.raw(["worktree", "add", worktreePath, "-b", branch]);
+
+		console.log(`Created worktree at ${worktreePath} with branch ${branch}`);
+	} catch (error) {
+		console.error(`Failed to create worktree: ${error}`);
+		throw new Error(`Failed to create worktree: ${error}`);
+	}
+}
+
+export async function removeWorktree(
+	mainRepoPath: string,
+	worktreePath: string,
+): Promise<void> {
+	try {
+		const git = simpleGit(mainRepoPath);
+		await git.raw(["worktree", "remove", worktreePath, "--force"]);
+
+		console.log(`Removed worktree at ${worktreePath}`);
+	} catch (error) {
+		console.error(`Failed to remove worktree: ${error}`);
+		throw new Error(`Failed to remove worktree: ${error}`);
+	}
+}
+
+export async function getGitRoot(path: string): Promise<string> {
+	try {
+		const git = simpleGit(path);
+		const root = await git.revparse(["--show-toplevel"]);
+		return root.trim();
+	} catch (error) {
+		throw new Error(`Not a git repository: ${path}`);
+	}
+}