refactor(claude-do): merge refactor(worker): move the merge and worktree MCP tools out
ClaudeDo-Task: 1862e160-ffde-4a50-aa03-bb7251f56088
This commit is contained in:
Mika Kuns
+7
-2
@@ -85,8 +85,13 @@ public sealed class BatchMcpTools
|
|||||||
};
|
};
|
||||||
|
|
||||||
private readonly ExternalMcpService _svc;
|
private readonly ExternalMcpService _svc;
|
||||||
|
private readonly WorktreeMcpTools _worktree;
|
||||||
|
|
||||||
public BatchMcpTools(ExternalMcpService svc) => _svc = svc;
|
public BatchMcpTools(ExternalMcpService svc, WorktreeMcpTools worktree)
|
||||||
|
{
|
||||||
|
_svc = svc;
|
||||||
|
_worktree = worktree;
|
||||||
|
}
|
||||||
|
|
||||||
[McpServerTool, Description(
|
[McpServerTool, Description(
|
||||||
"Fetch a snapshot of many tasks in one call — use for an overview or polling a fan-out instead of " +
|
"Fetch a snapshot of many tasks in one call — use for an overview or polling a fan-out instead of " +
|
||||||
@@ -365,7 +370,7 @@ public sealed class BatchMcpTools
|
|||||||
var id = taskIds[i];
|
var id = taskIds[i];
|
||||||
try
|
try
|
||||||
{
|
{
|
||||||
var r = await _svc.CleanupTaskWorktree(id, force, cancellationToken);
|
var r = await _worktree.CleanupTaskWorktree(id, force, cancellationToken);
|
||||||
results.Add(new BatchCleanupResult(id, true, r.Removed, r.BranchDeleted, null, r.Number));
|
results.Add(new BatchCleanupResult(id, true, r.Removed, r.BranchDeleted, null, r.Number));
|
||||||
}
|
}
|
||||||
catch (OperationCanceledException) { throw; }
|
catch (OperationCanceledException) { throw; }
|
||||||
|
|||||||
+6
-865
@@ -102,78 +102,6 @@ public sealed record PossibleDuplicateDto(string TaskId, int Number, string Titl
|
|||||||
public sealed record AddTaskResult(TaskRefDto Task, IReadOnlyList<PossibleDuplicateDto> PossibleDuplicates);
|
public sealed record AddTaskResult(TaskRefDto Task, IReadOnlyList<PossibleDuplicateDto> PossibleDuplicates);
|
||||||
|
|
||||||
|
|
||||||
public sealed record WorktreeInfoDto(
|
|
||||||
string Path, string Branch, string HeadCommit, string BaseCommit,
|
|
||||||
int Ahead, int Behind, bool IsDirty, string? MergeCommit = null);
|
|
||||||
|
|
||||||
public sealed record TaskDiffDto(
|
|
||||||
string Content, IReadOnlyList<string> Files, bool Truncated, int TotalBytes);
|
|
||||||
|
|
||||||
public sealed record MergeTaskResultDto(
|
|
||||||
bool Merged, string? MergeCommit, IReadOnlyList<string> Conflicts,
|
|
||||||
bool ConflictsInTree = false, string? RepoPath = null);
|
|
||||||
|
|
||||||
public sealed record MergeContinuationResultDto(
|
|
||||||
bool Merged, string TaskStatus, IReadOnlyList<string> Conflicts,
|
|
||||||
string? RepoPath, string? Message);
|
|
||||||
|
|
||||||
public sealed record ConflictHunkDto(
|
|
||||||
int Index, int StartLine, string Ours, string? Base, string Theirs);
|
|
||||||
|
|
||||||
public sealed record ConflictFileHunksDto(
|
|
||||||
string Path, bool IsBinary, IReadOnlyList<ConflictHunkDto> Hunks);
|
|
||||||
|
|
||||||
public sealed record GetMergeConflictsResultDto(
|
|
||||||
IReadOnlyList<ConflictFileHunksDto> Files, int RemainingHunks, string ConflictStyleNote = McpToolDocs.Diff3Note);
|
|
||||||
|
|
||||||
public sealed record ResolveConflictHunkResultDto(
|
|
||||||
bool Resolved, int RemainingHunks, string ConflictStyleNote = McpToolDocs.Diff3Note);
|
|
||||||
|
|
||||||
// IsEmpty = the review range contributed nothing (worktree ahead-of-base is empty, or a
|
|
||||||
// worktree-less handler task's HandlerBaseCommit == HandlerHeadCommit) -- distinguishable from
|
|
||||||
// a merge that is merely small, so an empty branch can't be misread as "changedFileCount: 0
|
|
||||||
// means tiny" when it actually means "nothing to review".
|
|
||||||
// VerifyExitCode/VerifyDurationMs/VerifyOutputTail are null unless a verify run was attempted
|
|
||||||
// (see PreviewMerge/PreviewMergeSet descriptions) -- 0 exit means the merge-tree result built/
|
|
||||||
// tested clean; a non-zero or -1 (timeout/failed to start) exit means it doesn't, with the tail
|
|
||||||
// of its output in VerifyOutputTail.
|
|
||||||
public sealed record MergePreviewToolDto(
|
|
||||||
string Status, IReadOnlyList<string> ConflictFiles, int ChangedFileCount, int Behind, bool IsEmpty = false,
|
|
||||||
int? VerifyExitCode = null, long? VerifyDurationMs = null, string? VerifyOutputTail = null,
|
|
||||||
// Files this branch touches that the target branch ALSO touched since the branch's fork
|
|
||||||
// point -- an honest staleness signal `behind` alone can't give (a branch can be far behind
|
|
||||||
// yet touch nothing the target changed, or close behind yet collide on the one file that
|
|
||||||
// matters). Empty for a worktree-less handler task, which commits straight onto the list's
|
|
||||||
// working dir and has no fork point to compare against.
|
|
||||||
IReadOnlyList<string>? StaleFiles = null);
|
|
||||||
|
|
||||||
public sealed record MergePreviewSetEntryDto(
|
|
||||||
string TaskId, string Status, IReadOnlyList<string> ConflictFiles, int ChangedFileCount, int Behind, string? Error, bool IsEmpty = false,
|
|
||||||
int? VerifyExitCode = null, long? VerifyDurationMs = null, string? VerifyOutputTail = null,
|
|
||||||
IReadOnlyList<string>? StaleFiles = null, int? Number = null);
|
|
||||||
|
|
||||||
public sealed record FileOverlapDto(string File, IReadOnlyList<string> TaskIds, IReadOnlyList<int> Numbers);
|
|
||||||
|
|
||||||
// TaskId's changed-file list is a non-empty PROPER subset of SupersetTaskId's -- e.g. one task
|
|
||||||
// deletes two files and another deletes just one of those same two. Stronger than an Overlaps
|
|
||||||
// entry (which only says some files are shared): a real subset is the best available machine
|
|
||||||
// signal that TaskId's work may already be entirely covered by SupersetTaskId.
|
|
||||||
public sealed record SubsetRelationDto(string TaskId, int Number, string SupersetTaskId, int SupersetNumber);
|
|
||||||
|
|
||||||
public sealed record MergePreviewSetResultDto(
|
|
||||||
IReadOnlyList<MergePreviewSetEntryDto> Tasks, IReadOnlyList<FileOverlapDto> Overlaps,
|
|
||||||
IReadOnlyList<SubsetRelationDto> Subsets);
|
|
||||||
|
|
||||||
public sealed record WorktreeListItemDto(
|
|
||||||
string? TaskId, int? Number, string Path, string Branch,
|
|
||||||
string HeadCommit, bool IsDirty, bool MergedIntoMain);
|
|
||||||
|
|
||||||
public sealed record CleanupWorktreeResult(
|
|
||||||
bool Removed, string WorktreePath, bool BranchDeleted, int? Number = null);
|
|
||||||
|
|
||||||
public sealed record RevertMergeResultDto(
|
|
||||||
bool Reverted, string? RevertCommit, IReadOnlyList<string> Conflicts, string? Message);
|
|
||||||
|
|
||||||
public sealed record DailyPrepCandidateDto(
|
public sealed record DailyPrepCandidateDto(
|
||||||
string Id, int Number, string ListId, string ListName, string Title, string? Description,
|
string Id, int Number, string ListId, string ListName, string Title, string? Description,
|
||||||
bool IsStarred, DateTime? ScheduledFor, DateTime CreatedAt);
|
bool IsStarred, DateTime? ScheduledFor, DateTime CreatedAt);
|
||||||
@@ -199,7 +127,6 @@ public sealed class ExternalMcpService
|
|||||||
private readonly ITaskStateService _state;
|
private readonly ITaskStateService _state;
|
||||||
private readonly GitService _git;
|
private readonly GitService _git;
|
||||||
private readonly IDbContextFactory<ClaudeDoDbContext> _dbFactory;
|
private readonly IDbContextFactory<ClaudeDoDbContext> _dbFactory;
|
||||||
private readonly WorktreeMaintenanceService _maintenance;
|
|
||||||
private readonly TaskMergeService _merge;
|
private readonly TaskMergeService _merge;
|
||||||
private readonly PlanningMergeOrchestrator _planningMerge;
|
private readonly PlanningMergeOrchestrator _planningMerge;
|
||||||
private readonly BaseDirtyChecker _baseDirtyChecker;
|
private readonly BaseDirtyChecker _baseDirtyChecker;
|
||||||
@@ -212,7 +139,6 @@ public sealed class ExternalMcpService
|
|||||||
ITaskStateService state,
|
ITaskStateService state,
|
||||||
GitService git,
|
GitService git,
|
||||||
IDbContextFactory<ClaudeDoDbContext> dbFactory,
|
IDbContextFactory<ClaudeDoDbContext> dbFactory,
|
||||||
WorktreeMaintenanceService maintenance,
|
|
||||||
TaskMergeService merge,
|
TaskMergeService merge,
|
||||||
PlanningMergeOrchestrator planningMerge,
|
PlanningMergeOrchestrator planningMerge,
|
||||||
BaseDirtyChecker baseDirtyChecker)
|
BaseDirtyChecker baseDirtyChecker)
|
||||||
@@ -224,7 +150,6 @@ public sealed class ExternalMcpService
|
|||||||
_state = state;
|
_state = state;
|
||||||
_git = git;
|
_git = git;
|
||||||
_dbFactory = dbFactory;
|
_dbFactory = dbFactory;
|
||||||
_maintenance = maintenance;
|
|
||||||
_merge = merge;
|
_merge = merge;
|
||||||
_planningMerge = planningMerge;
|
_planningMerge = planningMerge;
|
||||||
_baseDirtyChecker = baseDirtyChecker;
|
_baseDirtyChecker = baseDirtyChecker;
|
||||||
@@ -912,732 +837,6 @@ public sealed class ExternalMcpService
|
|||||||
return new DeleteTaskResult(true, taskId, task.Number);
|
return new DeleteTaskResult(true, taskId, task.Number);
|
||||||
}
|
}
|
||||||
|
|
||||||
// ── Worktree / git tools ──────────────────────────────────────────────────
|
|
||||||
|
|
||||||
[McpServerTool, Description(
|
|
||||||
"Get a task's git worktree state — path, branch, base/head commit, ahead/behind counts, isDirty, and the " +
|
|
||||||
"mergeCommit its branch produced once merged. behind is 0 when the 'main' ref is unreachable, so do not " +
|
|
||||||
"read 0 as \"up to date\" without checking. A null mergeCommit means revert_merge cannot act on this task. " +
|
|
||||||
"Throws if the task or its worktree does not exist.")]
|
|
||||||
public async Task<WorktreeInfoDto> GetTaskWorktree(string taskId, CancellationToken cancellationToken)
|
|
||||||
{
|
|
||||||
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
|
||||||
var (_, _, wt) = await LoadWorktreeContextAsync(taskId, cancellationToken);
|
|
||||||
|
|
||||||
var headCommit = !string.IsNullOrWhiteSpace(wt.HeadCommit)
|
|
||||||
? wt.HeadCommit
|
|
||||||
: await TryRunGitAsync(wt.Path, ["rev-parse", "HEAD"], cancellationToken) ?? wt.BaseCommit;
|
|
||||||
|
|
||||||
var isDirty = Directory.Exists(wt.Path) && await _git.HasChangesAsync(wt.Path, cancellationToken);
|
|
||||||
var ahead = await GitRevListCountAsync(wt.Path, $"{wt.BaseCommit}..HEAD", cancellationToken);
|
|
||||||
var behind = await GitRevListCountAsync(wt.Path, "HEAD..main", cancellationToken);
|
|
||||||
|
|
||||||
return new WorktreeInfoDto(wt.Path, wt.BranchName, headCommit!, wt.BaseCommit, ahead, behind, isDirty, wt.MergeCommit);
|
|
||||||
}
|
|
||||||
|
|
||||||
[McpServerTool, Description(
|
|
||||||
"Read what a task actually changed — the diff of its worktree against its base commit (for a worktree-less " +
|
|
||||||
"list-handler host task, the fixed HandlerBaseCommit..HandlerHeadCommit range over the list's working dir " +
|
|
||||||
"instead). files lists the changed paths in either mode; truncated=true means the diff was capped and " +
|
|
||||||
"totalBytes holds its real size. Throws if the task has no worktree/review range, or the relevant " +
|
|
||||||
"directory is missing from disk.")]
|
|
||||||
public async Task<TaskDiffDto> GetTaskDiff(
|
|
||||||
string taskId,
|
|
||||||
[Description("false (default): the full unified diff, capped at 200 KB. true: a --stat summary with " +
|
|
||||||
"per-file insertion/deletion counts — start here when the diff may be large.")]
|
|
||||||
bool stat = false,
|
|
||||||
[Description("Restrict the diff to these paths (relative to the repo root), e.g. after a --stat pass or a " +
|
|
||||||
"conflict report already narrowed down which files matter. Omit/empty for every changed file " +
|
|
||||||
"— the default and the only prior behavior. Works in both stat and full-diff mode.")]
|
|
||||||
IReadOnlyList<string>? paths = null,
|
|
||||||
CancellationToken cancellationToken = default,
|
|
||||||
IProgress<ProgressNotificationValue>? progress = null)
|
|
||||||
{
|
|
||||||
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
|
||||||
var (repoPath, baseCommit, headCommit) = await LoadDiffRangeAsync(taskId, cancellationToken);
|
|
||||||
|
|
||||||
const int maxBytes = 200 * 1024;
|
|
||||||
|
|
||||||
if (stat)
|
|
||||||
{
|
|
||||||
var diffStat = await ProgressReporter.RunAsync(
|
|
||||||
_git.DiffStatAsync(repoPath, baseCommit, headCommit ?? "HEAD", paths, cancellationToken),
|
|
||||||
ProgressReportInterval, progress, "computing diff stat");
|
|
||||||
return new TaskDiffDto(diffStat, ParseDiffStatFileNames(diffStat), false, diffStat.Length);
|
|
||||||
}
|
|
||||||
|
|
||||||
var diff = headCommit is null
|
|
||||||
? await ProgressReporter.RunAsync(
|
|
||||||
_git.GetBranchDiffAsync(repoPath, baseCommit, paths, cancellationToken), ProgressReportInterval, progress, "computing diff")
|
|
||||||
: await ProgressReporter.RunAsync(
|
|
||||||
_git.GetCommitRangeDiffAsync(repoPath, baseCommit, headCommit, paths, cancellationToken), ProgressReportInterval, progress, "computing diff");
|
|
||||||
var files = ParseDiffFileNames(diff);
|
|
||||||
|
|
||||||
if (diff.Length <= maxBytes)
|
|
||||||
return new TaskDiffDto(diff, files, false, diff.Length);
|
|
||||||
|
|
||||||
return new TaskDiffDto(diff[..maxBytes], files, true, diff.Length);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Resolves where a task's diff lives: a live worktree (repo path = worktree path, diffed
|
|
||||||
// against HEAD) or, for a worktree-less list-handler host task, the fixed
|
|
||||||
// HandlerBaseCommit..HandlerHeadCommit range over the list's working dir (headCommit
|
|
||||||
// non-null signals "fixed range" to the caller instead of "diff against live HEAD").
|
|
||||||
private async Task<(string RepoPath, string BaseCommit, string? HeadCommit)> LoadDiffRangeAsync(
|
|
||||||
string taskId, CancellationToken ct)
|
|
||||||
{
|
|
||||||
using var ctx = _dbFactory.CreateDbContext();
|
|
||||||
var task = await new TaskRepository(ctx).GetByIdAsync(taskId, ct)
|
|
||||||
?? throw new InvalidOperationException($"Task {taskId} not found.");
|
|
||||||
var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(taskId, ct);
|
|
||||||
|
|
||||||
if (wt is not null)
|
|
||||||
{
|
|
||||||
if (!Directory.Exists(wt.Path))
|
|
||||||
throw new InvalidOperationException($"Worktree directory does not exist on disk: {wt.Path}");
|
|
||||||
return (wt.Path, wt.BaseCommit, null);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (task.HandlerBaseCommit is { Length: > 0 } handlerBase && task.HandlerHeadCommit is { Length: > 0 } handlerHead)
|
|
||||||
{
|
|
||||||
var list = await new ListRepository(ctx).GetByIdAsync(task.ListId, ct)
|
|
||||||
?? throw new InvalidOperationException("List not found.");
|
|
||||||
if (string.IsNullOrEmpty(list.WorkingDir) || !Directory.Exists(list.WorkingDir))
|
|
||||||
throw new InvalidOperationException("The list's working directory no longer exists.");
|
|
||||||
return (list.WorkingDir, handlerBase, handlerHead);
|
|
||||||
}
|
|
||||||
|
|
||||||
throw new InvalidOperationException($"Task {taskId} has no worktree.");
|
|
||||||
}
|
|
||||||
|
|
||||||
[McpServerTool, Description(
|
|
||||||
"Merge a Done task's worktree branch into targetBranch. For a task still in WaitingForReview prefer " +
|
|
||||||
"review_task, which merges as part of approving. merged=true carries the new mergeCommit SHA; on conflict " +
|
|
||||||
"merged=false and conflicts lists the affected files." + McpToolDocs.ProgressHint)]
|
|
||||||
public async Task<MergeTaskResultDto> MergeTask(
|
|
||||||
string taskId,
|
|
||||||
string targetBranch = "main",
|
|
||||||
[Description("true (default): always create a merge commit (--no-ff).")]
|
|
||||||
bool noFf = true,
|
|
||||||
[Description("true: validate preconditions only and do not merge — merged=false then means \"not attempted\".")]
|
|
||||||
bool dryRun = false,
|
|
||||||
[Description("true: also allow merging a task in WaitingForReview; false (default) allows Done only.")]
|
|
||||||
bool allowWaitingForReview = false,
|
|
||||||
[Description("What to do on conflict. false (default): abort cleanly, leaving no half-merged state. true: " +
|
|
||||||
"leave the conflict markers in the working tree at repoPath (conflictsInTree=true) so you can " +
|
|
||||||
"resolve them there and call continue_merge, or abort_merge to cancel.")]
|
|
||||||
bool leaveConflictsInTree = false,
|
|
||||||
[Description("Batch mode: defer the list's verify command instead of running it after this one merge " +
|
|
||||||
"(see review_task's skipVerify). Call verify_merges once after the batch.")]
|
|
||||||
bool skipVerify = false,
|
|
||||||
CancellationToken cancellationToken = default,
|
|
||||||
IProgress<ProgressNotificationValue>? progress = null)
|
|
||||||
{
|
|
||||||
progress?.Report(new ProgressNotificationValue { Progress = 0, Message = "merge_task started" });
|
|
||||||
|
|
||||||
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
|
||||||
var task = await _tasks.GetByIdAsync(taskId, cancellationToken)
|
|
||||||
?? throw new InvalidOperationException($"Task {taskId} not found.");
|
|
||||||
var canMerge = task.Status == TaskStatus.Done ||
|
|
||||||
(allowWaitingForReview && task.Status == TaskStatus.WaitingForReview);
|
|
||||||
if (!canMerge)
|
|
||||||
throw new InvalidOperationException(
|
|
||||||
$"Task must be Done to merge (current status: {task.Status}). " +
|
|
||||||
"Pass allowWaitingForReview=true to also merge a WaitingForReview task.");
|
|
||||||
|
|
||||||
var list = await _lists.GetByIdAsync(task.ListId, cancellationToken);
|
|
||||||
|
|
||||||
if (dryRun)
|
|
||||||
{
|
|
||||||
using var ctx = _dbFactory.CreateDbContext();
|
|
||||||
var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(taskId, cancellationToken)
|
|
||||||
?? throw new InvalidOperationException($"Task {taskId} has no worktree.");
|
|
||||||
if (wt.State != WorktreeState.Active)
|
|
||||||
throw new InvalidOperationException(
|
|
||||||
$"Worktree state must be Active to merge (current: {wt.State}).");
|
|
||||||
return new MergeTaskResultDto(false, null, []);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Blank on purpose: TaskMergeService builds the conventional default message.
|
|
||||||
var result = await _merge.MergeAsync(
|
|
||||||
taskId, targetBranch, removeWorktree: false, commitMessage: "", leaveConflictsInTree, cancellationToken, progress, skipVerify);
|
|
||||||
|
|
||||||
// merged_verify_pending: the branch IS merged (that's what this tool reports on) — only
|
|
||||||
// the task's own Done transition is deferred to verify_merges.
|
|
||||||
if (result.Status is TaskMergeService.StatusMerged or TaskMergeService.StatusMergedVerifyPending)
|
|
||||||
{
|
|
||||||
string? mergeCommit = null;
|
|
||||||
try
|
|
||||||
{
|
|
||||||
if (!string.IsNullOrWhiteSpace(list?.WorkingDir) && Directory.Exists(list.WorkingDir))
|
|
||||||
mergeCommit = await _git.RevParseHeadAsync(list.WorkingDir, cancellationToken);
|
|
||||||
}
|
|
||||||
catch { /* mergeCommit is optional */ }
|
|
||||||
return new MergeTaskResultDto(true, mergeCommit, []);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (result.Status == TaskMergeService.StatusConflict)
|
|
||||||
return leaveConflictsInTree
|
|
||||||
? new MergeTaskResultDto(false, null, result.ConflictFiles,
|
|
||||||
ConflictsInTree: true, RepoPath: list?.WorkingDir)
|
|
||||||
: new MergeTaskResultDto(false, null, result.ConflictFiles);
|
|
||||||
|
|
||||||
throw new InvalidOperationException(result.ErrorMessage ?? $"Merge blocked: {result.Status}");
|
|
||||||
}
|
|
||||||
|
|
||||||
[McpServerTool, Description(
|
|
||||||
"Finish an in-progress conflicted merge once you have resolved the conflict markers in the working tree " +
|
|
||||||
"(repoPath from merge_task/review_task). Pass the PARENT task id to continue a parent/children unit merge. " +
|
|
||||||
"merged=false with conflicts listed means markers are still present — resolve them and call again. " +
|
|
||||||
"Throws if there is no in-progress merge for the task; use abort_merge to cancel a paused merge instead." +
|
|
||||||
McpToolDocs.ProgressHint)]
|
|
||||||
public async Task<MergeContinuationResultDto> ContinueMerge(
|
|
||||||
string taskId,
|
|
||||||
[Description("Batch mode: defer the list's verify command (see review_task's skipVerify). Pass the same " +
|
|
||||||
"value you approved with — a unit merge remembers its own flag and ignores this one.")]
|
|
||||||
bool skipVerify = false,
|
|
||||||
CancellationToken cancellationToken = default,
|
|
||||||
IProgress<ProgressNotificationValue>? progress = null)
|
|
||||||
{
|
|
||||||
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
|
||||||
var task = await _tasks.GetByIdAsync(taskId, cancellationToken)
|
|
||||||
?? throw new InvalidOperationException($"Task {taskId} not found.");
|
|
||||||
var list = await _lists.GetByIdAsync(task.ListId, cancellationToken);
|
|
||||||
var workingDir = list?.WorkingDir;
|
|
||||||
|
|
||||||
bool merged;
|
|
||||||
IReadOnlyList<string> conflicts = Array.Empty<string>();
|
|
||||||
string? repoPath = null;
|
|
||||||
string? message = null;
|
|
||||||
|
|
||||||
if (_planningMerge.HasActiveMerge(taskId))
|
|
||||||
{
|
|
||||||
var unitResult = await _planningMerge.ContinueAsync(taskId, cancellationToken, progress);
|
|
||||||
var parent = (await _tasks.GetByIdAsync(taskId, cancellationToken))!;
|
|
||||||
if (unitResult.Status == TaskMergeService.StatusMergedVerifyPending)
|
|
||||||
{
|
|
||||||
merged = true;
|
|
||||||
message = "unit merged; verify deferred — the parent stays WaitingForReview until " +
|
|
||||||
"verify_merges (with this parent's id) passes";
|
|
||||||
}
|
|
||||||
else if (parent.Status == TaskStatus.Done)
|
|
||||||
{
|
|
||||||
merged = true;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
var remaining = !string.IsNullOrWhiteSpace(workingDir)
|
|
||||||
? await _git.ListConflictedFilesAsync(workingDir, cancellationToken)
|
|
||||||
: new List<string>();
|
|
||||||
merged = false;
|
|
||||||
if (remaining.Count > 0)
|
|
||||||
{
|
|
||||||
conflicts = remaining;
|
|
||||||
repoPath = workingDir;
|
|
||||||
message = "conflicts remain — resolve and call continue_merge again";
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
message = "unit merge did not complete — the orchestrator aborted or was blocked; " +
|
|
||||||
"check the parent task and approve again to restart the merge";
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
var r = await _merge.ContinueMergeAsync(taskId, cancellationToken, progress, skipVerify);
|
|
||||||
if (r.Status == TaskMergeService.StatusMerged)
|
|
||||||
{
|
|
||||||
merged = true;
|
|
||||||
}
|
|
||||||
else if (r.Status == TaskMergeService.StatusMergedVerifyPending)
|
|
||||||
{
|
|
||||||
merged = true;
|
|
||||||
message = "merged; verify deferred — the task stays WaitingForReview until " +
|
|
||||||
"verify_merges (with its id) passes";
|
|
||||||
}
|
|
||||||
else if (r.Status == TaskMergeService.StatusConflict)
|
|
||||||
{
|
|
||||||
merged = false;
|
|
||||||
conflicts = r.ConflictFiles;
|
|
||||||
repoPath = workingDir;
|
|
||||||
message = r.ErrorMessage;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
throw new InvalidOperationException(r.ErrorMessage ?? "continue failed");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
var reloaded = (await _tasks.GetByIdAsync(taskId, cancellationToken))!;
|
|
||||||
await _broadcaster.TaskUpdated(taskId);
|
|
||||||
return new MergeContinuationResultDto(merged, reloaded.Status.ToString(), conflicts, repoPath, message);
|
|
||||||
}
|
|
||||||
|
|
||||||
[McpServerTool, Description(
|
|
||||||
"Run the list's verify command ONCE for a batch of merges made with skipVerify=true, then promote the " +
|
|
||||||
"listed tasks to Done. Call it a single time after the LAST merge of the batch instead of paying the " +
|
|
||||||
"verify per merge. All tasks must belong to the same list; each must be WaitingForReview with its merge " +
|
|
||||||
"already landed (mergeStatus merged_verify_pending). status verify_passed: check each entry's promoted " +
|
|
||||||
"flag (an ineligible task is skipped with a reason, the rest still promote). status verify_failed: the " +
|
|
||||||
"merges stay in place but NO task reaches Done; the command's output tail is in errorMessage — report it, " +
|
|
||||||
"don't fix it yourself. A list without a verify command promotes directly." + McpToolDocs.ProgressHint)]
|
|
||||||
public async Task<ListVerifyResult> VerifyMerges(
|
|
||||||
[Description("Every task merged with skipVerify=true in this batch (accepts #numbers or ids).")]
|
|
||||||
string[] taskIds,
|
|
||||||
CancellationToken cancellationToken = default,
|
|
||||||
IProgress<ProgressNotificationValue>? progress = null)
|
|
||||||
{
|
|
||||||
if (taskIds.Length == 0)
|
|
||||||
throw new InvalidOperationException("taskIds must not be empty.");
|
|
||||||
// Same rationale as review_task's first report: the verify itself reports periodically,
|
|
||||||
// but the wait on the per-repo merge gate before it would otherwise sit silent.
|
|
||||||
progress?.Report(new ProgressNotificationValue { Progress = 0, Message = "verify_merges started" });
|
|
||||||
|
|
||||||
string? listId = null;
|
|
||||||
var resolved = new List<string>(taskIds.Length);
|
|
||||||
foreach (var raw in taskIds)
|
|
||||||
{
|
|
||||||
var id = await TaskIdResolver.ResolveAsync(_tasks, raw, cancellationToken);
|
|
||||||
var task = await _tasks.GetByIdAsync(id, cancellationToken)
|
|
||||||
?? throw new InvalidOperationException($"Task {raw} not found.");
|
|
||||||
listId ??= task.ListId;
|
|
||||||
if (task.ListId != listId)
|
|
||||||
throw new InvalidOperationException(
|
|
||||||
"All tasks must belong to the same list — one verify command gates one repo.");
|
|
||||||
resolved.Add(id);
|
|
||||||
}
|
|
||||||
|
|
||||||
var result = await _merge.RunListVerifyAsync(listId!, resolved, cancellationToken, progress);
|
|
||||||
if (result.Status == TaskMergeService.StatusBlocked)
|
|
||||||
throw new InvalidOperationException(result.ErrorMessage ?? "verify blocked");
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
[McpServerTool, Description(
|
|
||||||
"Abort an in-progress conflicted merge, discarding the conflict markers and restoring a clean working tree. " +
|
|
||||||
"Pass the PARENT task id to abort a parent/children unit merge. The task keeps its pre-merge status " +
|
|
||||||
"(e.g. WaitingForReview). Throws if there is no in-progress merge for the task." + McpToolDocs.LeanTaskRef)]
|
|
||||||
public async Task<TaskRefDto> AbortMerge(string taskId, CancellationToken cancellationToken)
|
|
||||||
{
|
|
||||||
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
|
||||||
_ = await _tasks.GetByIdAsync(taskId, cancellationToken)
|
|
||||||
?? throw new InvalidOperationException($"Task {taskId} not found.");
|
|
||||||
|
|
||||||
if (_planningMerge.HasActiveMerge(taskId))
|
|
||||||
{
|
|
||||||
await _planningMerge.AbortAsync(taskId, cancellationToken);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
var r = await _merge.AbortMergeAsync(taskId, cancellationToken);
|
|
||||||
if (r.Status == TaskMergeService.StatusBlocked)
|
|
||||||
throw new InvalidOperationException(r.ErrorMessage ?? "abort failed");
|
|
||||||
}
|
|
||||||
|
|
||||||
await _broadcaster.TaskUpdated(taskId);
|
|
||||||
return ToRefDto((await _tasks.GetByIdAsync(taskId, cancellationToken))!);
|
|
||||||
}
|
|
||||||
|
|
||||||
[McpServerTool, Description(
|
|
||||||
"List every conflict hunk left in a paused merge (started via merge_task/review_task with " +
|
|
||||||
"leaveConflictsInTree=true), so you can resolve them with resolve_conflict_hunk instead of parsing marker " +
|
|
||||||
"text yourself. Each hunk carries the file's path, its index within that file (what resolve_conflict_hunk " +
|
|
||||||
"expects back), and its startLine. remainingHunks is the total across every file — call continue_merge once " +
|
|
||||||
"it reaches 0, or abort_merge to cancel. Throws if the task has no in-progress merge." + " " + McpToolDocs.Diff3Note)]
|
|
||||||
public async Task<GetMergeConflictsResultDto> GetMergeConflicts(string taskId, CancellationToken cancellationToken = default)
|
|
||||||
{
|
|
||||||
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
|
||||||
_ = await _tasks.GetByIdAsync(taskId, cancellationToken)
|
|
||||||
?? throw new InvalidOperationException($"Task {taskId} not found.");
|
|
||||||
|
|
||||||
var docs = await _merge.GetConflictDocumentsAsync(taskId, cancellationToken);
|
|
||||||
var files = docs.Files.Select(ToConflictFileHunksDto).ToList();
|
|
||||||
var remaining = files.Sum(f => f.Hunks.Count);
|
|
||||||
return new GetMergeConflictsResultDto(files, remaining);
|
|
||||||
}
|
|
||||||
|
|
||||||
[McpServerTool, Description(
|
|
||||||
"Resolve exactly one conflict hunk from get_merge_conflicts, identified by file path and its index within " +
|
|
||||||
"that file. Writes only that hunk — every other hunk (in this file or another) is left exactly as it was, " +
|
|
||||||
"so call get_merge_conflicts again afterward: resolved hunks disappear and every remaining hunk's index " +
|
|
||||||
"shifts down to stay zero-based. This never decides FOR you which side wins — resolution must be 'ours', " +
|
|
||||||
"'theirs', 'base' (only valid when that hunk has a diff3 base), or literal replacement text (used exactly " +
|
|
||||||
"as given, including any trailing newline the surrounding file needs). remainingHunks is the total across " +
|
|
||||||
"every file; call continue_merge once it reaches 0. Throws if the file/index don't match a current hunk." +
|
|
||||||
" " + McpToolDocs.Diff3Note)]
|
|
||||||
public async Task<ResolveConflictHunkResultDto> ResolveConflictHunk(
|
|
||||||
string taskId,
|
|
||||||
[Description("File path exactly as returned by get_merge_conflicts, relative to the repo root.")]
|
|
||||||
string file,
|
|
||||||
[Description("Zero-based hunk index within that file, as returned by get_merge_conflicts.")]
|
|
||||||
int index,
|
|
||||||
[Description("'ours', 'theirs', 'base', or literal text to use for this hunk.")]
|
|
||||||
string resolution,
|
|
||||||
CancellationToken cancellationToken = default)
|
|
||||||
{
|
|
||||||
if (string.IsNullOrEmpty(resolution))
|
|
||||||
throw new InvalidOperationException("resolution is required.");
|
|
||||||
|
|
||||||
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
|
||||||
var docs = await _merge.GetConflictDocumentsAsync(taskId, cancellationToken);
|
|
||||||
var doc = docs.Files.FirstOrDefault(f => string.Equals(f.Path, file, StringComparison.Ordinal))
|
|
||||||
?? throw new InvalidOperationException($"File '{file}' has no conflict for task {taskId}.");
|
|
||||||
if (doc.IsBinary)
|
|
||||||
throw new InvalidOperationException($"File '{file}' is binary; resolve it directly in the working tree.");
|
|
||||||
|
|
||||||
var hunkCount = doc.Segments.Count(s => s.IsConflict);
|
|
||||||
if (index < 0 || index >= hunkCount)
|
|
||||||
throw new InvalidOperationException(
|
|
||||||
$"Hunk index {index} is out of range for '{file}' ({hunkCount} hunk(s) remaining).");
|
|
||||||
|
|
||||||
var counter = -1;
|
|
||||||
var composed = ConflictMarkerParser.Compose(doc.Segments, seg =>
|
|
||||||
{
|
|
||||||
counter++;
|
|
||||||
if (counter != index) return ReconstructConflictMarkers(seg);
|
|
||||||
|
|
||||||
var choice = resolution.Trim().ToLowerInvariant();
|
|
||||||
return choice switch
|
|
||||||
{
|
|
||||||
"ours" => seg.Ours,
|
|
||||||
"theirs" => seg.Theirs,
|
|
||||||
"base" => seg.Base ?? throw new InvalidOperationException(
|
|
||||||
$"Hunk {index} in '{file}' has no diff3 base to resolve to."),
|
|
||||||
_ => resolution,
|
|
||||||
};
|
|
||||||
});
|
|
||||||
|
|
||||||
await _merge.WriteConflictFileAsync(taskId, file, composed, cancellationToken);
|
|
||||||
|
|
||||||
var refreshed = await _merge.GetConflictDocumentsAsync(taskId, cancellationToken);
|
|
||||||
var remaining = refreshed.Files.Sum(f => f.Segments.Count(s => s.IsConflict));
|
|
||||||
return new ResolveConflictHunkResultDto(true, remaining);
|
|
||||||
}
|
|
||||||
|
|
||||||
private static ConflictFileHunksDto ToConflictFileHunksDto(ConflictDocumentContent f)
|
|
||||||
{
|
|
||||||
var hunks = new List<ConflictHunkDto>();
|
|
||||||
foreach (var seg in f.Segments)
|
|
||||||
{
|
|
||||||
if (!seg.IsConflict) continue;
|
|
||||||
hunks.Add(new ConflictHunkDto(hunks.Count, seg.StartLine, seg.Ours, seg.Base, seg.Theirs));
|
|
||||||
}
|
|
||||||
return new ConflictFileHunksDto(f.Path, f.IsBinary, hunks);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Re-renders a still-unresolved hunk as valid (unlabeled) conflict markers so it round-trips through
|
|
||||||
// ConflictMarkerParser.Parse again untouched, and git still refuses continue_merge while it stands. The
|
|
||||||
// original marker labels (e.g. "<<<<<<< HEAD") aren't recoverable from a parsed MergeSegment and aren't
|
|
||||||
// needed for either check -- ConflictMarkerParser.IsMarker and ContinueMergeAsync's rescan only match the
|
|
||||||
// marker prefixes.
|
|
||||||
private static string ReconstructConflictMarkers(MergeSegment seg)
|
|
||||||
{
|
|
||||||
var sb = new StringBuilder();
|
|
||||||
sb.Append("<<<<<<<\n").Append(seg.Ours);
|
|
||||||
if (seg.Base is not null)
|
|
||||||
sb.Append("|||||||\n").Append(seg.Base);
|
|
||||||
sb.Append("=======\n").Append(seg.Theirs);
|
|
||||||
sb.Append(">>>>>>>\n");
|
|
||||||
return sb.ToString();
|
|
||||||
}
|
|
||||||
|
|
||||||
[McpServerTool, Description(
|
|
||||||
"Check whether a task would merge cleanly before touching anything — `git merge-tree --write-tree`, so the " +
|
|
||||||
"working tree, index and HEAD are untouched. status is 'clean', 'conflict' (conflictFiles lists where git " +
|
|
||||||
"would stop), or 'untracked_collision' (conflictFiles lists a path the branch adds that already exists, " +
|
|
||||||
"untracked, in the target working directory — merge-tree can't see the working tree at all, so this is the " +
|
|
||||||
"only way to catch it before a real merge either refuses or, if that path became tracked in the meantime, " +
|
|
||||||
"silently overwrites it); behind counts commits on targetBranch not yet on this branch, which flags a stale " +
|
|
||||||
"branch even when the preview is clean. If the list has a verify command configured, a clean preview is " +
|
|
||||||
"additionally built/tested in a scratch worktree (still without touching the real working tree) — " +
|
|
||||||
"verifyExitCode 0 means it built clean, non-zero or -1 (timeout/failed to start) means it doesn't, with the " +
|
|
||||||
"tail of its output in verifyOutputTail; verifyExitCode stays null when no verify command is configured. " +
|
|
||||||
"isEmpty=true means the task's review range contributed nothing; check that flag rather than reading a " +
|
|
||||||
"small changedFileCount as empty. staleFiles lists files this branch touches that the target branch ALSO " +
|
|
||||||
"changed since this branch's fork point — a more honest staleness signal than `behind` alone, since a " +
|
|
||||||
"branch can be far behind yet touch nothing the target changed, or barely behind yet collide on the one " +
|
|
||||||
"file that matters (always empty for a worktree-less handler task, which has no fork point). Throws if the " +
|
|
||||||
"task has neither an active worktree nor a handler commit range, or the list's working directory is missing " +
|
|
||||||
"from disk." + McpToolDocs.ProgressHint)]
|
|
||||||
public async Task<MergePreviewToolDto> PreviewMerge(
|
|
||||||
string taskId,
|
|
||||||
[Description("Branch to preview against; defaults to the repo's current branch.")]
|
|
||||||
string? targetBranch = null,
|
|
||||||
CancellationToken cancellationToken = default,
|
|
||||||
IProgress<ProgressNotificationValue>? progress = null)
|
|
||||||
{
|
|
||||||
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
|
||||||
var (preview, behind, _, isEmpty, staleFiles, _) = await PreviewMergeCoreAsync(taskId, targetBranch, runVerify: true, cancellationToken, progress);
|
|
||||||
return new MergePreviewToolDto(preview.Status, preview.ConflictFiles, preview.ChangedFileCount, behind, isEmpty,
|
|
||||||
preview.VerifyExitCode, preview.VerifyDurationMs, preview.VerifyOutputTail, staleFiles);
|
|
||||||
}
|
|
||||||
|
|
||||||
[McpServerTool, Description(
|
|
||||||
"Plan a batch merge: preview_merge for several tasks against the same targetBranch, plus a file-overlap " +
|
|
||||||
"check between them. Per entry you get preview_merge's fields, or error instead when that task could not " +
|
|
||||||
"be previewed (it is then left out of the overlap/subset computation). overlaps names, for each file " +
|
|
||||||
"touched by MORE THAN ONE of the given tasks, which tasks touch it — a single taskId always yields no " +
|
|
||||||
"overlaps. subsets flags a stronger relation: TaskId's changed files are a PROPER subset of " +
|
|
||||||
"SupersetTaskId's — the strongest hint you get post-hoc that TaskId may be redundant with SupersetTaskId, " +
|
|
||||||
"worth checking before merging both. IMPORTANT: neither overlap nor subset is a safety guarantee — two " +
|
|
||||||
"tasks touching entirely different files (one deleting a symbol, another still referencing it) can still " +
|
|
||||||
"collide unflagged, and as with preview_merge a clean result does not mean the merge builds. " +
|
|
||||||
"runVerify=false (default) never builds — set it true to also run each task's list's verify command in a " +
|
|
||||||
"scratch worktree per entry (same fields as preview_merge); this can take a long time across many tasks, " +
|
|
||||||
"since builds run one at a time." + McpToolDocs.ProgressHint)]
|
|
||||||
public async Task<MergePreviewSetResultDto> PreviewMergeSet(
|
|
||||||
IReadOnlyList<string> taskIds,
|
|
||||||
[Description("Branch to preview every task against; defaults to the repo's current branch.")]
|
|
||||||
string? targetBranch = null,
|
|
||||||
[Description("true: also run the verify command (if configured) for each task, one build at a time. " +
|
|
||||||
"false (default): no builds, however many tasks are given.")]
|
|
||||||
bool runVerify = false,
|
|
||||||
CancellationToken cancellationToken = default,
|
|
||||||
IProgress<ProgressNotificationValue>? progress = null)
|
|
||||||
{
|
|
||||||
if (taskIds is null || taskIds.Count == 0)
|
|
||||||
throw new InvalidOperationException("taskIds must contain at least one task id.");
|
|
||||||
|
|
||||||
taskIds = await TaskIdResolver.ResolveManyAsync(_tasks, taskIds, cancellationToken);
|
|
||||||
|
|
||||||
var entries = new List<MergePreviewSetEntryDto>();
|
|
||||||
var filesByTask = new Dictionary<string, IReadOnlyList<string>>();
|
|
||||||
var numbersByTask = new Dictionary<string, int>();
|
|
||||||
|
|
||||||
for (var i = 0; i < taskIds.Count; i++)
|
|
||||||
{
|
|
||||||
var taskId = taskIds[i];
|
|
||||||
try
|
|
||||||
{
|
|
||||||
var (preview, behind, changedFiles, isEmpty, staleFiles, number) = await PreviewMergeCoreAsync(taskId, targetBranch, runVerify, cancellationToken, progress);
|
|
||||||
entries.Add(new MergePreviewSetEntryDto(
|
|
||||||
taskId, preview.Status, preview.ConflictFiles, preview.ChangedFileCount, behind, null, isEmpty,
|
|
||||||
preview.VerifyExitCode, preview.VerifyDurationMs, preview.VerifyOutputTail, staleFiles, number));
|
|
||||||
filesByTask[taskId] = changedFiles;
|
|
||||||
numbersByTask[taskId] = number;
|
|
||||||
}
|
|
||||||
catch (InvalidOperationException ex)
|
|
||||||
{
|
|
||||||
var task = await _tasks.GetByIdAsync(taskId, cancellationToken);
|
|
||||||
entries.Add(new MergePreviewSetEntryDto(
|
|
||||||
taskId, TaskMergeService.PreviewUnavailable, Array.Empty<string>(), 0, 0, ex.Message,
|
|
||||||
Number: task?.Number));
|
|
||||||
}
|
|
||||||
|
|
||||||
ProgressReporter.ReportItem(progress, "Previewing merges", i + 1, taskIds.Count);
|
|
||||||
}
|
|
||||||
|
|
||||||
var overlaps = filesByTask
|
|
||||||
.SelectMany(kv => kv.Value.Select(f => (File: f, TaskId: kv.Key)))
|
|
||||||
.GroupBy(x => x.File, StringComparer.OrdinalIgnoreCase)
|
|
||||||
.Where(g => g.Select(x => x.TaskId).Distinct().Count() > 1)
|
|
||||||
.Select(g =>
|
|
||||||
{
|
|
||||||
var ids = g.Select(x => x.TaskId).Distinct().ToList();
|
|
||||||
return new FileOverlapDto(g.Key, ids, ids.Select(id => numbersByTask[id]).ToList());
|
|
||||||
})
|
|
||||||
.OrderBy(o => o.File, StringComparer.OrdinalIgnoreCase)
|
|
||||||
.ToList();
|
|
||||||
|
|
||||||
var subsets = FindSubsetRelations(filesByTask, numbersByTask);
|
|
||||||
|
|
||||||
return new MergePreviewSetResultDto(entries, overlaps, subsets);
|
|
||||||
}
|
|
||||||
|
|
||||||
// A task's changed-file set is flagged only against another task's STRICTLY LARGER set that
|
|
||||||
// contains every one of its files -- an empty set (isEmpty task) never qualifies, since that
|
|
||||||
// case is already surfaced via IsEmpty and would otherwise match every other task trivially.
|
|
||||||
private static List<SubsetRelationDto> FindSubsetRelations(
|
|
||||||
Dictionary<string, IReadOnlyList<string>> filesByTask, Dictionary<string, int> numbersByTask)
|
|
||||||
{
|
|
||||||
var fileSets = filesByTask.ToDictionary(
|
|
||||||
kv => kv.Key,
|
|
||||||
kv => new HashSet<string>(kv.Value, StringComparer.OrdinalIgnoreCase));
|
|
||||||
|
|
||||||
var subsets = new List<SubsetRelationDto>();
|
|
||||||
foreach (var (taskId, fileSet) in fileSets)
|
|
||||||
{
|
|
||||||
if (fileSet.Count == 0) continue;
|
|
||||||
foreach (var (otherTaskId, otherFileSet) in fileSets)
|
|
||||||
{
|
|
||||||
if (otherTaskId == taskId || otherFileSet.Count <= fileSet.Count) continue;
|
|
||||||
if (fileSet.IsSubsetOf(otherFileSet))
|
|
||||||
subsets.Add(new SubsetRelationDto(taskId, numbersByTask[taskId], otherTaskId, numbersByTask[otherTaskId]));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return subsets
|
|
||||||
.OrderBy(s => s.TaskId, StringComparer.OrdinalIgnoreCase)
|
|
||||||
.ThenBy(s => s.SupersetTaskId, StringComparer.OrdinalIgnoreCase)
|
|
||||||
.ToList();
|
|
||||||
}
|
|
||||||
|
|
||||||
// Shared core for PreviewMerge/PreviewMergeSet: throws a clear InvalidOperationException instead of
|
|
||||||
// TaskMergeService.PreviewAsync's silent "unavailable" status, and adds `behind` + the task's own
|
|
||||||
// changed-file list (via diff-stat, not the merge-tree preview) for overlap detection, plus
|
|
||||||
// `isEmpty`. A worktree-less list-handler host task has no branch to merge-tree-preview at all
|
|
||||||
// (its commits already sit on the list's working dir) — falls back to the fixed
|
|
||||||
// HandlerBaseCommit..HandlerHeadCommit range, reporting a synthetic "clean" preview of that
|
|
||||||
// range's own diff-stat instead of throwing "has no worktree".
|
|
||||||
private async Task<(MergePreviewResult Preview, int Behind, IReadOnlyList<string> ChangedFiles, bool IsEmpty, IReadOnlyList<string> StaleFiles, int Number)> PreviewMergeCoreAsync(
|
|
||||||
string taskId, string? targetBranch, bool runVerify, CancellationToken ct,
|
|
||||||
IProgress<ProgressNotificationValue>? progress = null)
|
|
||||||
{
|
|
||||||
using var ctx = _dbFactory.CreateDbContext();
|
|
||||||
var task = await new TaskRepository(ctx).GetByIdAsync(taskId, ct)
|
|
||||||
?? throw new InvalidOperationException($"Task {taskId} not found.");
|
|
||||||
var list = await new ListRepository(ctx).GetByIdAsync(task.ListId, ct)
|
|
||||||
?? throw new InvalidOperationException("List not found.");
|
|
||||||
var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(taskId, ct);
|
|
||||||
|
|
||||||
if (wt is not null)
|
|
||||||
{
|
|
||||||
if (wt.State != WorktreeState.Active)
|
|
||||||
throw new InvalidOperationException(
|
|
||||||
$"Worktree state must be Active to preview a merge (current: {wt.State}).");
|
|
||||||
if (string.IsNullOrWhiteSpace(list.WorkingDir) || !Directory.Exists(list.WorkingDir))
|
|
||||||
throw new InvalidOperationException("The list's working directory no longer exists.");
|
|
||||||
|
|
||||||
var preview = await _merge.PreviewAsync(taskId, targetBranch ?? "", runVerify, ct, progress);
|
|
||||||
if (preview.Status == TaskMergeService.PreviewUnavailable)
|
|
||||||
throw new InvalidOperationException(
|
|
||||||
"Merge preview unavailable for this task (worktree inactive or repo is not a git repository).");
|
|
||||||
|
|
||||||
var target = string.IsNullOrWhiteSpace(targetBranch)
|
|
||||||
? await _git.GetCurrentBranchAsync(list.WorkingDir, ct)
|
|
||||||
: targetBranch;
|
|
||||||
var behind = await GitRevListCountAsync(list.WorkingDir, $"{wt.BranchName}..{target}", ct);
|
|
||||||
|
|
||||||
var changedFiles = Directory.Exists(wt.Path)
|
|
||||||
? ParseDiffStatFileNames(await _git.DiffStatAsync(wt.Path, wt.BaseCommit, "HEAD", ct: ct))
|
|
||||||
: Array.Empty<string>();
|
|
||||||
|
|
||||||
// What the target itself picked up since this branch's fork point, so `behind`
|
|
||||||
// (a commit count) doesn't have to stand in for "does this collide" -- a branch can
|
|
||||||
// be far behind but touch nothing the target changed, or close behind and collide on
|
|
||||||
// the one file that matters.
|
|
||||||
var targetChangedSinceFork = await _git.GetChangedFileNamesAsync(list.WorkingDir, wt.BaseCommit, target, ct);
|
|
||||||
var staleFiles = changedFiles
|
|
||||||
.Intersect(targetChangedSinceFork, StringComparer.OrdinalIgnoreCase)
|
|
||||||
.ToList();
|
|
||||||
|
|
||||||
return (preview, behind, changedFiles, changedFiles.Count == 0, staleFiles, task.Number);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (task.HandlerBaseCommit is { Length: > 0 } handlerBase && task.HandlerHeadCommit is { Length: > 0 } handlerHead)
|
|
||||||
{
|
|
||||||
if (string.IsNullOrWhiteSpace(list.WorkingDir) || !Directory.Exists(list.WorkingDir))
|
|
||||||
throw new InvalidOperationException("The list's working directory no longer exists.");
|
|
||||||
|
|
||||||
var isEmpty = string.Equals(handlerBase, handlerHead, StringComparison.Ordinal);
|
|
||||||
var changedFiles = isEmpty
|
|
||||||
? Array.Empty<string>()
|
|
||||||
: ParseDiffStatFileNames(await _git.DiffStatAsync(list.WorkingDir, handlerBase, handlerHead, ct: ct));
|
|
||||||
|
|
||||||
var preview = new MergePreviewResult(TaskMergeService.PreviewClean, Array.Empty<string>(), changedFiles.Count);
|
|
||||||
// No fork point to diff against: a handler task commits straight onto the list's
|
|
||||||
// working dir instead of a branch, so there is nothing else that could have "changed
|
|
||||||
// in the target since the fork".
|
|
||||||
return (preview, 0, changedFiles, isEmpty, Array.Empty<string>(), task.Number);
|
|
||||||
}
|
|
||||||
|
|
||||||
throw new InvalidOperationException($"Task {taskId} has no worktree.");
|
|
||||||
}
|
|
||||||
|
|
||||||
[McpServerTool, Description(
|
|
||||||
"Undo a merged task by reverting its merge commit — `git revert -m 1`, always a new commit and never a " +
|
|
||||||
"reset/rewrite, since the target working directory is shared with other sessions. Requires the task to be " +
|
|
||||||
"Done with a Merged worktree that has a recorded merge commit (check get_task_worktree's mergeCommit " +
|
|
||||||
"first). On success the task returns to WaitingForReview so it can be reconsidered. On conflict the revert " +
|
|
||||||
"is aborted immediately and conflicts lists the files. Throws if there is no recorded merge commit, the " +
|
|
||||||
"repo is mid-merge/mid-revert, or the target working tree has uncommitted changes from another session.")]
|
|
||||||
public async Task<RevertMergeResultDto> RevertMerge(
|
|
||||||
string taskId,
|
|
||||||
[Description("Branch carrying the merge commit; defaults to main.")]
|
|
||||||
string targetBranch = "main",
|
|
||||||
CancellationToken cancellationToken = default)
|
|
||||||
{
|
|
||||||
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
|
||||||
var result = await _merge.RevertMergeAsync(taskId, targetBranch, cancellationToken);
|
|
||||||
|
|
||||||
if (result.Status == TaskMergeService.StatusReverted)
|
|
||||||
{
|
|
||||||
await _broadcaster.TaskUpdated(taskId);
|
|
||||||
return new RevertMergeResultDto(true, result.RevertCommit, Array.Empty<string>(), null);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (result.Status == TaskMergeService.StatusConflictAborted)
|
|
||||||
return new RevertMergeResultDto(false, null, result.ConflictFiles, result.ErrorMessage);
|
|
||||||
|
|
||||||
throw new InvalidOperationException(result.ErrorMessage ?? $"Revert blocked: {result.Status}");
|
|
||||||
}
|
|
||||||
|
|
||||||
[McpServerTool, Description(
|
|
||||||
"Survey every worktree ClaudeDo tracks — use it to find leftovers to clean up. Only worktrees recorded in " +
|
|
||||||
"the ClaudeDo database appear here, and headCommit is empty when the path is missing from disk." +
|
|
||||||
McpToolDocs.ProgressHint)]
|
|
||||||
public async Task<IReadOnlyList<WorktreeListItemDto>> ListWorktrees(
|
|
||||||
CancellationToken cancellationToken = default,
|
|
||||||
IProgress<ProgressNotificationValue>? progress = null)
|
|
||||||
{
|
|
||||||
var rows = await _maintenance.GetOverviewAsync(null, cancellationToken);
|
|
||||||
// One git status + one rev-parse per row, run concurrently -- with many tracked worktrees
|
|
||||||
// (this tool's whole point is surfacing leftovers nobody cleaned up) that can still take a
|
|
||||||
// while, so this reports on the same elapsed-time cadence as a single long git call rather
|
|
||||||
// than per-row (rows finish out of order under Task.WhenAll, so there's no natural i/n).
|
|
||||||
var results = await ProgressReporter.RunAsync(
|
|
||||||
Task.WhenAll(rows.Select(async row =>
|
|
||||||
{
|
|
||||||
var isDirty = row.PathExistsOnDisk && await TryGetIsDirtyAsync(row.Path, cancellationToken);
|
|
||||||
var headCommit = row.PathExistsOnDisk
|
|
||||||
? (await TryRunGitAsync(row.Path, ["rev-parse", "HEAD"], cancellationToken) ?? "")
|
|
||||||
: "";
|
|
||||||
return new WorktreeListItemDto(
|
|
||||||
row.TaskId, row.TaskNumber, row.Path, row.BranchName, headCommit,
|
|
||||||
isDirty, row.State == WorktreeState.Merged);
|
|
||||||
})),
|
|
||||||
ProgressReportInterval, progress, "surveying worktrees");
|
|
||||||
return results;
|
|
||||||
}
|
|
||||||
|
|
||||||
[McpServerTool, Description(
|
|
||||||
"Remove a task's worktree directory and delete its git branch. branchDeleted reports whether the branch " +
|
|
||||||
"went too." + McpToolDocs.NotWhileRunning)]
|
|
||||||
public async Task<CleanupWorktreeResult> CleanupTaskWorktree(
|
|
||||||
string taskId,
|
|
||||||
[Description("false (default): refuse a worktree with uncommitted changes. true: remove it anyway, losing " +
|
|
||||||
"those changes.")]
|
|
||||||
bool force = false,
|
|
||||||
CancellationToken cancellationToken = default,
|
|
||||||
IProgress<ProgressNotificationValue>? progress = null)
|
|
||||||
{
|
|
||||||
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
|
||||||
|
|
||||||
using var ctx = _dbFactory.CreateDbContext();
|
|
||||||
var task = await new TaskRepository(ctx).GetByIdAsync(taskId, cancellationToken)
|
|
||||||
?? throw new InvalidOperationException($"Task {taskId} not found.");
|
|
||||||
var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(taskId, cancellationToken)
|
|
||||||
?? throw new InvalidOperationException($"Task {taskId} has no worktree.");
|
|
||||||
|
|
||||||
if (task.Status == TaskStatus.Running)
|
|
||||||
throw new InvalidOperationException("Cannot remove worktree of a running task.");
|
|
||||||
|
|
||||||
if (!force && Directory.Exists(wt.Path))
|
|
||||||
{
|
|
||||||
var isDirty = await ProgressReporter.RunAsync(
|
|
||||||
_git.HasChangesAsync(wt.Path, cancellationToken), ProgressReportInterval, progress, "checking worktree for changes");
|
|
||||||
if (isDirty)
|
|
||||||
throw new InvalidOperationException(
|
|
||||||
"Worktree has uncommitted changes. Use force=true to remove anyway (changes will be lost).");
|
|
||||||
}
|
|
||||||
|
|
||||||
var path = wt.Path;
|
|
||||||
var result = await ProgressReporter.RunAsync(
|
|
||||||
_maintenance.ForceRemoveAsync(taskId, cancellationToken), ProgressReportInterval, progress, "removing worktree");
|
|
||||||
return new CleanupWorktreeResult(result.Removed, path, result.BranchDeleted, task.Number);
|
|
||||||
}
|
|
||||||
|
|
||||||
[McpServerTool, Description(
|
[McpServerTool, Description(
|
||||||
"Send a follow-up prompt to a task's existing Claude session instead of starting a fresh run — the agent " +
|
"Send a follow-up prompt to a task's existing Claude session instead of starting a fresh run — the agent " +
|
||||||
"resumes via --resume with the session id from the task's last run, so its prior context is kept. Uses the " +
|
"resumes via --resume with the session id from the task's last run, so its prior context is kept. Uses the " +
|
||||||
@@ -1752,69 +951,10 @@ public sealed class ExternalMcpService
|
|||||||
|
|
||||||
// ── Private helpers ───────────────────────────────────────────────────────
|
// ── Private helpers ───────────────────────────────────────────────────────
|
||||||
|
|
||||||
private async Task<(TaskEntity Task, ListEntity List, WorktreeEntity Wt)> LoadWorktreeContextAsync(
|
// internal: also used by MergeMcpTools/WorktreeMcpTools' diff-stat parsing, which need it via
|
||||||
string taskId, CancellationToken ct)
|
// an ExternalMcpService.ParseDiffStatFileNames(...) call since a private member of one class
|
||||||
{
|
// isn't visible from another, even in the same namespace.
|
||||||
using var ctx = _dbFactory.CreateDbContext();
|
internal static IReadOnlyList<string> ParseDiffStatFileNames(string stat)
|
||||||
var task = await new TaskRepository(ctx).GetByIdAsync(taskId, ct)
|
|
||||||
?? throw new InvalidOperationException($"Task {taskId} not found.");
|
|
||||||
var list = await new ListRepository(ctx).GetByIdAsync(task.ListId, ct)
|
|
||||||
?? throw new InvalidOperationException("List not found.");
|
|
||||||
var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(taskId, ct)
|
|
||||||
?? throw new InvalidOperationException($"Task {taskId} has no worktree.");
|
|
||||||
return (task, list, wt);
|
|
||||||
}
|
|
||||||
|
|
||||||
private async Task<bool> TryGetIsDirtyAsync(string path, CancellationToken ct)
|
|
||||||
{
|
|
||||||
try { return await _git.HasChangesAsync(path, ct); }
|
|
||||||
catch { return false; }
|
|
||||||
}
|
|
||||||
|
|
||||||
// Minimal git runner for operations not covered by GitService (rev-list --count, rev-parse from worktree).
|
|
||||||
private static async Task<string?> TryRunGitAsync(string dir, string[] args, CancellationToken ct)
|
|
||||||
{
|
|
||||||
try
|
|
||||||
{
|
|
||||||
var psi = new ProcessStartInfo("git")
|
|
||||||
{
|
|
||||||
UseShellExecute = false,
|
|
||||||
RedirectStandardOutput = true,
|
|
||||||
CreateNoWindow = true,
|
|
||||||
};
|
|
||||||
psi.ArgumentList.Add("-C");
|
|
||||||
psi.ArgumentList.Add(dir);
|
|
||||||
foreach (var a in args) psi.ArgumentList.Add(a);
|
|
||||||
using var proc = Process.Start(psi)!;
|
|
||||||
await using var _ = ct.Register(() => { try { proc.Kill(entireProcessTree: true); } catch { } });
|
|
||||||
var stdout = await proc.StandardOutput.ReadToEndAsync();
|
|
||||||
await proc.WaitForExitAsync(CancellationToken.None);
|
|
||||||
ct.ThrowIfCancellationRequested();
|
|
||||||
return proc.ExitCode == 0 ? stdout.Trim() : null;
|
|
||||||
}
|
|
||||||
catch (OperationCanceledException) { throw; }
|
|
||||||
catch { return null; }
|
|
||||||
}
|
|
||||||
|
|
||||||
private static async Task<int> GitRevListCountAsync(string dir, string range, CancellationToken ct)
|
|
||||||
{
|
|
||||||
var result = await TryRunGitAsync(dir, ["rev-list", "--count", range], ct);
|
|
||||||
return int.TryParse(result, out var n) ? n : 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
private static IReadOnlyList<string> ParseDiffFileNames(string diff)
|
|
||||||
{
|
|
||||||
var files = new List<string>();
|
|
||||||
foreach (var line in diff.Split('\n'))
|
|
||||||
{
|
|
||||||
var s = line.TrimEnd('\r');
|
|
||||||
if (s.StartsWith("+++ b/", StringComparison.Ordinal))
|
|
||||||
files.Add(s[6..]);
|
|
||||||
}
|
|
||||||
return files;
|
|
||||||
}
|
|
||||||
|
|
||||||
private static IReadOnlyList<string> ParseDiffStatFileNames(string stat)
|
|
||||||
{
|
{
|
||||||
var files = new List<string>();
|
var files = new List<string>();
|
||||||
foreach (var line in stat.Split('\n'))
|
foreach (var line in stat.Split('\n'))
|
||||||
@@ -1848,7 +988,8 @@ public sealed class ExternalMcpService
|
|||||||
blockedReason,
|
blockedReason,
|
||||||
t.IsManual);
|
t.IsManual);
|
||||||
|
|
||||||
private static TaskRefDto ToRefDto(TaskEntity t, bool blocked = false, string? blockedReason = null) => new(
|
// internal: AbortMerge in MergeMcpTools also needs this to build its TaskRefDto result.
|
||||||
|
internal static TaskRefDto ToRefDto(TaskEntity t, bool blocked = false, string? blockedReason = null) => new(
|
||||||
t.Id,
|
t.Id,
|
||||||
t.Number,
|
t.Number,
|
||||||
t.ListId,
|
t.ListId,
|
||||||
|
|||||||
+668
@@ -0,0 +1,668 @@
|
|||||||
|
using System.ComponentModel;
|
||||||
|
using System.Diagnostics;
|
||||||
|
using System.Text;
|
||||||
|
using ClaudeDo.Data;
|
||||||
|
using ClaudeDo.Data.Git;
|
||||||
|
using ClaudeDo.Data.Models;
|
||||||
|
using ClaudeDo.Data.Repositories;
|
||||||
|
using ClaudeDo.Worker.Git;
|
||||||
|
using ClaudeDo.Worker.Hub;
|
||||||
|
using ClaudeDo.Worker.Lifecycle;
|
||||||
|
using ClaudeDo.Worker.Planning;
|
||||||
|
using Microsoft.EntityFrameworkCore;
|
||||||
|
using ModelContextProtocol;
|
||||||
|
using ModelContextProtocol.Server;
|
||||||
|
using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
|
||||||
|
|
||||||
|
namespace ClaudeDo.Worker.External;
|
||||||
|
|
||||||
|
public sealed record MergeTaskResultDto(
|
||||||
|
bool Merged, string? MergeCommit, IReadOnlyList<string> Conflicts,
|
||||||
|
bool ConflictsInTree = false, string? RepoPath = null);
|
||||||
|
|
||||||
|
public sealed record MergeContinuationResultDto(
|
||||||
|
bool Merged, string TaskStatus, IReadOnlyList<string> Conflicts,
|
||||||
|
string? RepoPath, string? Message);
|
||||||
|
|
||||||
|
public sealed record ConflictHunkDto(
|
||||||
|
int Index, int StartLine, string Ours, string? Base, string Theirs);
|
||||||
|
|
||||||
|
public sealed record ConflictFileHunksDto(
|
||||||
|
string Path, bool IsBinary, IReadOnlyList<ConflictHunkDto> Hunks);
|
||||||
|
|
||||||
|
public sealed record GetMergeConflictsResultDto(
|
||||||
|
IReadOnlyList<ConflictFileHunksDto> Files, int RemainingHunks, string ConflictStyleNote = McpToolDocs.Diff3Note);
|
||||||
|
|
||||||
|
public sealed record ResolveConflictHunkResultDto(
|
||||||
|
bool Resolved, int RemainingHunks, string ConflictStyleNote = McpToolDocs.Diff3Note);
|
||||||
|
|
||||||
|
// IsEmpty = the review range contributed nothing (worktree ahead-of-base is empty, or a
|
||||||
|
// worktree-less handler task's HandlerBaseCommit == HandlerHeadCommit) -- distinguishable from
|
||||||
|
// a merge that is merely small, so an empty branch can't be misread as "changedFileCount: 0
|
||||||
|
// means tiny" when it actually means "nothing to review".
|
||||||
|
// VerifyExitCode/VerifyDurationMs/VerifyOutputTail are null unless a verify run was attempted
|
||||||
|
// (see PreviewMerge/PreviewMergeSet descriptions) -- 0 exit means the merge-tree result built/
|
||||||
|
// tested clean; a non-zero or -1 (timeout/failed to start) exit means it doesn't, with the tail
|
||||||
|
// of its output in VerifyOutputTail.
|
||||||
|
public sealed record MergePreviewToolDto(
|
||||||
|
string Status, IReadOnlyList<string> ConflictFiles, int ChangedFileCount, int Behind, bool IsEmpty = false,
|
||||||
|
int? VerifyExitCode = null, long? VerifyDurationMs = null, string? VerifyOutputTail = null,
|
||||||
|
// Files this branch touches that the target branch ALSO touched since the branch's fork
|
||||||
|
// point -- an honest staleness signal `behind` alone can't give (a branch can be far behind
|
||||||
|
// yet touch nothing the target changed, or close behind yet collide on the one file that
|
||||||
|
// matters). Empty for a worktree-less handler task, which commits straight onto the list's
|
||||||
|
// working dir and has no fork point to compare against.
|
||||||
|
IReadOnlyList<string>? StaleFiles = null);
|
||||||
|
|
||||||
|
public sealed record MergePreviewSetEntryDto(
|
||||||
|
string TaskId, string Status, IReadOnlyList<string> ConflictFiles, int ChangedFileCount, int Behind, string? Error, bool IsEmpty = false,
|
||||||
|
int? VerifyExitCode = null, long? VerifyDurationMs = null, string? VerifyOutputTail = null,
|
||||||
|
IReadOnlyList<string>? StaleFiles = null, int? Number = null);
|
||||||
|
|
||||||
|
public sealed record FileOverlapDto(string File, IReadOnlyList<string> TaskIds, IReadOnlyList<int> Numbers);
|
||||||
|
|
||||||
|
// TaskId's changed-file list is a non-empty PROPER subset of SupersetTaskId's -- e.g. one task
|
||||||
|
// deletes two files and another deletes just one of those same two. Stronger than an Overlaps
|
||||||
|
// entry (which only says some files are shared): a real subset is the best available machine
|
||||||
|
// signal that TaskId's work may already be entirely covered by SupersetTaskId.
|
||||||
|
public sealed record SubsetRelationDto(string TaskId, int Number, string SupersetTaskId, int SupersetNumber);
|
||||||
|
|
||||||
|
public sealed record MergePreviewSetResultDto(
|
||||||
|
IReadOnlyList<MergePreviewSetEntryDto> Tasks, IReadOnlyList<FileOverlapDto> Overlaps,
|
||||||
|
IReadOnlyList<SubsetRelationDto> Subsets);
|
||||||
|
|
||||||
|
public sealed record RevertMergeResultDto(
|
||||||
|
bool Reverted, string? RevertCommit, IReadOnlyList<string> Conflicts, string? Message);
|
||||||
|
|
||||||
|
[McpServerToolType]
|
||||||
|
public sealed class MergeMcpTools
|
||||||
|
{
|
||||||
|
private readonly TaskRepository _tasks;
|
||||||
|
private readonly ListRepository _lists;
|
||||||
|
private readonly HubBroadcaster _broadcaster;
|
||||||
|
private readonly GitService _git;
|
||||||
|
private readonly IDbContextFactory<ClaudeDoDbContext> _dbFactory;
|
||||||
|
private readonly TaskMergeService _merge;
|
||||||
|
private readonly PlanningMergeOrchestrator _planningMerge;
|
||||||
|
|
||||||
|
public MergeMcpTools(
|
||||||
|
TaskRepository tasks,
|
||||||
|
ListRepository lists,
|
||||||
|
HubBroadcaster broadcaster,
|
||||||
|
GitService git,
|
||||||
|
IDbContextFactory<ClaudeDoDbContext> dbFactory,
|
||||||
|
TaskMergeService merge,
|
||||||
|
PlanningMergeOrchestrator planningMerge)
|
||||||
|
{
|
||||||
|
_tasks = tasks;
|
||||||
|
_lists = lists;
|
||||||
|
_broadcaster = broadcaster;
|
||||||
|
_git = git;
|
||||||
|
_dbFactory = dbFactory;
|
||||||
|
_merge = merge;
|
||||||
|
_planningMerge = planningMerge;
|
||||||
|
}
|
||||||
|
|
||||||
|
[McpServerTool, Description(
|
||||||
|
"Merge a Done task's worktree branch into targetBranch. For a task still in WaitingForReview prefer " +
|
||||||
|
"review_task, which merges as part of approving. merged=true carries the new mergeCommit SHA; on conflict " +
|
||||||
|
"merged=false and conflicts lists the affected files." + McpToolDocs.ProgressHint)]
|
||||||
|
public async Task<MergeTaskResultDto> MergeTask(
|
||||||
|
string taskId,
|
||||||
|
string targetBranch = "main",
|
||||||
|
[Description("true (default): always create a merge commit (--no-ff).")]
|
||||||
|
bool noFf = true,
|
||||||
|
[Description("true: validate preconditions only and do not merge — merged=false then means \"not attempted\".")]
|
||||||
|
bool dryRun = false,
|
||||||
|
[Description("true: also allow merging a task in WaitingForReview; false (default) allows Done only.")]
|
||||||
|
bool allowWaitingForReview = false,
|
||||||
|
[Description("What to do on conflict. false (default): abort cleanly, leaving no half-merged state. true: " +
|
||||||
|
"leave the conflict markers in the working tree at repoPath (conflictsInTree=true) so you can " +
|
||||||
|
"resolve them there and call continue_merge, or abort_merge to cancel.")]
|
||||||
|
bool leaveConflictsInTree = false,
|
||||||
|
[Description("Batch mode: defer the list's verify command instead of running it after this one merge " +
|
||||||
|
"(see review_task's skipVerify). Call verify_merges once after the batch.")]
|
||||||
|
bool skipVerify = false,
|
||||||
|
CancellationToken cancellationToken = default,
|
||||||
|
IProgress<ProgressNotificationValue>? progress = null)
|
||||||
|
{
|
||||||
|
progress?.Report(new ProgressNotificationValue { Progress = 0, Message = "merge_task started" });
|
||||||
|
|
||||||
|
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
||||||
|
var task = await _tasks.GetByIdAsync(taskId, cancellationToken)
|
||||||
|
?? throw new InvalidOperationException($"Task {taskId} not found.");
|
||||||
|
var canMerge = task.Status == TaskStatus.Done ||
|
||||||
|
(allowWaitingForReview && task.Status == TaskStatus.WaitingForReview);
|
||||||
|
if (!canMerge)
|
||||||
|
throw new InvalidOperationException(
|
||||||
|
$"Task must be Done to merge (current status: {task.Status}). " +
|
||||||
|
"Pass allowWaitingForReview=true to also merge a WaitingForReview task.");
|
||||||
|
|
||||||
|
var list = await _lists.GetByIdAsync(task.ListId, cancellationToken);
|
||||||
|
|
||||||
|
if (dryRun)
|
||||||
|
{
|
||||||
|
using var ctx = _dbFactory.CreateDbContext();
|
||||||
|
var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(taskId, cancellationToken)
|
||||||
|
?? throw new InvalidOperationException($"Task {taskId} has no worktree.");
|
||||||
|
if (wt.State != WorktreeState.Active)
|
||||||
|
throw new InvalidOperationException(
|
||||||
|
$"Worktree state must be Active to merge (current: {wt.State}).");
|
||||||
|
return new MergeTaskResultDto(false, null, []);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Blank on purpose: TaskMergeService builds the conventional default message.
|
||||||
|
var result = await _merge.MergeAsync(
|
||||||
|
taskId, targetBranch, removeWorktree: false, commitMessage: "", leaveConflictsInTree, cancellationToken, progress, skipVerify);
|
||||||
|
|
||||||
|
// merged_verify_pending: the branch IS merged (that's what this tool reports on) — only
|
||||||
|
// the task's own Done transition is deferred to verify_merges.
|
||||||
|
if (result.Status is TaskMergeService.StatusMerged or TaskMergeService.StatusMergedVerifyPending)
|
||||||
|
{
|
||||||
|
string? mergeCommit = null;
|
||||||
|
try
|
||||||
|
{
|
||||||
|
if (!string.IsNullOrWhiteSpace(list?.WorkingDir) && Directory.Exists(list.WorkingDir))
|
||||||
|
mergeCommit = await _git.RevParseHeadAsync(list.WorkingDir, cancellationToken);
|
||||||
|
}
|
||||||
|
catch { /* mergeCommit is optional */ }
|
||||||
|
return new MergeTaskResultDto(true, mergeCommit, []);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (result.Status == TaskMergeService.StatusConflict)
|
||||||
|
return leaveConflictsInTree
|
||||||
|
? new MergeTaskResultDto(false, null, result.ConflictFiles,
|
||||||
|
ConflictsInTree: true, RepoPath: list?.WorkingDir)
|
||||||
|
: new MergeTaskResultDto(false, null, result.ConflictFiles);
|
||||||
|
|
||||||
|
throw new InvalidOperationException(result.ErrorMessage ?? $"Merge blocked: {result.Status}");
|
||||||
|
}
|
||||||
|
|
||||||
|
[McpServerTool, Description(
|
||||||
|
"Finish an in-progress conflicted merge once you have resolved the conflict markers in the working tree " +
|
||||||
|
"(repoPath from merge_task/review_task). Pass the PARENT task id to continue a parent/children unit merge. " +
|
||||||
|
"merged=false with conflicts listed means markers are still present — resolve them and call again. " +
|
||||||
|
"Throws if there is no in-progress merge for the task; use abort_merge to cancel a paused merge instead." +
|
||||||
|
McpToolDocs.ProgressHint)]
|
||||||
|
public async Task<MergeContinuationResultDto> ContinueMerge(
|
||||||
|
string taskId,
|
||||||
|
[Description("Batch mode: defer the list's verify command (see review_task's skipVerify). Pass the same " +
|
||||||
|
"value you approved with — a unit merge remembers its own flag and ignores this one.")]
|
||||||
|
bool skipVerify = false,
|
||||||
|
CancellationToken cancellationToken = default,
|
||||||
|
IProgress<ProgressNotificationValue>? progress = null)
|
||||||
|
{
|
||||||
|
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
||||||
|
var task = await _tasks.GetByIdAsync(taskId, cancellationToken)
|
||||||
|
?? throw new InvalidOperationException($"Task {taskId} not found.");
|
||||||
|
var list = await _lists.GetByIdAsync(task.ListId, cancellationToken);
|
||||||
|
var workingDir = list?.WorkingDir;
|
||||||
|
|
||||||
|
bool merged;
|
||||||
|
IReadOnlyList<string> conflicts = Array.Empty<string>();
|
||||||
|
string? repoPath = null;
|
||||||
|
string? message = null;
|
||||||
|
|
||||||
|
if (_planningMerge.HasActiveMerge(taskId))
|
||||||
|
{
|
||||||
|
var unitResult = await _planningMerge.ContinueAsync(taskId, cancellationToken, progress);
|
||||||
|
var parent = (await _tasks.GetByIdAsync(taskId, cancellationToken))!;
|
||||||
|
if (unitResult.Status == TaskMergeService.StatusMergedVerifyPending)
|
||||||
|
{
|
||||||
|
merged = true;
|
||||||
|
message = "unit merged; verify deferred — the parent stays WaitingForReview until " +
|
||||||
|
"verify_merges (with this parent's id) passes";
|
||||||
|
}
|
||||||
|
else if (parent.Status == TaskStatus.Done)
|
||||||
|
{
|
||||||
|
merged = true;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
var remaining = !string.IsNullOrWhiteSpace(workingDir)
|
||||||
|
? await _git.ListConflictedFilesAsync(workingDir, cancellationToken)
|
||||||
|
: new List<string>();
|
||||||
|
merged = false;
|
||||||
|
if (remaining.Count > 0)
|
||||||
|
{
|
||||||
|
conflicts = remaining;
|
||||||
|
repoPath = workingDir;
|
||||||
|
message = "conflicts remain — resolve and call continue_merge again";
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
message = "unit merge did not complete — the orchestrator aborted or was blocked; " +
|
||||||
|
"check the parent task and approve again to restart the merge";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
var r = await _merge.ContinueMergeAsync(taskId, cancellationToken, progress, skipVerify);
|
||||||
|
if (r.Status == TaskMergeService.StatusMerged)
|
||||||
|
{
|
||||||
|
merged = true;
|
||||||
|
}
|
||||||
|
else if (r.Status == TaskMergeService.StatusMergedVerifyPending)
|
||||||
|
{
|
||||||
|
merged = true;
|
||||||
|
message = "merged; verify deferred — the task stays WaitingForReview until " +
|
||||||
|
"verify_merges (with its id) passes";
|
||||||
|
}
|
||||||
|
else if (r.Status == TaskMergeService.StatusConflict)
|
||||||
|
{
|
||||||
|
merged = false;
|
||||||
|
conflicts = r.ConflictFiles;
|
||||||
|
repoPath = workingDir;
|
||||||
|
message = r.ErrorMessage;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
throw new InvalidOperationException(r.ErrorMessage ?? "continue failed");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var reloaded = (await _tasks.GetByIdAsync(taskId, cancellationToken))!;
|
||||||
|
await _broadcaster.TaskUpdated(taskId);
|
||||||
|
return new MergeContinuationResultDto(merged, reloaded.Status.ToString(), conflicts, repoPath, message);
|
||||||
|
}
|
||||||
|
|
||||||
|
[McpServerTool, Description(
|
||||||
|
"Run the list's verify command ONCE for a batch of merges made with skipVerify=true, then promote the " +
|
||||||
|
"listed tasks to Done. Call it a single time after the LAST merge of the batch instead of paying the " +
|
||||||
|
"verify per merge. All tasks must belong to the same list; each must be WaitingForReview with its merge " +
|
||||||
|
"already landed (mergeStatus merged_verify_pending). status verify_passed: check each entry's promoted " +
|
||||||
|
"flag (an ineligible task is skipped with a reason, the rest still promote). status verify_failed: the " +
|
||||||
|
"merges stay in place but NO task reaches Done; the command's output tail is in errorMessage — report it, " +
|
||||||
|
"don't fix it yourself. A list without a verify command promotes directly." + McpToolDocs.ProgressHint)]
|
||||||
|
public async Task<ListVerifyResult> VerifyMerges(
|
||||||
|
[Description("Every task merged with skipVerify=true in this batch (accepts #numbers or ids).")]
|
||||||
|
string[] taskIds,
|
||||||
|
CancellationToken cancellationToken = default,
|
||||||
|
IProgress<ProgressNotificationValue>? progress = null)
|
||||||
|
{
|
||||||
|
if (taskIds.Length == 0)
|
||||||
|
throw new InvalidOperationException("taskIds must not be empty.");
|
||||||
|
// Same rationale as review_task's first report: the verify itself reports periodically,
|
||||||
|
// but the wait on the per-repo merge gate before it would otherwise sit silent.
|
||||||
|
progress?.Report(new ProgressNotificationValue { Progress = 0, Message = "verify_merges started" });
|
||||||
|
|
||||||
|
string? listId = null;
|
||||||
|
var resolved = new List<string>(taskIds.Length);
|
||||||
|
foreach (var raw in taskIds)
|
||||||
|
{
|
||||||
|
var id = await TaskIdResolver.ResolveAsync(_tasks, raw, cancellationToken);
|
||||||
|
var task = await _tasks.GetByIdAsync(id, cancellationToken)
|
||||||
|
?? throw new InvalidOperationException($"Task {raw} not found.");
|
||||||
|
listId ??= task.ListId;
|
||||||
|
if (task.ListId != listId)
|
||||||
|
throw new InvalidOperationException(
|
||||||
|
"All tasks must belong to the same list — one verify command gates one repo.");
|
||||||
|
resolved.Add(id);
|
||||||
|
}
|
||||||
|
|
||||||
|
var result = await _merge.RunListVerifyAsync(listId!, resolved, cancellationToken, progress);
|
||||||
|
if (result.Status == TaskMergeService.StatusBlocked)
|
||||||
|
throw new InvalidOperationException(result.ErrorMessage ?? "verify blocked");
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
[McpServerTool, Description(
|
||||||
|
"Abort an in-progress conflicted merge, discarding the conflict markers and restoring a clean working tree. " +
|
||||||
|
"Pass the PARENT task id to abort a parent/children unit merge. The task keeps its pre-merge status " +
|
||||||
|
"(e.g. WaitingForReview). Throws if there is no in-progress merge for the task." + McpToolDocs.LeanTaskRef)]
|
||||||
|
public async Task<TaskRefDto> AbortMerge(string taskId, CancellationToken cancellationToken)
|
||||||
|
{
|
||||||
|
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
||||||
|
_ = await _tasks.GetByIdAsync(taskId, cancellationToken)
|
||||||
|
?? throw new InvalidOperationException($"Task {taskId} not found.");
|
||||||
|
|
||||||
|
if (_planningMerge.HasActiveMerge(taskId))
|
||||||
|
{
|
||||||
|
await _planningMerge.AbortAsync(taskId, cancellationToken);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
var r = await _merge.AbortMergeAsync(taskId, cancellationToken);
|
||||||
|
if (r.Status == TaskMergeService.StatusBlocked)
|
||||||
|
throw new InvalidOperationException(r.ErrorMessage ?? "abort failed");
|
||||||
|
}
|
||||||
|
|
||||||
|
await _broadcaster.TaskUpdated(taskId);
|
||||||
|
return ExternalMcpService.ToRefDto((await _tasks.GetByIdAsync(taskId, cancellationToken))!);
|
||||||
|
}
|
||||||
|
|
||||||
|
[McpServerTool, Description(
|
||||||
|
"List every conflict hunk left in a paused merge (started via merge_task/review_task with " +
|
||||||
|
"leaveConflictsInTree=true), so you can resolve them with resolve_conflict_hunk instead of parsing marker " +
|
||||||
|
"text yourself. Each hunk carries the file's path, its index within that file (what resolve_conflict_hunk " +
|
||||||
|
"expects back), and its startLine. remainingHunks is the total across every file — call continue_merge once " +
|
||||||
|
"it reaches 0, or abort_merge to cancel. Throws if the task has no in-progress merge." + " " + McpToolDocs.Diff3Note)]
|
||||||
|
public async Task<GetMergeConflictsResultDto> GetMergeConflicts(string taskId, CancellationToken cancellationToken = default)
|
||||||
|
{
|
||||||
|
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
||||||
|
_ = await _tasks.GetByIdAsync(taskId, cancellationToken)
|
||||||
|
?? throw new InvalidOperationException($"Task {taskId} not found.");
|
||||||
|
|
||||||
|
var docs = await _merge.GetConflictDocumentsAsync(taskId, cancellationToken);
|
||||||
|
var files = docs.Files.Select(ToConflictFileHunksDto).ToList();
|
||||||
|
var remaining = files.Sum(f => f.Hunks.Count);
|
||||||
|
return new GetMergeConflictsResultDto(files, remaining);
|
||||||
|
}
|
||||||
|
|
||||||
|
[McpServerTool, Description(
|
||||||
|
"Resolve exactly one conflict hunk from get_merge_conflicts, identified by file path and its index within " +
|
||||||
|
"that file. Writes only that hunk — every other hunk (in this file or another) is left exactly as it was, " +
|
||||||
|
"so call get_merge_conflicts again afterward: resolved hunks disappear and every remaining hunk's index " +
|
||||||
|
"shifts down to stay zero-based. This never decides FOR you which side wins — resolution must be 'ours', " +
|
||||||
|
"'theirs', 'base' (only valid when that hunk has a diff3 base), or literal replacement text (used exactly " +
|
||||||
|
"as given, including any trailing newline the surrounding file needs). remainingHunks is the total across " +
|
||||||
|
"every file; call continue_merge once it reaches 0. Throws if the file/index don't match a current hunk." +
|
||||||
|
" " + McpToolDocs.Diff3Note)]
|
||||||
|
public async Task<ResolveConflictHunkResultDto> ResolveConflictHunk(
|
||||||
|
string taskId,
|
||||||
|
[Description("File path exactly as returned by get_merge_conflicts, relative to the repo root.")]
|
||||||
|
string file,
|
||||||
|
[Description("Zero-based hunk index within that file, as returned by get_merge_conflicts.")]
|
||||||
|
int index,
|
||||||
|
[Description("'ours', 'theirs', 'base', or literal text to use for this hunk.")]
|
||||||
|
string resolution,
|
||||||
|
CancellationToken cancellationToken = default)
|
||||||
|
{
|
||||||
|
if (string.IsNullOrEmpty(resolution))
|
||||||
|
throw new InvalidOperationException("resolution is required.");
|
||||||
|
|
||||||
|
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
||||||
|
var docs = await _merge.GetConflictDocumentsAsync(taskId, cancellationToken);
|
||||||
|
var doc = docs.Files.FirstOrDefault(f => string.Equals(f.Path, file, StringComparison.Ordinal))
|
||||||
|
?? throw new InvalidOperationException($"File '{file}' has no conflict for task {taskId}.");
|
||||||
|
if (doc.IsBinary)
|
||||||
|
throw new InvalidOperationException($"File '{file}' is binary; resolve it directly in the working tree.");
|
||||||
|
|
||||||
|
var hunkCount = doc.Segments.Count(s => s.IsConflict);
|
||||||
|
if (index < 0 || index >= hunkCount)
|
||||||
|
throw new InvalidOperationException(
|
||||||
|
$"Hunk index {index} is out of range for '{file}' ({hunkCount} hunk(s) remaining).");
|
||||||
|
|
||||||
|
var counter = -1;
|
||||||
|
var composed = ConflictMarkerParser.Compose(doc.Segments, seg =>
|
||||||
|
{
|
||||||
|
counter++;
|
||||||
|
if (counter != index) return ReconstructConflictMarkers(seg);
|
||||||
|
|
||||||
|
var choice = resolution.Trim().ToLowerInvariant();
|
||||||
|
return choice switch
|
||||||
|
{
|
||||||
|
"ours" => seg.Ours,
|
||||||
|
"theirs" => seg.Theirs,
|
||||||
|
"base" => seg.Base ?? throw new InvalidOperationException(
|
||||||
|
$"Hunk {index} in '{file}' has no diff3 base to resolve to."),
|
||||||
|
_ => resolution,
|
||||||
|
};
|
||||||
|
});
|
||||||
|
|
||||||
|
await _merge.WriteConflictFileAsync(taskId, file, composed, cancellationToken);
|
||||||
|
|
||||||
|
var refreshed = await _merge.GetConflictDocumentsAsync(taskId, cancellationToken);
|
||||||
|
var remaining = refreshed.Files.Sum(f => f.Segments.Count(s => s.IsConflict));
|
||||||
|
return new ResolveConflictHunkResultDto(true, remaining);
|
||||||
|
}
|
||||||
|
|
||||||
|
private static ConflictFileHunksDto ToConflictFileHunksDto(ConflictDocumentContent f)
|
||||||
|
{
|
||||||
|
var hunks = new List<ConflictHunkDto>();
|
||||||
|
foreach (var seg in f.Segments)
|
||||||
|
{
|
||||||
|
if (!seg.IsConflict) continue;
|
||||||
|
hunks.Add(new ConflictHunkDto(hunks.Count, seg.StartLine, seg.Ours, seg.Base, seg.Theirs));
|
||||||
|
}
|
||||||
|
return new ConflictFileHunksDto(f.Path, f.IsBinary, hunks);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Re-renders a still-unresolved hunk as valid (unlabeled) conflict markers so it round-trips through
|
||||||
|
// ConflictMarkerParser.Parse again untouched, and git still refuses continue_merge while it stands. The
|
||||||
|
// original marker labels (e.g. "<<<<<<< HEAD") aren't recoverable from a parsed MergeSegment and aren't
|
||||||
|
// needed for either check -- ConflictMarkerParser.IsMarker and ContinueMergeAsync's rescan only match the
|
||||||
|
// marker prefixes.
|
||||||
|
private static string ReconstructConflictMarkers(MergeSegment seg)
|
||||||
|
{
|
||||||
|
var sb = new StringBuilder();
|
||||||
|
sb.Append("<<<<<<<\n").Append(seg.Ours);
|
||||||
|
if (seg.Base is not null)
|
||||||
|
sb.Append("|||||||\n").Append(seg.Base);
|
||||||
|
sb.Append("=======\n").Append(seg.Theirs);
|
||||||
|
sb.Append(">>>>>>>\n");
|
||||||
|
return sb.ToString();
|
||||||
|
}
|
||||||
|
|
||||||
|
[McpServerTool, Description(
|
||||||
|
"Check whether a task would merge cleanly before touching anything — `git merge-tree --write-tree`, so the " +
|
||||||
|
"working tree, index and HEAD are untouched. status is 'clean', 'conflict' (conflictFiles lists where git " +
|
||||||
|
"would stop), or 'untracked_collision' (conflictFiles lists a path the branch adds that already exists, " +
|
||||||
|
"untracked, in the target working directory — merge-tree can't see the working tree at all, so this is the " +
|
||||||
|
"only way to catch it before a real merge either refuses or, if that path became tracked in the meantime, " +
|
||||||
|
"silently overwrites it); behind counts commits on targetBranch not yet on this branch, which flags a stale " +
|
||||||
|
"branch even when the preview is clean. If the list has a verify command configured, a clean preview is " +
|
||||||
|
"additionally built/tested in a scratch worktree (still without touching the real working tree) — " +
|
||||||
|
"verifyExitCode 0 means it built clean, non-zero or -1 (timeout/failed to start) means it doesn't, with the " +
|
||||||
|
"tail of its output in verifyOutputTail; verifyExitCode stays null when no verify command is configured. " +
|
||||||
|
"isEmpty=true means the task's review range contributed nothing; check that flag rather than reading a " +
|
||||||
|
"small changedFileCount as empty. staleFiles lists files this branch touches that the target branch ALSO " +
|
||||||
|
"changed since this branch's fork point — a more honest staleness signal than `behind` alone, since a " +
|
||||||
|
"branch can be far behind yet touch nothing the target changed, or barely behind yet collide on the one " +
|
||||||
|
"file that matters (always empty for a worktree-less handler task, which has no fork point). Throws if the " +
|
||||||
|
"task has neither an active worktree nor a handler commit range, or the list's working directory is missing " +
|
||||||
|
"from disk." + McpToolDocs.ProgressHint)]
|
||||||
|
public async Task<MergePreviewToolDto> PreviewMerge(
|
||||||
|
string taskId,
|
||||||
|
[Description("Branch to preview against; defaults to the repo's current branch.")]
|
||||||
|
string? targetBranch = null,
|
||||||
|
CancellationToken cancellationToken = default,
|
||||||
|
IProgress<ProgressNotificationValue>? progress = null)
|
||||||
|
{
|
||||||
|
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
||||||
|
var (preview, behind, _, isEmpty, staleFiles, _) = await PreviewMergeCoreAsync(taskId, targetBranch, runVerify: true, cancellationToken, progress);
|
||||||
|
return new MergePreviewToolDto(preview.Status, preview.ConflictFiles, preview.ChangedFileCount, behind, isEmpty,
|
||||||
|
preview.VerifyExitCode, preview.VerifyDurationMs, preview.VerifyOutputTail, staleFiles);
|
||||||
|
}
|
||||||
|
|
||||||
|
[McpServerTool, Description(
|
||||||
|
"Plan a batch merge: preview_merge for several tasks against the same targetBranch, plus a file-overlap " +
|
||||||
|
"check between them. Per entry you get preview_merge's fields, or error instead when that task could not " +
|
||||||
|
"be previewed (it is then left out of the overlap/subset computation). overlaps names, for each file " +
|
||||||
|
"touched by MORE THAN ONE of the given tasks, which tasks touch it — a single taskId always yields no " +
|
||||||
|
"overlaps. subsets flags a stronger relation: TaskId's changed files are a PROPER subset of " +
|
||||||
|
"SupersetTaskId's — the strongest hint you get post-hoc that TaskId may be redundant with SupersetTaskId, " +
|
||||||
|
"worth checking before merging both. IMPORTANT: neither overlap nor subset is a safety guarantee — two " +
|
||||||
|
"tasks touching entirely different files (one deleting a symbol, another still referencing it) can still " +
|
||||||
|
"collide unflagged, and as with preview_merge a clean result does not mean the merge builds. " +
|
||||||
|
"runVerify=false (default) never builds — set it true to also run each task's list's verify command in a " +
|
||||||
|
"scratch worktree per entry (same fields as preview_merge); this can take a long time across many tasks, " +
|
||||||
|
"since builds run one at a time." + McpToolDocs.ProgressHint)]
|
||||||
|
public async Task<MergePreviewSetResultDto> PreviewMergeSet(
|
||||||
|
IReadOnlyList<string> taskIds,
|
||||||
|
[Description("Branch to preview every task against; defaults to the repo's current branch.")]
|
||||||
|
string? targetBranch = null,
|
||||||
|
[Description("true: also run the verify command (if configured) for each task, one build at a time. " +
|
||||||
|
"false (default): no builds, however many tasks are given.")]
|
||||||
|
bool runVerify = false,
|
||||||
|
CancellationToken cancellationToken = default,
|
||||||
|
IProgress<ProgressNotificationValue>? progress = null)
|
||||||
|
{
|
||||||
|
if (taskIds is null || taskIds.Count == 0)
|
||||||
|
throw new InvalidOperationException("taskIds must contain at least one task id.");
|
||||||
|
|
||||||
|
taskIds = await TaskIdResolver.ResolveManyAsync(_tasks, taskIds, cancellationToken);
|
||||||
|
|
||||||
|
var entries = new List<MergePreviewSetEntryDto>();
|
||||||
|
var filesByTask = new Dictionary<string, IReadOnlyList<string>>();
|
||||||
|
var numbersByTask = new Dictionary<string, int>();
|
||||||
|
|
||||||
|
for (var i = 0; i < taskIds.Count; i++)
|
||||||
|
{
|
||||||
|
var taskId = taskIds[i];
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var (preview, behind, changedFiles, isEmpty, staleFiles, number) = await PreviewMergeCoreAsync(taskId, targetBranch, runVerify, cancellationToken, progress);
|
||||||
|
entries.Add(new MergePreviewSetEntryDto(
|
||||||
|
taskId, preview.Status, preview.ConflictFiles, preview.ChangedFileCount, behind, null, isEmpty,
|
||||||
|
preview.VerifyExitCode, preview.VerifyDurationMs, preview.VerifyOutputTail, staleFiles, number));
|
||||||
|
filesByTask[taskId] = changedFiles;
|
||||||
|
numbersByTask[taskId] = number;
|
||||||
|
}
|
||||||
|
catch (InvalidOperationException ex)
|
||||||
|
{
|
||||||
|
var task = await _tasks.GetByIdAsync(taskId, cancellationToken);
|
||||||
|
entries.Add(new MergePreviewSetEntryDto(
|
||||||
|
taskId, TaskMergeService.PreviewUnavailable, Array.Empty<string>(), 0, 0, ex.Message,
|
||||||
|
Number: task?.Number));
|
||||||
|
}
|
||||||
|
|
||||||
|
ProgressReporter.ReportItem(progress, "Previewing merges", i + 1, taskIds.Count);
|
||||||
|
}
|
||||||
|
|
||||||
|
var overlaps = filesByTask
|
||||||
|
.SelectMany(kv => kv.Value.Select(f => (File: f, TaskId: kv.Key)))
|
||||||
|
.GroupBy(x => x.File, StringComparer.OrdinalIgnoreCase)
|
||||||
|
.Where(g => g.Select(x => x.TaskId).Distinct().Count() > 1)
|
||||||
|
.Select(g =>
|
||||||
|
{
|
||||||
|
var ids = g.Select(x => x.TaskId).Distinct().ToList();
|
||||||
|
return new FileOverlapDto(g.Key, ids, ids.Select(id => numbersByTask[id]).ToList());
|
||||||
|
})
|
||||||
|
.OrderBy(o => o.File, StringComparer.OrdinalIgnoreCase)
|
||||||
|
.ToList();
|
||||||
|
|
||||||
|
var subsets = FindSubsetRelations(filesByTask, numbersByTask);
|
||||||
|
|
||||||
|
return new MergePreviewSetResultDto(entries, overlaps, subsets);
|
||||||
|
}
|
||||||
|
|
||||||
|
// A task's changed-file set is flagged only against another task's STRICTLY LARGER set that
|
||||||
|
// contains every one of its files -- an empty set (isEmpty task) never qualifies, since that
|
||||||
|
// case is already surfaced via IsEmpty and would otherwise match every other task trivially.
|
||||||
|
private static List<SubsetRelationDto> FindSubsetRelations(
|
||||||
|
Dictionary<string, IReadOnlyList<string>> filesByTask, Dictionary<string, int> numbersByTask)
|
||||||
|
{
|
||||||
|
var fileSets = filesByTask.ToDictionary(
|
||||||
|
kv => kv.Key,
|
||||||
|
kv => new HashSet<string>(kv.Value, StringComparer.OrdinalIgnoreCase));
|
||||||
|
|
||||||
|
var subsets = new List<SubsetRelationDto>();
|
||||||
|
foreach (var (taskId, fileSet) in fileSets)
|
||||||
|
{
|
||||||
|
if (fileSet.Count == 0) continue;
|
||||||
|
foreach (var (otherTaskId, otherFileSet) in fileSets)
|
||||||
|
{
|
||||||
|
if (otherTaskId == taskId || otherFileSet.Count <= fileSet.Count) continue;
|
||||||
|
if (fileSet.IsSubsetOf(otherFileSet))
|
||||||
|
subsets.Add(new SubsetRelationDto(taskId, numbersByTask[taskId], otherTaskId, numbersByTask[otherTaskId]));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return subsets
|
||||||
|
.OrderBy(s => s.TaskId, StringComparer.OrdinalIgnoreCase)
|
||||||
|
.ThenBy(s => s.SupersetTaskId, StringComparer.OrdinalIgnoreCase)
|
||||||
|
.ToList();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Shared core for PreviewMerge/PreviewMergeSet: throws a clear InvalidOperationException instead of
|
||||||
|
// TaskMergeService.PreviewAsync's silent "unavailable" status, and adds `behind` + the task's own
|
||||||
|
// changed-file list (via diff-stat, not the merge-tree preview) for overlap detection, plus
|
||||||
|
// `isEmpty`. A worktree-less list-handler host task has no branch to merge-tree-preview at all
|
||||||
|
// (its commits already sit on the list's working dir) — falls back to the fixed
|
||||||
|
// HandlerBaseCommit..HandlerHeadCommit range, reporting a synthetic "clean" preview of that
|
||||||
|
// range's own diff-stat instead of throwing "has no worktree".
|
||||||
|
private async Task<(MergePreviewResult Preview, int Behind, IReadOnlyList<string> ChangedFiles, bool IsEmpty, IReadOnlyList<string> StaleFiles, int Number)> PreviewMergeCoreAsync(
|
||||||
|
string taskId, string? targetBranch, bool runVerify, CancellationToken ct,
|
||||||
|
IProgress<ProgressNotificationValue>? progress = null)
|
||||||
|
{
|
||||||
|
using var ctx = _dbFactory.CreateDbContext();
|
||||||
|
var task = await new TaskRepository(ctx).GetByIdAsync(taskId, ct)
|
||||||
|
?? throw new InvalidOperationException($"Task {taskId} not found.");
|
||||||
|
var list = await new ListRepository(ctx).GetByIdAsync(task.ListId, ct)
|
||||||
|
?? throw new InvalidOperationException("List not found.");
|
||||||
|
var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(taskId, ct);
|
||||||
|
|
||||||
|
if (wt is not null)
|
||||||
|
{
|
||||||
|
if (wt.State != WorktreeState.Active)
|
||||||
|
throw new InvalidOperationException(
|
||||||
|
$"Worktree state must be Active to preview a merge (current: {wt.State}).");
|
||||||
|
if (string.IsNullOrWhiteSpace(list.WorkingDir) || !Directory.Exists(list.WorkingDir))
|
||||||
|
throw new InvalidOperationException("The list's working directory no longer exists.");
|
||||||
|
|
||||||
|
var preview = await _merge.PreviewAsync(taskId, targetBranch ?? "", runVerify, ct, progress);
|
||||||
|
if (preview.Status == TaskMergeService.PreviewUnavailable)
|
||||||
|
throw new InvalidOperationException(
|
||||||
|
"Merge preview unavailable for this task (worktree inactive or repo is not a git repository).");
|
||||||
|
|
||||||
|
var target = string.IsNullOrWhiteSpace(targetBranch)
|
||||||
|
? await _git.GetCurrentBranchAsync(list.WorkingDir, ct)
|
||||||
|
: targetBranch;
|
||||||
|
var behind = await WorktreeMcpTools.GitRevListCountAsync(list.WorkingDir, $"{wt.BranchName}..{target}", ct);
|
||||||
|
|
||||||
|
var changedFiles = Directory.Exists(wt.Path)
|
||||||
|
? ExternalMcpService.ParseDiffStatFileNames(await _git.DiffStatAsync(wt.Path, wt.BaseCommit, "HEAD", ct: ct))
|
||||||
|
: Array.Empty<string>();
|
||||||
|
|
||||||
|
// What the target itself picked up since this branch's fork point, so `behind`
|
||||||
|
// (a commit count) doesn't have to stand in for "does this collide" -- a branch can
|
||||||
|
// be far behind but touch nothing the target changed, or close behind and collide on
|
||||||
|
// the one file that matters.
|
||||||
|
var targetChangedSinceFork = await _git.GetChangedFileNamesAsync(list.WorkingDir, wt.BaseCommit, target, ct);
|
||||||
|
var staleFiles = changedFiles
|
||||||
|
.Intersect(targetChangedSinceFork, StringComparer.OrdinalIgnoreCase)
|
||||||
|
.ToList();
|
||||||
|
|
||||||
|
return (preview, behind, changedFiles, changedFiles.Count == 0, staleFiles, task.Number);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (task.HandlerBaseCommit is { Length: > 0 } handlerBase && task.HandlerHeadCommit is { Length: > 0 } handlerHead)
|
||||||
|
{
|
||||||
|
if (string.IsNullOrWhiteSpace(list.WorkingDir) || !Directory.Exists(list.WorkingDir))
|
||||||
|
throw new InvalidOperationException("The list's working directory no longer exists.");
|
||||||
|
|
||||||
|
var isEmpty = string.Equals(handlerBase, handlerHead, StringComparison.Ordinal);
|
||||||
|
var changedFiles = isEmpty
|
||||||
|
? Array.Empty<string>()
|
||||||
|
: ExternalMcpService.ParseDiffStatFileNames(await _git.DiffStatAsync(list.WorkingDir, handlerBase, handlerHead, ct: ct));
|
||||||
|
|
||||||
|
var preview = new MergePreviewResult(TaskMergeService.PreviewClean, Array.Empty<string>(), changedFiles.Count);
|
||||||
|
// No fork point to diff against: a handler task commits straight onto the list's
|
||||||
|
// working dir instead of a branch, so there is nothing else that could have "changed
|
||||||
|
// in the target since the fork".
|
||||||
|
return (preview, 0, changedFiles, isEmpty, Array.Empty<string>(), task.Number);
|
||||||
|
}
|
||||||
|
|
||||||
|
throw new InvalidOperationException($"Task {taskId} has no worktree.");
|
||||||
|
}
|
||||||
|
|
||||||
|
[McpServerTool, Description(
|
||||||
|
"Undo a merged task by reverting its merge commit — `git revert -m 1`, always a new commit and never a " +
|
||||||
|
"reset/rewrite, since the target working directory is shared with other sessions. Requires the task to be " +
|
||||||
|
"Done with a Merged worktree that has a recorded merge commit (check get_task_worktree's mergeCommit " +
|
||||||
|
"first). On success the task returns to WaitingForReview so it can be reconsidered. On conflict the revert " +
|
||||||
|
"is aborted immediately and conflicts lists the files. Throws if there is no recorded merge commit, the " +
|
||||||
|
"repo is mid-merge/mid-revert, or the target working tree has uncommitted changes from another session.")]
|
||||||
|
public async Task<RevertMergeResultDto> RevertMerge(
|
||||||
|
string taskId,
|
||||||
|
[Description("Branch carrying the merge commit; defaults to main.")]
|
||||||
|
string targetBranch = "main",
|
||||||
|
CancellationToken cancellationToken = default)
|
||||||
|
{
|
||||||
|
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
||||||
|
var result = await _merge.RevertMergeAsync(taskId, targetBranch, cancellationToken);
|
||||||
|
|
||||||
|
if (result.Status == TaskMergeService.StatusReverted)
|
||||||
|
{
|
||||||
|
await _broadcaster.TaskUpdated(taskId);
|
||||||
|
return new RevertMergeResultDto(true, result.RevertCommit, Array.Empty<string>(), null);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (result.Status == TaskMergeService.StatusConflictAborted)
|
||||||
|
return new RevertMergeResultDto(false, null, result.ConflictFiles, result.ErrorMessage);
|
||||||
|
|
||||||
|
throw new InvalidOperationException(result.ErrorMessage ?? $"Revert blocked: {result.Status}");
|
||||||
|
}
|
||||||
|
}
|
||||||
+279
@@ -0,0 +1,279 @@
|
|||||||
|
using System.ComponentModel;
|
||||||
|
using System.Diagnostics;
|
||||||
|
using ClaudeDo.Data;
|
||||||
|
using ClaudeDo.Data.Git;
|
||||||
|
using ClaudeDo.Data.Models;
|
||||||
|
using ClaudeDo.Data.Repositories;
|
||||||
|
using ClaudeDo.Worker.Git;
|
||||||
|
using ClaudeDo.Worker.Lifecycle;
|
||||||
|
using ClaudeDo.Worker.Worktrees;
|
||||||
|
using Microsoft.EntityFrameworkCore;
|
||||||
|
using ModelContextProtocol;
|
||||||
|
using ModelContextProtocol.Server;
|
||||||
|
using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
|
||||||
|
|
||||||
|
namespace ClaudeDo.Worker.External;
|
||||||
|
|
||||||
|
public sealed record WorktreeInfoDto(
|
||||||
|
string Path, string Branch, string HeadCommit, string BaseCommit,
|
||||||
|
int Ahead, int Behind, bool IsDirty, string? MergeCommit = null);
|
||||||
|
|
||||||
|
public sealed record TaskDiffDto(
|
||||||
|
string Content, IReadOnlyList<string> Files, bool Truncated, int TotalBytes);
|
||||||
|
|
||||||
|
public sealed record WorktreeListItemDto(
|
||||||
|
string? TaskId, int? Number, string Path, string Branch,
|
||||||
|
string HeadCommit, bool IsDirty, bool MergedIntoMain);
|
||||||
|
|
||||||
|
public sealed record CleanupWorktreeResult(
|
||||||
|
bool Removed, string WorktreePath, bool BranchDeleted, int? Number = null);
|
||||||
|
|
||||||
|
[McpServerToolType]
|
||||||
|
public sealed class WorktreeMcpTools
|
||||||
|
{
|
||||||
|
// Mirrors TaskMergeService.ProgressReportInterval / TaskWaitMcpTools.ProgressReportInterval:
|
||||||
|
// a separate field (not shared) so shrinking one for a test can't race another's tests. Used
|
||||||
|
// by the single-element long-runners here (GetTaskDiff, CleanupTaskWorktree) that wrap a bare
|
||||||
|
// GitService/WorktreeMaintenanceService call with no natural i/n to report instead.
|
||||||
|
internal static TimeSpan ProgressReportInterval = TimeSpan.FromSeconds(30);
|
||||||
|
|
||||||
|
private readonly TaskRepository _tasks;
|
||||||
|
private readonly GitService _git;
|
||||||
|
private readonly IDbContextFactory<ClaudeDoDbContext> _dbFactory;
|
||||||
|
private readonly WorktreeMaintenanceService _maintenance;
|
||||||
|
|
||||||
|
public WorktreeMcpTools(
|
||||||
|
TaskRepository tasks,
|
||||||
|
GitService git,
|
||||||
|
IDbContextFactory<ClaudeDoDbContext> dbFactory,
|
||||||
|
WorktreeMaintenanceService maintenance)
|
||||||
|
{
|
||||||
|
_tasks = tasks;
|
||||||
|
_git = git;
|
||||||
|
_dbFactory = dbFactory;
|
||||||
|
_maintenance = maintenance;
|
||||||
|
}
|
||||||
|
|
||||||
|
[McpServerTool, Description(
|
||||||
|
"Get a task's git worktree state — path, branch, base/head commit, ahead/behind counts, isDirty, and the " +
|
||||||
|
"mergeCommit its branch produced once merged. behind is 0 when the 'main' ref is unreachable, so do not " +
|
||||||
|
"read 0 as \"up to date\" without checking. A null mergeCommit means revert_merge cannot act on this task. " +
|
||||||
|
"Throws if the task or its worktree does not exist.")]
|
||||||
|
public async Task<WorktreeInfoDto> GetTaskWorktree(string taskId, CancellationToken cancellationToken)
|
||||||
|
{
|
||||||
|
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
||||||
|
var (_, _, wt) = await LoadWorktreeContextAsync(taskId, cancellationToken);
|
||||||
|
|
||||||
|
var headCommit = !string.IsNullOrWhiteSpace(wt.HeadCommit)
|
||||||
|
? wt.HeadCommit
|
||||||
|
: await TryRunGitAsync(wt.Path, ["rev-parse", "HEAD"], cancellationToken) ?? wt.BaseCommit;
|
||||||
|
|
||||||
|
var isDirty = Directory.Exists(wt.Path) && await _git.HasChangesAsync(wt.Path, cancellationToken);
|
||||||
|
var ahead = await GitRevListCountAsync(wt.Path, $"{wt.BaseCommit}..HEAD", cancellationToken);
|
||||||
|
var behind = await GitRevListCountAsync(wt.Path, "HEAD..main", cancellationToken);
|
||||||
|
|
||||||
|
return new WorktreeInfoDto(wt.Path, wt.BranchName, headCommit!, wt.BaseCommit, ahead, behind, isDirty, wt.MergeCommit);
|
||||||
|
}
|
||||||
|
|
||||||
|
[McpServerTool, Description(
|
||||||
|
"Read what a task actually changed — the diff of its worktree against its base commit (for a worktree-less " +
|
||||||
|
"list-handler host task, the fixed HandlerBaseCommit..HandlerHeadCommit range over the list's working dir " +
|
||||||
|
"instead). files lists the changed paths in either mode; truncated=true means the diff was capped and " +
|
||||||
|
"totalBytes holds its real size. Throws if the task has no worktree/review range, or the relevant " +
|
||||||
|
"directory is missing from disk.")]
|
||||||
|
public async Task<TaskDiffDto> GetTaskDiff(
|
||||||
|
string taskId,
|
||||||
|
[Description("false (default): the full unified diff, capped at 200 KB. true: a --stat summary with " +
|
||||||
|
"per-file insertion/deletion counts — start here when the diff may be large.")]
|
||||||
|
bool stat = false,
|
||||||
|
[Description("Restrict the diff to these paths (relative to the repo root), e.g. after a --stat pass or a " +
|
||||||
|
"conflict report already narrowed down which files matter. Omit/empty for every changed file " +
|
||||||
|
"— the default and the only prior behavior. Works in both stat and full-diff mode.")]
|
||||||
|
IReadOnlyList<string>? paths = null,
|
||||||
|
CancellationToken cancellationToken = default,
|
||||||
|
IProgress<ProgressNotificationValue>? progress = null)
|
||||||
|
{
|
||||||
|
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
||||||
|
var (repoPath, baseCommit, headCommit) = await LoadDiffRangeAsync(taskId, cancellationToken);
|
||||||
|
|
||||||
|
const int maxBytes = 200 * 1024;
|
||||||
|
|
||||||
|
if (stat)
|
||||||
|
{
|
||||||
|
var diffStat = await ProgressReporter.RunAsync(
|
||||||
|
_git.DiffStatAsync(repoPath, baseCommit, headCommit ?? "HEAD", paths, cancellationToken),
|
||||||
|
ProgressReportInterval, progress, "computing diff stat");
|
||||||
|
return new TaskDiffDto(diffStat, ExternalMcpService.ParseDiffStatFileNames(diffStat), false, diffStat.Length);
|
||||||
|
}
|
||||||
|
|
||||||
|
var diff = headCommit is null
|
||||||
|
? await ProgressReporter.RunAsync(
|
||||||
|
_git.GetBranchDiffAsync(repoPath, baseCommit, paths, cancellationToken), ProgressReportInterval, progress, "computing diff")
|
||||||
|
: await ProgressReporter.RunAsync(
|
||||||
|
_git.GetCommitRangeDiffAsync(repoPath, baseCommit, headCommit, paths, cancellationToken), ProgressReportInterval, progress, "computing diff");
|
||||||
|
var files = ParseDiffFileNames(diff);
|
||||||
|
|
||||||
|
if (diff.Length <= maxBytes)
|
||||||
|
return new TaskDiffDto(diff, files, false, diff.Length);
|
||||||
|
|
||||||
|
return new TaskDiffDto(diff[..maxBytes], files, true, diff.Length);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Resolves where a task's diff lives: a live worktree (repo path = worktree path, diffed
|
||||||
|
// against HEAD) or, for a worktree-less list-handler host task, the fixed
|
||||||
|
// HandlerBaseCommit..HandlerHeadCommit range over the list's working dir (headCommit
|
||||||
|
// non-null signals "fixed range" to the caller instead of "diff against live HEAD").
|
||||||
|
private async Task<(string RepoPath, string BaseCommit, string? HeadCommit)> LoadDiffRangeAsync(
|
||||||
|
string taskId, CancellationToken ct)
|
||||||
|
{
|
||||||
|
using var ctx = _dbFactory.CreateDbContext();
|
||||||
|
var task = await new TaskRepository(ctx).GetByIdAsync(taskId, ct)
|
||||||
|
?? throw new InvalidOperationException($"Task {taskId} not found.");
|
||||||
|
var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(taskId, ct);
|
||||||
|
|
||||||
|
if (wt is not null)
|
||||||
|
{
|
||||||
|
if (!Directory.Exists(wt.Path))
|
||||||
|
throw new InvalidOperationException($"Worktree directory does not exist on disk: {wt.Path}");
|
||||||
|
return (wt.Path, wt.BaseCommit, null);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (task.HandlerBaseCommit is { Length: > 0 } handlerBase && task.HandlerHeadCommit is { Length: > 0 } handlerHead)
|
||||||
|
{
|
||||||
|
var list = await new ListRepository(ctx).GetByIdAsync(task.ListId, ct)
|
||||||
|
?? throw new InvalidOperationException("List not found.");
|
||||||
|
if (string.IsNullOrEmpty(list.WorkingDir) || !Directory.Exists(list.WorkingDir))
|
||||||
|
throw new InvalidOperationException("The list's working directory no longer exists.");
|
||||||
|
return (list.WorkingDir, handlerBase, handlerHead);
|
||||||
|
}
|
||||||
|
|
||||||
|
throw new InvalidOperationException($"Task {taskId} has no worktree.");
|
||||||
|
}
|
||||||
|
|
||||||
|
[McpServerTool, Description(
|
||||||
|
"Survey every worktree ClaudeDo tracks — use it to find leftovers to clean up. Only worktrees recorded in " +
|
||||||
|
"the ClaudeDo database appear here, and headCommit is empty when the path is missing from disk." +
|
||||||
|
McpToolDocs.ProgressHint)]
|
||||||
|
public async Task<IReadOnlyList<WorktreeListItemDto>> ListWorktrees(
|
||||||
|
CancellationToken cancellationToken = default,
|
||||||
|
IProgress<ProgressNotificationValue>? progress = null)
|
||||||
|
{
|
||||||
|
var rows = await _maintenance.GetOverviewAsync(null, cancellationToken);
|
||||||
|
// One git status + one rev-parse per row, run concurrently -- with many tracked worktrees
|
||||||
|
// (this tool's whole point is surfacing leftovers nobody cleaned up) that can still take a
|
||||||
|
// while, so this reports on the same elapsed-time cadence as a single long git call rather
|
||||||
|
// than per-row (rows finish out of order under Task.WhenAll, so there's no natural i/n).
|
||||||
|
var results = await ProgressReporter.RunAsync(
|
||||||
|
Task.WhenAll(rows.Select(async row =>
|
||||||
|
{
|
||||||
|
var isDirty = row.PathExistsOnDisk && await TryGetIsDirtyAsync(row.Path, cancellationToken);
|
||||||
|
var headCommit = row.PathExistsOnDisk
|
||||||
|
? (await TryRunGitAsync(row.Path, ["rev-parse", "HEAD"], cancellationToken) ?? "")
|
||||||
|
: "";
|
||||||
|
return new WorktreeListItemDto(
|
||||||
|
row.TaskId, row.TaskNumber, row.Path, row.BranchName, headCommit,
|
||||||
|
isDirty, row.State == WorktreeState.Merged);
|
||||||
|
})),
|
||||||
|
ProgressReportInterval, progress, "surveying worktrees");
|
||||||
|
return results;
|
||||||
|
}
|
||||||
|
|
||||||
|
[McpServerTool, Description(
|
||||||
|
"Remove a task's worktree directory and delete its git branch. branchDeleted reports whether the branch " +
|
||||||
|
"went too." + McpToolDocs.NotWhileRunning)]
|
||||||
|
public async Task<CleanupWorktreeResult> CleanupTaskWorktree(
|
||||||
|
string taskId,
|
||||||
|
[Description("false (default): refuse a worktree with uncommitted changes. true: remove it anyway, losing " +
|
||||||
|
"those changes.")]
|
||||||
|
bool force = false,
|
||||||
|
CancellationToken cancellationToken = default,
|
||||||
|
IProgress<ProgressNotificationValue>? progress = null)
|
||||||
|
{
|
||||||
|
taskId = await TaskIdResolver.ResolveAsync(_tasks, taskId, cancellationToken);
|
||||||
|
|
||||||
|
using var ctx = _dbFactory.CreateDbContext();
|
||||||
|
var task = await new TaskRepository(ctx).GetByIdAsync(taskId, cancellationToken)
|
||||||
|
?? throw new InvalidOperationException($"Task {taskId} not found.");
|
||||||
|
var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(taskId, cancellationToken)
|
||||||
|
?? throw new InvalidOperationException($"Task {taskId} has no worktree.");
|
||||||
|
|
||||||
|
if (task.Status == TaskStatus.Running)
|
||||||
|
throw new InvalidOperationException("Cannot remove worktree of a running task.");
|
||||||
|
|
||||||
|
if (!force && Directory.Exists(wt.Path))
|
||||||
|
{
|
||||||
|
var isDirty = await ProgressReporter.RunAsync(
|
||||||
|
_git.HasChangesAsync(wt.Path, cancellationToken), ProgressReportInterval, progress, "checking worktree for changes");
|
||||||
|
if (isDirty)
|
||||||
|
throw new InvalidOperationException(
|
||||||
|
"Worktree has uncommitted changes. Use force=true to remove anyway (changes will be lost).");
|
||||||
|
}
|
||||||
|
|
||||||
|
var path = wt.Path;
|
||||||
|
var result = await ProgressReporter.RunAsync(
|
||||||
|
_maintenance.ForceRemoveAsync(taskId, cancellationToken), ProgressReportInterval, progress, "removing worktree");
|
||||||
|
return new CleanupWorktreeResult(result.Removed, path, result.BranchDeleted, task.Number);
|
||||||
|
}
|
||||||
|
|
||||||
|
private async Task<(TaskEntity Task, ListEntity List, WorktreeEntity Wt)> LoadWorktreeContextAsync(
|
||||||
|
string taskId, CancellationToken ct)
|
||||||
|
{
|
||||||
|
using var ctx = _dbFactory.CreateDbContext();
|
||||||
|
var task = await new TaskRepository(ctx).GetByIdAsync(taskId, ct)
|
||||||
|
?? throw new InvalidOperationException($"Task {taskId} not found.");
|
||||||
|
var list = await new ListRepository(ctx).GetByIdAsync(task.ListId, ct)
|
||||||
|
?? throw new InvalidOperationException("List not found.");
|
||||||
|
var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(taskId, ct)
|
||||||
|
?? throw new InvalidOperationException($"Task {taskId} has no worktree.");
|
||||||
|
return (task, list, wt);
|
||||||
|
}
|
||||||
|
|
||||||
|
private async Task<bool> TryGetIsDirtyAsync(string path, CancellationToken ct)
|
||||||
|
{
|
||||||
|
try { return await _git.HasChangesAsync(path, ct); }
|
||||||
|
catch { return false; }
|
||||||
|
}
|
||||||
|
|
||||||
|
// Minimal git runner for operations not covered by GitService (rev-list --count, rev-parse from worktree).
|
||||||
|
private static async Task<string?> TryRunGitAsync(string dir, string[] args, CancellationToken ct)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var psi = new ProcessStartInfo("git")
|
||||||
|
{
|
||||||
|
UseShellExecute = false,
|
||||||
|
RedirectStandardOutput = true,
|
||||||
|
CreateNoWindow = true,
|
||||||
|
};
|
||||||
|
psi.ArgumentList.Add("-C");
|
||||||
|
psi.ArgumentList.Add(dir);
|
||||||
|
foreach (var a in args) psi.ArgumentList.Add(a);
|
||||||
|
using var proc = Process.Start(psi)!;
|
||||||
|
await using var _ = ct.Register(() => { try { proc.Kill(entireProcessTree: true); } catch { } });
|
||||||
|
var stdout = await proc.StandardOutput.ReadToEndAsync();
|
||||||
|
await proc.WaitForExitAsync(CancellationToken.None);
|
||||||
|
ct.ThrowIfCancellationRequested();
|
||||||
|
return proc.ExitCode == 0 ? stdout.Trim() : null;
|
||||||
|
}
|
||||||
|
catch (OperationCanceledException) { throw; }
|
||||||
|
catch { return null; }
|
||||||
|
}
|
||||||
|
|
||||||
|
internal static async Task<int> GitRevListCountAsync(string dir, string range, CancellationToken ct)
|
||||||
|
{
|
||||||
|
var result = await TryRunGitAsync(dir, ["rev-list", "--count", range], ct);
|
||||||
|
return int.TryParse(result, out var n) ? n : 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static IReadOnlyList<string> ParseDiffFileNames(string diff)
|
||||||
|
{
|
||||||
|
var files = new List<string>();
|
||||||
|
foreach (var line in diff.Split('\n'))
|
||||||
|
{
|
||||||
|
var s = line.TrimEnd('\r');
|
||||||
|
if (s.StartsWith("+++ b/", StringComparison.Ordinal))
|
||||||
|
files.Add(s[6..]);
|
||||||
|
}
|
||||||
|
return files;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -345,6 +345,8 @@ if (cfg.ExternalMcpPort > 0)
|
|||||||
externalBuilder.Services.AddSingleton<HandoffRoundTracker>();
|
externalBuilder.Services.AddSingleton<HandoffRoundTracker>();
|
||||||
externalBuilder.Services.AddScoped<FindingsStoreLocator>();
|
externalBuilder.Services.AddScoped<FindingsStoreLocator>();
|
||||||
externalBuilder.Services.AddScoped<ExternalMcpService>();
|
externalBuilder.Services.AddScoped<ExternalMcpService>();
|
||||||
|
externalBuilder.Services.AddScoped<MergeMcpTools>();
|
||||||
|
externalBuilder.Services.AddScoped<WorktreeMcpTools>();
|
||||||
externalBuilder.Services.AddScoped<BatchMcpTools>();
|
externalBuilder.Services.AddScoped<BatchMcpTools>();
|
||||||
externalBuilder.Services.AddScoped<ListMcpTools>();
|
externalBuilder.Services.AddScoped<ListMcpTools>();
|
||||||
externalBuilder.Services.AddScoped<ConfigMcpTools>();
|
externalBuilder.Services.AddScoped<ConfigMcpTools>();
|
||||||
@@ -363,6 +365,8 @@ if (cfg.ExternalMcpPort > 0)
|
|||||||
.WithHttpTransport(o => o.Stateless = true)
|
.WithHttpTransport(o => o.Stateless = true)
|
||||||
.WithRequestFilters(f => f.AddCallToolFilter(ExternalMcpExceptionFilter.Wrap))
|
.WithRequestFilters(f => f.AddCallToolFilter(ExternalMcpExceptionFilter.Wrap))
|
||||||
.WithTools<ExternalMcpService>()
|
.WithTools<ExternalMcpService>()
|
||||||
|
.WithTools<MergeMcpTools>()
|
||||||
|
.WithTools<WorktreeMcpTools>()
|
||||||
.WithTools<BatchMcpTools>()
|
.WithTools<BatchMcpTools>()
|
||||||
.WithTools<ListMcpTools>()
|
.WithTools<ListMcpTools>()
|
||||||
.WithTools<ConfigMcpTools>()
|
.WithTools<ConfigMcpTools>()
|
||||||
|
|||||||
@@ -81,7 +81,6 @@ public sealed class AddSubtaskToolTests : IDisposable
|
|||||||
var queue = new QueueService(dbFactory, runner, cfg, NullLogger<QueueService>.Instance, waker, picker, overrideSlot, state, runCancels,
|
var queue = new QueueService(dbFactory, runner, cfg, NullLogger<QueueService>.Instance, waker, picker, overrideSlot, state, runCancels,
|
||||||
new FakeUsageGate(), usageState, broadcaster,
|
new FakeUsageGate(), usageState, broadcaster,
|
||||||
new UsageLimitAutoContinueCoordinator(dbFactory, usageState, overrideSlot, broadcaster, NullLogger<UsageLimitAutoContinueCoordinator>.Instance));
|
new UsageLimitAutoContinueCoordinator(dbFactory, usageState, overrideSlot, broadcaster, NullLogger<UsageLimitAutoContinueCoordinator>.Instance));
|
||||||
var maintenance = new WorktreeMaintenanceService(dbFactory, git, NullLogger<WorktreeMaintenanceService>.Instance);
|
|
||||||
var merge = new TaskMergeService(dbFactory, git, broadcaster, state, new VerifyCommandRunner(), NullLogger<TaskMergeService>.Instance);
|
var merge = new TaskMergeService(dbFactory, git, broadcaster, state, new VerifyCommandRunner(), NullLogger<TaskMergeService>.Instance);
|
||||||
var aggregator = new PlanningAggregator(dbFactory, git, NullLogger<PlanningAggregator>.Instance);
|
var aggregator = new PlanningAggregator(dbFactory, git, NullLogger<PlanningAggregator>.Instance);
|
||||||
var planningMerge = new PlanningMergeOrchestrator(
|
var planningMerge = new PlanningMergeOrchestrator(
|
||||||
@@ -89,7 +88,7 @@ public sealed class AddSubtaskToolTests : IDisposable
|
|||||||
return new ExternalMcpService(
|
return new ExternalMcpService(
|
||||||
_tasks, _lists, queue, broadcaster,
|
_tasks, _lists, queue, broadcaster,
|
||||||
state,
|
state,
|
||||||
git, dbFactory, maintenance, merge, planningMerge,
|
git, dbFactory, merge, planningMerge,
|
||||||
new BaseDirtyChecker(git, NullLogger<BaseDirtyChecker>.Instance));
|
new BaseDirtyChecker(git, NullLogger<BaseDirtyChecker>.Instance));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -79,7 +79,6 @@ public sealed class BatchMcpToolsTests : IDisposable
|
|||||||
{
|
{
|
||||||
var git = new GitService();
|
var git = new GitService();
|
||||||
var factory = _db.CreateFactory();
|
var factory = _db.CreateFactory();
|
||||||
var maintenance = new WorktreeMaintenanceService(factory, git, NullLogger<WorktreeMaintenanceService>.Instance);
|
|
||||||
var state = TaskStateServiceBuilder.Build(factory).State;
|
var state = TaskStateServiceBuilder.Build(factory).State;
|
||||||
var merge = new TaskMergeService(factory, git, _broadcaster, state, new VerifyCommandRunner(), NullLogger<TaskMergeService>.Instance);
|
var merge = new TaskMergeService(factory, git, _broadcaster, state, new VerifyCommandRunner(), NullLogger<TaskMergeService>.Instance);
|
||||||
var aggregator = new PlanningAggregator(factory, git, NullLogger<PlanningAggregator>.Instance);
|
var aggregator = new PlanningAggregator(factory, git, NullLogger<PlanningAggregator>.Instance);
|
||||||
@@ -88,9 +87,11 @@ public sealed class BatchMcpToolsTests : IDisposable
|
|||||||
var svc = new ExternalMcpService(
|
var svc = new ExternalMcpService(
|
||||||
_tasks, _lists, CreateQueue(), _broadcaster,
|
_tasks, _lists, CreateQueue(), _broadcaster,
|
||||||
state,
|
state,
|
||||||
git, factory, maintenance, merge, planningMerge,
|
git, factory, merge, planningMerge,
|
||||||
new BaseDirtyChecker(git, NullLogger<BaseDirtyChecker>.Instance));
|
new BaseDirtyChecker(git, NullLogger<BaseDirtyChecker>.Instance));
|
||||||
return new BatchMcpTools(svc);
|
var maintenance = new WorktreeMaintenanceService(factory, git, NullLogger<WorktreeMaintenanceService>.Instance);
|
||||||
|
var worktree = new WorktreeMcpTools(_tasks, git, factory, maintenance);
|
||||||
|
return new BatchMcpTools(svc, worktree);
|
||||||
}
|
}
|
||||||
|
|
||||||
private QueueService CreateQueue()
|
private QueueService CreateQueue()
|
||||||
|
|||||||
+1
-1430
File diff suppressed because it is too large
Load Diff
@@ -84,4 +84,57 @@ public sealed class ExternalMcpToolSchemaTests
|
|||||||
|
|
||||||
Assert.True(hasHint, "No external tool description carries McpToolDocs.TaskNumberHint.");
|
Assert.True(hasHint, "No external tool description carries McpToolDocs.TaskNumberHint.");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Full inventory of registered external tool names, computed via the SDK's own
|
||||||
|
// McpServerTool.Create (the same call Program.cs's WithTools<T>() makes internally) rather
|
||||||
|
// than reimplementing the PascalCase-to-snake_case conversion — so this only breaks on an
|
||||||
|
// actual rename/add/remove, not on a divergent reimplementation of the naming rule. Used to
|
||||||
|
// prove that splitting ExternalMcpService.cs into topic files (MergeMcpTools, WorktreeMcpTools,
|
||||||
|
// ...) is a byte-identical rename-preserving move: the set below must not change across that split.
|
||||||
|
private static readonly string[] ExpectedToolNames =
|
||||||
|
[
|
||||||
|
"list_task_lists", "list_tasks", "get_task", "add_task", "update_task", "add_subtask",
|
||||||
|
"update_task_status", "review_task", "run_task_now", "cancel_task", "delete_task",
|
||||||
|
"get_task_worktree", "get_task_diff", "merge_task", "continue_merge", "verify_merges",
|
||||||
|
"abort_merge", "get_merge_conflicts", "resolve_conflict_hunk", "preview_merge",
|
||||||
|
"preview_merge_set", "revert_merge", "list_worktrees", "cleanup_task_worktree",
|
||||||
|
"continue_task", "get_daily_prep_candidates", "set_my_day",
|
||||||
|
"batch_get_tasks", "batch_add_tasks", "batch_update_task_status", "batch_cancel_tasks",
|
||||||
|
"batch_delete_tasks", "batch_set_my_day", "batch_cleanup_task_worktrees",
|
||||||
|
"create_list", "update_list", "delete_list",
|
||||||
|
"get_list_config", "set_list_config", "set_task_config", "get_task_config", "get_effective_run_config",
|
||||||
|
"list_runs", "get_run", "get_task_log",
|
||||||
|
"list_agents",
|
||||||
|
"reset_failed_task", "submit_task_for_review",
|
||||||
|
"handoff_list_handler",
|
||||||
|
"get_app_settings",
|
||||||
|
"wait_for_task_change",
|
||||||
|
"get_queue_state",
|
||||||
|
"add_task_attachment", "list_task_attachments", "remove_task_attachment",
|
||||||
|
"save_finding",
|
||||||
|
"add_note",
|
||||||
|
];
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public void ExternalToolNames_MatchExpectedInventory()
|
||||||
|
{
|
||||||
|
// A throwaway, never-constructed instance per declaring type — McpServerTool.Create needs a
|
||||||
|
// non-null target reference to bind the method to, but naming/schema derivation never
|
||||||
|
// touches instance state, so skipping the real constructor (and its DI dependencies) is safe.
|
||||||
|
var targets = new Dictionary<Type, object>();
|
||||||
|
var actual = ExternalToolMethods()
|
||||||
|
.Select(m =>
|
||||||
|
{
|
||||||
|
var target = targets.TryGetValue(m.DeclaringType!, out var t)
|
||||||
|
? t
|
||||||
|
: targets[m.DeclaringType!] = System.Runtime.CompilerServices.RuntimeHelpers.GetUninitializedObject(m.DeclaringType!);
|
||||||
|
return McpServerTool.Create(m, target).ProtocolTool.Name;
|
||||||
|
})
|
||||||
|
.OrderBy(n => n, StringComparer.Ordinal)
|
||||||
|
.ToList();
|
||||||
|
|
||||||
|
var expected = ExpectedToolNames.OrderBy(n => n, StringComparer.Ordinal).ToList();
|
||||||
|
|
||||||
|
Assert.Equal(expected, actual);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -57,14 +57,13 @@ public sealed class LifecycleMcpToolsTests : IDisposable
|
|||||||
var wtManager = new WorktreeManager(git, dbFactory, cfg, NullLogger<WorktreeManager>.Instance);
|
var wtManager = new WorktreeManager(git, dbFactory, cfg, NullLogger<WorktreeManager>.Instance);
|
||||||
var state = TaskStateServiceBuilder.Build(dbFactory).State;
|
var state = TaskStateServiceBuilder.Build(dbFactory).State;
|
||||||
var reset = new TaskResetService(dbFactory, wtManager, broadcaster, state, NullLogger<TaskResetService>.Instance);
|
var reset = new TaskResetService(dbFactory, wtManager, broadcaster, state, NullLogger<TaskResetService>.Instance);
|
||||||
var maintenance = new WorktreeMaintenanceService(dbFactory, git, NullLogger<WorktreeMaintenanceService>.Instance);
|
|
||||||
var merge = new TaskMergeService(dbFactory, git, broadcaster, state, new VerifyCommandRunner(), NullLogger<TaskMergeService>.Instance);
|
var merge = new TaskMergeService(dbFactory, git, broadcaster, state, new VerifyCommandRunner(), NullLogger<TaskMergeService>.Instance);
|
||||||
var aggregator = new PlanningAggregator(dbFactory, git, NullLogger<PlanningAggregator>.Instance);
|
var aggregator = new PlanningAggregator(dbFactory, git, NullLogger<PlanningAggregator>.Instance);
|
||||||
var planningMerge = new PlanningMergeOrchestrator(
|
var planningMerge = new PlanningMergeOrchestrator(
|
||||||
dbFactory, merge, aggregator, broadcaster, git, state, NullLogger<PlanningMergeOrchestrator>.Instance);
|
dbFactory, merge, aggregator, broadcaster, git, state, NullLogger<PlanningMergeOrchestrator>.Instance);
|
||||||
var svc = new ExternalMcpService(
|
var svc = new ExternalMcpService(
|
||||||
_tasks, _lists, CreateQueue(dbFactory, wtManager, state, broadcaster), broadcaster,
|
_tasks, _lists, CreateQueue(dbFactory, wtManager, state, broadcaster), broadcaster,
|
||||||
state, git, dbFactory, maintenance, merge, planningMerge,
|
state, git, dbFactory, merge, planningMerge,
|
||||||
new BaseDirtyChecker(git, NullLogger<BaseDirtyChecker>.Instance));
|
new BaseDirtyChecker(git, NullLogger<BaseDirtyChecker>.Instance));
|
||||||
var reviewSubmission = new InteractiveReviewSubmissionService(dbFactory, git, state, wtManager);
|
var reviewSubmission = new InteractiveReviewSubmissionService(dbFactory, git, state, wtManager);
|
||||||
return new LifecycleMcpTools(_tasks, reset, svc, reviewSubmission);
|
return new LifecycleMcpTools(_tasks, reset, svc, reviewSubmission);
|
||||||
|
|||||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,492 @@
|
|||||||
|
using ClaudeDo.Data;
|
||||||
|
using ClaudeDo.Data.Git;
|
||||||
|
using ClaudeDo.Data.Models;
|
||||||
|
using ClaudeDo.Data.Repositories;
|
||||||
|
using ClaudeDo.Worker.Config;
|
||||||
|
using ClaudeDo.Worker.External;
|
||||||
|
using ClaudeDo.Worker.Git;
|
||||||
|
using ClaudeDo.Worker.Hub;
|
||||||
|
using ClaudeDo.Worker.Lifecycle;
|
||||||
|
using ClaudeDo.Worker.Planning;
|
||||||
|
using ClaudeDo.Worker.Queue;
|
||||||
|
using ClaudeDo.Worker.Runner;
|
||||||
|
using ClaudeDo.Worker.Tests.Infrastructure;
|
||||||
|
using ClaudeDo.Worker.Tests.Services;
|
||||||
|
using ClaudeDo.Worker.Usage;
|
||||||
|
using ClaudeDo.Worker.Worktrees;
|
||||||
|
using Microsoft.Extensions.Logging.Abstractions;
|
||||||
|
using ModelContextProtocol;
|
||||||
|
using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
|
||||||
|
|
||||||
|
namespace ClaudeDo.Worker.Tests.External;
|
||||||
|
|
||||||
|
// A synchronously-collecting IProgress<T>: Progress<T> marshals through the SynchronizationContext
|
||||||
|
// captured at construction, which is unreliable to assert on immediately in a test.
|
||||||
|
file sealed class SyncProgress<T> : IProgress<T>
|
||||||
|
{
|
||||||
|
public readonly List<T> Reports = new();
|
||||||
|
public void Report(T value) => Reports.Add(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
public sealed class WorktreeMcpToolsTests : IDisposable
|
||||||
|
{
|
||||||
|
private readonly DbFixture _db = new();
|
||||||
|
private readonly ClaudeDoDbContext _ctx;
|
||||||
|
private readonly TaskRepository _tasks;
|
||||||
|
private readonly ListRepository _lists;
|
||||||
|
private readonly HubBroadcaster _broadcaster;
|
||||||
|
private readonly List<GitRepoFixture> _repos = new();
|
||||||
|
private readonly List<(string repoDir, string wtPath)> _worktreeCleanups = new();
|
||||||
|
private int _numberSeed;
|
||||||
|
|
||||||
|
private static bool GitAvailable => GitRepoFixture.IsGitAvailable();
|
||||||
|
|
||||||
|
public WorktreeMcpToolsTests()
|
||||||
|
{
|
||||||
|
_ctx = _db.CreateContext();
|
||||||
|
_tasks = new TaskRepository(_ctx);
|
||||||
|
_lists = new ListRepository(_ctx);
|
||||||
|
_broadcaster = new HubBroadcaster(new CapturingHubContext());
|
||||||
|
}
|
||||||
|
|
||||||
|
public void Dispose()
|
||||||
|
{
|
||||||
|
foreach (var (repoDir, wtPath) in _worktreeCleanups)
|
||||||
|
{
|
||||||
|
try { GitRepoFixture.RunGit(repoDir, "worktree", "remove", "--force", wtPath); } catch { }
|
||||||
|
}
|
||||||
|
foreach (var r in _repos) r.Dispose();
|
||||||
|
_ctx.Dispose();
|
||||||
|
_db.Dispose();
|
||||||
|
}
|
||||||
|
|
||||||
|
private async Task<(TaskEntity task, ListEntity list, WorktreeContext wt)> SeedWorktreeAsync(
|
||||||
|
TaskStatus status = TaskStatus.Done)
|
||||||
|
{
|
||||||
|
var repo = new GitRepoFixture();
|
||||||
|
_repos.Add(repo);
|
||||||
|
|
||||||
|
var listId = Guid.NewGuid().ToString();
|
||||||
|
var list = new ListEntity { Id = listId, Name = "L", WorkingDir = repo.RepoDir, CreatedAt = DateTime.UtcNow };
|
||||||
|
await _lists.AddAsync(list);
|
||||||
|
var task = await SeedTaskAsync(listId, status: status);
|
||||||
|
|
||||||
|
var cfg = new WorkerConfig { WorktreeRootStrategy = "sibling" };
|
||||||
|
var mgr = new WorktreeManager(new GitService(), _db.CreateFactory(), cfg, NullLogger<WorktreeManager>.Instance);
|
||||||
|
var wt = await mgr.CreateAsync(task, list, CancellationToken.None);
|
||||||
|
_worktreeCleanups.Add((repo.RepoDir, wt.WorktreePath));
|
||||||
|
return (task, list, wt);
|
||||||
|
}
|
||||||
|
|
||||||
|
private async Task<string> SeedListAsync(string name = "L")
|
||||||
|
{
|
||||||
|
var id = Guid.NewGuid().ToString();
|
||||||
|
await _lists.AddAsync(new ListEntity { Id = id, Name = name, CreatedAt = DateTime.UtcNow });
|
||||||
|
return id;
|
||||||
|
}
|
||||||
|
|
||||||
|
private async Task<TaskEntity> SeedTaskAsync(
|
||||||
|
string listId, string title = "t", TaskStatus status = TaskStatus.Idle, string? parentId = null)
|
||||||
|
{
|
||||||
|
var task = new TaskEntity
|
||||||
|
{
|
||||||
|
Id = Guid.NewGuid().ToString(),
|
||||||
|
ListId = listId,
|
||||||
|
Title = title,
|
||||||
|
Status = status,
|
||||||
|
ParentTaskId = parentId,
|
||||||
|
CreatedAt = DateTime.UtcNow,
|
||||||
|
CommitType = "chore",
|
||||||
|
Number = ++_numberSeed,
|
||||||
|
};
|
||||||
|
await _tasks.AddAsync(task);
|
||||||
|
return task;
|
||||||
|
}
|
||||||
|
|
||||||
|
// queue is accepted (and ignored) so every extracted test body can keep calling
|
||||||
|
// BuildSut(CreateQueue()) unchanged -- WorktreeMcpTools itself has no QueueService dependency.
|
||||||
|
private WorktreeMcpTools BuildSut(QueueService queue)
|
||||||
|
{
|
||||||
|
var git = new GitService();
|
||||||
|
var factory = _db.CreateFactory();
|
||||||
|
var maintenance = new WorktreeMaintenanceService(factory, git, NullLogger<WorktreeMaintenanceService>.Instance);
|
||||||
|
return new WorktreeMcpTools(_tasks, git, factory, maintenance);
|
||||||
|
}
|
||||||
|
|
||||||
|
// GetTaskWorktree_AfterMerge_ExposesMergeCommit needs a real merge first -- MergeTask lives on
|
||||||
|
// MergeMcpTools now, not here. A fresh instance is fine (TaskMergeService/GitService are
|
||||||
|
// git-disk- and DB-backed, no shared in-memory state to worry about for a plain merge).
|
||||||
|
private MergeMcpTools BuildMergeSut()
|
||||||
|
{
|
||||||
|
var git = new GitService();
|
||||||
|
var factory = _db.CreateFactory();
|
||||||
|
var state = TaskStateServiceBuilder.Build(factory).State;
|
||||||
|
var merge = new TaskMergeService(factory, git, _broadcaster, state, new VerifyCommandRunner(), NullLogger<TaskMergeService>.Instance);
|
||||||
|
var aggregator = new PlanningAggregator(factory, git, NullLogger<PlanningAggregator>.Instance);
|
||||||
|
var planningMerge = new PlanningMergeOrchestrator(
|
||||||
|
factory, merge, aggregator, _broadcaster, git, state, NullLogger<PlanningMergeOrchestrator>.Instance);
|
||||||
|
return new MergeMcpTools(_tasks, _lists, _broadcaster, git, factory, merge, planningMerge);
|
||||||
|
}
|
||||||
|
|
||||||
|
private QueueService CreateQueue()
|
||||||
|
{
|
||||||
|
var tempDir = Path.Combine(Path.GetTempPath(), $"claudedo_worktree_{Guid.NewGuid():N}");
|
||||||
|
Directory.CreateDirectory(tempDir);
|
||||||
|
var cfg = new WorkerConfig
|
||||||
|
{
|
||||||
|
SandboxRoot = Path.Combine(tempDir, "sandbox"),
|
||||||
|
LogRoot = Path.Combine(tempDir, "logs"),
|
||||||
|
QueueBackstopIntervalMs = 50,
|
||||||
|
};
|
||||||
|
var fake = new FakeClaudeProcess();
|
||||||
|
var hubCtx = new CapturingHubContext();
|
||||||
|
var broadcaster = new HubBroadcaster(hubCtx);
|
||||||
|
var dbFactory = _db.CreateFactory();
|
||||||
|
var wtManager = new WorktreeManager(new GitService(), dbFactory, cfg, NullLogger<WorktreeManager>.Instance);
|
||||||
|
var argsBuilder = new ClaudeArgsBuilder();
|
||||||
|
var state = TaskStateServiceBuilder.Build(dbFactory).State;
|
||||||
|
var runner = new TaskRunner(fake, dbFactory, broadcaster, wtManager, argsBuilder, cfg,
|
||||||
|
NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore(), new FakeSessionSkillSeeder(), new FakeTranscriptUsageReader());
|
||||||
|
var waker = new ClaudeDo.Worker.Queue.QueueWaker();
|
||||||
|
var picker = new ClaudeDo.Worker.Queue.QueuePicker(dbFactory);
|
||||||
|
var runCancels = new RunCancellationRegistry(NullLogger<RunCancellationRegistry>.Instance);
|
||||||
|
var overrideSlot = new OverrideSlotService(dbFactory, runner, NullLogger<OverrideSlotService>.Instance, runCancels);
|
||||||
|
var usageState = new UsageState();
|
||||||
|
return new QueueService(dbFactory, runner, cfg, NullLogger<QueueService>.Instance, waker, picker, overrideSlot, state, runCancels,
|
||||||
|
new FakeUsageGate(), usageState, broadcaster,
|
||||||
|
new UsageLimitAutoContinueCoordinator(dbFactory, usageState, overrideSlot, broadcaster, NullLogger<UsageLimitAutoContinueCoordinator>.Instance));
|
||||||
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public async Task GetTaskWorktree_NoWorktree_Throws()
|
||||||
|
{
|
||||||
|
var listId = await SeedListAsync();
|
||||||
|
var task = await SeedTaskAsync(listId);
|
||||||
|
var sut = BuildSut(CreateQueue());
|
||||||
|
|
||||||
|
await Assert.ThrowsAsync<InvalidOperationException>(
|
||||||
|
() => sut.GetTaskWorktree(task.Id, CancellationToken.None));
|
||||||
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public async Task GetTaskWorktree_ReturnsBranchAndBaseCommit()
|
||||||
|
{
|
||||||
|
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
|
||||||
|
|
||||||
|
var (task, _, wt) = await SeedWorktreeAsync();
|
||||||
|
var sut = BuildSut(CreateQueue());
|
||||||
|
|
||||||
|
var info = await sut.GetTaskWorktree(task.Id, CancellationToken.None);
|
||||||
|
|
||||||
|
Assert.Equal(wt.BranchName, info.Branch);
|
||||||
|
Assert.Equal(wt.BaseCommit, info.BaseCommit);
|
||||||
|
Assert.Equal(0, info.Ahead);
|
||||||
|
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 mergeSut = BuildMergeSut();
|
||||||
|
await mergeSut.MergeTask(task.Id, target, true, false, false, cancellationToken: CancellationToken.None);
|
||||||
|
|
||||||
|
var sut = BuildSut(CreateQueue());
|
||||||
|
var info = await sut.GetTaskWorktree(task.Id, CancellationToken.None);
|
||||||
|
|
||||||
|
var expected = GitRepoFixture.RunGit(list.WorkingDir!, "rev-parse", "HEAD").Trim();
|
||||||
|
Assert.Equal(expected, info.MergeCommit);
|
||||||
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public async Task GetTaskDiff_NoWorktree_Throws()
|
||||||
|
{
|
||||||
|
var listId = await SeedListAsync();
|
||||||
|
var task = await SeedTaskAsync(listId);
|
||||||
|
var sut = BuildSut(CreateQueue());
|
||||||
|
|
||||||
|
await Assert.ThrowsAsync<InvalidOperationException>(
|
||||||
|
() => sut.GetTaskDiff(task.Id, false, null, CancellationToken.None));
|
||||||
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public async Task GetTaskDiff_AfterCommit_ListsChangedFile()
|
||||||
|
{
|
||||||
|
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
|
||||||
|
|
||||||
|
var (task, list, wt) = await SeedWorktreeAsync();
|
||||||
|
File.WriteAllText(Path.Combine(wt.WorktreePath, "added.txt"), "content");
|
||||||
|
|
||||||
|
var cfg = new WorkerConfig { WorktreeRootStrategy = "sibling" };
|
||||||
|
var mgr = new WorktreeManager(new GitService(), _db.CreateFactory(), cfg, NullLogger<WorktreeManager>.Instance);
|
||||||
|
await mgr.CommitIfChangedAsync(wt, task, list, CancellationToken.None);
|
||||||
|
|
||||||
|
var sut = BuildSut(CreateQueue());
|
||||||
|
var diff = await sut.GetTaskDiff(task.Id, false, null, CancellationToken.None);
|
||||||
|
|
||||||
|
Assert.Contains("added.txt", diff.Files);
|
||||||
|
Assert.False(diff.Truncated);
|
||||||
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public async Task GetTaskDiff_WithPathsFilter_ReturnsOnlyRequestedFile()
|
||||||
|
{
|
||||||
|
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
|
||||||
|
|
||||||
|
var (task, list, wt) = await SeedWorktreeAsync();
|
||||||
|
File.WriteAllText(Path.Combine(wt.WorktreePath, "added.txt"), "content");
|
||||||
|
File.WriteAllText(Path.Combine(wt.WorktreePath, "other.txt"), "other content");
|
||||||
|
|
||||||
|
var cfg = new WorkerConfig { WorktreeRootStrategy = "sibling" };
|
||||||
|
var mgr = new WorktreeManager(new GitService(), _db.CreateFactory(), cfg, NullLogger<WorktreeManager>.Instance);
|
||||||
|
await mgr.CommitIfChangedAsync(wt, task, list, CancellationToken.None);
|
||||||
|
|
||||||
|
var sut = BuildSut(CreateQueue());
|
||||||
|
var diff = await sut.GetTaskDiff(task.Id, false, ["added.txt"], CancellationToken.None);
|
||||||
|
|
||||||
|
Assert.Equal(new[] { "added.txt" }, diff.Files);
|
||||||
|
Assert.DoesNotContain("other.txt", diff.Content);
|
||||||
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public async Task GetTaskDiff_StatMode_WithPathsFilter_ReturnsOnlyRequestedFile()
|
||||||
|
{
|
||||||
|
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
|
||||||
|
|
||||||
|
var (task, list, wt) = await SeedWorktreeAsync();
|
||||||
|
File.WriteAllText(Path.Combine(wt.WorktreePath, "added.txt"), "content");
|
||||||
|
File.WriteAllText(Path.Combine(wt.WorktreePath, "other.txt"), "other content");
|
||||||
|
|
||||||
|
var cfg = new WorkerConfig { WorktreeRootStrategy = "sibling" };
|
||||||
|
var mgr = new WorktreeManager(new GitService(), _db.CreateFactory(), cfg, NullLogger<WorktreeManager>.Instance);
|
||||||
|
await mgr.CommitIfChangedAsync(wt, task, list, CancellationToken.None);
|
||||||
|
|
||||||
|
var sut = BuildSut(CreateQueue());
|
||||||
|
var diff = await sut.GetTaskDiff(task.Id, true, ["other.txt"], CancellationToken.None);
|
||||||
|
|
||||||
|
Assert.Equal(new[] { "other.txt" }, diff.Files);
|
||||||
|
Assert.DoesNotContain("added.txt", diff.Content);
|
||||||
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public async Task GetTaskDiff_WorktreeLessHandlerTask_UsesHandlerCommitRangeOverListWorkingDir()
|
||||||
|
{
|
||||||
|
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
|
||||||
|
|
||||||
|
var repo = new GitRepoFixture();
|
||||||
|
_repos.Add(repo);
|
||||||
|
var listId = Guid.NewGuid().ToString();
|
||||||
|
await _lists.AddAsync(new ListEntity { Id = listId, Name = "L", WorkingDir = repo.RepoDir, CreatedAt = DateTime.UtcNow });
|
||||||
|
var task = await SeedTaskAsync(listId, status: TaskStatus.WaitingForReview);
|
||||||
|
// No WorktreeEntity for this task -- it's a worktree-less list-handler host task
|
||||||
|
// (Mission Control's "Let Claude handle it"): the handler merged its own commit
|
||||||
|
// straight into the list's working dir after HandlerBaseCommit was stamped.
|
||||||
|
|
||||||
|
File.WriteAllText(Path.Combine(repo.RepoDir, "handled.txt"), "content");
|
||||||
|
GitRepoFixture.RunGit(repo.RepoDir, "add", "-A");
|
||||||
|
GitRepoFixture.RunGit(repo.RepoDir, "commit", "-m", "handled task merge");
|
||||||
|
var headCommit = GitRepoFixture.RunGit(repo.RepoDir, "rev-parse", "HEAD").Trim();
|
||||||
|
|
||||||
|
using (var ctx = _db.CreateContext())
|
||||||
|
{
|
||||||
|
var t = await ctx.Tasks.FindAsync(task.Id);
|
||||||
|
t!.HandlerBaseCommit = repo.BaseCommit;
|
||||||
|
t.HandlerHeadCommit = headCommit;
|
||||||
|
await ctx.SaveChangesAsync();
|
||||||
|
}
|
||||||
|
|
||||||
|
var sut = BuildSut(CreateQueue());
|
||||||
|
var diff = await sut.GetTaskDiff(task.Id, false, null, CancellationToken.None);
|
||||||
|
|
||||||
|
Assert.Contains("handled.txt", diff.Files);
|
||||||
|
Assert.False(diff.Truncated);
|
||||||
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public async Task GetTaskDiff_WorktreeLessHandlerTask_StatMode_UsesHandlerCommitRange()
|
||||||
|
{
|
||||||
|
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
|
||||||
|
|
||||||
|
var repo = new GitRepoFixture();
|
||||||
|
_repos.Add(repo);
|
||||||
|
var listId = Guid.NewGuid().ToString();
|
||||||
|
await _lists.AddAsync(new ListEntity { Id = listId, Name = "L", WorkingDir = repo.RepoDir, CreatedAt = DateTime.UtcNow });
|
||||||
|
var task = await SeedTaskAsync(listId, status: TaskStatus.WaitingForReview);
|
||||||
|
|
||||||
|
File.WriteAllText(Path.Combine(repo.RepoDir, "handled.txt"), "content");
|
||||||
|
GitRepoFixture.RunGit(repo.RepoDir, "add", "-A");
|
||||||
|
GitRepoFixture.RunGit(repo.RepoDir, "commit", "-m", "handled task merge");
|
||||||
|
var headCommit = GitRepoFixture.RunGit(repo.RepoDir, "rev-parse", "HEAD").Trim();
|
||||||
|
|
||||||
|
using (var ctx = _db.CreateContext())
|
||||||
|
{
|
||||||
|
var t = await ctx.Tasks.FindAsync(task.Id);
|
||||||
|
t!.HandlerBaseCommit = repo.BaseCommit;
|
||||||
|
t.HandlerHeadCommit = headCommit;
|
||||||
|
await ctx.SaveChangesAsync();
|
||||||
|
}
|
||||||
|
|
||||||
|
var sut = BuildSut(CreateQueue());
|
||||||
|
var diff = await sut.GetTaskDiff(task.Id, true, null, CancellationToken.None);
|
||||||
|
|
||||||
|
Assert.Contains("handled.txt", diff.Content);
|
||||||
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public async Task GetTaskDiff_ReportsProgressWhileDiffing()
|
||||||
|
{
|
||||||
|
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
|
||||||
|
|
||||||
|
var original = WorktreeMcpTools.ProgressReportInterval;
|
||||||
|
WorktreeMcpTools.ProgressReportInterval = TimeSpan.Zero;
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var (task, list, wt) = await SeedWorktreeAsync();
|
||||||
|
File.WriteAllText(Path.Combine(wt.WorktreePath, "added.txt"), "content");
|
||||||
|
var cfg = new WorkerConfig { WorktreeRootStrategy = "sibling" };
|
||||||
|
var mgr = new WorktreeManager(new GitService(), _db.CreateFactory(), cfg, NullLogger<WorktreeManager>.Instance);
|
||||||
|
await mgr.CommitIfChangedAsync(wt, task, list, CancellationToken.None);
|
||||||
|
|
||||||
|
var sut = BuildSut(CreateQueue());
|
||||||
|
var progress = new SyncProgress<ProgressNotificationValue>();
|
||||||
|
|
||||||
|
var diff = await sut.GetTaskDiff(task.Id, false, null, CancellationToken.None, progress);
|
||||||
|
|
||||||
|
Assert.Contains("added.txt", diff.Files);
|
||||||
|
Assert.NotEmpty(progress.Reports);
|
||||||
|
Assert.All(progress.Reports, r => Assert.Contains("computing diff", r.Message));
|
||||||
|
}
|
||||||
|
finally
|
||||||
|
{
|
||||||
|
WorktreeMcpTools.ProgressReportInterval = original;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public async Task ListWorktrees_Empty_ReturnsEmpty()
|
||||||
|
{
|
||||||
|
var sut = BuildSut(CreateQueue());
|
||||||
|
|
||||||
|
var rows = await sut.ListWorktrees(CancellationToken.None);
|
||||||
|
|
||||||
|
Assert.Empty(rows);
|
||||||
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public async Task ListWorktrees_ReturnsCreatedWorktree()
|
||||||
|
{
|
||||||
|
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
|
||||||
|
|
||||||
|
var (task, _, _) = await SeedWorktreeAsync();
|
||||||
|
var sut = BuildSut(CreateQueue());
|
||||||
|
|
||||||
|
var rows = await sut.ListWorktrees(CancellationToken.None);
|
||||||
|
|
||||||
|
Assert.Contains(rows, r => r.TaskId == task.Id);
|
||||||
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public async Task ListWorktrees_ReportsProgressWhileSurveying()
|
||||||
|
{
|
||||||
|
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
|
||||||
|
|
||||||
|
var original = WorktreeMcpTools.ProgressReportInterval;
|
||||||
|
WorktreeMcpTools.ProgressReportInterval = TimeSpan.Zero;
|
||||||
|
try
|
||||||
|
{
|
||||||
|
await SeedWorktreeAsync();
|
||||||
|
var sut = BuildSut(CreateQueue());
|
||||||
|
var progress = new SyncProgress<ProgressNotificationValue>();
|
||||||
|
|
||||||
|
var rows = await sut.ListWorktrees(CancellationToken.None, progress);
|
||||||
|
|
||||||
|
Assert.NotEmpty(rows);
|
||||||
|
Assert.NotEmpty(progress.Reports);
|
||||||
|
}
|
||||||
|
finally
|
||||||
|
{
|
||||||
|
WorktreeMcpTools.ProgressReportInterval = original;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public async Task CleanupTaskWorktree_NotFound_Throws()
|
||||||
|
{
|
||||||
|
var sut = BuildSut(CreateQueue());
|
||||||
|
|
||||||
|
await Assert.ThrowsAsync<InvalidOperationException>(
|
||||||
|
() => sut.CleanupTaskWorktree("does-not-exist", false, CancellationToken.None));
|
||||||
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public async Task CleanupTaskWorktree_Running_Throws()
|
||||||
|
{
|
||||||
|
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
|
||||||
|
|
||||||
|
var (task, _, _) = await SeedWorktreeAsync(TaskStatus.Running);
|
||||||
|
var sut = BuildSut(CreateQueue());
|
||||||
|
|
||||||
|
var ex = await Assert.ThrowsAsync<InvalidOperationException>(
|
||||||
|
() => sut.CleanupTaskWorktree(task.Id, false, CancellationToken.None));
|
||||||
|
Assert.Contains("running", ex.Message, StringComparison.OrdinalIgnoreCase);
|
||||||
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public async Task CleanupTaskWorktree_CleanWorktree_Removes()
|
||||||
|
{
|
||||||
|
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
|
||||||
|
|
||||||
|
var (task, _, wt) = await SeedWorktreeAsync(TaskStatus.Done);
|
||||||
|
var sut = BuildSut(CreateQueue());
|
||||||
|
|
||||||
|
var result = await sut.CleanupTaskWorktree(task.Id, false, CancellationToken.None);
|
||||||
|
|
||||||
|
Assert.True(result.Removed);
|
||||||
|
Assert.False(Directory.Exists(wt.WorktreePath));
|
||||||
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public async Task CleanupTaskWorktree_ReportsProgressWhileRemoving()
|
||||||
|
{
|
||||||
|
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
|
||||||
|
|
||||||
|
var original = WorktreeMcpTools.ProgressReportInterval;
|
||||||
|
WorktreeMcpTools.ProgressReportInterval = TimeSpan.Zero;
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var (task, _, wt) = await SeedWorktreeAsync(TaskStatus.Done);
|
||||||
|
var sut = BuildSut(CreateQueue());
|
||||||
|
var progress = new SyncProgress<ProgressNotificationValue>();
|
||||||
|
|
||||||
|
var result = await sut.CleanupTaskWorktree(task.Id, false, CancellationToken.None, progress);
|
||||||
|
|
||||||
|
Assert.True(result.Removed);
|
||||||
|
Assert.False(Directory.Exists(wt.WorktreePath));
|
||||||
|
Assert.NotEmpty(progress.Reports);
|
||||||
|
}
|
||||||
|
finally
|
||||||
|
{
|
||||||
|
WorktreeMcpTools.ProgressReportInterval = original;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
Reference in New Issue
Block a user