Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
Extract git functions and add integration tests
Julius Marmingef47dc3c78ca9
diff --git a/apps/desktop/src/git.test.ts b/apps/desktop/src/git.test.tsnew file mode 100644index 000000000..37f3e8e09--- /dev/null+++ b/apps/desktop/src/git.test.ts@@ -0,0 +1,379 @@+import { existsSync } from "node:fs";+import { mkdtemp, rm, writeFile } from "node:fs/promises";+import { tmpdir } from "node:os";+import path from "node:path";+import { afterEach, beforeEach, describe, expect, it } from "vitest";++import {+ checkoutGitBranch,+ createGitBranch,+ createGitWorktree,+ initGitRepo,+ listGitBranches,+ removeGitWorktree,+ runTerminalCommand,+} from "./git";++// ── Helpers ──++/** Run a raw git command for test setup (not under test). */+async function git(cwd: string, command: string): Promise<string> {+ const result = await runTerminalCommand({+ command: `git ${command}`,+ cwd,+ timeoutMs: 10_000,+ });+ if (result.code !== 0) {+ throw new Error(`git ${command} failed: ${result.stderr}`);+ }+ return result.stdout.trim();+}++/** Create a repo with an initial commit so branches work. */+async function initRepoWithCommit(cwd: string): Promise<void> {+ await initGitRepo({ cwd });+ await git(cwd, "config user.email '[email protected]'");+ await git(cwd, "config user.name 'Test'");+ await writeFile(path.join(cwd, "README.md"), "# test\n");+ await git(cwd, "add .");+ await git(cwd, "commit -m 'initial commit'");+}++// ── Tests ──++describe("git integration", () => {+ let tmpDir: string;++ beforeEach(async () => {+ tmpDir = await mkdtemp(path.join(tmpdir(), "git-test-"));+ });++ afterEach(async () => {+ await rm(tmpDir, { recursive: true, force: true });+ });++ // ── initGitRepo ──++ describe("initGitRepo", () => {+ it("creates a valid git repo", async () => {+ await initGitRepo({ cwd: tmpDir });+ expect(existsSync(path.join(tmpDir, ".git"))).toBe(true);+ });++ it("listGitBranches reports isRepo: true after init + commit", async () => {+ await initRepoWithCommit(tmpDir);+ const result = await listGitBranches({ cwd: tmpDir });+ expect(result.isRepo).toBe(true);+ expect(result.branches.length).toBeGreaterThanOrEqual(1);+ });+ });++ // ── listGitBranches ──++ describe("listGitBranches", () => {+ it("returns isRepo: false for non-git directory", async () => {+ const result = await listGitBranches({ cwd: tmpDir });+ expect(result.isRepo).toBe(false);+ expect(result.branches).toEqual([]);+ });++ it("returns the current branch with current: true", async () => {+ await initRepoWithCommit(tmpDir);+ const result = await listGitBranches({ cwd: tmpDir });+ const current = result.branches.find((b) => b.current);+ expect(current).toBeDefined();+ expect(current!.current).toBe(true);+ });++ it("sorts current branch first", async () => {+ await initRepoWithCommit(tmpDir);+ await createGitBranch({ cwd: tmpDir, branch: "aaa-first-alpha" });+ await createGitBranch({ cwd: tmpDir, branch: "zzz-last" });++ const result = await listGitBranches({ cwd: tmpDir });+ expect(result.branches[0]!.current).toBe(true);+ });++ it("lists multiple branches after creating them", async () => {+ await initRepoWithCommit(tmpDir);+ await createGitBranch({ cwd: tmpDir, branch: "feature-a" });+ await createGitBranch({ cwd: tmpDir, branch: "feature-b" });++ const result = await listGitBranches({ cwd: tmpDir });+ const names = result.branches.map((b) => b.name);+ expect(names).toContain("feature-a");+ expect(names).toContain("feature-b");+ });++ it("isDefault is false when no remote exists", async () => {+ await initRepoWithCommit(tmpDir);+ const result = await listGitBranches({ cwd: tmpDir });+ expect(result.branches.every((b) => b.isDefault === false)).toBe(true);+ });+ });++ // ── checkoutGitBranch ──++ describe("checkoutGitBranch", () => {+ it("checks out an existing branch", async () => {+ await initRepoWithCommit(tmpDir);+ await createGitBranch({ cwd: tmpDir, branch: "feature" });++ await checkoutGitBranch({ cwd: tmpDir, branch: "feature" });++ const result = await listGitBranches({ cwd: tmpDir });+ const current = result.branches.find((b) => b.current);+ expect(current!.name).toBe("feature");+ });++ it("throws when branch does not exist", async () => {+ await initRepoWithCommit(tmpDir);+ await expect(+ checkoutGitBranch({ cwd: tmpDir, branch: "nonexistent" }),+ ).rejects.toThrow();+ });++ it("throws when checkout would overwrite uncommitted changes", async () => {+ await initRepoWithCommit(tmpDir);+ await createGitBranch({ cwd: tmpDir, branch: "other" });++ // Create a conflicting change: modify README on current branch+ await writeFile(path.join(tmpDir, "README.md"), "modified\n");+ await git(tmpDir, "add README.md");++ // On the other branch, README has original content — checkout should conflict+ // Actually git checkout with staged changes can sometimes work, so let's+ // create a real conflict: commit different content on other branch first.+ // Simpler: write to a tracked file without committing, then checkout a branch+ // where that file differs.++ // First, checkout other branch cleanly+ await git(tmpDir, "stash");+ await checkoutGitBranch({ cwd: tmpDir, branch: "other" });+ await writeFile(path.join(tmpDir, "README.md"), "other content\n");+ await git(tmpDir, "add .");+ await git(tmpDir, "commit -m 'other change'");++ // Go back to default branch+ const defaultBranch = (+ await listGitBranches({ cwd: tmpDir })+ ).branches.find((b) => !b.current)!.name;+ await checkoutGitBranch({ cwd: tmpDir, branch: defaultBranch });++ // Make uncommitted changes to the same file+ await writeFile(path.join(tmpDir, "README.md"), "conflicting local\n");++ // Checkout should fail due to uncommitted changes+ await expect(+ checkoutGitBranch({ cwd: tmpDir, branch: "other" }),+ ).rejects.toThrow();+ });+ });++ // ── createGitBranch ──++ describe("createGitBranch", () => {+ it("creates a new branch visible in listGitBranches", async () => {+ await initRepoWithCommit(tmpDir);+ await createGitBranch({ cwd: tmpDir, branch: "new-feature" });++ const result = await listGitBranches({ cwd: tmpDir });+ expect(result.branches.some((b) => b.name === "new-feature")).toBe(true);+ });++ it("throws when branch already exists", async () => {+ await initRepoWithCommit(tmpDir);+ await createGitBranch({ cwd: tmpDir, branch: "dupe" });+ await expect(+ createGitBranch({ cwd: tmpDir, branch: "dupe" }),+ ).rejects.toThrow();+ });+ });++ // ── createGitWorktree + removeGitWorktree ──++ describe("createGitWorktree", () => {+ it("creates a worktree directory at the expected path", async () => {+ await initRepoWithCommit(tmpDir);+ await createGitBranch({ cwd: tmpDir, branch: "wt-branch" });++ const wtPath = path.join(tmpDir, "worktree-out");+ const result = await createGitWorktree({+ cwd: tmpDir,+ branch: "wt-branch",+ path: wtPath,+ });++ expect(result.worktree.path).toBe(wtPath);+ expect(result.worktree.branch).toBe("wt-branch");+ expect(existsSync(wtPath)).toBe(true);+ expect(existsSync(path.join(wtPath, "README.md"))).toBe(true);++ // Clean up worktree+ await removeGitWorktree({ cwd: tmpDir, path: wtPath });+ });++ it("worktree has the correct branch checked out", async () => {+ await initRepoWithCommit(tmpDir);+ await createGitBranch({ cwd: tmpDir, branch: "wt-check" });++ const wtPath = path.join(tmpDir, "wt-check-dir");+ await createGitWorktree({+ cwd: tmpDir,+ branch: "wt-check",+ path: wtPath,+ });++ // Verify the worktree is on the right branch+ const branchOutput = await git(wtPath, "branch --show-current");+ expect(branchOutput).toBe("wt-check");++ await removeGitWorktree({ cwd: tmpDir, path: wtPath });+ });++ it("throws when branch is already checked out in main worktree", async () => {+ await initRepoWithCommit(tmpDir);+ // Try to create a worktree for the current branch (already checked out)+ const branches = await listGitBranches({ cwd: tmpDir });+ const currentBranch = branches.branches.find((b) => b.current)!.name;++ const wtPath = path.join(tmpDir, "wt-conflict");+ await expect(+ createGitWorktree({+ cwd: tmpDir,+ branch: currentBranch,+ path: wtPath,+ }),+ ).rejects.toThrow();+ });++ it("removeGitWorktree cleans up the worktree", async () => {+ await initRepoWithCommit(tmpDir);+ await createGitBranch({ cwd: tmpDir, branch: "wt-remove" });++ const wtPath = path.join(tmpDir, "wt-remove-dir");+ await createGitWorktree({+ cwd: tmpDir,+ branch: "wt-remove",+ path: wtPath,+ });+ expect(existsSync(wtPath)).toBe(true);++ await removeGitWorktree({ cwd: tmpDir, path: wtPath });+ expect(existsSync(wtPath)).toBe(false);+ });+ });++ // ── Full flow: local branch checkout ──++ describe("full flow: local branch checkout", () => {+ it("init → commit → create branch → checkout → verify current", async () => {+ await initRepoWithCommit(tmpDir);+ await createGitBranch({ cwd: tmpDir, branch: "feature-login" });+ await checkoutGitBranch({ cwd: tmpDir, branch: "feature-login" });++ const result = await listGitBranches({ cwd: tmpDir });+ const current = result.branches.find((b) => b.current);+ expect(current!.name).toBe("feature-login");+ });+ });++ // ── Full flow: worktree creation from selected branch ──++ describe("full flow: worktree creation", () => {+ it("creates worktree from a non-current branch", async () => {+ await initRepoWithCommit(tmpDir);+ await createGitBranch({ cwd: tmpDir, branch: "feature-wt" });++ const wtPath = path.join(tmpDir, "my-worktree");+ const result = await createGitWorktree({+ cwd: tmpDir,+ branch: "feature-wt",+ path: wtPath,+ });++ // Worktree exists+ expect(existsSync(result.worktree.path)).toBe(true);++ // Main repo still on original branch+ const mainBranches = await listGitBranches({ cwd: tmpDir });+ const mainCurrent = mainBranches.branches.find((b) => b.current);+ expect(mainCurrent!.name).not.toBe("feature-wt");++ // Worktree is on feature-wt+ const wtBranch = await git(wtPath, "branch --show-current");+ expect(wtBranch).toBe("feature-wt");++ await removeGitWorktree({ cwd: tmpDir, path: wtPath });+ });+ });++ // ── Full flow: thread switching simulation ──++ describe("full flow: thread switching (checkout toggling)", () => {+ it("checkout a → checkout b → checkout a → current matches", async () => {+ await initRepoWithCommit(tmpDir);+ await createGitBranch({ cwd: tmpDir, branch: "branch-a" });+ await createGitBranch({ cwd: tmpDir, branch: "branch-b" });++ // Simulate switching to thread A's branch+ await checkoutGitBranch({ cwd: tmpDir, branch: "branch-a" });+ let branches = await listGitBranches({ cwd: tmpDir });+ expect(branches.branches.find((b) => b.current)!.name).toBe("branch-a");++ // Simulate switching to thread B's branch+ await checkoutGitBranch({ cwd: tmpDir, branch: "branch-b" });+ branches = await listGitBranches({ cwd: tmpDir });+ expect(branches.branches.find((b) => b.current)!.name).toBe("branch-b");++ // Switch back to thread A+ await checkoutGitBranch({ cwd: tmpDir, branch: "branch-a" });+ branches = await listGitBranches({ cwd: tmpDir });+ expect(branches.branches.find((b) => b.current)!.name).toBe("branch-a");+ });+ });++ // ── Full flow: checkout conflict ──++ describe("full flow: checkout conflict", () => {+ it("uncommitted changes prevent checkout to a diverged branch", async () => {+ await initRepoWithCommit(tmpDir);+ await createGitBranch({ cwd: tmpDir, branch: "diverged" });++ // Make diverged branch have different file content+ await checkoutGitBranch({ cwd: tmpDir, branch: "diverged" });+ await writeFile(path.join(tmpDir, "README.md"), "diverged content\n");+ await git(tmpDir, "add .");+ await git(tmpDir, "commit -m 'diverge'");++ // Go back to default branch+ const defaultBranch = (+ await git(tmpDir, "rev-parse --abbrev-ref HEAD")+ ).includes("diverged")+ ? // we're on diverged, need to find the other one+ (await listGitBranches({ cwd: tmpDir })).branches.find(+ (b) => !b.current && b.name !== "diverged",+ )!.name+ : (await git(tmpDir, "rev-parse --abbrev-ref HEAD"));++ // Actually, let's just get back to the initial branch explicitly+ const allBranches = await listGitBranches({ cwd: tmpDir });+ const initialBranch = allBranches.branches.find(+ (b) => b.name !== "diverged",+ )!.name;+ await checkoutGitBranch({ cwd: tmpDir, branch: initialBranch });++ // Make local uncommitted changes to the same file+ await writeFile(path.join(tmpDir, "README.md"), "local uncommitted\n");++ // Attempt checkout should fail+ await expect(+ checkoutGitBranch({ cwd: tmpDir, branch: "diverged" }),+ ).rejects.toThrow();++ // Current branch should still be the initial one+ const result = await listGitBranches({ cwd: tmpDir });+ expect(result.branches.find((b) => b.current)!.name).toBe(initialBranch);+ });+ });+});diff --git a/apps/desktop/src/git.ts b/apps/desktop/src/git.tsnew file mode 100644index 000000000..6f253b4d5--- /dev/null+++ b/apps/desktop/src/git.ts@@ -0,0 +1,202 @@+import { spawn } from "node:child_process";+import path from "node:path";++import type {+ GitCheckoutInput,+ GitCreateBranchInput,+ GitCreateWorktreeInput,+ GitCreateWorktreeResult,+ GitInitInput,+ GitListBranchesInput,+ GitListBranchesResult,+ GitRemoveWorktreeInput,+ TerminalCommandInput,+ TerminalCommandResult,+} from "@t3tools/contracts";++export async function runTerminalCommand(+ input: TerminalCommandInput,+): Promise<TerminalCommandResult> {+ const shellPath =+ process.platform === "win32"+ ? (process.env.ComSpec ?? "cmd.exe")+ : (process.env.SHELL ?? "/bin/sh");++ const args =+ process.platform === "win32"+ ? ["/d", "/s", "/c", input.command]+ : ["-lc", input.command];++ return new Promise((resolve, reject) => {+ const child = spawn(shellPath, args, {+ cwd: input.cwd,+ env: process.env,+ stdio: ["ignore", "pipe", "pipe"],+ });++ let stdout = "";+ let stderr = "";+ let timedOut = false;++ const timeout = setTimeout(() => {+ timedOut = true;+ child.kill("SIGTERM");+ setTimeout(() => {+ if (!child.killed) {+ child.kill("SIGKILL");+ }+ }, 1_000).unref();+ }, input.timeoutMs ?? 30_000);++ child.stdout?.on("data", (chunk: Buffer) => {+ stdout += chunk.toString();+ });++ child.stderr?.on("data", (chunk: Buffer) => {+ stderr += chunk.toString();+ });++ child.on("error", (error) => {+ clearTimeout(timeout);+ reject(error);+ });++ child.on("close", (code, signal) => {+ clearTimeout(timeout);+ resolve({+ stdout,+ stderr,+ code: code ?? null,+ signal: signal ?? null,+ timedOut,+ });+ });+ });+}++export async function listGitBranches(+ input: GitListBranchesInput,+): Promise<GitListBranchesResult> {+ const result = await runTerminalCommand({+ command: "git branch --no-color",+ cwd: input.cwd,+ timeoutMs: 10_000,+ });++ if (result.code !== 0) {+ const stderr = result.stderr.trim();+ if (stderr.includes("not a git repository")) {+ return { branches: [], isRepo: false };+ }+ throw new Error(stderr || "git branch failed");+ }++ // Resolve the real default branch from the remote+ const defaultRef = await runTerminalCommand({+ command: "git symbolic-ref refs/remotes/origin/HEAD",+ cwd: input.cwd,+ timeoutMs: 5_000,+ });+ const defaultBranch =+ defaultRef.code === 0+ ? defaultRef.stdout.trim().replace(/^refs\/remotes\/origin\//, "")+ : null;++ const branches = result.stdout+ .split("\n")+ .map((line) => line.trim())+ .filter((line) => line.length > 0)+ .map((line) => ({+ name: line.replace(/^[*+]\s+/, ""),+ current: line.startsWith("* "),+ isDefault: line.replace(/^[*+]\s+/, "") === defaultBranch,+ }))+ .sort((a, b) => {+ if (a.current !== b.current) return a.current ? -1 : 1;+ if (a.isDefault !== b.isDefault) return a.isDefault ? -1 : 1;+ return a.name.localeCompare(b.name);+ });++ return { branches, isRepo: true };+}++export async function createGitWorktree(+ input: GitCreateWorktreeInput,+): Promise<GitCreateWorktreeResult> {+ const sanitizedBranch = input.branch.replace(/\//g, "-");+ const repoName = path.basename(input.cwd);+ const worktreePath =+ input.path ??+ path.join(input.cwd, "..", `${repoName}-worktrees`, sanitizedBranch);++ const result = await runTerminalCommand({+ command: `git worktree add '${worktreePath.replace(/'/g, "'\\''")}' '${input.branch.replace(/'/g, "'\\''")}'`,+ cwd: input.cwd,+ timeoutMs: 30_000,+ });++ if (result.code !== 0) {+ throw new Error(result.stderr.trim() || "git worktree add failed");+ }++ return {+ worktree: {+ path: worktreePath,+ branch: input.branch,+ },+ };+}++export async function removeGitWorktree(+ input: GitRemoveWorktreeInput,+): Promise<void> {+ const result = await runTerminalCommand({+ command: `git worktree remove '${input.path.replace(/'/g, "'\\''")}'`,+ cwd: input.cwd,+ timeoutMs: 15_000,+ });++ if (result.code !== 0) {+ throw new Error(result.stderr.trim() || "git worktree remove failed");+ }+}++export async function createGitBranch(+ input: GitCreateBranchInput,+): Promise<void> {+ const result = await runTerminalCommand({+ command: `git branch '${input.branch.replace(/'/g, "'\\''")}'`,+ cwd: input.cwd,+ timeoutMs: 10_000,+ });++ if (result.code !== 0) {+ throw new Error(result.stderr.trim() || "git branch create failed");+ }+}++export async function checkoutGitBranch(+ input: GitCheckoutInput,+): Promise<void> {+ const result = await runTerminalCommand({+ command: `git checkout '${input.branch.replace(/'/g, "'\\''")}'`,+ cwd: input.cwd,+ timeoutMs: 10_000,+ });++ if (result.code !== 0) {+ throw new Error(result.stderr.trim() || "git checkout failed");+ }+}++export async function initGitRepo(input: GitInitInput): Promise<void> {+ const result = await runTerminalCommand({+ command: "git init",+ cwd: input.cwd,+ timeoutMs: 10_000,+ });++ if (result.code !== 0) {+ throw new Error(result.stderr.trim() || "git init failed");+ }+}diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsxindex 128e3f2e9..0635064ea 100644--- a/apps/web/src/components/ChatView.tsx+++ b/apps/web/src/components/ChatView.tsx@@ -384,7 +384,9 @@ export default function ChatView() {setIsEditorMenuOpen(false);};- const ensureSession = async (): Promise<EnsuredSessionInfo | null> => {+ const ensureSession = async (+ cwdOverride?: string,+ ): Promise<EnsuredSessionInfo | null> => {if (!api || !activeThread || !activeProject) return null;if (activeThread.session && activeThread.session.status !== "closed") {const sessionThreadId = activeThread.session.threadId ?? null;@@ -406,7 +408,7 @@ export default function ChatView() {try {const session = await api.providers.startSession({provider: "codex",- cwd: activeProject.cwd || undefined,+ cwd: cwdOverride ?? activeThread.worktreePath ?? activeProject.cwd,model: selectedModel || undefined,resumeThreadId: priorCodexThreadId ?? undefined,approvalPolicy: runtimeSessionConfig.approvalPolicy,@@ -471,7 +473,7 @@ export default function ChatView() {const previousMessages = activeThread.messages;setPrompt("");- const sessionInfo = await ensureSession();+ const sessionInfo = await ensureSession(activeThread.worktreePath ?? undefined);if (!sessionInfo) return;setIsSending(true);