trident-git 0.2.0

package/src/app/api/custom-scripts/route.ts

@@ -0,0 +1,203 @@
+import { NextResponse } from 'next/server';
+import { spawn, ChildProcessWithoutNullStreams } from 'node:child_process';
+import fs from 'node:fs';
+import { z } from 'zod';
+import { GitService } from '@/lib/git';
+
+export const runtime = 'nodejs';
+
+type ExecutionStatus = 'running' | 'completed' | 'failed' | 'canceled';
+
+interface ScriptExecution {
+  id: string;
+  status: ExecutionStatus;
+  cancelRequested: boolean;
+  output: string;
+  exitCode: number | null;
+  signal: NodeJS.Signals | null;
+  startedAt: string;
+  finishedAt: string | null;
+  process: ChildProcessWithoutNullStreams | null;
+}
+
+const executions = new Map<string, ScriptExecution>();
+const MAX_OUTPUT_LENGTH = 500_000;
+const FINISHED_EXECUTION_TTL_MS = 30 * 60 * 1000;
+
+const startSchema = z.object({
+  command: z.literal('start'),
+  repoPath: z.string().min(1),
+  branchRef: z.string().min(1),
+  scriptContent: z.string(),
+});
+
+const statusSchema = z.object({
+  command: z.literal('status'),
+  executionId: z.string().min(1),
+});
+
+const cancelSchema = z.object({
+  command: z.literal('cancel'),
+  executionId: z.string().min(1),
+});
+
+const requestSchema = z.discriminatedUnion('command', [startSchema, statusSchema, cancelSchema]);
+
+function normalizeBranchForCheckout(branchRef: string): string {
+  return branchRef.startsWith('remotes/') ? branchRef.slice('remotes/'.length) : branchRef;
+}
+
+function appendOutput(execution: ScriptExecution, text: string) {
+  execution.output += text;
+  if (execution.output.length > MAX_OUTPUT_LENGTH) {
+    execution.output = execution.output.slice(execution.output.length - MAX_OUTPUT_LENGTH);
+  }
+}
+
+function toResponsePayload(execution: ScriptExecution) {
+  return {
+    executionId: execution.id,
+    status: execution.status,
+    cancelRequested: execution.cancelRequested,
+    output: execution.output,
+    exitCode: execution.exitCode,
+    signal: execution.signal,
+    startedAt: execution.startedAt,
+    finishedAt: execution.finishedAt,
+  };
+}
+
+function cleanupFinishedExecutions() {
+  const now = Date.now();
+  for (const [id, execution] of executions.entries()) {
+    if (execution.status === 'running') continue;
+    if (!execution.finishedAt) continue;
+    const finishedAtMs = new Date(execution.finishedAt).getTime();
+    if (Number.isNaN(finishedAtMs)) continue;
+    if (now - finishedAtMs > FINISHED_EXECUTION_TTL_MS) {
+      executions.delete(id);
+    }
+  }
+}
+
+export async function POST(request: Request) {
+  try {
+    cleanupFinishedExecutions();
+
+    const body = await request.json();
+    const payload = requestSchema.parse(body);
+
+    if (payload.command === 'status') {
+      const execution = executions.get(payload.executionId);
+      if (!execution) {
+        return NextResponse.json({ error: 'Execution not found' }, { status: 404 });
+      }
+
+      return NextResponse.json({ success: true, ...toResponsePayload(execution) });
+    }
+
+    if (payload.command === 'cancel') {
+      const execution = executions.get(payload.executionId);
+      if (!execution) {
+        return NextResponse.json({ error: 'Execution not found' }, { status: 404 });
+      }
+
+      if (execution.status === 'running' && execution.process) {
+        execution.cancelRequested = true;
+        appendOutput(execution, '\n[info] Cancel requested...\n');
+        execution.process.kill('SIGTERM');
+
+        setTimeout(() => {
+          if (execution.process && execution.cancelRequested) {
+            execution.process.kill('SIGKILL');
+          }
+        }, 1500);
+      }
+
+      return NextResponse.json({ success: true, ...toResponsePayload(execution) });
+    }
+
+    const { repoPath, branchRef, scriptContent } = payload;
+
+    if (!fs.existsSync(repoPath)) {
+      return NextResponse.json({ error: `Path not found: ${repoPath}` }, { status: 404 });
+    }
+
+    if (!fs.statSync(repoPath).isDirectory()) {
+      return NextResponse.json({ error: 'Repository path must be a directory' }, { status: 400 });
+    }
+
+    const git = new GitService(repoPath);
+    const branches = await git.getBranches();
+    const checkoutBranch = normalizeBranchForCheckout(branchRef);
+    const currentBranch = branches.current;
+
+    if (!currentBranch || currentBranch !== checkoutBranch) {
+      await git.checkout(checkoutBranch);
+    }
+
+    const executionId = crypto.randomUUID();
+    const child = spawn('bash', ['-s'], {
+      cwd: repoPath,
+      env: process.env,
+      stdio: 'pipe',
+    });
+
+    const execution: ScriptExecution = {
+      id: executionId,
+      status: 'running',
+      cancelRequested: false,
+      output: '',
+      exitCode: null,
+      signal: null,
+      startedAt: new Date().toISOString(),
+      finishedAt: null,
+      process: child,
+    };
+
+    executions.set(executionId, execution);
+
+    const onData = (chunk: Buffer | string) => {
+      appendOutput(execution, typeof chunk === 'string' ? chunk : chunk.toString('utf-8'));
+    };
+
+    child.stdout.on('data', onData);
+    child.stderr.on('data', onData);
+
+    child.on('error', (error) => {
+      appendOutput(execution, `\n[error] ${error.message}\n`);
+      execution.status = execution.cancelRequested ? 'canceled' : 'failed';
+      execution.finishedAt = new Date().toISOString();
+      execution.process = null;
+    });
+
+    child.on('close', (code, signal) => {
+      execution.exitCode = code;
+      execution.signal = signal;
+      execution.finishedAt = new Date().toISOString();
+      execution.process = null;
+
+      if (execution.cancelRequested) {
+        execution.status = 'canceled';
+        return;
+      }
+
+      execution.status = code === 0 ? 'completed' : 'failed';
+    });
+
+    child.stdin.write(scriptContent);
+    child.stdin.end();
+
+    return NextResponse.json({
+      success: true,
+      ...toResponsePayload(execution),
+      checkedOutBranch: checkoutBranch,
+      previousBranch: currentBranch,
+    });
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json({ error: error.issues }, { status: 400 });
+    }
+    return NextResponse.json({ error: (error as Error).message }, { status: 500 });
+  }
+}

package/src/app/api/fs/route.ts

@@ -0,0 +1,75 @@
+import { NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const requestedPath = searchParams.get('path');
+
+  // Default to home directory
+  const currentPath = requestedPath ? requestedPath : os.homedir();
+
+  try {
+      // Security check: though this is local app, basic sanity check
+      // For now, allow reading anywhere as it's a dev tool/local tool.
+      
+      const stats = await fs.promises.stat(currentPath);
+      if (!stats.isDirectory()) {
+          return NextResponse.json({ error: 'Not a directory' }, { status: 400 });
+      }
+
+      const items = await fs.promises.readdir(currentPath, { withFileTypes: true });
+      
+      // Let's verify if they are git repos
+      const directories = items.filter(item => item.isDirectory());
+
+      const contents = [];
+      const BATCH_SIZE = 50;
+
+      for (let i = 0; i < directories.length; i += BATCH_SIZE) {
+          const batch = directories.slice(i, i + BATCH_SIZE);
+          const batchResults = await Promise.all(batch.map(async (item) => {
+              const itemPath = path.join(currentPath, item.name);
+              let isRepo = false;
+              try {
+                  // Check for .git directory inside
+                  await fs.promises.access(path.join(itemPath, '.git'), fs.constants.F_OK);
+                  isRepo = true;
+              } catch (e) {}
+
+              return {
+                  name: item.name,
+                  path: itemPath,
+                  isRepo
+              };
+          }));
+          contents.push(...batchResults);
+      }
+
+      // Sort: Visible folders first, then Repos first within that group, then alphabetical
+      contents.sort((a, b) => {
+          const aHidden = a.name.startsWith('.');
+          const bHidden = b.name.startsWith('.');
+
+          // Visible first
+          if (!aHidden && bHidden) return -1;
+          if (aHidden && !bHidden) return 1;
+
+          // Repos first
+          if (a.isRepo && !b.isRepo) return -1;
+          if (!a.isRepo && b.isRepo) return 1;
+
+          return a.name.localeCompare(b.name);
+      });
+
+      return NextResponse.json({
+          path: currentPath,
+          folders: contents,
+          parent: path.dirname(currentPath)
+      });
+      
+  } catch (error) {
+      return NextResponse.json({ error: (error as Error).message }, { status: 500 });
+  }
+}

package/src/app/api/git/action/route.ts

@@ -0,0 +1,383 @@
+import { NextResponse } from 'next/server';
+import { GitService } from '@/lib/git';
+import { getRepositories } from '@/lib/store';
+import { getCredentialById, getCredentialToken, findCredentialForRemote } from '@/lib/credentials';
+import { getImageMimeType, isImageFile } from '@/lib/utils';
+import { handleGitError } from '@/lib/api-utils';
+import { z } from 'zod';
+import fs from 'node:fs';
+
+const actionSchema = z.object({
+  repoPath: z.string(),
+  action: z.enum(['commit', 'push', 'pull', 'stage', 'unstage', 'fetch', 'checkout', 'checkout-to-local', 'branch', 'create-tag', 'delete-branch', 'delete-remote-branch', 'delete-remote', 'delete-tag', 'delete-remote-tag', 'rename-branch', 'rename-remote-branch', 'rename-remote', 'add-remote', 'reset', 'revert', 'cherry-pick', 'cherry-pick-multiple', 'cherry-pick-abort', 'rebase', 'merge', 'check-merge-conflicts', 'check-rebase-conflicts', 'get-remotes', 'get-remote-branches', 'get-tracking-branch', 'get-latest-commit-message', 'push-to-remote', 'pull-from-remote', 'stash', 'stash-list', 'stash-apply', 'stash-drop', 'stash-pop', 'stash-files', 'stash-file-diff', 'reword', 'discard', 'cleanup-lock-file']),
+  data: z.any().optional(), // Payload depends on action
+});
+
+async function resolveCredentials(repoPath: string, git: GitService, remoteName?: string) {
+  const repos = getRepositories();
+  const repoConfig = repos.find(r => r.path === repoPath);
+  
+  // 1. Check for explicitly associated credential
+  if (repoConfig?.credentialId) {
+    const cred = await getCredentialById(repoConfig.credentialId);
+    if (cred) {
+      const token = await getCredentialToken(cred.id);
+      if (token) {
+        return { username: cred.username, token };
+      }
+    }
+  }
+
+  // 2. Fallback: try to find matching credential by URL
+  if (remoteName) {
+    const remoteUrl = await git.getRemoteUrl(remoteName);
+    if (remoteUrl) {
+       const result = await findCredentialForRemote(remoteUrl);
+       if (result) {
+         return { username: result.credential.username, token: result.token };
+       }
+    }
+  }
+
+  return undefined;
+}
+
+function toImageSide(buffer: Buffer | null, mimeType: string) {
+  if (!buffer) return null;
+  return {
+    mimeType,
+    base64: buffer.toString('base64'),
+  };
+}
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { repoPath, action, data } = actionSchema.parse(body);
+
+    // Check if path exists
+    if (!fs.existsSync(repoPath)) {
+      return NextResponse.json({ error: `Path not found: ${repoPath}` }, { status: 404 });
+    }
+
+    const git = new GitService(repoPath);
+
+    switch (action) {
+      case 'commit':
+        if (!data?.message) throw new Error('Commit message is required');
+        await git.commit(data.message, data.files);
+        break;
+      case 'push':
+        // Try to resolve credentials
+        let pushCredentials = await resolveCredentials(repoPath, git, undefined);
+        
+        if (!pushCredentials) {
+            // If no associated credential, try to infer from upstream
+            try {
+                const status = await git.getBranches();
+                const current = status.current;
+                const tracking = status.trackingInfo[current];
+                if (tracking && tracking.upstream) {
+                    const slashIndex = tracking.upstream.indexOf('/');
+                    if (slashIndex > 0) {
+                        const remoteName = tracking.upstream.slice(0, slashIndex);
+                        pushCredentials = await resolveCredentials(repoPath, git, remoteName);
+                    }
+                }
+            } catch (e) {
+                // Ignore errors finding upstream, just proceed without creds
+                console.warn('[API] Failed to resolve upstream for push credentials:', e);
+            }
+        }
+        
+        await git.push({ credentials: pushCredentials });
+        break;
+      case 'pull':
+        await git.pull();
+        break;
+      case 'fetch':
+        if (data?.allRemotes) {
+          await git.fetchAllRemotes();
+        } else if (data?.remote) {
+          await git.fetchRemote(data.remote);
+        } else {
+          await git.fetch();
+        }
+        break;
+      case 'stage':
+        if (!data?.files) throw new Error('Files are required for staging');
+        await git.stage(data.files);
+        break;
+      case 'unstage':
+        if (!data?.files) throw new Error('Files are required for unstaging');
+        await git.unstage(data.files);
+        break;
+      case 'discard':
+        await git.discardUnstagedChanges({
+          includeUntracked: data?.includeUntracked ?? true,
+        });
+        break;
+      case 'checkout':
+        if (!data?.branch) throw new Error('Branch name is required for checkout');
+        await git.checkout(data.branch);
+        break;
+      case 'checkout-to-local':
+        if (!data?.remoteBranch) throw new Error('Remote branch is required for checkout-to-local');
+        if (!data?.localBranch) throw new Error('Local branch name is required for checkout-to-local');
+        await git.checkoutRemoteToLocal(data.remoteBranch, data.localBranch);
+        break;
+      case 'branch':
+        if (!data?.branch) throw new Error('Branch name is required to create branch');
+        await git.createBranch(data.branch, data?.fromRef);
+        break;
+      case 'create-tag':
+        if (!data?.tagName) throw new Error('Tag name is required to create tag');
+        if (!data?.commitHash) throw new Error('Commit hash is required to create tag');
+        if (data?.pushToRemote) {
+          let remoteForTag = typeof data?.remote === 'string' && data.remote.trim() ? data.remote.trim() : undefined;
+          if (!remoteForTag) {
+            const branches = await git.getBranches();
+            const current = branches.current;
+            const trackingUpstream = current ? branches.trackingInfo?.[current]?.upstream : undefined;
+            if (trackingUpstream) {
+              const slashIndex = trackingUpstream.indexOf('/');
+              if (slashIndex > 0) {
+                remoteForTag = trackingUpstream.slice(0, slashIndex);
+              }
+            }
+          }
+          if (!remoteForTag) {
+            const remotes = await git.getRemotes();
+            if (remotes.includes('origin')) {
+              remoteForTag = 'origin';
+            } else {
+              remoteForTag = remotes[0];
+            }
+          }
+
+          const tagCreds = remoteForTag ? await resolveCredentials(repoPath, git, remoteForTag) : undefined;
+          await git.createTag(data.tagName, data.commitHash, {
+            pushToRemote: true,
+            remote: remoteForTag ?? undefined,
+            credentials: tagCreds,
+          });
+        } else {
+          await git.createTag(data.tagName, data.commitHash, { pushToRemote: false });
+        }
+        break;
+      case 'delete-branch':
+        if (!data?.branch) throw new Error('Branch name is required to delete branch');
+        await git.deleteBranch(data.branch);
+        break;
+      case 'delete-remote-branch':
+        if (!data?.remote) throw new Error('Remote name is required to delete remote branch');
+        if (!data?.branch) throw new Error('Branch name is required to delete remote branch');
+        
+        const deleteCreds = await resolveCredentials(repoPath, git, data.remote);
+        await git.deleteRemoteBranch(data.remote, data.branch, deleteCreds);
+        break;
+      case 'delete-remote':
+        if (!data?.name) throw new Error('Remote name is required to delete remote');
+        await git.deleteRemote(data.name);
+        break;
+      case 'delete-tag':
+        if (!data?.tag) throw new Error('Tag name is required to delete tag');
+        await git.deleteTag(data.tag);
+        break;
+      case 'delete-remote-tag':
+        if (!data?.remote) throw new Error('Remote name is required to delete remote tag');
+        if (!data?.tag) throw new Error('Tag name is required to delete remote tag');
+
+        const deleteTagCreds = await resolveCredentials(repoPath, git, data.remote);
+        await git.deleteRemoteTag(data.remote, data.tag, deleteTagCreds);
+        break;
+      case 'rename-branch':
+        if (!data?.oldName) throw new Error('Old branch name is required to rename branch');
+        if (!data?.newName) throw new Error('New branch name is required to rename branch');
+        if (data?.renameTrackingRemote) {
+          const tracking = await git.getTrackingBranch(data.oldName);
+          const renameTrackingCreds = tracking
+            ? await resolveCredentials(repoPath, git, tracking.remote)
+            : undefined;
+          await git.renameBranch(data.oldName, data.newName, {
+            renameTrackingRemote: true,
+            credentials: renameTrackingCreds,
+          });
+        } else {
+          await git.renameBranch(data.oldName, data.newName);
+        }
+        break;
+      case 'rename-remote-branch':
+        if (!data?.remote) throw new Error('Remote name is required to rename remote branch');
+        if (!data?.oldName) throw new Error('Old branch name is required to rename remote branch');
+        if (!data?.newName) throw new Error('New branch name is required to rename remote branch');
+
+        const renameCreds = await resolveCredentials(repoPath, git, data.remote);
+        await git.renameRemoteBranch(data.remote, data.oldName, data.newName, renameCreds);
+        break;
+      case 'rename-remote':
+        if (!data?.oldName) throw new Error('Old remote name is required to rename remote');
+        if (!data?.newName) throw new Error('New remote name is required to rename remote');
+        await git.renameRemote(data.oldName, data.newName);
+        break;
+      case 'add-remote':
+        if (!data?.name) throw new Error('Remote name is required to add remote');
+        if (!data?.url) throw new Error('Remote URL is required to add remote');
+        await git.addRemote(data.name, data.url);
+        break;
+      case 'reset':
+        if (!data?.commitHash) throw new Error('Commit hash is required for reset');
+        await git.reset(data.commitHash, data.mode ?? 'hard');
+        break;
+      case 'revert':
+        if (!data?.commitHash) throw new Error('Commit hash is required for revert');
+        await git.revert(data.commitHash);
+        break;
+      case 'cherry-pick':
+        if (!data?.commitHash) throw new Error('Commit hash is required for cherry-pick');
+        await git.cherryPick(data.commitHash);
+        break;
+      case 'cherry-pick-multiple':
+        if (!Array.isArray(data?.commitHashes) || data.commitHashes.length === 0) {
+          throw new Error('Commit hashes are required for multi cherry-pick');
+        }
+        if (!data.commitHashes.every((hash: unknown) => typeof hash === 'string' && hash.trim().length > 0)) {
+          throw new Error('All commit hashes must be non-empty strings');
+        }
+        await git.cherryPickMultiple(data.commitHashes);
+        break;
+      case 'cherry-pick-abort':
+        await git.abortCherryPick();
+        break;
+      case 'rebase':
+        if (!data?.ontoBranch) throw new Error('Target branch is required for rebase');
+        await git.rebase(data.ontoBranch, data.stashChanges ?? true);
+        break;
+      case 'reword':
+        if (!data?.commitHash) throw new Error('Commit hash is required for reword');
+        if (!data?.message) throw new Error('New message is required for reword');
+        await git.reword(data.commitHash, data.message, data.branch);
+        break;
+      case 'merge':
+        if (!data?.targetBranch) throw new Error('Target branch is required for merge');
+        await git.merge(data.targetBranch, {
+          rebaseBeforeMerge: data.rebaseBeforeMerge ?? false,
+          squash: data.squash ?? false,
+          fastForward: data.fastForward ?? false,
+          squashMessage: data.squashMessage,
+        });
+        break;
+      case 'check-merge-conflicts':
+        if (!data?.sourceBranch) throw new Error('Source branch is required for merge conflict check');
+        const hasConflicts = await git.willMergeHaveConflicts(data.sourceBranch, data.targetBranch);
+        return NextResponse.json({ success: true, hasConflicts });
+      case 'check-rebase-conflicts':
+        if (!data?.ontoBranch) throw new Error('Target branch is required for rebase conflict check');
+        if (!data?.sourceBranch) throw new Error('Source branch is required for rebase conflict check');
+        const hasRebaseConflicts = await git.willRebaseHaveConflicts(data.ontoBranch, data.sourceBranch);
+        return NextResponse.json({ success: true, hasConflicts: hasRebaseConflicts });
+      case 'get-remotes':
+        const remotes = await git.getRemotes();
+        return NextResponse.json({ success: true, remotes });
+      case 'get-remote-branches':
+        if (!data?.remote) throw new Error('Remote name is required');
+        const remoteBranches = await git.getRemoteBranches(data.remote);
+        return NextResponse.json({ success: true, branches: remoteBranches });
+      case 'get-tracking-branch':
+        if (!data?.branch) throw new Error('Branch name is required');
+        const tracking = await git.getTrackingBranch(data.branch);
+        return NextResponse.json({ success: true, tracking });
+      case 'get-latest-commit-message':
+        if (!data?.branch) throw new Error('Branch name is required');
+        const message = await git.getLatestCommitMessage(data.branch);
+        return NextResponse.json({ success: true, message });
+      case 'push-to-remote':
+        console.log('[API] push-to-remote action received:', data);
+        if (!data?.localBranch) throw new Error('Local branch is required');
+        if (!data?.remote) throw new Error('Remote is required');
+        if (!data?.remoteBranch) throw new Error('Remote branch is required');
+        
+        const creds = await resolveCredentials(repoPath, git, data.remote);
+        
+        console.log('[API] Calling git.pushToRemote...');
+        await git.pushToRemote(data.localBranch, data.remote, data.remoteBranch, {
+          rebaseFirst: data.rebaseFirst ?? !(data.forcePush ?? false),
+          forcePush: data.forcePush ?? false,
+          pushLocalOnlyTags: data.pushLocalOnlyTags ?? true,
+          setUpstream: data.setUpstream ?? false,
+          squash: data.squash ?? false,
+          squashMessage: data.squashMessage,
+          credentials: creds,
+        });
+        console.log('[API] git.pushToRemote completed');
+        break;
+      case 'pull-from-remote':
+        console.log('[API] pull-from-remote action received:', data);
+        if (!data?.localBranch) throw new Error('Local branch is required');
+        if (!data?.remote) throw new Error('Remote is required');
+        if (!data?.remoteBranch) throw new Error('Remote branch is required');
+        console.log('[API] Calling git.pullFromRemote...');
+        await git.pullFromRemote(data.localBranch, data.remote, data.remoteBranch, {
+          rebase: data.rebase ?? true,
+        });
+        console.log('[API] git.pullFromRemote completed');
+        break;
+      case 'stash':
+        await git.stash(data?.message);
+        break;
+      case 'stash-list':
+        const stashes = await git.getStashes();
+        return NextResponse.json({ success: true, stashes });
+      case 'stash-apply':
+        if (data?.index === undefined) throw new Error('Stash index is required');
+        await git.applyStash(data.index);
+        break;
+      case 'stash-drop':
+        if (data?.index === undefined) throw new Error('Stash index is required');
+        await git.dropStash(data.index);
+        break;
+      case 'stash-pop':
+        if (data?.index === undefined) throw new Error('Stash index is required');
+        await git.popStash(data.index);
+        break;
+      case 'stash-files':
+        if (data?.index === undefined) throw new Error('Stash index is required');
+        const stashFiles = await git.getStashFiles(data.index);
+        return NextResponse.json({ success: true, files: stashFiles });
+      case 'stash-file-diff':
+        if (data?.index === undefined) throw new Error('Stash index is required');
+        if (!data?.file) throw new Error('File path is required');
+        if (isImageFile(data.file)) {
+          const mimeType = getImageMimeType(data.file);
+          const [leftBuffer, rightBuffer, diff] = await Promise.all([
+            git.getFileContentBuffer(data.file, `stash@{${data.index}}^1`),
+            git.getFileContentBuffer(data.file, `stash@{${data.index}}`),
+            git.getStashFilePatch(data.index, data.file),
+          ]);
+
+          return NextResponse.json({
+            success: true,
+            left: '',
+            right: '',
+            diff,
+            imageDiff: {
+              left: toImageSide(leftBuffer, mimeType),
+              right: toImageSide(rightBuffer, mimeType),
+            },
+          });
+        }
+
+        const stashFileDiff = await git.getStashFileDiff(data.index, data.file);
+        return NextResponse.json({ success: true, ...stashFileDiff });
+      case 'cleanup-lock-file':
+        const cleaned = await git.cleanupLockFile();
+        return NextResponse.json({ success: true, cleaned });
+      default:
+        return NextResponse.json({ error: 'Invalid action' }, { status: 400 });
+    }
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    return handleGitError(error);
+  }
+}

package/src/app/api/git/branches/route.ts

@@ -0,0 +1,20 @@
+import { NextResponse } from 'next/server';
+import { GitService } from '@/lib/git';
+import { handleGitError } from '@/lib/api-utils';
+
+export async function GET(req: Request) {
+    const { searchParams } = new URL(req.url);
+    const path = searchParams.get('path');
+
+    if (!path) {
+        return NextResponse.json({ error: 'Path is required' }, { status: 400 });
+    }
+
+    try {
+        const git = new GitService(path);
+        const branches = await git.getBranches();
+        return NextResponse.json(branches);
+    } catch (err) {
+        return handleGitError(err);
+    }
+}