Add git merge and remote fallback handling

Author: DevDominic

electron/main.ts

@@ -6,7 +6,7 @@ import os from 'os';
 import path from 'path';
 import { addWorkspace, createWorkspace, listWorkspaces, loadLayout, loadRestoreState, removeWorkspace, saveLayout, saveRestoreState, updateWorkspace } from './workspaceStore';
 import { createFile, createFolder, deletePath, pathExists, readDirectory, readFile, readFileDataUrl, renamePath, revealInExplorer, writeFile } from './fileService';
-import { addAll, commit, discardFile, fetch, getGitDiff, getGitFileContents, getGitStatus, getIgnoredFiles, listBranches, pull, push, stageFile, switchBranch, unstageFile } from '../extensions/builtin/git/main/gitService';
+import { abortMerge, addAll, commit, discardFile, fetch, getGitDiff, getGitFileContents, getGitStatus, getIgnoredFiles, listBranches, pull, pullMerge, push, stageFile, switchBranch, unstageFile } from '../extensions/builtin/git/main/gitService';
 import { createTerminal, forgetTerminalSnapshot, getTerminalProfiles, getTerminalSnapshot, killTerminal, loadOpenTerminalState, markTerminalReady, resizeTerminal, saveOpenTerminalState, setTerminalWindow, setVisibleTerminals, updateTerminalSession, writeTerminal } from './terminalManager';
 import { setBridgeWindow, startBrowserBridge } from './browserBridge';
 import { ensureDataDirs } from './storage';
@@ -234,6 +234,8 @@ function registerIpc() {
   ipcMain.handle('git:switchBranch', async (_event, targetPath: unknown, branch: unknown) => switchBranch(assertAbsolutePath(targetPath, 'targetPath'), assertNonEmptyString(branch, 'branch')));
   ipcMain.handle('git:push', async (_event, targetPath: unknown) => push(assertAbsolutePath(targetPath, 'targetPath')));
   ipcMain.handle('git:pull', async (_event, targetPath: unknown) => pull(assertAbsolutePath(targetPath, 'targetPath')));
+  ipcMain.handle('git:pullMerge', async (_event, targetPath: unknown) => pullMerge(assertAbsolutePath(targetPath, 'targetPath')));
+  ipcMain.handle('git:abortMerge', async (_event, targetPath: unknown) => abortMerge(assertAbsolutePath(targetPath, 'targetPath')));
   ipcMain.handle('git:fetch', async (_event, targetPath: unknown) => fetch(assertAbsolutePath(targetPath, 'targetPath')));
   ipcMain.handle('git:ignored', async (_event, targetPath: unknown, paths: unknown) => getIgnoredFiles(assertAbsolutePath(targetPath, 'targetPath'), Array.isArray(paths) ? paths.map((item) => assertNonEmptyString(item, 'path')) : []));
 

electron/preload.ts

@@ -67,6 +67,8 @@ const api: StackDockApi = {
     switchBranch: (targetPath, branch) => ipcRenderer.invoke('git:switchBranch', targetPath, branch),
     push: (targetPath) => ipcRenderer.invoke('git:push', targetPath),
     pull: (targetPath) => ipcRenderer.invoke('git:pull', targetPath),
+    pullMerge: (targetPath) => ipcRenderer.invoke('git:pullMerge', targetPath),
+    abortMerge: (targetPath) => ipcRenderer.invoke('git:abortMerge', targetPath),
     fetch: (targetPath) => ipcRenderer.invoke('git:fetch', targetPath),
     ignored: (targetPath, paths) => ipcRenderer.invoke('git:ignored', targetPath, paths),
   },

extensions/builtin/git/main/gitParser.ts

@@ -5,17 +5,23 @@ export interface ParsedGitFileStatus {
   staged: boolean;
   unstaged: boolean;
   untracked: boolean;
+  conflicted: boolean;
+  conflictStatus?: string;
 }
 
+const unmergedStatusCodes = new Set(['DD', 'AU', 'UD', 'UA', 'DU', 'AA', 'UU']);
+
 export function parseStatusLine(line: string): ParsedGitFileStatus | null {
   if (line.startsWith('?? ')) {
     const filePath = line.slice(3).trim();
-    return { path: filePath, indexStatus: '?', worktreeStatus: '?', staged: false, unstaged: true, untracked: true };
+    return { path: filePath, indexStatus: '?', worktreeStatus: '?', staged: false, unstaged: true, untracked: true, conflicted: false };
   }
   if (line.length < 4) return null;
   const indexStatus = line[0] ?? ' ';
   const worktreeStatus = line[1] ?? ' ';
+  const statusCode = `${indexStatus}${worktreeStatus}`;
   let filePath = line.slice(3).trim();
   if (filePath.includes(' -> ')) filePath = filePath.split(' -> ').pop() ?? filePath;
-  return { path: filePath, indexStatus, worktreeStatus, staged: indexStatus !== ' ', unstaged: worktreeStatus !== ' ', untracked: false };
+  if (unmergedStatusCodes.has(statusCode)) return { path: filePath, indexStatus, worktreeStatus, staged: false, unstaged: true, untracked: false, conflicted: true, conflictStatus: statusCode };
+  return { path: filePath, indexStatus, worktreeStatus, staged: indexStatus !== ' ', unstaged: worktreeStatus !== ' ', untracked: false, conflicted: false };
 }

extensions/builtin/git/main/gitService.ts

@@ -7,13 +7,72 @@ import { parseStatusLine } from './gitParser';
 
 const execFileAsync = promisify(execFile);
 
-async function runGit(cwd: string, args: string[], options?: { timeoutMs?: number }) {
-  const { stdout } = await execFileAsync('git', ['-C', cwd, ...args], {
-    maxBuffer: 1024 * 1024 * 10,
-    timeout: options?.timeoutMs ?? 30000,
-    env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
-  });
-  return stdout.toString();
+interface GitResult { stdout: string; stderr: string }
+
+export class GitCommandError extends Error {
+  stdout: string;
+  stderr: string;
+  remoteErrorKind: 'auth' | 'terminal-required' | 'other';
+
+  constructor(message: string, stdout: string, stderr: string) {
+    super(message);
+    this.name = 'GitCommandError';
+    this.stdout = stdout;
+    this.stderr = stderr;
+    this.remoteErrorKind = isAuthErrorText(`${stderr}\n${stdout}`) ? 'auth' : 'other';
+  }
+}
+
+function formatGitError(stdout: string, stderr: string) {
+  const detail = `${stderr}\n${stdout}`.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(0, 8).join('\n');
+  return detail || 'Git command failed';
+}
+
+async function runGit(cwd: string, args: string[], options?: { timeoutMs?: number }): Promise<GitResult> {
+  try {
+    const { stdout, stderr } = await execFileAsync('git', ['-C', cwd, ...args], {
+      maxBuffer: 1024 * 1024 * 10,
+      timeout: options?.timeoutMs ?? 30000,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+    });
+    return { stdout: stdout.toString(), stderr: stderr.toString() };
+  } catch (error) {
+    const stdout = typeof error === 'object' && error && 'stdout' in error ? String((error as { stdout?: unknown }).stdout ?? '') : '';
+    const stderr = typeof error === 'object' && error && 'stderr' in error ? String((error as { stderr?: unknown }).stderr ?? '') : '';
+    throw new GitCommandError(formatGitError(stdout, stderr), stdout, stderr);
+  }
+}
+
+function isAuthErrorText(text: string) {
+  return /Authentication failed|Credentials are incorrect or have expired|could not read Username|terminal prompts disabled|Permission denied \(publickey\)|Repository not found.*(Authentication|auth|credential|permission)/i.test(text);
+}
+
+export function isAuthError(error: unknown) {
+  if (error instanceof GitCommandError) return error.remoteErrorKind === 'auth';
+  return error instanceof Error ? isAuthErrorText(error.message) : isAuthErrorText(String(error));
+}
+
+async function gitOutput(cwd: string, args: string[], options?: { timeoutMs?: number }) {
+  return (await runGit(cwd, args, options)).stdout;
+}
+
+async function gitPathExists(cwd: string, gitPath: string) {
+  try {
+    const resolved = (await gitOutput(cwd, ['rev-parse', '--git-path', gitPath])).trim();
+    if (!resolved) return false;
+    const target = path.isAbsolute(resolved) ? resolved : path.join(cwd, resolved);
+    await fs.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function detectOperation(cwd: string): Promise<GitStatus['operation']> {
+  if (await gitPathExists(cwd, 'MERGE_HEAD')) return 'merge';
+  if (await gitPathExists(cwd, 'REBASE_HEAD') || await gitPathExists(cwd, 'rebase-merge') || await gitPathExists(cwd, 'rebase-apply')) return 'rebase';
+  if (await gitPathExists(cwd, 'CHERRY_PICK_HEAD')) return 'cherry-pick';
+  return undefined;
 }
 
 function assertSafeGitRef(ref: string) {
@@ -25,7 +84,7 @@ function assertSafeGitRef(ref: string) {
 
 export async function listBranches(cwd: string): Promise<string[]> {
   try {
-    const output = await runGit(cwd, ['branch', '--format=%(refname:short)']);
+    const output = await gitOutput(cwd, ['branch', '--format=%(refname:short)']);
     return [...new Set(output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean))];
   } catch {
     return [];
@@ -34,7 +93,7 @@ export async function listBranches(cwd: string): Promise<string[]> {
 
 export async function getGitStatus(cwd: string): Promise<GitStatus> {
   try {
-    const output = await runGit(cwd, ['status', '--porcelain=v1', '-b']);
+    const output = await gitOutput(cwd, ['status', '--porcelain=v1', '-b']);
     const lines = output.trim().split(/\r?\n/).filter(Boolean);
     const branchLine = lines.shift() ?? '';
     const status: GitStatus = { isRepo: true, files: [] };
@@ -49,6 +108,9 @@ export async function getGitStatus(cwd: string): Promise<GitStatus> {
     }
     status.files = lines.map(parseStatusLine).filter(Boolean) as GitFileStatus[];
     status.branches = await listBranches(cwd);
+    status.operation = await detectOperation(cwd);
+    status.conflicts = status.files.filter((file) => file.conflicted).length;
+    status.mergeReady = status.operation === 'merge' && status.conflicts === 0;
     return status;
   } catch {
     return { isRepo: false, files: [] };
@@ -60,70 +122,38 @@ export async function getGitDiff(cwd: string, filePath?: string, staged = false)
     const args = ['diff'];
     if (staged) args.push('--staged');
     if (filePath) args.push('--', filePath);
-    return await runGit(cwd, args);
+    return await gitOutput(cwd, args);
   } catch (error) {
     return error instanceof Error ? error.message : String(error);
   }
 }
 
 async function readGitObject(cwd: string, revision: string, filePath: string) {
-  try {
-    return await runGit(cwd, ['show', `${revision}:${filePath}`]);
-  } catch {
-    return '';
-  }
+  try { return await gitOutput(cwd, ['show', `${revision}:${filePath}`]); } catch { return ''; }
 }
-
 async function readIndexObject(cwd: string, filePath: string) {
-  try {
-    return await runGit(cwd, ['show', `:${filePath}`]);
-  } catch {
-    return '';
-  }
+  try { return await gitOutput(cwd, ['show', `:${filePath}`]); } catch { return ''; }
 }
-
 async function readWorkingFile(cwd: string, filePath: string) {
-  try {
-    return await fs.readFile(path.join(cwd, filePath), 'utf8');
-  } catch {
-    return '';
-  }
+  try { return await fs.readFile(path.join(cwd, filePath), 'utf8'); } catch { return ''; }
 }
 
 export async function getGitFileContents(cwd: string, filePath: string, staged = false): Promise<GitFileContents> {
   if (staged) {
-    const [original, modified] = await Promise.all([
-      readGitObject(cwd, 'HEAD', filePath),
-      readIndexObject(cwd, filePath),
-    ]);
+    const [original, modified] = await Promise.all([readGitObject(cwd, 'HEAD', filePath), readIndexObject(cwd, filePath)]);
     return { path: filePath, original, modified };
   }
-
   const indexContent = await readIndexObject(cwd, filePath);
   const original = indexContent || await readGitObject(cwd, 'HEAD', filePath);
   const modified = await readWorkingFile(cwd, filePath);
   return { path: filePath, original, modified };
 }
 
-export async function stageFile(cwd: string, filePath: string) {
-  await runGit(cwd, ['add', '--', filePath]);
-}
-
-export async function unstageFile(cwd: string, filePath: string) {
-  await runGit(cwd, ['restore', '--staged', '--', filePath]);
-}
-
-export async function discardFile(cwd: string, filePath: string) {
-  await runGit(cwd, ['restore', '--', filePath]);
-}
-
-export async function commit(cwd: string, message: string) {
-  await runGit(cwd, ['commit', '-m', message]);
-}
-
-export async function addAll(cwd: string) {
-  await runGit(cwd, ['add', '.']);
-}
+export async function stageFile(cwd: string, filePath: string) { await runGit(cwd, ['add', '--', filePath]); }
+export async function unstageFile(cwd: string, filePath: string) { await runGit(cwd, ['restore', '--staged', '--', filePath]); }
+export async function discardFile(cwd: string, filePath: string) { await runGit(cwd, ['restore', '--', filePath]); }
+export async function commit(cwd: string, message: string) { await runGit(cwd, ['commit', '-m', message]); }
+export async function addAll(cwd: string) { await runGit(cwd, ['add', '.']); }
 
 export async function switchBranch(cwd: string, branch: string) {
   const safeBranch = assertSafeGitRef(branch);
@@ -132,26 +162,28 @@ export async function switchBranch(cwd: string, branch: string) {
   await runGit(cwd, ['switch', safeBranch]);
 }
 
-export async function push(cwd: string) {
-  await runGit(cwd, ['push'], { timeoutMs: 120000 });
-}
-
-export async function pull(cwd: string) {
-  await runGit(cwd, ['pull', '--ff-only'], { timeoutMs: 120000 });
-}
-
-export async function fetch(cwd: string) {
-  await runGit(cwd, ['fetch'], { timeoutMs: 120000 });
+export async function push(cwd: string) { await runGit(cwd, ['push'], { timeoutMs: 120000 }); }
+export async function pull(cwd: string) { await runGit(cwd, ['pull', '--ff-only'], { timeoutMs: 120000 }); }
+export async function pullMerge(cwd: string) {
+  try {
+    await runGit(cwd, ['pull', '--no-rebase', '--no-edit'], { timeoutMs: 120000 });
+  } catch (error) {
+    const status = await getGitStatus(cwd);
+    if (status.operation === 'merge' && (status.conflicts ?? 0) > 0) throw new Error('Merge has conflicts. Resolve them, stage the files, then commit the merge.');
+    throw error;
+  }
 }
+export async function abortMerge(cwd: string) { await runGit(cwd, ['merge', '--abort']); }
+export async function fetch(cwd: string) { await runGit(cwd, ['fetch'], { timeoutMs: 120000 }); }
 
 export async function getIgnoredFiles(cwd: string, filePaths: string[]): Promise<string[]> {
   if (!filePaths.length) return [];
   const relativePaths = filePaths.map((filePath) => path.relative(cwd, path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath)).replace(/\\/g, '/'));
   try {
-    const output = await runGit(cwd, ['check-ignore', ...relativePaths]);
+    const output = await gitOutput(cwd, ['check-ignore', ...relativePaths]);
     return output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
   } catch (error) {
-    const output = typeof error === 'object' && error && 'stdout' in error ? String((error as { stdout?: unknown }).stdout ?? '') : '';
+    const output = error instanceof GitCommandError ? error.stdout : '';
     return output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
   }
 }