@minionry/minion 0.7.36

package/dist/server/services/git/merge-ops.js

@@ -0,0 +1,314 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { executeGitCommand, gitErrorText } from './command.js';
+import { findWorktreePathForBranch, parseGitStatus, parseMergeCommits, parseMergeTreeConflicts, parseMergeTreeOid, parseOverwritePaths, } from './parsers.js';
+import { gitFail, gitOk, } from './types.js';
+import { resolveMainWorktreePath } from './worktree-ops.js';
+export async function detectMergeBlockers(targetWorktreePath, sourceBranch, targetBranch) {
+    const statusResult = await executeGitCommand(['status', '--porcelain=v1'], targetWorktreePath);
+    if (statusResult.exitCode !== 0)
+        return [];
+    const { staged, unstaged, untracked } = parseGitStatus(statusResult.stdout);
+    const diffResult = await executeGitCommand(['diff', '--name-only', `${targetBranch}..${sourceBranch}`], targetWorktreePath);
+    if (diffResult.exitCode !== 0)
+        return [];
+    const mergeTouches = new Set(diffResult.stdout.split('\n').map(s => s.trim()).filter(Boolean));
+    if (mergeTouches.size === 0)
+        return [];
+    const seen = new Map();
+    const consider = (entries) => {
+        for (const entry of entries) {
+            if (!mergeTouches.has(entry.path))
+                continue;
+            if (seen.has(entry.path))
+                continue;
+            seen.set(entry.path, { path: entry.path, status: entry.status, staged: entry.staged });
+        }
+    };
+    consider(unstaged);
+    consider(staged);
+    consider(untracked);
+    return Array.from(seen.values()).sort((a, b) => {
+        if (a.status === 'D' && b.status !== 'D')
+            return 1;
+        if (a.status !== 'D' && b.status === 'D')
+            return -1;
+        return a.path.localeCompare(b.path);
+    });
+}
+export async function resolveTargetWorktree({ cwd, targetBranch }) {
+    const wtList = await executeGitCommand(['worktree', 'list', '--porcelain'], cwd);
+    return findWorktreePathForBranch(wtList.stdout, targetBranch);
+}
+export async function previewMerge({ cwd, sourceBranch, targetBranch }) {
+    let clean = true;
+    let conflicts = [];
+    const mergeTreeResult = await executeGitCommand(['merge-tree', '--write-tree', targetBranch, sourceBranch], cwd);
+    if (mergeTreeResult.exitCode !== 0) {
+        clean = false;
+        conflicts = parseMergeTreeConflicts(mergeTreeResult.stdout);
+    }
+    const statResult = await executeGitCommand(['diff', `${targetBranch}...${sourceBranch}`, '--stat'], cwd);
+    const stat = statResult.stdout.trim();
+    const logResult = await executeGitCommand(['log', `${targetBranch}..${sourceBranch}`, '--oneline', '--format=%h|%s'], cwd);
+    const commits = parseMergeCommits(logResult.stdout);
+    const targetWorktreePath = await resolveTargetWorktree({ cwd, targetBranch });
+    const blockers = targetWorktreePath
+        ? await detectMergeBlockers(targetWorktreePath, sourceBranch, targetBranch)
+        : [];
+    return {
+        clean,
+        conflicts,
+        stat,
+        commits,
+        ahead: commits.length,
+        targetWorktreePath: targetWorktreePath ?? undefined,
+        targetWorktreeBlockers: blockers,
+    };
+}
+async function executeMergeStrategy(strategy, sourceBranch, commitMessage, targetPath) {
+    if (strategy === 'squash') {
+        const squashResult = await executeGitCommand(['merge', '--squash', sourceBranch], targetPath);
+        if (squashResult.exitCode !== 0)
+            return { exitCode: squashResult.exitCode, error: squashResult.stderr };
+        const msg2 = commitMessage || `Squash merge branch '${sourceBranch}'`;
+        const commitResult = await executeGitCommand(['commit', '-m', msg2], targetPath);
+        if (commitResult.exitCode !== 0)
+            return { exitCode: commitResult.exitCode, error: commitResult.stderr || 'Failed to commit squash merge' };
+        return { exitCode: 0 };
+    }
+    if (strategy === 'rebase') {
+        const result = await executeGitCommand(['merge', '--ff-only', sourceBranch], targetPath);
+        return { exitCode: result.exitCode, error: result.stderr };
+    }
+    const mergeArgs = commitMessage ? ['merge', sourceBranch, '-m', commitMessage] : ['merge', sourceBranch];
+    const result = await executeGitCommand(mergeArgs, targetPath);
+    return { exitCode: result.exitCode, error: result.stderr };
+}
+async function detectMergeConflicts(targetPath) {
+    const result = await executeGitCommand(['diff', '--name-only', '--diff-filter=U'], targetPath);
+    return result.stdout.trim().split('\n').filter(f => f.trim());
+}
+async function removeWorktreeWithFallback(mainPath, worktreePath) {
+    const removeResult = await executeGitCommand(['worktree', 'remove', worktreePath], mainPath);
+    if (removeResult.exitCode === 0)
+        return { success: true };
+    const forceResult = await executeGitCommand(['worktree', 'remove', '--force', worktreePath], mainPath);
+    if (forceResult.exitCode === 0)
+        return { success: true };
+    return { success: false, warning: `Failed to remove worktree: ${forceResult.stderr || 'unknown error'}` };
+}
+async function isAncestor(cwd, ancestor, descendant) {
+    const result = await executeGitCommand(['merge-base', '--is-ancestor', ancestor, descendant], cwd);
+    return result.exitCode === 0;
+}
+async function deleteBranchAfterMerge(mainPath, branchName, targetBranch, strategy) {
+    const force = strategy === 'squash' || (await isAncestor(mainPath, branchName, targetBranch));
+    const result = await executeGitCommand(['branch', force ? '-D' : '-d', branchName], mainPath);
+    if (result.exitCode !== 0) {
+        return `Failed to delete branch: ${result.stderr || 'unknown error'}`;
+    }
+    return undefined;
+}
+async function cleanupAfterMerge(mainPath, sourceBranch, targetBranch, strategy, deleteWorktree, deleteBranch) {
+    const warnings = [];
+    let removedWorktreePath = null;
+    if (deleteWorktree) {
+        const wtList = await executeGitCommand(['worktree', 'list', '--porcelain'], mainPath);
+        const worktreePath = findWorktreePathForBranch(wtList.stdout, sourceBranch);
+        if (worktreePath && worktreePath !== mainPath) {
+            const result = await removeWorktreeWithFallback(mainPath, worktreePath);
+            if (result.success) {
+                removedWorktreePath = worktreePath;
+            }
+            else if (result.warning) {
+                warnings.push(result.warning);
+            }
+        }
+    }
+    if (deleteBranch) {
+        const warning = await deleteBranchAfterMerge(mainPath, sourceBranch, targetBranch, strategy);
+        if (warning)
+            warnings.push(warning);
+    }
+    await executeGitCommand(['worktree', 'prune'], mainPath);
+    return { warnings, removedWorktreePath };
+}
+const STASH_MESSAGE_TAG = 'minionry:pre-merge';
+async function pushMergeStash(targetWorktreePath, sourceBranch, targetBranch) {
+    const message = `${STASH_MESSAGE_TAG} ${targetBranch} <- ${sourceBranch} @ ${new Date().toISOString()}`;
+    const result = await executeGitCommand(['stash', 'push', '-u', '-m', message], targetWorktreePath);
+    if (result.exitCode !== 0)
+        return null;
+    const top = await executeGitCommand(['stash', 'list', '-n', '1', '--format=%H%x09%gs'], targetWorktreePath);
+    if (top.exitCode !== 0)
+        return null;
+    const [sha, ...rest] = top.stdout.trim().split('\t');
+    const stashedMsg = rest.join('\t');
+    if (!sha || !stashedMsg.includes(STASH_MESSAGE_TAG))
+        return null;
+    return { ref: 'stash@{0}', sha, message };
+}
+export async function popMergeStashBySha(targetWorktreePath, sha) {
+    const list = await executeGitCommand(['stash', 'list', '--format=%gd%x09%H'], targetWorktreePath);
+    if (list.exitCode !== 0)
+        return { exitCode: list.exitCode, error: list.stderr || 'Failed to read stash list' };
+    const ref = list.stdout.split('\n').map(l => l.split('\t')).find(([, h]) => h === sha)?.[0];
+    if (!ref)
+        return { exitCode: 1, error: 'Stash no longer exists — it may have already been popped or dropped.' };
+    const pop = await executeGitCommand(['stash', 'pop', ref], targetWorktreePath);
+    return { exitCode: pop.exitCode, error: pop.exitCode !== 0 ? pop.stderr : undefined };
+}
+function alreadyUpToDateError(sourceBranch, targetBranch) {
+    return `Already up to date — "${sourceBranch}" has no new commits to merge into "${targetBranch}"`;
+}
+async function buildMergeFailurePayload(targetPath, sourceBranch, targetBranch, mergeError) {
+    const conflictFiles = await detectMergeConflicts(targetPath);
+    if (conflictFiles.length > 0) {
+        return { success: false, conflictFiles, targetWorktreePath: targetPath };
+    }
+    const overwritten = parseOverwritePaths(mergeError || '');
+    if (overwritten.length > 0) {
+        const blockers = await detectMergeBlockers(targetPath, sourceBranch, targetBranch);
+        const targetWorktreeBlockers = blockers.length > 0
+            ? blockers
+            : overwritten.map(p => ({ path: p, status: 'M', staged: false }));
+        return { success: false, targetWorktreePath: targetPath, targetWorktreeBlockers };
+    }
+    return { success: false, error: mergeError || 'Merge failed', targetWorktreePath: targetPath };
+}
+function buildMergeSuccessPayload(targetPath, mergeCommit, warnings, stash) {
+    const data = { success: true, mergeCommit, targetWorktreePath: targetPath };
+    if (warnings.length > 0)
+        data.warnings = warnings;
+    if (stash) {
+        data.stashRef = stash.ref;
+        data.stashSha = stash.sha;
+        data.stashMessage = stash.message;
+    }
+    return data;
+}
+export async function mergeWorktreeBranch(args) {
+    const targetPath = await resolveTargetWorktree({ cwd: args.cwd, targetBranch: args.targetBranch });
+    return targetPath ? mergeInWorktree(args, targetPath) : mergeRefOnly(args);
+}
+async function mergeInWorktree(args, targetPath) {
+    const { cwd, sourceBranch, targetBranch, strategy, commitMessage, deleteWorktree, deleteBranch, stashFirst } = args;
+    const stash = stashFirst ? await pushMergeStash(targetPath, sourceBranch, targetBranch) : null;
+    const headBefore = await executeGitCommand(['rev-parse', 'HEAD'], targetPath);
+    const mergeResult = await executeMergeStrategy(strategy, sourceBranch, commitMessage, targetPath);
+    if (mergeResult.exitCode !== 0) {
+        if (stash)
+            await popMergeStashBySha(targetPath, stash.sha).catch(() => undefined);
+        const data = await buildMergeFailurePayload(targetPath, sourceBranch, targetBranch, mergeResult.error);
+        return { data, removedWorktreePath: null };
+    }
+    const headAfter = await executeGitCommand(['rev-parse', 'HEAD'], targetPath);
+    if (headBefore.stdout.trim() === headAfter.stdout.trim()) {
+        if (stash)
+            await popMergeStashBySha(targetPath, stash.sha).catch(() => undefined);
+        return {
+            data: { success: false, error: alreadyUpToDateError(sourceBranch, targetBranch), targetWorktreePath: targetPath },
+            removedWorktreePath: null,
+        };
+    }
+    const commitHashResult = await executeGitCommand(['rev-parse', '--short', 'HEAD'], targetPath);
+    const mainPath = await resolveMainWorktreePath(cwd);
+    const { warnings, removedWorktreePath } = await cleanupAfterMerge(mainPath, sourceBranch, targetBranch, strategy, !!deleteWorktree, !!deleteBranch);
+    return {
+        data: buildMergeSuccessPayload(targetPath, commitHashResult.stdout.trim(), warnings, stash),
+        removedWorktreePath,
+    };
+}
+function refOnlyFailure(data) {
+    return { failure: { success: false, ...data } };
+}
+async function readCommitSha(cwd, ref) {
+    const result = await executeGitCommand(['rev-parse', '--verify', '--quiet', ref], cwd);
+    const sha = result.stdout.trim();
+    return result.exitCode === 0 && sha ? sha : null;
+}
+async function resolveRefOnlyEndpoints(cwd, sourceBranch, targetBranch) {
+    const targetSha = await readCommitSha(cwd, `refs/heads/${targetBranch}`);
+    if (!targetSha)
+        return refOnlyFailure({ error: `Unknown target branch "${targetBranch}"` });
+    const sourceSha = await readCommitSha(cwd, `${sourceBranch}^{commit}`);
+    if (!sourceSha)
+        return refOnlyFailure({ error: `Unknown source branch "${sourceBranch}"` });
+    if (await isAncestor(cwd, sourceSha, targetSha))
+        return refOnlyFailure({ error: alreadyUpToDateError(sourceBranch, targetBranch) });
+    return { targetSha, sourceSha };
+}
+async function writeMergedCommit(cwd, sourceBranch, targetBranch, parents, message) {
+    const mergeTree = await executeGitCommand(['merge-tree', '--write-tree', targetBranch, sourceBranch], cwd);
+    if (mergeTree.exitCode !== 0) {
+        const conflictFiles = parseMergeTreeConflicts(mergeTree.stdout);
+        if (conflictFiles.length === 0)
+            return refOnlyFailure({ error: gitErrorText(mergeTree, 'Failed to compute merge') });
+        return refOnlyFailure({ conflictFiles, error: `Merge has conflicts — check out "${targetBranch}" in a worktree to resolve them` });
+    }
+    const tree = parseMergeTreeOid(mergeTree.stdout);
+    const commitTree = await executeGitCommand(['commit-tree', tree, ...parents.flatMap(p => ['-p', p]), '-m', message], cwd);
+    if (commitTree.exitCode !== 0)
+        return refOnlyFailure({ error: commitTree.stderr || 'Failed to write merge commit' });
+    return { sha: commitTree.stdout.trim() };
+}
+async function resolveRefOnlyTip(args, targetSha, sourceSha) {
+    const { cwd, sourceBranch, targetBranch, strategy, commitMessage } = args;
+    if (strategy === 'squash') {
+        const message = commitMessage || `Squash merge branch '${sourceBranch}'`;
+        return writeMergedCommit(cwd, sourceBranch, targetBranch, [targetSha], message);
+    }
+    if (await isAncestor(cwd, targetSha, sourceSha))
+        return { sha: sourceSha };
+    if (strategy === 'rebase') {
+        return refOnlyFailure({ error: `Cannot fast-forward "${targetBranch}" to "${sourceBranch}" — check out "${targetBranch}" in a worktree to rebase` });
+    }
+    const message = commitMessage || `Merge branch '${sourceBranch}' into ${targetBranch}`;
+    return writeMergedCommit(cwd, sourceBranch, targetBranch, [targetSha, sourceSha], message);
+}
+async function mergeRefOnly(args) {
+    const { cwd, sourceBranch, targetBranch, strategy, deleteWorktree, deleteBranch } = args;
+    const endpoints = await resolveRefOnlyEndpoints(cwd, sourceBranch, targetBranch);
+    if ('failure' in endpoints)
+        return { data: endpoints.failure, removedWorktreePath: null };
+    const tip = await resolveRefOnlyTip(args, endpoints.targetSha, endpoints.sourceSha);
+    if ('failure' in tip)
+        return { data: tip.failure, removedWorktreePath: null };
+    const update = await executeGitCommand(['update-ref', '-m', `merge ${sourceBranch}: ref-only ${strategy}`, `refs/heads/${targetBranch}`, tip.sha, endpoints.targetSha], cwd);
+    if (update.exitCode !== 0) {
+        return { data: { success: false, error: update.stderr || `Failed to update "${targetBranch}"` }, removedWorktreePath: null };
+    }
+    const shortResult = await executeGitCommand(['rev-parse', '--short', tip.sha], cwd);
+    const mainPath = await resolveMainWorktreePath(cwd);
+    const { warnings, removedWorktreePath } = await cleanupAfterMerge(mainPath, sourceBranch, targetBranch, strategy, !!deleteWorktree, !!deleteBranch);
+    const data = { success: true, mergeCommit: shortResult.stdout.trim() };
+    if (warnings.length > 0)
+        data.warnings = warnings;
+    return { data, removedWorktreePath };
+}
+export async function abortMerge({ cwd, targetWorktreePath }) {
+    const path = targetWorktreePath || (await resolveMainWorktreePath(cwd));
+    const result = await executeGitCommand(['merge', '--abort'], path);
+    if (result.exitCode !== 0) {
+        return gitFail(result.stderr || 'Failed to abort merge');
+    }
+    return gitOk(null);
+}
+export async function completeMerge({ cwd, targetWorktreePath }) {
+    const path = targetWorktreePath || (await resolveMainWorktreePath(cwd));
+    const result = await executeGitCommand(['commit', '--no-edit'], path);
+    if (result.exitCode !== 0) {
+        return gitFail(result.stderr || 'Failed to complete merge');
+    }
+    const hashResult = await executeGitCommand(['rev-parse', '--short', 'HEAD'], path);
+    return gitOk({ mergeCommit: hashResult.stdout.trim() });
+}
+export async function discardMergeBlockers({ cwd, paths }) {
+    const checkoutResult = await executeGitCommand(['checkout', 'HEAD', '--', ...paths], cwd);
+    const cleanResult = await executeGitCommand(['clean', '-f', '--', ...paths], cwd);
+    if (checkoutResult.exitCode !== 0 && cleanResult.exitCode !== 0) {
+        return gitFail(checkoutResult.stderr || cleanResult.stderr || 'Failed to discard changes');
+    }
+    return gitOk({ paths });
+}