im-pickle-rick 0.1.0

package/src/services/git/diff.ts

@@ -0,0 +1,323 @@
+import simpleGit, { type SimpleGit } from "simple-git";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+export interface ChangedFile {
+        path: string;
+        status: "added" | "modified" | "deleted" | "renamed";
+        additions: number;
+        deletions: number;
+        oldPath?: string; // For renamed files
+}
+
+/**
+ * Get list of changed files between worktree branch and base branch
+ * Includes both committed changes AND uncommitted working tree changes
+ */
+export async function getChangedFiles(
+        worktreeDir: string,
+        baseBranch: string,
+        gitInstance?: SimpleGit
+): Promise<ChangedFile[]> {
+        const git: SimpleGit = gitInstance || simpleGit(worktreeDir);
+        const filesMap = new Map<string, ChangedFile>();
+
+        try {
+                // 1. Get committed changes between base branch and HEAD
+                try {
+                        const committedDiff = await git.diffSummary([`${baseBranch}...HEAD`]);
+                        for (const file of committedDiff.files) {
+                                let path = file.file;
+                                let oldPath: string | undefined;
+                                let status: ChangedFile["status"] = "modified";
+
+                                // Parse renamed files (format: "old => new" or "{old => new}")
+                                if (file.file.includes(" => ")) {
+                                        status = "renamed";
+                                        let match = file.file.match(/(.*?){(.+?)\s*=>\s*(.+?)}(.*)/);
+                                        if (match) {
+                                                const prefix = match[1] || "";
+                                                const suffix = match[4] || "";
+                                                oldPath = prefix + match[2] + suffix;
+                                                path = prefix + match[3] + suffix;
+                                        } else {
+                                                match = file.file.match(/(.+?)\s*=>\s*(.+)/);
+                                                if (match) {
+                                                        oldPath = match[1];
+                                                        path = match[2];
+                                                }
+                                        }
+                                }
+
+                                filesMap.set(path, {
+                                        path,
+                                        oldPath,
+                                        status,
+                                        additions: "insertions" in file ? file.insertions : 0,
+                                        deletions: "deletions" in file ? file.deletions : 0,
+                                });
+                        }
+
+                        // Get accurate status using --name-status for committed changes
+                        const nameStatus = await git.raw(["diff", "--name-status", `${baseBranch}...HEAD`]);
+                        for (const line of nameStatus.split("\n").filter(Boolean)) {
+                                const [statusStr, ...pathParts] = line.split("\t");
+                                const filePath = pathParts.join("\t");
+                                const existing = filesMap.get(filePath);
+                                if (existing) {
+                                        const statusChar = statusStr[0];
+                                        if (statusChar === "A") existing.status = "added";
+                                        else if (statusChar === "D") existing.status = "deleted";
+                                        else if (statusChar === "R") existing.status = "renamed";
+                                }
+                        }
+                } catch {
+                        // No committed changes
+                }
+
+                // 2. Get uncommitted working tree changes (staged + unstaged)
+                try {
+                        // Get working tree changes (unstaged)
+                        const workingTreeDiff = await git.diffSummary();
+                        for (const file of workingTreeDiff.files) {
+                                const path = file.file;
+                                const existing = filesMap.get(path);
+                                if (existing) {
+                                        // Add to existing stats
+                                        existing.additions += "insertions" in file ? file.insertions : 0;
+                                        existing.deletions += "deletions" in file ? file.deletions : 0;
+                                } else {
+                                        filesMap.set(path, {
+                                                path,
+                                                status: "modified",
+                                                additions: "insertions" in file ? file.insertions : 0,
+                                                deletions: "deletions" in file ? file.deletions : 0,
+                                        });
+                                }
+                        }
+
+                        // Get staged changes
+                        const stagedDiff = await git.diffSummary(["--staged"]);
+                        for (const file of stagedDiff.files) {
+                                const path = file.file;
+                                const existing = filesMap.get(path);
+                                if (existing) {
+                                        existing.additions += "insertions" in file ? file.insertions : 0;
+                                        existing.deletions += "deletions" in file ? file.deletions : 0;
+                                } else {
+                                        filesMap.set(path, {
+                                                path,
+                                                status: "modified",
+                                                additions: "insertions" in file ? file.insertions : 0,
+                                                deletions: "deletions" in file ? file.deletions : 0,
+                                        });
+                                }
+                        }
+
+                        // Get status for untracked files
+                        const status = await git.status();
+                        for (const file of status.not_added) {
+                                if (!filesMap.has(file)) {
+                                        filesMap.set(file, {
+                                                path: file,
+                                                status: "added",
+                                                additions: 0,
+                                                deletions: 0,
+                                        });
+                                }
+                        }
+                        for (const file of status.created) {
+                                const existing = filesMap.get(file);
+                                if (existing) {
+                                        existing.status = "added";
+                                } else {
+                                        filesMap.set(file, {
+                                                path: file,
+                                                status: "added",
+                                                additions: 0,
+                                                deletions: 0,
+                                        });
+                                }
+                        }
+                        for (const file of status.deleted) {
+                                const existing = filesMap.get(file);
+                                if (existing) {
+                                        existing.status = "deleted";
+                                } else {
+                                        filesMap.set(file, {
+                                                path: file,
+                                                status: "deleted",
+                                                additions: 0,
+                                                deletions: 0,
+                                        });
+                                }
+                        }
+                } catch {
+                        // No working tree changes
+                }
+
+                return Array.from(filesMap.values());
+        } catch (error) {
+                console.error("Error getting changed files:", error);
+                return [];
+        }
+}
+
+/**
+ * Get unified diff for a specific file
+ * Compares the file against baseBranch, including uncommitted changes
+ * For new files, creates a diff showing all lines as additions
+ */
+export async function getFileDiff(
+        worktreeDir: string,
+        baseBranch: string,
+        filePath: string,
+        fileStatus?: "added" | "modified" | "deleted" | "renamed",
+        gitInstance?: SimpleGit
+): Promise<string> {
+        const git: SimpleGit = gitInstance || simpleGit(worktreeDir);
+
+        try {
+                // Get diff from baseBranch to current working tree (includes uncommitted changes)
+                let diff = await git.diff([baseBranch, "--", filePath]);
+
+                // If diff is empty and file is added/new, create a synthetic diff
+                if (!diff && (fileStatus === "added" || !fileStatus)) {
+                        // Check if file exists in base branch
+                        let existsInBase = true;
+                        try {
+                                await git.show([`${baseBranch}:${filePath}`]);
+                        } catch {
+                                existsInBase = false;
+                        }
+
+                        // If file doesn't exist in base, it's a new file - read and create diff
+                        if (!existsInBase) {
+                                try {
+                                        const fullPath = join(worktreeDir, filePath);
+                                        const content = await readFile(fullPath, "utf-8");
+                                        const lines = content.split("\n");
+                                        const lineCount = lines.length;
+
+                                        // Create a unified diff format for a new file
+                                        diff = `diff --git a/${filePath} b/${filePath}
+new file mode 100644
+--- /dev/null
++++ b/${filePath}
+@@ -0,0 +1,${lineCount} @@
+${lines.map(line => `+${line}`).join("\n")}`;
+                                } catch (readError) {
+                                        console.error(`Error reading new file ${filePath}:`, readError);
+                                }
+                        }
+                }
+
+                return diff;
+        } catch (error) {
+                console.error(`Error getting diff for ${filePath}:`, error);
+                return "";
+        }
+}
+
+/**
+ * Get combined diff for all files
+ */
+export async function getFullDiff(
+        worktreeDir: string,
+        baseBranch: string,
+        gitInstance?: SimpleGit
+): Promise<string> {
+        const git: SimpleGit = gitInstance || simpleGit(worktreeDir);
+
+        try {
+                const diff = await git.diff([`${baseBranch}...HEAD`]);
+                return diff;
+        } catch (error) {
+                console.error("Error getting full diff:", error);
+                return "";
+        }
+}
+
+/**
+ * Get file extension for syntax highlighting
+ */
+export function getFileType(filePath: string): string {
+        const ext = filePath.split(".").pop()?.toLowerCase() || "";
+
+        const extMap: Record<string, string> = {
+                ts: "typescript",
+                tsx: "typescript",
+                js: "javascript",
+                jsx: "javascript",
+                py: "python",
+                rb: "ruby",
+                go: "go",
+                rs: "rust",
+                java: "java",
+                kt: "kotlin",
+                swift: "swift",
+                c: "c",
+                cpp: "cpp",
+                h: "c",
+                hpp: "cpp",
+                cs: "csharp",
+                php: "php",
+                md: "markdown",
+                json: "json",
+                yaml: "yaml",
+                yml: "yaml",
+                toml: "toml",
+                xml: "xml",
+                html: "html",
+                css: "css",
+                scss: "scss",
+                sass: "sass",
+                less: "less",
+                sql: "sql",
+                sh: "bash",
+                bash: "bash",
+                zsh: "bash",
+                fish: "fish",
+                ps1: "powershell",
+                dockerfile: "dockerfile",
+                makefile: "makefile",
+        };
+
+        return extMap[ext] || "text";
+}
+
+/**
+ * Get status indicator character for display
+ */
+export function getStatusIndicator(status: ChangedFile["status"]): string {
+        switch (status) {
+                case "added":
+                        return "A";
+                case "modified":
+                        return "M";
+                case "deleted":
+                        return "D";
+                case "renamed":
+                        return "R";
+                default:
+                        return "?";
+        }
+}
+
+/**
+ * Get status color for display
+ */
+export function getStatusColor(status: ChangedFile["status"]): string {
+        switch (status) {
+                case "added":
+                        return "#4caf50"; // Green
+                case "modified":
+                        return "#2196f3"; // Blue
+                case "deleted":
+                        return "#f44336"; // Red
+                case "renamed":
+                        return "#ff9800"; // Orange
+                default:
+                        return "#888888";
+        }
+}

package/src/services/git/index.ts

@@ -0,0 +1,4 @@
+export * from "./branch.js";
+export * from "./pr.js";
+export * from "./worktree.js";
+export * from "./diff.js";

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

@@ -0,0 +1,104 @@
+import { mock, expect, test, describe, beforeEach } from "bun:test";
+
+const mockGit = {
+        push: mock(async () => {}),
+        getRemotes: mock(async () => [{ name: "origin", refs: { fetch: "git@github.com:user/repo.git" } }]),
+};
+
+mock.module("simple-git", () => ({
+        default: mock(() => mockGit),
+        simpleGit: mock(() => mockGit),
+}));
+
+const mockExec = mock(async () => ({ stdout: "https://github.com/user/repo/pull/1", exitCode: 0 }));
+
+mock.module("../providers/base.js", () => ({
+        execCommand: mockExec,
+}));
+
+mock.module("node:fs", () => ({
+        existsSync: mock((path: string) => path.endsWith("prd.md")),
+        readdirSync: mock(() => []),
+}));
+
+mock.module("node:fs/promises", () => ({
+        readFile: mock(async (path: string) => {
+                if (path.endsWith("prd.md")) return `# My PRD
+## Problem Statement
+This is a problem.`;
+                return "";
+        }),
+}));
+
+import * as prService from "./pr.js";
+
+describe("PR Service", () => {
+        beforeEach(() => {
+                mockExec.mockClear();
+                Object.values(mockGit).forEach(m => m.mockClear());
+        });
+
+        describe("generatePRDescription", () => {
+                test("should generate description from PRD", async () => {
+                        const desc = await prService.generatePRDescription("/tmp/session", "feat/test", "main");
+
+                        expect(desc.title).toBe("My");
+                        expect(desc.body).toContain("**Problem:** This is a problem.");
+                        expect(desc.body).toContain("**Branch:** `feat/test` → `main`")
+                });
+        });
+
+        describe("pushBranch", () => {
+                test("should push with upstream flag", async () => {
+                        await prService.pushBranch("feat/test", undefined, mockGit as any);
+                        expect(mockGit.push).toHaveBeenCalledWith("origin", "feat/test", ["--set-upstream"]);
+                });
+        });
+
+        describe("createPullRequest", () => {
+                test("should push branch and then call gh pr create", async () => {
+                        const url = await prService.createPullRequest(
+                                "feat/test",
+                                "main",
+                                "Title",
+                                "Body",
+                                false,
+                                undefined,
+                                mockGit as any
+                        );
+
+                        expect(mockGit.push).toHaveBeenCalled();
+                        expect(mockExec).toHaveBeenCalled();
+                        const args = (mockExec.mock.calls[0] as any[])[1] as string[];
+                        expect(args).toContain("pr");
+                        expect(args).toContain("create");
+                        expect(args).toContain("feat/test");
+                        expect(url).toBe("https://github.com/user/repo/pull/1");
+                });
+
+                test("should return null if push fails", async () => {
+                        mockGit.push.mockRejectedValue(new Error("Push failed"));
+                        const url = await prService.createPullRequest("feat/test", "main", "Title", "Body", false, undefined, mockGit as any);
+                        expect(url).toBeNull();
+                });
+        });
+
+        describe("isGhAvailable", () => {
+                test("should return true if gh auth status succeeds", async () => {
+                        mockExec.mockResolvedValueOnce({ stdout: "Logged in", exitCode: 0 });
+                        expect(await prService.isGhAvailable()).toBe(true);
+                });
+
+                test("should return false if gh auth status fails", async () => {
+                        mockExec.mockResolvedValueOnce({ stdout: "Not logged in", exitCode: 1 });
+                        expect(await prService.isGhAvailable()).toBe(false);
+                });
+        });
+
+        describe("getOriginUrl", () => {
+                test("should return fetch URL for origin", async () => {
+                        const url = await prService.getOriginUrl(undefined, mockGit as any);
+                        expect(url).toBe("git@github.com:user/repo.git");
+                });
+        });
+});

package/src/services/git/pr.ts

@@ -0,0 +1,192 @@
+import simpleGit, { type SimpleGit } from "simple-git";
+import { execCommand } from "../providers/base.js";
+import { readFile } from "node:fs/promises";
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+export interface PRDescription {
+        title: string;
+        body: string;
+}
+
+/**
+ * Generate a PR description from session artifacts
+ */
+export async function generatePRDescription(
+        sessionDir: string,
+        branchName: string,
+        baseBranch: string
+): Promise<PRDescription> {
+        let prdContent = "";
+        let ticketSummaries: string[] = [];
+
+        // Try to read PRD
+        const prdPath = join(sessionDir, "prd.md");
+        if (existsSync(prdPath)) {
+                try {
+                        prdContent = await readFile(prdPath, "utf-8");
+                } catch {}
+        }
+
+        // Extract title from PRD (first heading)
+        let title = "Pickle Rick Session Changes";
+        const titleMatch = prdContent.match(/^#\s+(.*)$/m);
+        if (titleMatch) {
+                title = titleMatch[1].replace(/\s+PRD$/i, "").trim();
+        }
+
+        // Gather ticket summaries from implementation docs
+        try {
+                const entries = readdirSync(sessionDir, { withFileTypes: true });
+                for (const entry of entries) {
+                        if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "debug") {
+                                const ticketDir = join(sessionDir, entry.name);
+                                const implPath = join(ticketDir, "implementation.md");
+                                const ticketPath = join(ticketDir, `linear_ticket_${entry.name}.md`);
+
+                                let ticketTitle = entry.name;
+                                if (existsSync(ticketPath)) {
+                                        try {
+                                                const ticketContent = await readFile(ticketPath, "utf-8");
+                                                const ticketTitleMatch = ticketContent.match(/^#\s+(.+)$/m);
+                                                if (ticketTitleMatch) ticketTitle = ticketTitleMatch[1];
+                                        } catch {}
+                                }
+
+                                if (existsSync(implPath)) {
+                                        try {
+                                                const implContent = await readFile(implPath, "utf-8");
+                                                // Extract summary section or first few lines
+                                                const summaryMatch = implContent.match(/##\s*Summary\s*\n([\s\S]*?)(?=\n##|$)/i);
+                                                const summary = summaryMatch
+                                                        ? summaryMatch[1].trim().slice(0, 500)
+                                                        : implContent.slice(0, 300).trim();
+                                                ticketSummaries.push(`### ${ticketTitle}\n${summary}`);
+                                        } catch {}
+                                }
+                        }
+                }
+        } catch {}
+
+        // Extract key sections from PRD for the body
+        let problemStatement = "";
+        let objective = "";
+        const problemMatch = prdContent.match(/##\s*Problem Statement\s*\n([\s\S]*?)(?=\n##|$)/i);
+        if (problemMatch) problemStatement = problemMatch[1].trim();
+        const objectiveMatch = prdContent.match(/##\s*Objective.*?\n([\s\S]*?)(?=\n##|$)/i);
+        if (objectiveMatch) objective = objectiveMatch[1].trim();
+
+        // Build PR body
+        const body = `## Summary
+
+${problemStatement ? `**Problem:** ${problemStatement.split('\n')[0]}` : 'Automated changes from Pickle Rick session.'}
+
+${objective ? `**Objective:** ${objective.split('\n')[0]}` : ''}
+
+## Changes
+
+${ticketSummaries.length > 0 ? ticketSummaries.join('\n\n') : 'See commit history for details.'}
+
+## Test Plan
+
+- [ ] Review code changes
+- [ ] Run tests locally
+- [ ] Verify functionality
+
+---
+
+🥒 Generated by [Pickle Rick CLI](https://github.com/anthropics/pickle-rick)
+
+**Branch:** \`${branchName}\` → \`${baseBranch}\`
+`;
+
+        return { title, body };
+}
+
+/**
+ * Push a branch to origin
+ */
+export async function pushBranch(branch: string, workDir = process.cwd(), gitInstance?: SimpleGit): Promise<boolean> {
+        const git: SimpleGit = gitInstance || simpleGit(workDir);
+
+        try {
+                await git.push("origin", branch, ["--set-upstream"]);
+                return true;
+        } catch {
+                return false;
+        }
+}
+
+/**
+ * Create a pull request using gh CLI
+ */
+export async function createPullRequest(
+        branch: string,
+        baseBranch: string,
+        title: string,
+        body: string,
+        draft = false,
+        workDir = process.cwd(),
+        gitInstance?: SimpleGit
+): Promise<string | null> {
+        // Push branch first
+        const pushed = await pushBranch(branch, workDir, gitInstance);
+        if (!pushed) {
+                return null;
+        }
+
+        // Build gh pr create command args
+        const args = [
+                "pr",
+                "create",
+                "--base",
+                baseBranch,
+                "--head",
+                branch,
+                "--title",
+                title,
+                "--body",
+                body,
+        ];
+
+        if (draft) {
+                args.push("--draft");
+        }
+
+        // Execute gh CLI
+        const { stdout, exitCode } = await execCommand("gh", args, workDir);
+
+        if (exitCode !== 0) {
+                return null;
+        }
+
+        // Return the PR URL (gh outputs the URL on success)
+        return stdout.trim() || null;
+}
+
+/**
+ * Check if gh CLI is available and authenticated
+ */
+export async function isGhAvailable(): Promise<boolean> {
+        try {
+                const { exitCode } = await execCommand("gh", ["auth", "status"], process.cwd());
+                return exitCode === 0;
+        } catch {
+                return false;
+        }
+}
+
+/**
+ * Get the remote URL for origin
+ */
+export async function getOriginUrl(workDir = process.cwd(), gitInstance?: SimpleGit): Promise<string | null> {
+        const git: SimpleGit = gitInstance || simpleGit(workDir);
+
+        try {
+                const remotes = await git.getRemotes(true);
+                const origin = remotes.find((r) => r.name === "origin");
+                return origin?.refs?.fetch || null;
+        } catch {
+                return null;
+        }
+}