im-pickle-rick 0.1.0

package/src/services/git/branch.test.ts

@@ -0,0 +1,147 @@
+import { mock, expect, test, describe, beforeEach } from "bun:test";
+
+const mockGit = {
+        status: mock(async () => ({ files: [], current: "main" })),
+        stash: mock(async () => {}),
+        checkout: mock(async () => {}),
+        pull: mock(async () => ({ catch: () => ({}) })),
+        checkoutLocalBranch: mock(async () => {}),
+        branchLocal: mock(async () => ({ all: ["main"], current: "main" })),
+};
+
+mock.module("simple-git", () => ({
+        default: mock(() => mockGit),
+        simpleGit: mock(() => mockGit),
+}));
+
+import * as branchService from "./branch.js";
+
+describe("Branch Service", () => {
+        beforeEach(() => {
+                // Reset mockGit manual mocks
+                Object.values(mockGit).forEach(m => m.mockClear());
+
+                // Setup default behaviors
+                mockGit.status.mockResolvedValue({ files: [], current: "main" } as any);
+                mockGit.branchLocal.mockResolvedValue({ all: ["main", "master"], current: "main" } as any);
+                mockGit.pull.mockResolvedValue({ catch: () => ({}) } as any);
+        });
+
+        describe("slugify", () => {
+                test("should convert text to kebab-case", () => {
+                        expect(branchService.slugify("Feature: Add tests")).toBe("feature-add-tests");
+                });
+
+                test("should remove special characters", () => {
+                        expect(branchService.slugify("Fix! @bug #123")).toBe("fix-bug-123");
+                });
+
+                test("should limit length to 50 characters", () => {
+                        const long = "a".repeat(100);
+                        expect(branchService.slugify(long)).toHaveLength(50);
+                });
+
+                test("should trim dashes from ends", () => {
+                        expect(branchService.slugify("-start-and-end-")).toBe("start-and-end");
+                });
+        });
+
+        describe("createTaskBranch", () => {
+                test("should create a branch with slugified task name", async () => {
+                        const branchName = await branchService.createTaskBranch("New Task", "main");
+                        expect(branchName).toBe("pickle/new-task");
+                        expect(mockGit.checkoutLocalBranch).toHaveBeenCalledWith("pickle/new-task");
+                });
+
+                test("should stash if there are uncommitted changes", async () => {
+                        mockGit.status.mockResolvedValue({ files: ["file1.ts"], current: "main" } as any);
+
+                        await branchService.createTaskBranch("New Task", "main");
+
+                        expect(mockGit.stash).toHaveBeenCalledWith(["push", "-m", "pickle-autostash"]);
+                        expect(mockGit.stash).toHaveBeenCalledWith(["pop"]);
+                });
+
+                test("should checkout and pull base branch", async () => {
+                        await branchService.createTaskBranch("New Task", "main");
+
+                        expect(mockGit.checkout).toHaveBeenCalledWith("main");
+                        expect(mockGit.pull).toHaveBeenCalledWith("origin", "main");
+                });
+
+                test("should fallback to checkout if checkoutLocalBranch fails", async () => {
+                        mockGit.checkoutLocalBranch.mockRejectedValue(new Error("Already exists"));
+
+                        await branchService.createTaskBranch("New Task", "main");
+
+                        expect(mockGit.checkout).toHaveBeenCalledWith("pickle/new-task");
+                });
+        });
+
+        describe("getCurrentBranch", () => {
+                test("should return current branch from status", async () => {
+                        mockGit.status.mockResolvedValue({ current: "feature-branch" } as any);
+                        const branch = await branchService.getCurrentBranch(undefined, mockGit as any);
+                        expect(branch).toBe("feature-branch");
+                });
+        });
+
+        describe("getDefaultBaseBranch", () => {
+                test("should prefer main if available", async () => {
+                        mockGit.branchLocal.mockResolvedValue({ all: ["main", "master"], current: "main" } as any);
+                        const base = await branchService.getDefaultBaseBranch();
+                        expect(base).toBe("main");
+                });
+
+                test("should use master if main is missing", async () => {
+                        mockGit.branchLocal.mockResolvedValue({ all: ["master", "other"], current: "master" } as any);
+                        const base = await branchService.getDefaultBaseBranch();
+                        expect(base).toBe("master");
+                });
+
+                test("should fallback to current branch if neither main nor master exists", async () => {
+                        mockGit.branchLocal.mockResolvedValue({ all: ["dev"], current: "dev" } as any);
+                        const base = await branchService.getDefaultBaseBranch();
+                        expect(base).toBe("dev");
+                });
+        });
+
+        describe("hasUncommittedChanges", () => {
+                test("should return true if status has files", async () => {
+                        mockGit.status.mockResolvedValue({ files: ["one"] } as any);
+                        expect(await branchService.hasUncommittedChanges()).toBe(true);
+                });
+
+                test("should return false if status has no files", async () => {
+                        mockGit.status.mockResolvedValue({ files: [] } as any);
+                        expect(await branchService.hasUncommittedChanges()).toBe(false);
+                });
+        });
+
+        describe("getGitStatusInfo", () => {
+                test("should return mapped status info", async () => {
+                        mockGit.status.mockResolvedValue({
+                                current: "main",
+                                ahead: 2,
+                                behind: 1,
+                                files: ["file.ts"]
+                        } as any);
+
+                        const info = await branchService.getGitStatusInfo();
+                        expect(info).toEqual({
+                                branch: "main",
+                                ahead: 2,
+                                behind: 1,
+                                modified: 1,
+                                isClean: false
+                        });
+                });
+
+                test("should return default info on error", async () => {
+                        mockGit.status.mockRejectedValue(new Error("Git error"));
+                        const info = await branchService.getGitStatusInfo();
+                        expect(info.branch).toBe("unknown");
+                        expect(info.isClean).toBe(true);
+                });
+        });
+});

package/src/services/git/branch.ts

@@ -0,0 +1,128 @@
+import simpleGit, { type SimpleGit } from "simple-git";
+import type { GitStatusInfo } from "../../types/tasks.js";
+
+/**
+ * Slugify text for branch names
+ */
+export function slugify(text: string): string {
+	return text
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-|-$/g, "")
+		.slice(0, 50);
+}
+
+/**
+ * Create a task branch
+ */
+export async function createTaskBranch(
+	task: string,
+	baseBranch: string,
+	workDir = process.cwd(),
+): Promise<string> {
+	const git: SimpleGit = simpleGit(workDir);
+	const branchName = `pickle/${slugify(task)}`;
+
+	// Stash any changes
+	let stashed = false;
+	const status = await git.status();
+	if (status.files.length > 0) {
+		await git.stash(["push", "-m", "pickle-autostash"]);
+		stashed = true;
+	}
+
+	try {
+		// Checkout base branch and pull
+		await git.checkout(baseBranch);
+		await git.pull("origin", baseBranch).catch(() => {
+			// Ignore pull errors
+		});
+
+		// Create new branch (or checkout if exists)
+		try {
+			await git.checkoutLocalBranch(branchName);
+		} catch {
+			await git.checkout(branchName);
+		}
+	} finally {
+		// Pop stash if we stashed
+		if (stashed) {
+			await git.stash(["pop"]).catch(() => {
+				// Ignore stash pop errors
+			});
+		}
+	}
+
+	return branchName;
+}
+
+/**
+ * Return to the base branch
+ */
+export async function returnToBaseBranch(
+	baseBranch: string,
+	workDir = process.cwd(),
+): Promise<void> {
+	const git: SimpleGit = simpleGit(workDir);
+	await git.checkout(baseBranch).catch(() => {
+		// Ignore checkout errors
+	});
+}
+
+/**
+ * Get the current branch name
+ */
+export async function getCurrentBranch(workDir = process.cwd(), gitInstance?: SimpleGit): Promise<string> {
+        const git: SimpleGit = gitInstance || simpleGit(workDir);
+        const status = await git.status();
+        return status.current || "";
+}
+/**
+ * Get the default base branch (main or master)
+ */
+export async function getDefaultBaseBranch(workDir = process.cwd()): Promise<string> {
+	const git: SimpleGit = simpleGit(workDir);
+
+	// Try main first, then master
+	const branches = await git.branchLocal();
+	if (branches.all.includes("main")) return "main";
+	if (branches.all.includes("master")) return "master";
+
+	// Fall back to current branch
+	return branches.current;
+}
+
+/**
+ * Check if there are uncommitted changes
+ */
+export async function hasUncommittedChanges(workDir = process.cwd()): Promise<boolean> {
+	const git: SimpleGit = simpleGit(workDir);
+	const status = await git.status();
+	return status.files.length > 0;
+}
+
+/**
+ * Get comprehensive git status info for display
+ */
+export async function getGitStatusInfo(workDir = process.cwd()): Promise<GitStatusInfo> {
+	const git: SimpleGit = simpleGit(workDir);
+
+	try {
+		const status = await git.status();
+		return {
+			branch: status.current || "unknown",
+			ahead: status.ahead || 0,
+			behind: status.behind || 0,
+			modified: status.files.length,
+			isClean: status.files.length === 0,
+		};
+	} catch {
+		return {
+			branch: "unknown",
+			ahead: 0,
+			behind: 0,
+			modified: 0,
+			isClean: true,
+		};
+	}
+}

package/src/services/git/diff.test.ts

@@ -0,0 +1,113 @@
+import { mock, expect, test, describe, beforeEach } from "bun:test";
+
+const mockGit = {
+        diffSummary: mock(async () => ({ files: [] })),
+        raw: mock(async () => ""),
+        status: mock(async () => ({ not_added: [], created: [], deleted: [] })),
+        diff: mock(async () => ""),
+        show: mock(async () => ""),
+};
+
+mock.module("simple-git", () => ({
+        default: mock(() => mockGit),
+        simpleGit: mock(() => mockGit),
+}));
+
+mock.module("node:fs/promises", () => ({
+        readFile: mock(async () => "line1\nline2"),
+}));
+
+import * as diffService from "./diff.js";
+
+describe("Diff Service", () => {
+        beforeEach(() => {
+                Object.values(mockGit).forEach(m => m.mockClear());
+        });
+
+        describe("getChangedFiles", () => {
+                test("should combine committed and uncommitted changes", async () => {
+                        mockGit.diffSummary.mockResolvedValueOnce({
+                                files: [{ file: "file1.ts", insertions: 10, deletions: 5 }]
+                        } as any);
+                        mockGit.raw.mockResolvedValueOnce("A\tfile1.ts");
+
+                        const files = await diffService.getChangedFiles("/wt", "main", mockGit as any);
+                        expect(files).toHaveLength(1);
+                        expect(files[0].path).toBe("file1.ts");
+                        expect(files[0].status).toBe("added");
+                });
+
+                test("should handle renamed files in committed diff", async () => {
+                        mockGit.diffSummary.mockResolvedValueOnce({
+                                files: [{ file: "old.ts => new.ts" }]
+                        } as any);
+
+                        const files = await diffService.getChangedFiles("/wt", "main", mockGit as any);
+                        expect(files[0].status).toBe("renamed");
+                        expect(files[0].oldPath).toBe("old.ts");
+                        expect(files[0].path).toBe("new.ts");
+                });
+
+                test("should handle complex renamed files (with braces)", async () => {
+                        mockGit.diffSummary.mockResolvedValueOnce({
+                                files: [{ file: "src/{old.ts => new.ts}" }]
+                        } as any);
+
+                        const files = await diffService.getChangedFiles("/wt", "main", mockGit as any);
+                        expect(files[0].status).toBe("renamed");
+                        expect(files[0].oldPath).toBe("src/old.ts");
+                        expect(files[0].path).toBe("src/new.ts");
+                });
+
+                test("should include untracked and deleted files from status", async () => {
+                        mockGit.status.mockResolvedValueOnce({
+                                not_added: ["untracked.ts"],
+                                created: [],
+                                deleted: ["gone.ts"]
+                        } as any);
+
+                        const files = await diffService.getChangedFiles("/wt", "main", mockGit as any);
+                        expect(files.find(f => f.path === "untracked.ts")?.status).toBe("added");
+                        expect(files.find(f => f.path === "gone.ts")?.status).toBe("deleted");
+                });
+        });
+
+        describe("getFileDiff", () => {
+                test("should return diff for existing file", async () => {
+                        mockGit.diff.mockResolvedValueOnce("some diff");
+                        const diff = await diffService.getFileDiff("/wt", "main", "file.ts", "modified", mockGit as any);
+                        expect(diff).toBe("some diff");
+                });
+
+                test("should create synthetic diff for new files", async () => {
+                        mockGit.diff.mockResolvedValueOnce("");
+                        mockGit.show.mockRejectedValueOnce(new Error("No such file in base"));
+
+                        const diff = await diffService.getFileDiff("/wt", "main", "new.ts", "added", mockGit as any);
+                        expect(diff).toContain("new file mode 100644");
+                        expect(diff).toContain("+line1");
+                });
+        });
+
+        describe("getFileType", () => {
+                test("should return correct language for extensions", () => {
+                        expect(diffService.getFileType("test.ts")).toBe("typescript");
+                        expect(diffService.getFileType("app.jsx")).toBe("javascript");
+                        expect(diffService.getFileType("README.md")).toBe("markdown");
+                });
+
+                test("should return text for unknown extensions", () => {
+                        expect(diffService.getFileType("config.unknown")).toBe("text");
+                        expect(diffService.getFileType("no-ext")).toBe("text");
+                });
+        });
+
+        describe("getStatusIndicator", () => {
+                test("should return correct character", () => {
+                        expect(diffService.getStatusIndicator("added")).toBe("A");
+                        expect(diffService.getStatusIndicator("modified")).toBe("M");
+                        expect(diffService.getStatusIndicator("deleted")).toBe("D");
+                        expect(diffService.getStatusIndicator("renamed")).toBe("R");
+                });
+        });
+});