Fetch and point new workspaces to origin/main

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

@@ -50,15 +50,18 @@ export async function createWorktree(
 	mainRepoPath: string,
 	branch: string,
 	worktreePath: string,
+	startPoint = "origin/main",
 ): Promise<void> {
 	try {
 		const parentDir = join(worktreePath, "..");
 		await mkdir(parentDir, { recursive: true });
 
 		const git = simpleGit(mainRepoPath);
-		await git.raw(["worktree", "add", worktreePath, "-b", branch]);
+		await git.raw(["worktree", "add", worktreePath, "-b", branch, startPoint]);
 
-		console.log(`Created worktree at ${worktreePath} with branch ${branch}`);
+		console.log(
+			`Created worktree at ${worktreePath} with branch ${branch} from ${startPoint}`,
+		);
 	} catch (error) {
 		console.error(`Failed to create worktree: ${error}`);
 		throw new Error(`Failed to create worktree: ${error}`);
@@ -114,3 +117,30 @@ export async function worktreeExists(
 		throw error;
 	}
 }
+
+/**
+ * Fetches origin/main and returns the latest commit SHA
+ * @param mainRepoPath - Path to the main repository
+ * @returns The commit SHA of origin/main after fetch
+ */
+export async function fetchOriginMain(mainRepoPath: string): Promise<string> {
+	const git = simpleGit(mainRepoPath);
+	await git.fetch("origin", "main");
+	const commit = await git.revparse("origin/main");
+	return commit.trim();
+}
+
+/**
+ * Checks if a worktree's branch is behind origin/main
+ * @param worktreePath - Path to the worktree
+ * @returns true if the branch has commits on origin/main that it doesn't have
+ */
+export async function checkNeedsRebase(worktreePath: string): Promise<boolean> {
+	const git = simpleGit(worktreePath);
+	const behindCount = await git.raw([
+		"rev-list",
+		"--count",
+		"HEAD..origin/main",
+	]);
+	return Number.parseInt(behindCount.trim(), 10) > 0;
+}

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

@@ -6,7 +6,9 @@ import { SUPERSET_DIR_NAME, WORKTREES_DIR_NAME } from "shared/constants";
 import { z } from "zod";
 import { publicProcedure, router } from "../..";
 import {
+	checkNeedsRebase,
 	createWorktree,
+	fetchOriginMain,
 	generateBranchName,
 	removeWorktree,
 	worktreeExists,
@@ -39,14 +41,31 @@ export const createWorkspacesRouter = () => {
 					branch,
 				);
 
-				await createWorktree(project.mainRepoPath, branch, worktreePath);
+				// Fetch origin/main to ensure we're branching from latest (best-effort)
+				try {
+					await fetchOriginMain(project.mainRepoPath);
+				} catch {
+					// Silently continue - origin/main still exists locally, just might be stale
+				}
+
+				await createWorktree(
+					project.mainRepoPath,
+					branch,
+					worktreePath,
+					"origin/main",
+				);
 
 				const worktree = {
 					id: nanoid(),
 					projectId: input.projectId,
 					path: worktreePath,
 					branch,
 					createdAt: Date.now(),
+					gitStatus: {
+						branch,
+						needsRebase: false, // Fresh off main, doesn't need rebase
+						lastRefreshed: Date.now(),
+					},
 				};
 
 				const projectWorkspaces = db.data.workspaces.filter(
@@ -426,6 +445,55 @@ export const createWorkspacesRouter = () => {
 
 				return { success: true };
 			}),
+
+		refreshGitStatus: publicProcedure
+			.input(z.object({ workspaceId: z.string() }))
+			.mutation(async ({ input }) => {
+				const workspace = db.data.workspaces.find(
+					(w) => w.id === input.workspaceId,
+				);
+				if (!workspace) {
+					throw new Error(`Workspace ${input.workspaceId} not found`);
+				}
+
+				const worktree = db.data.worktrees.find(
+					(wt) => wt.id === workspace.worktreeId,
+				);
+				if (!worktree) {
+					throw new Error(
+						`Worktree for workspace ${input.workspaceId} not found`,
+					);
+				}
+
+				const project = db.data.projects.find(
+					(p) => p.id === workspace.projectId,
+				);
+				if (!project) {
+					throw new Error(`Project ${workspace.projectId} not found`);
+				}
+
+				// Fetch origin/main to get latest
+				await fetchOriginMain(project.mainRepoPath);
+
+				// Check if worktree branch is behind origin/main
+				const needsRebase = await checkNeedsRebase(worktree.path);
+
+				const gitStatus = {
+					branch: worktree.branch,
+					needsRebase,
+					lastRefreshed: Date.now(),
+				};
+
+				// Update worktree in db
+				await db.update((data) => {
+					const wt = data.worktrees.find((w) => w.id === worktree.id);
+					if (wt) {
+						wt.gitStatus = gitStatus;
+					}
+				});
+
+				return { gitStatus };
+			}),
 	});
 };
 

apps/desktop/src/main/lib/db/schemas.ts

@@ -8,12 +8,32 @@ export interface Project {
 	createdAt: number;
 }
 
+export interface GitStatus {
+	branch: string;
+	needsRebase: boolean;
+	lastRefreshed: number;
+}
+
+export interface GitHubStatus {
+	pr: {
+		number: number;
+		title: string;
+		url: string;
+		state: "open" | "draft" | "merged" | "closed";
+		mergedAt?: number;
+	} | null;
+	repoUrl: string;
+	lastRefreshed: number;
+}
+
 export interface Worktree {
 	id: string;
 	projectId: string;
 	path: string;
 	branch: string;
 	createdAt: number;
+	gitStatus?: GitStatus;
+	githubStatus?: GitHubStatus;
 }
 
 export interface Workspace {

apps/desktop/src/shared/ipc-channels/index.ts

@@ -13,8 +13,6 @@ import type { TabChannels } from "./tab";
 import type { TerminalChannels } from "./terminal";
 import type { UiChannels } from "./ui";
 import type { WindowChannels } from "./window";
-import type { WorkspaceChannels } from "./workspace";
-import type { WorktreeChannels } from "./worktree";
 
 // Re-export shared types
 export type {
@@ -28,9 +26,7 @@ export type {
  * Combine all channel definitions into a single interface
  */
 export interface IpcChannels
-	extends WorkspaceChannels,
-		WorktreeChannels,
-		TabChannels,
+	extends TabChannels,
 		TerminalChannels,
 		ProxyChannels,
 		ExternalChannels,