Merge branch 'claudedo/9e3071992eca4eb79057d2c675cc57ca'

2026-08-05 12:05:18 +02:00
parent 32c019bd5d 10e561f336
commit 3e7126b3f2
16 changed files with 1813 additions and 14 deletions
@@ -626,6 +626,39 @@ public sealed class ExternalMcpServiceTests : IDisposable
        Assert.False(info.IsDirty);
    }

+    [Fact]
+    public async Task GetTaskWorktree_BeforeMerge_MergeCommitIsNull()
+    {
+        if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
+
+        var (task, _, _) = await SeedWorktreeAsync();
+        var sut = BuildSut(CreateQueue());
+
+        var info = await sut.GetTaskWorktree(task.Id, CancellationToken.None);
+
+        Assert.Null(info.MergeCommit);
+    }
+
+    [Fact]
+    public async Task GetTaskWorktree_AfterMerge_ExposesMergeCommit()
+    {
+        if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
+
+        var (task, list, wt) = await SeedWorktreeAsync(TaskStatus.Done);
+        File.WriteAllText(Path.Combine(wt.WorktreePath, "added.txt"), "new\n");
+        GitRepoFixture.RunGit(wt.WorktreePath, "add", "-A");
+        GitRepoFixture.RunGit(wt.WorktreePath, "commit", "-m", "feat: add file");
+
+        var target = await new GitService().GetCurrentBranchAsync(list.WorkingDir!, CancellationToken.None);
+        var sut = BuildSut(CreateQueue());
+        await sut.MergeTask(task.Id, target, true, false, false, cancellationToken: CancellationToken.None);
+
+        var info = await sut.GetTaskWorktree(task.Id, CancellationToken.None);
+
+        var expected = GitRepoFixture.RunGit(list.WorkingDir!, "rev-parse", "HEAD").Trim();
+        Assert.Equal(expected, info.MergeCommit);
+    }
+
    // ── GetTaskDiff ────────────────────────────────────────────────────────────

    [Fact]
@@ -1138,6 +1171,78 @@ public sealed class ExternalMcpServiceTests : IDisposable
        Assert.Contains("mid-merge", ex.Message);
    }

+    // ── RevertMerge ────────────────────────────────────────────────────────────
+
+    [Fact]
+    public async Task RevertMerge_NotMerged_Throws()
+    {
+        if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
+
+        var (task, _, _) = await SeedWorktreeAsync(TaskStatus.Done);
+        var sut = BuildSut(CreateQueue());
+
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(
+            () => sut.RevertMerge(task.Id, "main", CancellationToken.None));
+        Assert.Contains("expected Merged", ex.Message);
+    }
+
+    [Fact]
+    public async Task RevertMerge_AfterCleanMerge_RevertsAndReturnsTaskToWaitingForReview()
+    {
+        if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
+
+        var (task, list, wt) = await SeedWorktreeAsync(TaskStatus.Done);
+        File.WriteAllText(Path.Combine(wt.WorktreePath, "added.txt"), "new\n");
+        GitRepoFixture.RunGit(wt.WorktreePath, "add", "-A");
+        GitRepoFixture.RunGit(wt.WorktreePath, "commit", "-m", "feat: add file");
+
+        var target = await new GitService().GetCurrentBranchAsync(list.WorkingDir!, CancellationToken.None);
+        var sut = BuildSut(CreateQueue());
+        await sut.MergeTask(task.Id, target, true, false, false, cancellationToken: CancellationToken.None);
+        Assert.True(File.Exists(Path.Combine(list.WorkingDir!, "added.txt")));
+
+        var result = await sut.RevertMerge(task.Id, target, CancellationToken.None);
+
+        Assert.True(result.Reverted);
+        Assert.False(string.IsNullOrWhiteSpace(result.RevertCommit));
+        Assert.Empty(result.Conflicts);
+        Assert.False(File.Exists(Path.Combine(list.WorkingDir!, "added.txt")));
+
+        var reloaded = await _tasks.GetByIdAsync(task.Id);
+        Assert.Equal(TaskStatus.WaitingForReview, reloaded!.Status);
+    }
+
+    [Fact]
+    public async Task RevertMerge_ConflictingRevert_ReturnsRevertedFalseWithConflictsAndAbortsCleanly()
+    {
+        if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
+
+        var (task, list, wt) = await SeedWorktreeAsync(TaskStatus.Done);
+        File.WriteAllText(Path.Combine(wt.WorktreePath, "README.md"), "# test repo\nfeature\n");
+        GitRepoFixture.RunGit(wt.WorktreePath, "add", "-A");
+        GitRepoFixture.RunGit(wt.WorktreePath, "commit", "-m", "feat: append feature line");
+
+        var target = await new GitService().GetCurrentBranchAsync(list.WorkingDir!, CancellationToken.None);
+        var sut = BuildSut(CreateQueue());
+        await sut.MergeTask(task.Id, target, true, false, false, cancellationToken: CancellationToken.None);
+
+        // A later commit on main edits the exact line the merge introduced, so the revert conflicts.
+        File.WriteAllText(Path.Combine(list.WorkingDir!, "README.md"), "# test repo\npost-merge edit\n");
+        GitRepoFixture.RunGit(list.WorkingDir!, "add", "-A");
+        GitRepoFixture.RunGit(list.WorkingDir!, "commit", "-m", "chore: edit the same line");
+        var headBefore = GitRepoFixture.RunGit(list.WorkingDir!, "rev-parse", "HEAD").Trim();
+
+        var result = await sut.RevertMerge(task.Id, target, CancellationToken.None);
+
+        Assert.False(result.Reverted);
+        Assert.Contains("README.md", result.Conflicts);
+        Assert.False(await new GitService().IsMidRevertAsync(list.WorkingDir!));
+        Assert.Equal(headBefore, GitRepoFixture.RunGit(list.WorkingDir!, "rev-parse", "HEAD").Trim());
+
+        var reloaded = await _tasks.GetByIdAsync(task.Id);
+        Assert.Equal(TaskStatus.Done, reloaded!.Status);
+    }
+
    [Fact]
    public async Task ContinueMerge_ParentUnitMergeConflict_RoutesToOrchestratorAndCompletes()
    {
@@ -226,4 +226,95 @@ public class GitServiceMergeTests : IDisposable

        await git.MergeAbortAsync(repo.RepoDir);
    }
+
+    [Fact]
+    public async Task IsMidRevertAsync_FreshRepo_ReturnsFalse()
+    {
+        if (!GitRepoFixture.IsGitAvailable()) return;
+        var repo = NewRepo();
+        var git = new GitService();
+
+        Assert.False(await git.IsMidRevertAsync(repo.RepoDir));
+    }
+
+    [Fact]
+    public async Task IsMidRevertAsync_RevertHeadPresent_ReturnsTrue()
+    {
+        if (!GitRepoFixture.IsGitAvailable()) return;
+        var repo = NewRepo();
+        var revertHead = Path.Combine(repo.RepoDir, ".git", "REVERT_HEAD");
+        File.WriteAllText(revertHead, "0000000000000000000000000000000000000000\n");
+
+        var git = new GitService();
+        Assert.True(await git.IsMidRevertAsync(repo.RepoDir));
+    }
+
+    [Fact]
+    public async Task RevertMergeCommitAsync_CleanMerge_ReturnsZero_AndUndoesMergedChange()
+    {
+        if (!GitRepoFixture.IsGitAvailable()) return;
+        var repo = NewRepo();
+
+        GitRepoFixture.RunGit(repo.RepoDir, "checkout", "-b", "feature/revert");
+        File.WriteAllText(Path.Combine(repo.RepoDir, "feature.txt"), "hello\n");
+        GitRepoFixture.RunGit(repo.RepoDir, "add", "-A");
+        GitRepoFixture.RunGit(repo.RepoDir, "commit", "-m", "feat: add feature.txt");
+
+        try { GitRepoFixture.RunGit(repo.RepoDir, "checkout", "main"); }
+        catch { GitRepoFixture.RunGit(repo.RepoDir, "checkout", "master"); }
+
+        var git = new GitService();
+        var (mergeExit, _) = await git.MergeNoFfAsync(repo.RepoDir, "feature/revert", "Merge feature/revert");
+        Assert.Equal(0, mergeExit);
+        var mergeSha = (await git.RevParseHeadAsync(repo.RepoDir)).Trim();
+        Assert.True(File.Exists(Path.Combine(repo.RepoDir, "feature.txt")));
+
+        var (revertExit, _) = await git.RevertMergeCommitAsync(repo.RepoDir, mergeSha);
+
+        Assert.Equal(0, revertExit);
+        Assert.False(File.Exists(Path.Combine(repo.RepoDir, "feature.txt")));
+        Assert.False(await git.IsMidRevertAsync(repo.RepoDir));
+        // History stays intact — both the merge and the new revert commit are reachable.
+        var log = GitRepoFixture.RunGit(repo.RepoDir, "log", "--oneline");
+        Assert.Contains(mergeSha[..7], log);
+    }
+
+    [Fact]
+    public async Task RevertMergeCommitAsync_ConflictingSubsequentEdit_ReturnsNonZero_AndAbortCleansUp()
+    {
+        if (!GitRepoFixture.IsGitAvailable()) return;
+        var repo = NewRepo();
+
+        GitRepoFixture.RunGit(repo.RepoDir, "checkout", "-b", "feature/revert-conflict");
+        File.WriteAllText(Path.Combine(repo.RepoDir, "README.md"), "# test repo\nfeature\n");
+        GitRepoFixture.RunGit(repo.RepoDir, "add", "-A");
+        GitRepoFixture.RunGit(repo.RepoDir, "commit", "-m", "feat: append feature line");
+
+        try { GitRepoFixture.RunGit(repo.RepoDir, "checkout", "main"); }
+        catch { GitRepoFixture.RunGit(repo.RepoDir, "checkout", "master"); }
+
+        var git = new GitService();
+        var (mergeExit, _) = await git.MergeNoFfAsync(repo.RepoDir, "feature/revert-conflict", "Merge feature/revert-conflict");
+        Assert.Equal(0, mergeExit);
+        var mergeSha = (await git.RevParseHeadAsync(repo.RepoDir)).Trim();
+
+        // A direct edit on main to the same line the merge introduced makes the revert conflict.
+        File.WriteAllText(Path.Combine(repo.RepoDir, "README.md"), "# test repo\npost-merge edit\n");
+        GitRepoFixture.RunGit(repo.RepoDir, "add", "-A");
+        GitRepoFixture.RunGit(repo.RepoDir, "commit", "-m", "chore: edit the same line");
+        var headBefore = GitRepoFixture.RunGit(repo.RepoDir, "rev-parse", "HEAD").Trim();
+
+        var (revertExit, _) = await git.RevertMergeCommitAsync(repo.RepoDir, mergeSha);
+
+        Assert.NotEqual(0, revertExit);
+        Assert.True(await git.IsMidRevertAsync(repo.RepoDir));
+        var conflicted = await git.ListConflictedFilesAsync(repo.RepoDir);
+        Assert.Contains("README.md", conflicted);
+
+        await git.RevertAbortAsync(repo.RepoDir);
+
+        Assert.False(await git.IsMidRevertAsync(repo.RepoDir));
+        Assert.Equal(headBefore, GitRepoFixture.RunGit(repo.RepoDir, "rev-parse", "HEAD").Trim());
+        Assert.True(string.IsNullOrWhiteSpace(GitRepoFixture.RunGit(repo.RepoDir, "status", "--porcelain")));
+    }
 }
@@ -54,7 +54,8 @@ public class TaskMergeServiceTests : IDisposable
    }

    private static async Task SeedWorktree(
-        DbFixture db, string taskId, string path, string branchName, string baseCommit)
+        DbFixture db, string taskId, string path, string branchName, string baseCommit,
+        WorktreeState state = WorktreeState.Active, string? mergeCommit = null)
    {
        var wt = new WorktreeEntity
        {
@@ -62,7 +63,8 @@ public class TaskMergeServiceTests : IDisposable
            Path = path,
            BranchName = branchName,
            BaseCommit = baseCommit,
-            State = WorktreeState.Active,
+            State = state,
+            MergeCommit = mergeCommit,
            CreatedAt = DateTime.UtcNow,
        };
        using var ctx = db.CreateContext();
@@ -772,6 +774,214 @@ public class TaskMergeServiceTests : IDisposable
        Assert.Equal("# resolved by user\n", File.ReadAllText(Path.Combine(repo.RepoDir, "README.md")));
        Assert.False(await new GitService().IsMidMergeAsync(repo.RepoDir));
    }
+
+    [Fact]
+    public async Task MergeAsync_Success_RecordsMergeCommitOnWorktree()
+    {
+        if (!GitRepoFixture.IsGitAvailable()) return;
+
+        var repo = NewRepo();
+        var db = NewDb();
+        var (list, task) = await SeedListAndTask(db, workingDir: repo.RepoDir, status: TaskStatus.Done);
+
+        var wtMgr = BuildWorktreeManager(db);
+        var wtCtx = await wtMgr.CreateAsync(task, list, CancellationToken.None);
+        _wtCleanups.Add((repo.RepoDir, wtCtx.WorktreePath));
+        File.WriteAllText(Path.Combine(wtCtx.WorktreePath, "added.txt"), "new\n");
+        await wtMgr.CommitIfChangedAsync(wtCtx, task, list, CancellationToken.None);
+
+        var (svc, _) = BuildService(db);
+        var currentBranch = await new GitService().GetCurrentBranchAsync(repo.RepoDir);
+
+        var result = await svc.MergeAsync(task.Id, currentBranch, removeWorktree: false,
+            commitMessage: "Merge task", ct: CancellationToken.None);
+        Assert.Equal("merged", result.Status);
+
+        var headSha = (await new GitService().RevParseHeadAsync(repo.RepoDir)).Trim();
+
+        using var ctx = db.CreateContext();
+        var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(task.Id);
+        Assert.Equal(headSha, wt!.MergeCommit);
+    }
+
+    [Fact]
+    public async Task RevertMergeAsync_NoWorktree_ReturnsBlocked()
+    {
+        var db = NewDb();
+        var (_, task) = await SeedListAndTask(db, workingDir: "/tmp", status: TaskStatus.Done);
+        var (svc, _) = BuildService(db);
+
+        var result = await svc.RevertMergeAsync(task.Id, "main", CancellationToken.None);
+
+        Assert.Equal(TaskMergeService.StatusBlocked, result.Status);
+        Assert.Contains("no worktree", result.ErrorMessage ?? "");
+    }
+
+    [Fact]
+    public async Task RevertMergeAsync_TaskNotDone_ReturnsBlocked()
+    {
+        var db = NewDb();
+        var (_, task) = await SeedListAndTask(db, workingDir: "/tmp", status: TaskStatus.WaitingForReview);
+        await SeedWorktree(db, task.Id, "/tmp/wt", "claudedo/x", "deadbeef",
+            state: WorktreeState.Merged, mergeCommit: "cafebabe");
+        var (svc, _) = BuildService(db);
+
+        var result = await svc.RevertMergeAsync(task.Id, "main", CancellationToken.None);
+
+        Assert.Equal(TaskMergeService.StatusBlocked, result.Status);
+        Assert.Contains("not Done", result.ErrorMessage ?? "");
+    }
+
+    [Fact]
+    public async Task RevertMergeAsync_NoMergeCommitRecorded_ReturnsBlocked()
+    {
+        // Simulates a worktree merged before this feature existed — Merged state, no SHA.
+        var db = NewDb();
+        var (_, task) = await SeedListAndTask(db, workingDir: "/tmp", status: TaskStatus.Done);
+        await SeedWorktree(db, task.Id, "/tmp/wt", "claudedo/x", "deadbeef",
+            state: WorktreeState.Merged, mergeCommit: null);
+        var (svc, _) = BuildService(db);
+
+        var result = await svc.RevertMergeAsync(task.Id, "main", CancellationToken.None);
+
+        Assert.Equal(TaskMergeService.StatusBlocked, result.Status);
+        Assert.Contains("no merge commit recorded", result.ErrorMessage ?? "");
+    }
+
+    [Fact]
+    public async Task RevertMergeAsync_WorktreeNotMerged_ReturnsBlocked()
+    {
+        var db = NewDb();
+        var (_, task) = await SeedListAndTask(db, workingDir: "/tmp", status: TaskStatus.Done);
+        await SeedWorktree(db, task.Id, "/tmp/wt", "claudedo/x", "deadbeef",
+            state: WorktreeState.Active, mergeCommit: null);
+        var (svc, _) = BuildService(db);
+
+        var result = await svc.RevertMergeAsync(task.Id, "main", CancellationToken.None);
+
+        Assert.Equal(TaskMergeService.StatusBlocked, result.Status);
+        Assert.Contains("expected Merged", result.ErrorMessage ?? "");
+    }
+
+    [Fact]
+    public async Task RevertMergeAsync_AfterCleanMerge_CreatesRevertCommitAndResetsState()
+    {
+        if (!GitRepoFixture.IsGitAvailable()) return;
+
+        var repo = NewRepo();
+        var db = NewDb();
+        var (list, task) = await SeedListAndTask(db, workingDir: repo.RepoDir, status: TaskStatus.Done);
+
+        var wtMgr = BuildWorktreeManager(db);
+        var wtCtx = await wtMgr.CreateAsync(task, list, CancellationToken.None);
+        _wtCleanups.Add((repo.RepoDir, wtCtx.WorktreePath));
+        File.WriteAllText(Path.Combine(wtCtx.WorktreePath, "added.txt"), "new\n");
+        await wtMgr.CommitIfChangedAsync(wtCtx, task, list, CancellationToken.None);
+
+        var (svc, proxy) = BuildService(db);
+        var currentBranch = await new GitService().GetCurrentBranchAsync(repo.RepoDir);
+
+        var mergeResult = await svc.MergeAsync(task.Id, currentBranch, removeWorktree: true,
+            commitMessage: "Merge task", ct: CancellationToken.None);
+        Assert.Equal("merged", mergeResult.Status);
+        Assert.True(File.Exists(Path.Combine(repo.RepoDir, "added.txt")));
+
+        var revertResult = await svc.RevertMergeAsync(task.Id, currentBranch, CancellationToken.None);
+
+        Assert.Equal(TaskMergeService.StatusReverted, revertResult.Status);
+        Assert.False(string.IsNullOrWhiteSpace(revertResult.RevertCommit));
+        Assert.Empty(revertResult.ConflictFiles);
+        Assert.False(File.Exists(Path.Combine(repo.RepoDir, "added.txt")));
+
+        using var ctx = db.CreateContext();
+        var updatedTask = await new TaskRepository(ctx).GetByIdAsync(task.Id);
+        Assert.Equal(TaskStatus.WaitingForReview, updatedTask!.Status);
+        var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(task.Id);
+        Assert.Equal(WorktreeState.Kept, wt!.State);
+
+        Assert.Contains(proxy.Calls, c => c.Method == "WorktreeUpdated" && c.Args[0] is string s && s == task.Id);
+    }
+
+    [Fact]
+    public async Task RevertMergeAsync_UncommittedChangesInTarget_ReturnsBlocked()
+    {
+        if (!GitRepoFixture.IsGitAvailable()) return;
+
+        var repo = NewRepo();
+        var db = NewDb();
+        var (list, task) = await SeedListAndTask(db, workingDir: repo.RepoDir, status: TaskStatus.Done);
+
+        var wtMgr = BuildWorktreeManager(db);
+        var wtCtx = await wtMgr.CreateAsync(task, list, CancellationToken.None);
+        _wtCleanups.Add((repo.RepoDir, wtCtx.WorktreePath));
+        File.WriteAllText(Path.Combine(wtCtx.WorktreePath, "added.txt"), "new\n");
+        await wtMgr.CommitIfChangedAsync(wtCtx, task, list, CancellationToken.None);
+
+        var (svc, _) = BuildService(db);
+        var currentBranch = await new GitService().GetCurrentBranchAsync(repo.RepoDir);
+
+        var mergeResult = await svc.MergeAsync(task.Id, currentBranch, removeWorktree: true,
+            commitMessage: "Merge task", ct: CancellationToken.None);
+        Assert.Equal("merged", mergeResult.Status);
+
+        // A concurrent session leaves an uncommitted, tracked-file change in the shared checkout.
+        File.WriteAllText(Path.Combine(repo.RepoDir, "README.md"), "dirty from another session\n");
+        var headBefore = GitRepoFixture.RunGit(repo.RepoDir, "rev-parse", "HEAD").Trim();
+
+        var revertResult = await svc.RevertMergeAsync(task.Id, currentBranch, CancellationToken.None);
+
+        Assert.Equal(TaskMergeService.StatusBlocked, revertResult.Status);
+        Assert.Contains("uncommitted", revertResult.ErrorMessage ?? "");
+        Assert.Equal(headBefore, GitRepoFixture.RunGit(repo.RepoDir, "rev-parse", "HEAD").Trim());
+
+        using var ctx = db.CreateContext();
+        var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(task.Id);
+        Assert.Equal(WorktreeState.Merged, wt!.State);
+    }
+
+    [Fact]
+    public async Task RevertMergeAsync_ConflictingRevert_AbortsCleanlyAndReportsConflictFiles()
+    {
+        if (!GitRepoFixture.IsGitAvailable()) return;
+
+        var repo = NewRepo();
+        var db = NewDb();
+        var (list, task) = await SeedListAndTask(db, workingDir: repo.RepoDir, status: TaskStatus.Done);
+
+        var wtMgr = BuildWorktreeManager(db);
+        var wtCtx = await wtMgr.CreateAsync(task, list, CancellationToken.None);
+        _wtCleanups.Add((repo.RepoDir, wtCtx.WorktreePath));
+        File.WriteAllText(Path.Combine(wtCtx.WorktreePath, "README.md"), "# test repo\nfeature\n");
+        await wtMgr.CommitIfChangedAsync(wtCtx, task, list, CancellationToken.None);
+
+        var (svc, _) = BuildService(db);
+        var currentBranch = await new GitService().GetCurrentBranchAsync(repo.RepoDir);
+
+        var mergeResult = await svc.MergeAsync(task.Id, currentBranch, removeWorktree: true,
+            commitMessage: "Merge task", ct: CancellationToken.None);
+        Assert.Equal("merged", mergeResult.Status);
+
+        // A later commit on the target edits the exact line the merge introduced, so the revert conflicts.
+        File.WriteAllText(Path.Combine(repo.RepoDir, "README.md"), "# test repo\npost-merge edit\n");
+        GitRepoFixture.RunGit(repo.RepoDir, "add", "-A");
+        GitRepoFixture.RunGit(repo.RepoDir, "commit", "-m", "chore: edit the same line");
+        var headBefore = GitRepoFixture.RunGit(repo.RepoDir, "rev-parse", "HEAD").Trim();
+
+        var revertResult = await svc.RevertMergeAsync(task.Id, currentBranch, CancellationToken.None);
+
+        Assert.Equal(TaskMergeService.StatusConflictAborted, revertResult.Status);
+        Assert.Contains("README.md", revertResult.ConflictFiles);
+        Assert.False(await new GitService().IsMidRevertAsync(repo.RepoDir));
+        Assert.Equal(headBefore, GitRepoFixture.RunGit(repo.RepoDir, "rev-parse", "HEAD").Trim());
+        Assert.True(string.IsNullOrWhiteSpace(GitRepoFixture.RunGit(repo.RepoDir, "status", "--porcelain")));
+
+        // Task/worktree state must not change on a conflicted, aborted revert.
+        using var ctx = db.CreateContext();
+        var updatedTask = await new TaskRepository(ctx).GetByIdAsync(task.Id);
+        Assert.Equal(TaskStatus.Done, updatedTask!.Status);
+        var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(task.Id);
+        Assert.Equal(WorktreeState.Merged, wt!.State);
+    }
 }

 #region Test doubles