42bb79e2b7
[Continue] keeps the reject-to-queue + resume behaviour. [Reset] now calls ResetTaskAsync (discards the task worktree and returns it to Idle) behind a confirmation, replacing the old park-to-idle action. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
1549 lines
60 KiB
C#
1549 lines
60 KiB
C#
using System.Collections.ObjectModel;
|
||
using System.Text;
|
||
using CommunityToolkit.Mvvm.ComponentModel;
|
||
using CommunityToolkit.Mvvm.Input;
|
||
using ClaudeDo.Data;
|
||
using ClaudeDo.Data.Models;
|
||
using ClaudeDo.Data.Repositories;
|
||
using ClaudeDo.Ui.Helpers;
|
||
using ClaudeDo.Ui.Localization;
|
||
using ClaudeDo.Ui.Services;
|
||
using ClaudeDo.Ui.Services.Interfaces;
|
||
using ClaudeDo.Ui.ViewModels.Modals;
|
||
using Microsoft.EntityFrameworkCore;
|
||
using Microsoft.Extensions.DependencyInjection;
|
||
|
||
namespace ClaudeDo.Ui.ViewModels.Islands;
|
||
|
||
public enum LogKind { Sys, Tool, Claude, Stdout, Stderr, Done, Msg }
|
||
|
||
public sealed class LogLineViewModel
|
||
{
|
||
public required LogKind Kind { get; init; }
|
||
public required string Text { get; init; }
|
||
public string TimestampFormatted { get; } = DateTime.Now.ToString("HH:mm:ss");
|
||
public string KindMarker => Kind switch
|
||
{
|
||
LogKind.Sys => "sys",
|
||
LogKind.Tool => "tool",
|
||
LogKind.Claude => "claude",
|
||
LogKind.Stdout => "out",
|
||
LogKind.Stderr => "err",
|
||
LogKind.Done => "done",
|
||
LogKind.Msg => "claude",
|
||
_ => "",
|
||
};
|
||
public string ClassName => Kind switch
|
||
{
|
||
LogKind.Sys => "log-sys",
|
||
LogKind.Tool => "log-tool",
|
||
LogKind.Claude => "log-claude",
|
||
LogKind.Stdout => "log-stdout",
|
||
LogKind.Stderr => "log-stderr",
|
||
LogKind.Done => "log-done",
|
||
LogKind.Msg => "log-msg",
|
||
_ => "",
|
||
};
|
||
}
|
||
|
||
public sealed partial class DetailsIslandViewModel : ViewModelBase
|
||
{
|
||
private readonly IDbContextFactory<ClaudeDoDbContext> _dbFactory;
|
||
private readonly IWorkerClient _worker;
|
||
private readonly IServiceProvider _services;
|
||
private readonly INotesApi _notesApi;
|
||
|
||
[ObservableProperty] private bool _isNotesMode;
|
||
[ObservableProperty] private bool _isPrepMode;
|
||
[ObservableProperty] private bool _isPrepRunning;
|
||
public ObservableCollection<LogLineViewModel> PrepLog { get; } = new();
|
||
public bool IsTaskDetailVisible => !IsNotesMode && !IsPrepMode;
|
||
|
||
partial void OnIsNotesModeChanged(bool value) => OnPropertyChanged(nameof(IsTaskDetailVisible));
|
||
partial void OnIsPrepModeChanged(bool value) => OnPropertyChanged(nameof(IsTaskDetailVisible));
|
||
|
||
public NotesEditorViewModel Notes { get; private set; } = null!;
|
||
|
||
// Current task row (set by IslandsShellViewModel via Bind)
|
||
[ObservableProperty]
|
||
[NotifyCanExecuteChangedFor(nameof(EnqueueCommand))]
|
||
[NotifyCanExecuteChangedFor(nameof(DequeueCommand))]
|
||
[NotifyCanExecuteChangedFor(nameof(ResetAndRetryCommand))]
|
||
[NotifyCanExecuteChangedFor(nameof(ReviewCombinedDiffCommand))]
|
||
[NotifyPropertyChangedFor(nameof(TaskIdBadge))]
|
||
private TaskRowViewModel? _task;
|
||
|
||
// Editable fields
|
||
[ObservableProperty]
|
||
[NotifyPropertyChangedFor(nameof(ComposedPreview))]
|
||
private string _editableTitle = "";
|
||
[ObservableProperty]
|
||
[NotifyPropertyChangedFor(nameof(ComposedPreview))]
|
||
private string _editableDescription = "";
|
||
[ObservableProperty] private bool _isEditingDescription;
|
||
[ObservableProperty] private bool _isDescriptionExpanded = true;
|
||
|
||
public bool IsDescriptionEditorVisible => IsDescriptionExpanded && IsEditingDescription;
|
||
public bool IsDescriptionPreviewVisible => IsDescriptionExpanded && !IsEditingDescription;
|
||
|
||
partial void OnIsDescriptionExpandedChanged(bool value)
|
||
{
|
||
OnPropertyChanged(nameof(IsDescriptionEditorVisible));
|
||
OnPropertyChanged(nameof(IsDescriptionPreviewVisible));
|
||
}
|
||
|
||
partial void OnIsEditingDescriptionChanged(bool value)
|
||
{
|
||
OnPropertyChanged(nameof(IsDescriptionEditorVisible));
|
||
OnPropertyChanged(nameof(IsDescriptionPreviewVisible));
|
||
}
|
||
|
||
[RelayCommand]
|
||
private void ToggleEditDescription() => IsEditingDescription = !IsEditingDescription;
|
||
|
||
[RelayCommand]
|
||
private void ToggleDescriptionExpanded() => IsDescriptionExpanded = !IsDescriptionExpanded;
|
||
|
||
// ── Description / Steps card (redesign) ─────────────────────────────
|
||
// Description is always the card body; steps live in an expandable summary
|
||
// strip below it so step presence is visible without switching views.
|
||
[ObservableProperty] private bool _isStepsExpanded;
|
||
|
||
[RelayCommand]
|
||
private void ToggleStepsExpanded() => IsStepsExpanded = !IsStepsExpanded;
|
||
|
||
public int TotalStepCount => Subtasks.Count;
|
||
public int OpenStepCount => Subtasks.Count(s => !s.Done);
|
||
public string StepsSummary =>
|
||
TotalStepCount == 0 ? "no steps yet"
|
||
: OpenStepCount == 0 ? $"all done · {TotalStepCount} total"
|
||
: $"{OpenStepCount} open · {TotalStepCount} total";
|
||
|
||
private void NotifyStepsChanged()
|
||
{
|
||
OnPropertyChanged(nameof(TotalStepCount));
|
||
OnPropertyChanged(nameof(OpenStepCount));
|
||
OnPropertyChanged(nameof(StepsSummary));
|
||
OnPropertyChanged(nameof(ComposedPreview));
|
||
}
|
||
|
||
// The exact text handed to Claude: title + description + open steps only.
|
||
public string ComposedPreview =>
|
||
ClaudeDo.Data.TaskPromptComposer.Compose(
|
||
EditableTitle, EditableDescription, Subtasks.Select(s => (s.Title, s.Done)));
|
||
|
||
// ── Work console (redesign) ────────────────────────────────────────
|
||
// Two tabs: Output (live log) and Session (review + merge/worktree +
|
||
// outcomes, each section gated on the relevant state).
|
||
[ObservableProperty]
|
||
[NotifyPropertyChangedFor(nameof(IsOutputTab))]
|
||
[NotifyPropertyChangedFor(nameof(IsGitTab))]
|
||
[NotifyPropertyChangedFor(nameof(IsSessionTab))]
|
||
private string _selectedTab = "output";
|
||
|
||
public bool IsOutputTab => SelectedTab == "output";
|
||
public bool IsGitTab => SelectedTab == "git";
|
||
public bool IsSessionTab => SelectedTab == "session";
|
||
|
||
[RelayCommand]
|
||
private void SelectTab(string? tab) => SelectedTab = tab ?? "output";
|
||
|
||
// Merge/worktree controls only matter once there's a worktree to manage
|
||
// (standalone task), or a planning parent / improvement parent with children.
|
||
public bool ShowMergeSection =>
|
||
WorktreePath != null || Task?.IsPlanningParent == true || HasChildOutcomes;
|
||
|
||
// Nothing to manage yet (idle/queued/running standalone): show a hint.
|
||
public bool ShowSessionEmpty =>
|
||
!IsWaitingForReview && !ShowMergeSection && !HasChildOutcomes;
|
||
|
||
private void NotifySessionSections()
|
||
{
|
||
OnPropertyChanged(nameof(ShowMergeSection));
|
||
OnPropertyChanged(nameof(ShowSessionEmpty));
|
||
}
|
||
|
||
public string TurnsText => $"{Turns}/{EffectiveMaxTurns}";
|
||
public string DiffAddText => $"+{DiffAdditions}";
|
||
public string DiffDelText => $"-{DiffDeletions}";
|
||
|
||
// Resolved turn budget: per-task override → list default → global default.
|
||
public int EffectiveMaxTurns =>
|
||
TaskMaxTurns is decimal t ? (int)t : (_listMaxTurns ?? _globalMaxTurns);
|
||
|
||
public bool ShowRoadblock => IsFailed || IsCancelled;
|
||
public string RoadblockMessage =>
|
||
IsFailed ? "The session ended with an error." :
|
||
IsCancelled ? "The session was cancelled." : "";
|
||
|
||
public string SessionLabel => "claude-session";
|
||
|
||
// Short task-id badge, e.g. "#T1A"
|
||
public string TaskIdBadge => Task != null ? $"#T{Task.Id[..Math.Min(3, Task.Id.Length)].ToUpperInvariant()}" : "";
|
||
|
||
[ObservableProperty]
|
||
[NotifyCanExecuteChangedFor(nameof(EnqueueCommand))]
|
||
[NotifyCanExecuteChangedFor(nameof(DequeueCommand))]
|
||
[NotifyCanExecuteChangedFor(nameof(ResetAndRetryCommand))]
|
||
[NotifyCanExecuteChangedFor(nameof(ContinueCommand))]
|
||
private string _agentState = "idle";
|
||
public string AgentStatusLabel => Loc.T($"vm.agentStatus.{AgentState}");
|
||
public bool IsIdle => AgentState == "idle";
|
||
public bool IsQueued => AgentState == "queued";
|
||
public bool IsRunning => AgentState == "running";
|
||
public bool IsWaitingForReview => AgentState == "review";
|
||
public bool IsWaitingForChildren => AgentState == "children";
|
||
public bool IsDone => AgentState == "done";
|
||
public bool IsFailed => AgentState == "failed";
|
||
public bool IsCancelled => AgentState == "cancelled";
|
||
|
||
// Recovery actions: Continue (resume session) for Failed/Cancelled.
|
||
public bool ShowContinue => IsFailed || IsCancelled;
|
||
// Reset & retry available from any terminal state.
|
||
public bool ShowResetAndRetry => IsFailed || IsCancelled || IsDone;
|
||
|
||
[ObservableProperty]
|
||
[NotifyCanExecuteChangedFor(nameof(ContinueCommand))]
|
||
private string? _latestRunSessionId;
|
||
|
||
partial void OnAgentStateChanged(string value)
|
||
{
|
||
OnPropertyChanged(nameof(AgentStatusLabel));
|
||
OnPropertyChanged(nameof(IsIdle));
|
||
OnPropertyChanged(nameof(IsQueued));
|
||
OnPropertyChanged(nameof(IsRunning));
|
||
OnPropertyChanged(nameof(IsWaitingForReview));
|
||
OnPropertyChanged(nameof(IsWaitingForChildren));
|
||
OnPropertyChanged(nameof(IsDone));
|
||
OnPropertyChanged(nameof(IsFailed));
|
||
OnPropertyChanged(nameof(IsCancelled));
|
||
OnPropertyChanged(nameof(ShowContinue));
|
||
OnPropertyChanged(nameof(ShowResetAndRetry));
|
||
OnPropertyChanged(nameof(IsAgentSectionEnabled));
|
||
OnPropertyChanged(nameof(ShowRoadblock));
|
||
OnPropertyChanged(nameof(RoadblockMessage));
|
||
NotifySessionSections();
|
||
}
|
||
[ObservableProperty] private string? _model;
|
||
|
||
// Agent settings overrides
|
||
[ObservableProperty] private string? _taskModelSelection; // null = inherit
|
||
[ObservableProperty] private string _taskSystemPrompt = "";
|
||
[ObservableProperty] private AgentInfo? _taskSelectedAgent;
|
||
[ObservableProperty] private decimal? _taskMaxTurns; // null = inherit
|
||
[ObservableProperty] private string _modelBadge = "";
|
||
[ObservableProperty] private string _modelInheritedHint = "";
|
||
[ObservableProperty] private string _turnsBadge = "";
|
||
[ObservableProperty] private string _turnsInheritedHint = "";
|
||
[ObservableProperty] private string _agentBadge = "";
|
||
[ObservableProperty] private string _effectiveSystemPromptHint = "";
|
||
|
||
private string _globalModel = ModelRegistry.DefaultAlias;
|
||
private int _globalMaxTurns = 100;
|
||
private string? _listModel;
|
||
private int? _listMaxTurns;
|
||
private string? _listAgentName;
|
||
|
||
partial void OnTaskModelSelectionChanged(string? value) { RecomputeModelBadge(); QueueAgentSave(); }
|
||
partial void OnTaskMaxTurnsChanged(decimal? value)
|
||
{
|
||
RecomputeTurnsBadge();
|
||
OnPropertyChanged(nameof(EffectiveMaxTurns));
|
||
OnPropertyChanged(nameof(TurnsText));
|
||
QueueAgentSave();
|
||
}
|
||
|
||
private void RecomputeModelBadge()
|
||
{
|
||
var (value, source) = InheritanceResolver.Resolve(TaskModelSelection, _listModel, _globalModel);
|
||
ModelInheritedHint = value;
|
||
ModelBadge = BadgeFor(source, !string.IsNullOrWhiteSpace(TaskModelSelection));
|
||
}
|
||
|
||
private void RecomputeTurnsBadge()
|
||
{
|
||
var (value, source) = InheritanceResolver.Resolve(
|
||
TaskMaxTurns?.ToString(), _listMaxTurns?.ToString(), _globalMaxTurns.ToString());
|
||
TurnsInheritedHint = value;
|
||
TurnsBadge = BadgeFor(source, TaskMaxTurns is not null);
|
||
}
|
||
|
||
private void RecomputeAgentBadge()
|
||
{
|
||
var taskSet = TaskSelectedAgent is not null && !string.IsNullOrWhiteSpace(TaskSelectedAgent.Path);
|
||
var (_, source) = InheritanceResolver.Resolve(
|
||
taskSet ? TaskSelectedAgent!.Path : null, _listAgentName, null);
|
||
AgentBadge = BadgeFor(source, taskSet);
|
||
}
|
||
|
||
private static string BadgeFor(InheritSource source, bool taskSet) => taskSet
|
||
? Loc.T("settings.inherit.overrideBadge")
|
||
: source == InheritSource.List
|
||
? Loc.T("settings.inherit.inheritedFromList")
|
||
: Loc.T("settings.inherit.inheritedFromGlobal");
|
||
|
||
public System.Collections.ObjectModel.ObservableCollection<string> TaskModelOptions { get; } = new(ModelRegistry.Aliases);
|
||
|
||
public System.Collections.ObjectModel.ObservableCollection<AgentInfo> TaskAgentOptions { get; } = new();
|
||
|
||
private bool _suppressAgentSave;
|
||
private CancellationTokenSource? _agentSaveCts;
|
||
|
||
private bool _suppressDescSave;
|
||
private CancellationTokenSource? _descSaveCts;
|
||
|
||
public bool IsAgentSectionEnabled => !IsRunning;
|
||
|
||
[ObservableProperty] private string? _worktreePath;
|
||
[ObservableProperty] private string? _worktreeBaseCommit;
|
||
[ObservableProperty] private string? _worktreeStateLabel;
|
||
[ObservableProperty] private string? _branchLine;
|
||
[ObservableProperty] private int _turns;
|
||
[ObservableProperty] private int _tokens;
|
||
[ObservableProperty] private int _diffAdditions;
|
||
[ObservableProperty] private int _diffDeletions;
|
||
[ObservableProperty] private int _commitsOnBranch;
|
||
|
||
public string TokensFormatted => Tokens >= 1000 ? $"{Tokens / 1000.0:F1}k" : Tokens.ToString();
|
||
public string ElapsedFormatted => ""; // placeholder — no start-time stored yet
|
||
|
||
partial void OnTokensChanged(int value) => OnPropertyChanged(nameof(TokensFormatted));
|
||
partial void OnTurnsChanged(int value) => OnPropertyChanged(nameof(TurnsText));
|
||
partial void OnDiffAdditionsChanged(int value) { OnPropertyChanged(nameof(DiffMeterRatio)); OnPropertyChanged(nameof(DiffAddText)); }
|
||
partial void OnDiffDeletionsChanged(int value) { OnPropertyChanged(nameof(DiffMeterRatio)); OnPropertyChanged(nameof(DiffDelText)); }
|
||
|
||
// 0.0–1.0 additions share for the diff meter
|
||
public double DiffMeterRatio
|
||
{
|
||
get
|
||
{
|
||
var total = DiffAdditions + DiffDeletions;
|
||
return total == 0 ? 0.0 : (double)DiffAdditions / total;
|
||
}
|
||
}
|
||
|
||
public ObservableCollection<LogLineViewModel> Log { get; } = new();
|
||
public ObservableCollection<SubtaskRowViewModel> Subtasks { get; } = new();
|
||
|
||
// Agent-suggested improvement children of a non-planning parent, surfaced on its
|
||
// review card with each child's outcome and rolled-up roadblock count.
|
||
public ObservableCollection<ChildOutcomeRowViewModel> ChildOutcomes { get; } = new();
|
||
public bool HasChildOutcomes => ChildOutcomes.Count > 0;
|
||
|
||
[ObservableProperty] private string _newSubtaskTitle = "";
|
||
|
||
// Planning merge controls
|
||
[ObservableProperty] private ObservableCollection<string> _mergeTargetBranches = new();
|
||
[ObservableProperty] private string? _selectedMergeTarget;
|
||
[ObservableProperty]
|
||
[NotifyCanExecuteChangedFor(nameof(MergeAllCommand))]
|
||
private bool _canMergeAll;
|
||
[ObservableProperty] private string? _mergeAllDisabledReason;
|
||
[ObservableProperty] private string? _mergeAllError;
|
||
|
||
[ObservableProperty]
|
||
[NotifyPropertyChangedFor(nameof(ShowMergePreviewMuted))]
|
||
private string _mergePreviewText = "";
|
||
|
||
[ObservableProperty]
|
||
[NotifyPropertyChangedFor(nameof(ShowMergePreviewMuted))]
|
||
private bool _mergeIsClean;
|
||
|
||
[ObservableProperty]
|
||
[NotifyPropertyChangedFor(nameof(ShowMergePreviewMuted))]
|
||
private bool _mergeIsConflict;
|
||
|
||
public bool ShowMergePreviewMuted =>
|
||
!MergeIsClean && !MergeIsConflict && !string.IsNullOrEmpty(MergePreviewText);
|
||
|
||
public bool ShowSingleMerge =>
|
||
WorktreePath != null && Task?.IsPlanningParent != true;
|
||
|
||
// Claude CLI stream-json parser + buffer for partial text deltas
|
||
private readonly StreamLineFormatter _formatter = new();
|
||
private readonly StringBuilder _claudeBuf = new();
|
||
private readonly StringBuilder _prepClaudeBuf = new();
|
||
|
||
// The task ID we are currently subscribed to for live log messages
|
||
private string? _subscribedTaskId;
|
||
|
||
private CancellationTokenSource? _loadCts;
|
||
|
||
// Set by shell so CloseDetailCommand can clear SelectedTask
|
||
public Action? CloseDetail { get; set; }
|
||
|
||
// Set by shell so DeleteTaskCommand can remove from list
|
||
public Func<TaskRowViewModel, System.Threading.Tasks.Task>? DeleteFromList { get; set; }
|
||
|
||
// Set by the view so OpenDiffCommand can show the modal as a dialog
|
||
public Func<DiffModalViewModel, System.Threading.Tasks.Task>? ShowDiffModal { get; set; }
|
||
|
||
// Set by the view so OpenDiff can pass through merge requests from the diff modal
|
||
public Func<MergeModalViewModel, System.Threading.Tasks.Task>? ShowMergeModal { get; set; }
|
||
|
||
// Set by the view so DeleteTaskCommand can prompt yes/no before deleting
|
||
public Func<string, System.Threading.Tasks.Task<bool>>? ConfirmAsync { get; set; }
|
||
|
||
// Set by the view so ReviewCombinedDiffCommand can show the planning diff modal
|
||
public Func<ViewModels.Planning.PlanningDiffViewModel, System.Threading.Tasks.Task>? ShowPlanningDiffModal { get; set; }
|
||
|
||
// Set by the view so DeleteTaskCommand can show an error message
|
||
public Func<string, System.Threading.Tasks.Task>? ShowErrorAsync { get; set; }
|
||
|
||
private static string StatusToStateKey(ClaudeDo.Data.Models.TaskStatus status) => status switch
|
||
{
|
||
ClaudeDo.Data.Models.TaskStatus.Queued => "queued",
|
||
ClaudeDo.Data.Models.TaskStatus.Running => "running",
|
||
ClaudeDo.Data.Models.TaskStatus.WaitingForReview => "review",
|
||
ClaudeDo.Data.Models.TaskStatus.WaitingForChildren => "children",
|
||
ClaudeDo.Data.Models.TaskStatus.Done => "done",
|
||
ClaudeDo.Data.Models.TaskStatus.Failed => "failed",
|
||
ClaudeDo.Data.Models.TaskStatus.Cancelled => "cancelled",
|
||
_ => "idle",
|
||
};
|
||
|
||
private static string FinishedStatusToStateKey(string status) => status switch
|
||
{
|
||
"done" => "done",
|
||
"failed" => "failed",
|
||
"cancelled" => "cancelled",
|
||
"waiting_for_review" => "review",
|
||
"waiting_for_children" => "children",
|
||
_ => status.ToLowerInvariant(),
|
||
};
|
||
|
||
private async System.Threading.Tasks.Task RefreshStatusAsync(string taskId)
|
||
{
|
||
try
|
||
{
|
||
await using var ctx = await _dbFactory.CreateDbContextAsync();
|
||
var entity = await ctx.Tasks
|
||
.AsNoTracking()
|
||
.FirstOrDefaultAsync(t => t.Id == taskId);
|
||
if (entity is null || Task?.Id != taskId) return;
|
||
|
||
AgentState = StatusToStateKey(entity.Status);
|
||
}
|
||
catch { }
|
||
}
|
||
|
||
public DetailsIslandViewModel(IDbContextFactory<ClaudeDoDbContext> dbFactory, IWorkerClient worker, IServiceProvider services, INotesApi notesApi)
|
||
{
|
||
_dbFactory = dbFactory;
|
||
_worker = worker;
|
||
_services = services;
|
||
_notesApi = notesApi;
|
||
Notes = new NotesEditorViewModel(_notesApi);
|
||
Subtasks.CollectionChanged += (_, _) => NotifyStepsChanged();
|
||
Loc.LanguageChanged += (_, _) =>
|
||
{
|
||
OnPropertyChanged(nameof(AgentStatusLabel));
|
||
RecomputeModelBadge();
|
||
RecomputeTurnsBadge();
|
||
RecomputeAgentBadge();
|
||
};
|
||
|
||
// Subscribe once; filter by current task id inside the handler
|
||
_worker.TaskMessageEvent += OnTaskMessage;
|
||
_worker.PrepStartedEvent += OnPrepStarted;
|
||
_worker.PrepLineEvent += OnPrepLine;
|
||
_worker.PrepFinishedEvent += OnPrepFinished;
|
||
|
||
// Re-evaluate CanExecute when worker connection flips.
|
||
_worker.PropertyChanged += (_, e) =>
|
||
{
|
||
if (e.PropertyName == nameof(WorkerClient.IsConnected))
|
||
{
|
||
EnqueueCommand.NotifyCanExecuteChanged();
|
||
DequeueCommand.NotifyCanExecuteChanged();
|
||
ResetAndRetryCommand.NotifyCanExecuteChanged();
|
||
ContinueCommand.NotifyCanExecuteChanged();
|
||
}
|
||
};
|
||
|
||
// If the task row's live status changes (e.g. TaskStarted/Finished), mirror it.
|
||
_worker.TaskStartedEvent += (slot, taskId, startedAt) =>
|
||
{
|
||
if (Task?.Id == taskId) AgentState = "running";
|
||
_ = RefreshChildOutcomeAsync(taskId);
|
||
};
|
||
_worker.TaskFinishedEvent += (slot, taskId, status, finishedAt) =>
|
||
{
|
||
if (Task?.Id != taskId) return;
|
||
FlushClaudeBuffer();
|
||
Log.Add(new LogLineViewModel
|
||
{
|
||
Kind = LogKind.Done,
|
||
Text = $"── {status.ToUpperInvariant()} · {finishedAt.ToLocalTime():HH:mm:ss} ──",
|
||
});
|
||
AgentState = FinishedStatusToStateKey(status);
|
||
// Re-query to pick up worktree created during the run.
|
||
_ = RefreshWorktreeAsync(taskId);
|
||
_ = RefreshChildOutcomeAsync(taskId);
|
||
};
|
||
|
||
_worker.WorktreeUpdatedEvent += taskId =>
|
||
{
|
||
if (Task?.Id == taskId) _ = RefreshWorktreeAsync(taskId);
|
||
if (Task?.IsPlanningParent == true) _ = RefreshPlanningChildAsync(taskId);
|
||
_ = RefreshChildOutcomeAsync(taskId);
|
||
};
|
||
|
||
_worker.TaskUpdatedEvent += taskId =>
|
||
{
|
||
if (Task?.Id == taskId) _ = RefreshStatusAsync(taskId);
|
||
if (Task?.IsPlanningParent == true) _ = RefreshPlanningChildAsync(taskId);
|
||
_ = RefreshChildOutcomeAsync(taskId);
|
||
};
|
||
|
||
Subtasks.CollectionChanged += (_, _) =>
|
||
{
|
||
RecomputeCanMergeAll();
|
||
ReviewCombinedDiffCommand.NotifyCanExecuteChanged();
|
||
};
|
||
|
||
ChildOutcomes.CollectionChanged += (_, _) =>
|
||
{
|
||
RecomputeCanMergeAll();
|
||
ReviewCombinedDiffCommand.NotifyCanExecuteChanged();
|
||
NotifySessionSections();
|
||
};
|
||
|
||
PrepLog.CollectionChanged += (_, _) => OnPropertyChanged(nameof(ShowPrepEmptyState));
|
||
}
|
||
|
||
private void OnTaskMessage(string taskId, string line)
|
||
{
|
||
if (taskId != _subscribedTaskId) return;
|
||
|
||
// `[stdout] ...json...` lines are Claude CLI stream-json; parse through the
|
||
// formatter so the user sees human text, not raw JSON.
|
||
if (line.StartsWith("[stdout]", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var body = line["[stdout]".Length..].TrimStart();
|
||
AppendStdoutLine(Log, body);
|
||
return;
|
||
}
|
||
|
||
// Non-stdout tagged lines: flush any buffered text then classify by prefix.
|
||
FlushClaudeBuffer();
|
||
|
||
var kind = line.StartsWith("[sys]", StringComparison.OrdinalIgnoreCase) ? LogKind.Sys
|
||
: line.StartsWith("[tool]", StringComparison.OrdinalIgnoreCase) ? LogKind.Tool
|
||
: line.StartsWith("[claude]", StringComparison.OrdinalIgnoreCase) ? LogKind.Claude
|
||
: line.StartsWith("[stderr]", StringComparison.OrdinalIgnoreCase) ? LogKind.Stderr
|
||
: line.StartsWith("[done]", StringComparison.OrdinalIgnoreCase) ? LogKind.Done
|
||
: LogKind.Msg;
|
||
Log.Add(new LogLineViewModel { Kind = kind, Text = line });
|
||
}
|
||
|
||
private void AppendStdoutLine(ObservableCollection<LogLineViewModel> target, string line)
|
||
{
|
||
var formatted = _formatter.FormatLine(line);
|
||
if (formatted is null) return;
|
||
var buf = ReferenceEquals(target, Log) ? _claudeBuf : _prepClaudeBuf;
|
||
AppendClaudeText(formatted, target, buf);
|
||
}
|
||
|
||
[RelayCommand]
|
||
private async Task PlanDayAsync()
|
||
{
|
||
if (_worker is null) return;
|
||
try { await _worker.RunDailyPrepNowAsync(); }
|
||
catch { /* worker offline; PrepStarted/PrepLine will reconcile */ }
|
||
}
|
||
|
||
public bool ShowPrepEmptyState => !IsPrepRunning && PrepLog.Count == 0;
|
||
|
||
partial void OnIsPrepRunningChanged(bool value) => OnPropertyChanged(nameof(ShowPrepEmptyState));
|
||
|
||
private void OnPrepStarted()
|
||
{
|
||
PrepLog.Clear();
|
||
IsPrepRunning = true;
|
||
}
|
||
|
||
private void OnPrepLine(string line) => AppendStdoutLine(PrepLog, line);
|
||
|
||
private void OnPrepFinished(bool success) => IsPrepRunning = false;
|
||
|
||
private void AppendClaudeText(string chunk) => AppendClaudeText(chunk, Log, _claudeBuf);
|
||
|
||
private static void AppendClaudeText(string chunk, ObservableCollection<LogLineViewModel> target, StringBuilder buf)
|
||
{
|
||
buf.Append(chunk);
|
||
// Emit a log entry for every completed line; keep the trailing remainder buffered.
|
||
while (true)
|
||
{
|
||
var text = buf.ToString();
|
||
var nl = text.IndexOf('\n');
|
||
if (nl < 0) break;
|
||
var piece = text[..nl].TrimEnd('\r');
|
||
if (!string.IsNullOrWhiteSpace(piece))
|
||
target.Add(new LogLineViewModel { Kind = LogKind.Claude, Text = piece });
|
||
buf.Clear();
|
||
buf.Append(text[(nl + 1)..]);
|
||
}
|
||
}
|
||
|
||
private void FlushClaudeBuffer()
|
||
{
|
||
if (_claudeBuf.Length == 0) return;
|
||
var piece = _claudeBuf.ToString().TrimEnd();
|
||
_claudeBuf.Clear();
|
||
if (!string.IsNullOrWhiteSpace(piece))
|
||
Log.Add(new LogLineViewModel { Kind = LogKind.Claude, Text = piece });
|
||
}
|
||
|
||
partial void OnTaskSystemPromptChanged(string value) => QueueAgentSave();
|
||
partial void OnTaskSelectedAgentChanged(AgentInfo? value) { RecomputeAgentBadge(); QueueAgentSave(); }
|
||
|
||
partial void OnEditableDescriptionChanged(string value)
|
||
{
|
||
if (_suppressDescSave || Task is null) return;
|
||
_descSaveCts?.Cancel();
|
||
_descSaveCts = new CancellationTokenSource();
|
||
_ = SaveDescriptionAsync(_descSaveCts.Token);
|
||
}
|
||
|
||
private async System.Threading.Tasks.Task SaveDescriptionAsync(CancellationToken ct)
|
||
{
|
||
try
|
||
{
|
||
await System.Threading.Tasks.Task.Delay(400, ct);
|
||
if (Task is null) return;
|
||
await using var ctx = _dbFactory.CreateDbContext();
|
||
var repo = new TaskRepository(ctx);
|
||
var entity = await repo.GetByIdAsync(Task.Id);
|
||
if (entity is null) return;
|
||
entity.Description = string.IsNullOrWhiteSpace(EditableDescription) ? null : EditableDescription;
|
||
await repo.UpdateAsync(entity);
|
||
}
|
||
catch (OperationCanceledException) { }
|
||
catch { }
|
||
}
|
||
|
||
private void QueueAgentSave()
|
||
{
|
||
if (_suppressAgentSave || Task is null) return;
|
||
_agentSaveCts?.Cancel();
|
||
_agentSaveCts = new CancellationTokenSource();
|
||
var ct = _agentSaveCts.Token;
|
||
_ = SaveAgentSettingsAsync(ct);
|
||
}
|
||
|
||
private async System.Threading.Tasks.Task SaveAgentSettingsAsync(CancellationToken ct)
|
||
{
|
||
try
|
||
{
|
||
await System.Threading.Tasks.Task.Delay(300, ct);
|
||
if (Task is null) return;
|
||
|
||
var model = string.IsNullOrWhiteSpace(TaskModelSelection) ? null : TaskModelSelection;
|
||
var sp = string.IsNullOrWhiteSpace(TaskSystemPrompt) ? null : TaskSystemPrompt;
|
||
var ap = TaskSelectedAgent is null || string.IsNullOrWhiteSpace(TaskSelectedAgent.Path)
|
||
? null : TaskSelectedAgent.Path;
|
||
var turns = TaskMaxTurns is decimal d ? (int?)d : null;
|
||
|
||
await _worker.UpdateTaskAgentSettingsAsync(
|
||
new ClaudeDo.Ui.Services.UpdateTaskAgentSettingsDto(Task.Id, model, sp, ap, turns));
|
||
}
|
||
catch (OperationCanceledException) { }
|
||
catch { }
|
||
}
|
||
|
||
private async System.Threading.Tasks.Task LoadAgentSettingsAsync(
|
||
ClaudeDo.Data.Models.TaskEntity entity, CancellationToken ct)
|
||
{
|
||
_suppressAgentSave = true;
|
||
try
|
||
{
|
||
TaskAgentOptions.Clear();
|
||
TaskAgentOptions.Add(new AgentInfo("(inherited)", "", ""));
|
||
var agents = await _worker.GetAgentsAsync();
|
||
foreach (var a in agents) TaskAgentOptions.Add(a);
|
||
|
||
TaskModelSelection = string.IsNullOrWhiteSpace(entity.Model) ? null : entity.Model!;
|
||
TaskMaxTurns = entity.MaxTurns is int tmt ? tmt : (decimal?)null;
|
||
TaskSystemPrompt = entity.SystemPrompt ?? "";
|
||
TaskSelectedAgent = string.IsNullOrWhiteSpace(entity.AgentPath)
|
||
? TaskAgentOptions[0]
|
||
: (TaskAgentOptions.FirstOrDefault(a => a.Path == entity.AgentPath) ?? TaskAgentOptions[0]);
|
||
|
||
var listCfg = await _worker.GetListConfigAsync(entity.ListId);
|
||
var app = await _worker.GetAppSettingsAsync();
|
||
_globalModel = app?.DefaultModel ?? ModelRegistry.DefaultAlias;
|
||
_globalMaxTurns = app?.DefaultMaxTurns ?? 100;
|
||
_listModel = listCfg?.Model;
|
||
_listMaxTurns = listCfg?.MaxTurns;
|
||
_listAgentName = string.IsNullOrWhiteSpace(listCfg?.AgentPath)
|
||
? null : System.IO.Path.GetFileName(listCfg!.AgentPath!);
|
||
|
||
EffectiveSystemPromptHint = string.IsNullOrWhiteSpace(listCfg?.SystemPrompt) ? "" : listCfg!.SystemPrompt!;
|
||
|
||
RecomputeModelBadge();
|
||
RecomputeTurnsBadge();
|
||
RecomputeAgentBadge();
|
||
OnPropertyChanged(nameof(EffectiveMaxTurns));
|
||
OnPropertyChanged(nameof(TurnsText));
|
||
}
|
||
finally
|
||
{
|
||
_suppressAgentSave = false;
|
||
}
|
||
}
|
||
|
||
public void ShowNotes()
|
||
{
|
||
Bind(null);
|
||
IsPrepMode = false;
|
||
IsNotesMode = true;
|
||
_ = Notes.LoadDayAsync(DateOnly.FromDateTime(DateTime.Today));
|
||
}
|
||
|
||
public void ShowPrep()
|
||
{
|
||
Bind(null);
|
||
IsNotesMode = false;
|
||
IsPrepMode = true;
|
||
_ = LoadLastPrepLogIfEmptyAsync();
|
||
}
|
||
|
||
public async Task LoadLastPrepLogIfEmptyAsync()
|
||
{
|
||
if (_worker is null || IsPrepRunning || PrepLog.Count > 0) return;
|
||
string text;
|
||
try { text = await _worker.GetLastPrepLogAsync(); }
|
||
catch { return; }
|
||
if (IsPrepRunning || PrepLog.Count > 0) return;
|
||
foreach (var line in text.Split('\n'))
|
||
{
|
||
var trimmed = line.TrimEnd('\r');
|
||
if (trimmed.Length > 0) AppendStdoutLine(PrepLog, trimmed);
|
||
}
|
||
}
|
||
|
||
public void Bind(TaskRowViewModel? row)
|
||
{
|
||
IsNotesMode = false;
|
||
IsPrepMode = false;
|
||
_loadCts?.Cancel();
|
||
_loadCts?.Dispose();
|
||
_loadCts = new CancellationTokenSource();
|
||
var ct = _loadCts.Token;
|
||
|
||
Task = row;
|
||
OnPropertyChanged(nameof(TaskIdBadge));
|
||
Log.Clear();
|
||
Subtasks.Clear();
|
||
ChildOutcomes.Clear();
|
||
OnPropertyChanged(nameof(HasChildOutcomes));
|
||
MergeTargetBranches.Clear();
|
||
SelectedMergeTarget = null;
|
||
CanMergeAll = false;
|
||
MergeAllDisabledReason = null;
|
||
MergeAllError = null;
|
||
_claudeBuf.Clear();
|
||
|
||
if (row == null)
|
||
{
|
||
_subscribedTaskId = null;
|
||
EditableTitle = "";
|
||
EditableDescription = "";
|
||
Model = null;
|
||
WorktreePath = null;
|
||
WorktreeStateLabel = null;
|
||
BranchLine = null;
|
||
DiffAdditions = 0;
|
||
DiffDeletions = 0;
|
||
AgentState = "idle";
|
||
LatestRunSessionId = null;
|
||
_suppressAgentSave = true;
|
||
try
|
||
{
|
||
TaskModelSelection = null;
|
||
TaskMaxTurns = null;
|
||
TaskSystemPrompt = "";
|
||
TaskSelectedAgent = null;
|
||
}
|
||
finally
|
||
{
|
||
_suppressAgentSave = false;
|
||
}
|
||
EffectiveSystemPromptHint = "";
|
||
return;
|
||
}
|
||
|
||
_ = BindAsync(row, ct);
|
||
}
|
||
|
||
private async System.Threading.Tasks.Task BindAsync(TaskRowViewModel row, CancellationToken ct)
|
||
{
|
||
try
|
||
{
|
||
await using var ctx = await _dbFactory.CreateDbContextAsync(ct);
|
||
var subtaskRepo = new SubtaskRepository(ctx);
|
||
|
||
// Own query with Include so WorktreePath/BranchLine are populated.
|
||
var entity = await ctx.Tasks
|
||
.AsNoTracking()
|
||
.Include(t => t.Worktree)
|
||
.FirstOrDefaultAsync(t => t.Id == row.Id, ct);
|
||
ct.ThrowIfCancellationRequested();
|
||
if (entity == null) return;
|
||
|
||
EditableTitle = entity.Title;
|
||
_suppressDescSave = true;
|
||
try { EditableDescription = entity.Description ?? ""; }
|
||
finally { _suppressDescSave = false; }
|
||
Model = entity.Model;
|
||
WorktreePath = entity.Worktree?.Path;
|
||
WorktreeBaseCommit = entity.Worktree?.BaseCommit;
|
||
WorktreeStateLabel = entity.Worktree?.State.ToString();
|
||
BranchLine = entity.Worktree is { } w ? $"{w.BranchName} \u2190 main" : null;
|
||
var (add, del) = ParseDiffStat(entity.Worktree?.DiffStat);
|
||
DiffAdditions = add;
|
||
DiffDeletions = del;
|
||
AgentState = StatusToStateKey(entity.Status);
|
||
await LoadAgentSettingsAsync(entity, ct);
|
||
ct.ThrowIfCancellationRequested();
|
||
|
||
var runRepo = new TaskRunRepository(ctx);
|
||
var latestRun = await runRepo.GetLatestByTaskIdAsync(row.Id, ct);
|
||
ct.ThrowIfCancellationRequested();
|
||
LatestRunSessionId = latestRun?.SessionId;
|
||
|
||
// Subscribe only after DB load confirms the task exists
|
||
_subscribedTaskId = row.Id;
|
||
|
||
// Replay the latest run's persisted log so output is visible across app restarts.
|
||
await ReplayLogFileAsync(entity.LogPath, ct);
|
||
|
||
var subs = await subtaskRepo.GetByTaskIdAsync(row.Id);
|
||
ct.ThrowIfCancellationRequested();
|
||
foreach (var s in subs)
|
||
Subtasks.Add(new SubtaskRowViewModel { Id = s.Id, Title = s.Title, Done = s.Completed });
|
||
|
||
if (entity.PlanningPhase != ClaudeDo.Data.Models.PlanningPhase.None)
|
||
{
|
||
await LoadPlanningChildrenAsync(row.Id, ct);
|
||
}
|
||
else
|
||
{
|
||
await LoadChildOutcomesAsync(row.Id, ct);
|
||
}
|
||
|
||
if (entity.Worktree != null
|
||
&& entity.PlanningPhase == ClaudeDo.Data.Models.PlanningPhase.None
|
||
&& MergeTargetBranches.Count == 0)
|
||
{
|
||
var targets = await _worker.GetMergeTargetsAsync(row.Id);
|
||
if (targets != null)
|
||
{
|
||
MergeTargetBranches.Clear();
|
||
foreach (var b in targets.LocalBranches) MergeTargetBranches.Add(b);
|
||
SelectedMergeTarget = targets.DefaultBranch; // triggers OnSelectedMergeTargetChanged → preview
|
||
}
|
||
}
|
||
await RefreshMergePreviewAsync();
|
||
}
|
||
catch (OperationCanceledException) { }
|
||
}
|
||
|
||
// Improvement parents (non-planning) surface their children's outcomes + roadblocks
|
||
// on the review card, and reuse the planning merge controls to fold the tree in.
|
||
private async System.Threading.Tasks.Task LoadChildOutcomesAsync(string parentTaskId, CancellationToken ct)
|
||
{
|
||
try
|
||
{
|
||
await using var ctx = await _dbFactory.CreateDbContextAsync(ct);
|
||
var children = await ctx.Tasks
|
||
.AsNoTracking()
|
||
.Include(t => t.Worktree)
|
||
.Where(t => t.ParentTaskId == parentTaskId)
|
||
.OrderBy(t => t.SortOrder).ThenBy(t => t.CreatedAt)
|
||
.ToListAsync(ct);
|
||
ct.ThrowIfCancellationRequested();
|
||
if (children.Count == 0) return;
|
||
|
||
ChildOutcomes.Clear();
|
||
foreach (var c in children)
|
||
ChildOutcomes.Add(new ChildOutcomeRowViewModel
|
||
{
|
||
Id = c.Id,
|
||
Title = c.Title,
|
||
Status = c.Status,
|
||
RoadblockCount = c.RoadblockCount,
|
||
WorktreeState = c.Worktree?.State ?? ClaudeDo.Data.Models.WorktreeState.Active,
|
||
});
|
||
OnPropertyChanged(nameof(HasChildOutcomes));
|
||
|
||
if (MergeTargetBranches.Count == 0)
|
||
{
|
||
var childWithWorktree = children.FirstOrDefault(c => c.Worktree != null);
|
||
if (childWithWorktree != null)
|
||
{
|
||
var targets = await _worker.GetMergeTargetsAsync(childWithWorktree.Id);
|
||
if (targets != null)
|
||
{
|
||
MergeTargetBranches.Clear();
|
||
foreach (var b in targets.LocalBranches)
|
||
MergeTargetBranches.Add(b);
|
||
SelectedMergeTarget = targets.DefaultBranch;
|
||
}
|
||
}
|
||
}
|
||
|
||
RecomputeCanMergeAll();
|
||
}
|
||
catch (OperationCanceledException) { }
|
||
catch { /* best-effort */ }
|
||
}
|
||
|
||
private async System.Threading.Tasks.Task ReplayLogFileAsync(string? logPath, CancellationToken ct)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(logPath)) return;
|
||
var expanded = ExpandUserPath(logPath);
|
||
if (!System.IO.File.Exists(expanded)) return;
|
||
|
||
try
|
||
{
|
||
const int maxLines = 2000;
|
||
string[] all;
|
||
await using (var fs = new System.IO.FileStream(
|
||
expanded,
|
||
System.IO.FileMode.Open,
|
||
System.IO.FileAccess.Read,
|
||
System.IO.FileShare.ReadWrite | System.IO.FileShare.Delete))
|
||
using (var reader = new System.IO.StreamReader(fs))
|
||
{
|
||
var list = new List<string>();
|
||
while (await reader.ReadLineAsync(ct) is { } line)
|
||
list.Add(line);
|
||
all = list.ToArray();
|
||
}
|
||
ct.ThrowIfCancellationRequested();
|
||
|
||
var start = Math.Max(0, all.Length - maxLines);
|
||
for (int i = start; i < all.Length; i++)
|
||
{
|
||
ct.ThrowIfCancellationRequested();
|
||
if (_subscribedTaskId is null) return;
|
||
// Worker writes raw Claude CLI stdout to disk (no prefix) but broadcasts
|
||
// it with a "[stdout] " prefix. Match the live-stream format so the same
|
||
// stream-json parser handles both.
|
||
var line = all[i];
|
||
var normalized = line.StartsWith("[", StringComparison.Ordinal) ? line : "[stdout] " + line;
|
||
OnTaskMessage(_subscribedTaskId, normalized);
|
||
}
|
||
FlushClaudeBuffer();
|
||
}
|
||
catch (OperationCanceledException) { throw; }
|
||
catch { /* best-effort replay */ }
|
||
}
|
||
|
||
private static string ExpandUserPath(string path)
|
||
{
|
||
if (path.StartsWith("~/", StringComparison.Ordinal) || path.StartsWith("~\\", StringComparison.Ordinal))
|
||
return System.IO.Path.Combine(
|
||
Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
|
||
path[2..]);
|
||
if (path == "~")
|
||
return Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
|
||
return path;
|
||
}
|
||
|
||
private async System.Threading.Tasks.Task LoadPlanningChildrenAsync(string parentTaskId, CancellationToken ct)
|
||
{
|
||
try
|
||
{
|
||
await using var ctx = await _dbFactory.CreateDbContextAsync(ct);
|
||
var children = await ctx.Tasks
|
||
.AsNoTracking()
|
||
.Include(t => t.Worktree)
|
||
.Where(t => t.ParentTaskId == parentTaskId)
|
||
.ToListAsync(ct);
|
||
ct.ThrowIfCancellationRequested();
|
||
|
||
foreach (var child in children)
|
||
{
|
||
var existing = Subtasks.FirstOrDefault(s => s.Id == child.Id);
|
||
if (existing != null)
|
||
{
|
||
existing.Status = child.Status;
|
||
existing.WorktreeState = child.Worktree?.State ?? ClaudeDo.Data.Models.WorktreeState.Active;
|
||
}
|
||
}
|
||
|
||
if (MergeTargetBranches.Count == 0)
|
||
{
|
||
var childWithWorktree = children.FirstOrDefault(c => c.Worktree != null);
|
||
if (childWithWorktree != null)
|
||
{
|
||
var targets = await _worker.GetMergeTargetsAsync(childWithWorktree.Id);
|
||
if (targets != null)
|
||
{
|
||
MergeTargetBranches.Clear();
|
||
foreach (var b in targets.LocalBranches)
|
||
MergeTargetBranches.Add(b);
|
||
SelectedMergeTarget = targets.DefaultBranch;
|
||
}
|
||
}
|
||
}
|
||
|
||
RecomputeCanMergeAll();
|
||
}
|
||
catch (OperationCanceledException) { }
|
||
catch { /* best-effort */ }
|
||
}
|
||
|
||
private async System.Threading.Tasks.Task RefreshPlanningChildAsync(string childTaskId)
|
||
{
|
||
if (Task is null) return;
|
||
try
|
||
{
|
||
await using var ctx = await _dbFactory.CreateDbContextAsync();
|
||
var child = await ctx.Tasks
|
||
.AsNoTracking()
|
||
.Include(t => t.Worktree)
|
||
.FirstOrDefaultAsync(t => t.Id == childTaskId && t.ParentTaskId == Task.Id);
|
||
if (child == null) return;
|
||
|
||
var existing = Subtasks.FirstOrDefault(s => s.Id == child.Id);
|
||
if (existing != null)
|
||
{
|
||
existing.Status = child.Status;
|
||
existing.WorktreeState = child.Worktree?.State ?? ClaudeDo.Data.Models.WorktreeState.Active;
|
||
}
|
||
|
||
RecomputeCanMergeAll();
|
||
}
|
||
catch { /* best-effort */ }
|
||
}
|
||
|
||
// Live-update a single improvement child's outcome row from a task event. No-op if the
|
||
// updated task isn't one of this parent's children.
|
||
private async System.Threading.Tasks.Task RefreshChildOutcomeAsync(string childTaskId)
|
||
{
|
||
var row = ChildOutcomes.FirstOrDefault(c => c.Id == childTaskId);
|
||
if (row is null) return;
|
||
try
|
||
{
|
||
await using var ctx = await _dbFactory.CreateDbContextAsync();
|
||
var child = await ctx.Tasks
|
||
.AsNoTracking()
|
||
.Include(t => t.Worktree)
|
||
.FirstOrDefaultAsync(t => t.Id == childTaskId);
|
||
if (child is null) return;
|
||
row.Status = child.Status;
|
||
row.RoadblockCount = child.RoadblockCount;
|
||
row.WorktreeState = child.Worktree?.State ?? ClaudeDo.Data.Models.WorktreeState.Active;
|
||
RecomputeCanMergeAll();
|
||
MergeAllCommand.NotifyCanExecuteChanged();
|
||
ReviewCombinedDiffCommand.NotifyCanExecuteChanged();
|
||
}
|
||
catch { /* best-effort */ }
|
||
}
|
||
|
||
internal void RecomputeCanMergeAll()
|
||
{
|
||
// Improvement parent: merge is allowed once every child is terminal. The
|
||
// orchestrator folds the parent's own branch and skips failed/cancelled children.
|
||
if (ChildOutcomes.Count > 0)
|
||
{
|
||
var unfinished = ChildOutcomes.Count(c =>
|
||
c.Status != ClaudeDo.Data.Models.TaskStatus.Done
|
||
&& c.Status != ClaudeDo.Data.Models.TaskStatus.Failed
|
||
&& c.Status != ClaudeDo.Data.Models.TaskStatus.Cancelled);
|
||
if (unfinished > 0)
|
||
{
|
||
CanMergeAll = false;
|
||
MergeAllDisabledReason = $"{unfinished} improvement(s) not finished";
|
||
return;
|
||
}
|
||
CanMergeAll = true;
|
||
MergeAllDisabledReason = null;
|
||
return;
|
||
}
|
||
|
||
var notDone = Subtasks.Count(c => c.Status != ClaudeDo.Data.Models.TaskStatus.Done);
|
||
if (notDone > 0)
|
||
{
|
||
CanMergeAll = false;
|
||
MergeAllDisabledReason = $"{notDone} subtask(s) not done";
|
||
return;
|
||
}
|
||
var badWt = Subtasks.FirstOrDefault(c =>
|
||
c.WorktreeState == ClaudeDo.Data.Models.WorktreeState.Discarded ||
|
||
c.WorktreeState == ClaudeDo.Data.Models.WorktreeState.Kept);
|
||
if (badWt is not null)
|
||
{
|
||
CanMergeAll = false;
|
||
MergeAllDisabledReason = "at least one worktree was discarded/kept";
|
||
return;
|
||
}
|
||
CanMergeAll = true;
|
||
MergeAllDisabledReason = null;
|
||
}
|
||
|
||
[RelayCommand(CanExecute = nameof(CanReviewDiff))]
|
||
private async System.Threading.Tasks.Task ReviewCombinedDiffAsync()
|
||
{
|
||
if (Task is null || ShowPlanningDiffModal is null) return;
|
||
var vm = new ViewModels.Planning.PlanningDiffViewModel(_worker, Task.Id, SelectedMergeTarget ?? "main");
|
||
await vm.InitializeAsync();
|
||
await ShowPlanningDiffModal(vm);
|
||
}
|
||
|
||
private bool CanReviewDiff() => (Task?.IsPlanningParent == true && Subtasks.Any()) || HasChildOutcomes;
|
||
|
||
[RelayCommand(CanExecute = nameof(CanMergeAll))]
|
||
private async System.Threading.Tasks.Task MergeAllAsync()
|
||
{
|
||
MergeAllError = null;
|
||
try
|
||
{
|
||
await _worker.MergeAllPlanningAsync(Task!.Id, SelectedMergeTarget ?? "main");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
MergeAllError = ex.Message;
|
||
}
|
||
}
|
||
|
||
private async System.Threading.Tasks.Task RefreshWorktreeAsync(string taskId)
|
||
{
|
||
try
|
||
{
|
||
await using var ctx = await _dbFactory.CreateDbContextAsync();
|
||
var entity = await ctx.Tasks
|
||
.AsNoTracking()
|
||
.Include(t => t.Worktree)
|
||
.FirstOrDefaultAsync(t => t.Id == taskId);
|
||
if (entity == null || Task?.Id != taskId) return;
|
||
|
||
WorktreePath = entity.Worktree?.Path;
|
||
WorktreeBaseCommit = entity.Worktree?.BaseCommit;
|
||
WorktreeStateLabel = entity.Worktree?.State.ToString();
|
||
BranchLine = entity.Worktree is { } w ? $"{w.BranchName} ← main" : null;
|
||
AgentState = StatusToStateKey(entity.Status);
|
||
if (Task is { } row && entity.Worktree?.DiffStat is { } stat)
|
||
row.DiffStat = stat;
|
||
var (add, del) = ParseDiffStat(entity.Worktree?.DiffStat);
|
||
DiffAdditions = add;
|
||
DiffDeletions = del;
|
||
}
|
||
catch { /* best-effort refresh */ }
|
||
}
|
||
|
||
private async System.Threading.Tasks.Task RefreshMergePreviewAsync()
|
||
{
|
||
if (Task is null || WorktreePath is null)
|
||
{
|
||
MergePreviewText = ""; MergeIsClean = false; MergeIsConflict = false;
|
||
return;
|
||
}
|
||
// Only probe Active worktrees; terminal states show their label instead.
|
||
if (WorktreeStateLabel is { } label && label != "Active")
|
||
{
|
||
MergePreviewText = label; MergeIsClean = false; MergeIsConflict = false;
|
||
return;
|
||
}
|
||
var capturedTaskId = Task.Id;
|
||
var capturedTarget = SelectedMergeTarget;
|
||
var dto = await _worker.PreviewMergeAsync(capturedTaskId, capturedTarget ?? "");
|
||
// Discard a probe that resolved after the user switched task or target.
|
||
if (Task?.Id != capturedTaskId || SelectedMergeTarget != capturedTarget) return;
|
||
var (text, clean, conflict) = MergePreviewPresenter.Describe(dto);
|
||
MergePreviewText = text; MergeIsClean = clean; MergeIsConflict = conflict;
|
||
}
|
||
|
||
[RelayCommand]
|
||
private async System.Threading.Tasks.Task MergeAsync()
|
||
{
|
||
if (Task is null || WorktreePath is null || !_worker.IsConnected) return;
|
||
try
|
||
{
|
||
var result = await _worker.MergeTaskAsync(Task.Id, SelectedMergeTarget ?? "", false, "Merge task");
|
||
if (result.Status == "conflict")
|
||
{
|
||
var (text, _, _) = MergePreviewPresenter.Describe(
|
||
new MergePreviewDto("conflict", result.ConflictFiles, 0));
|
||
MergePreviewText = text; MergeIsClean = false; MergeIsConflict = true;
|
||
}
|
||
else
|
||
{
|
||
await RefreshMergePreviewAsync();
|
||
}
|
||
}
|
||
catch { /* broadcast reconciles */ }
|
||
}
|
||
|
||
[RelayCommand(CanExecute = nameof(CanOpenDiff))]
|
||
private async System.Threading.Tasks.Task OpenDiffAsync()
|
||
{
|
||
if (WorktreePath == null || ShowDiffModal == null) return;
|
||
var diffVm = new DiffModalViewModel(_services.GetRequiredService<ClaudeDo.Data.Git.GitService>())
|
||
{
|
||
WorktreePath = WorktreePath,
|
||
BaseRef = WorktreeBaseCommit,
|
||
TaskId = Task?.Id,
|
||
TaskTitle = Task?.Title ?? "",
|
||
ShowMergeModal = ShowMergeModal,
|
||
ResolveMergeVm = () => _services.GetRequiredService<MergeModalViewModel>(),
|
||
};
|
||
await diffVm.LoadAsync();
|
||
await ShowDiffModal(diffVm);
|
||
}
|
||
|
||
private bool CanOpenDiff() => WorktreePath != null;
|
||
|
||
[RelayCommand(CanExecute = nameof(CanOpenWorktree))]
|
||
private void OpenWorktree()
|
||
{
|
||
if (WorktreePath == null) return;
|
||
try
|
||
{
|
||
System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo
|
||
{
|
||
FileName = WorktreePath,
|
||
UseShellExecute = true,
|
||
});
|
||
}
|
||
catch { /* explorer open is best-effort */ }
|
||
}
|
||
|
||
private bool CanOpenWorktree() => WorktreePath != null;
|
||
|
||
partial void OnSelectedMergeTargetChanged(string? value)
|
||
{
|
||
_ = RefreshMergePreviewAsync();
|
||
}
|
||
|
||
partial void OnWorktreePathChanged(string? value)
|
||
{
|
||
OpenDiffCommand.NotifyCanExecuteChanged();
|
||
OpenWorktreeCommand.NotifyCanExecuteChanged();
|
||
NotifySessionSections();
|
||
OnPropertyChanged(nameof(ShowSingleMerge));
|
||
}
|
||
|
||
partial void OnTaskChanged(TaskRowViewModel? value) => NotifySessionSections();
|
||
|
||
[RelayCommand]
|
||
private void CloseDetails() => CloseDetail?.Invoke();
|
||
|
||
[RelayCommand]
|
||
private async System.Threading.Tasks.Task ToggleStarAsync()
|
||
{
|
||
if (Task is null) return;
|
||
Task.IsStarred = !Task.IsStarred;
|
||
await using var ctx = _dbFactory.CreateDbContext();
|
||
var repo = new TaskRepository(ctx);
|
||
var entity = await repo.GetByIdAsync(Task.Id);
|
||
if (entity is null) return;
|
||
entity.IsStarred = Task.IsStarred;
|
||
await repo.UpdateAsync(entity);
|
||
}
|
||
|
||
[RelayCommand]
|
||
private async System.Threading.Tasks.Task ToggleDoneAsync()
|
||
{
|
||
if (Task is null) return;
|
||
Task.Done = !Task.Done;
|
||
await using var ctx = _dbFactory.CreateDbContext();
|
||
var repo = new TaskRepository(ctx);
|
||
var entity = await repo.GetByIdAsync(Task.Id);
|
||
if (entity is null) return;
|
||
entity.Status = Task.Done
|
||
? ClaudeDo.Data.Models.TaskStatus.Done
|
||
: ClaudeDo.Data.Models.TaskStatus.Idle;
|
||
Task.Status = entity.Status;
|
||
AgentState = StatusToStateKey(entity.Status);
|
||
await repo.UpdateAsync(entity);
|
||
}
|
||
|
||
[RelayCommand]
|
||
private async System.Threading.Tasks.Task ToggleSubtaskDoneAsync(SubtaskRowViewModel? row)
|
||
{
|
||
if (row is null) return;
|
||
row.Done = !row.Done;
|
||
NotifyStepsChanged();
|
||
await using var ctx = _dbFactory.CreateDbContext();
|
||
var repo = new SubtaskRepository(ctx);
|
||
var subs = await repo.GetByTaskIdAsync(Task?.Id ?? "");
|
||
var entity = subs.FirstOrDefault(s => s.Id == row.Id);
|
||
if (entity is null) return;
|
||
entity.Completed = row.Done;
|
||
await repo.UpdateAsync(entity);
|
||
}
|
||
|
||
[RelayCommand]
|
||
private async System.Threading.Tasks.Task DeleteTaskAsync()
|
||
{
|
||
if (Task == null) return;
|
||
var row = Task;
|
||
if (ConfirmAsync != null)
|
||
{
|
||
var ok = await ConfirmAsync($"Delete \"{row.Title}\"? This cannot be undone.");
|
||
if (!ok) return;
|
||
}
|
||
try
|
||
{
|
||
await using var ctx = _dbFactory.CreateDbContext();
|
||
var repo = new TaskRepository(ctx);
|
||
await repo.DeleteAsync(row.Id);
|
||
}
|
||
catch (DbUpdateException ex) when (
|
||
ex.Message.Contains("FOREIGN KEY", StringComparison.OrdinalIgnoreCase)
|
||
|| ex.InnerException?.Message.Contains("FOREIGN KEY", StringComparison.OrdinalIgnoreCase) == true)
|
||
{
|
||
if (ShowErrorAsync != null)
|
||
await ShowErrorAsync("This task has child tasks. Discard the planning session or delete child tasks first.");
|
||
return;
|
||
}
|
||
if (DeleteFromList != null)
|
||
await DeleteFromList(row);
|
||
CloseDetail?.Invoke();
|
||
}
|
||
|
||
[RelayCommand]
|
||
private async System.Threading.Tasks.Task CommitSubtaskEditAsync(SubtaskRowViewModel? row)
|
||
{
|
||
if (row is null || !row.IsEditing) return;
|
||
row.IsEditing = false;
|
||
|
||
var title = row.Title?.Trim() ?? "";
|
||
await using var ctx = _dbFactory.CreateDbContext();
|
||
var repo = new SubtaskRepository(ctx);
|
||
|
||
// Emptying the text removes the step.
|
||
if (string.IsNullOrEmpty(title))
|
||
{
|
||
await repo.DeleteAsync(row.Id);
|
||
Subtasks.Remove(row);
|
||
return;
|
||
}
|
||
|
||
var subs = await repo.GetByTaskIdAsync(Task?.Id ?? "");
|
||
var entity = subs.FirstOrDefault(s => s.Id == row.Id);
|
||
if (entity is null) return;
|
||
if (entity.Title != title)
|
||
{
|
||
entity.Title = title;
|
||
await repo.UpdateAsync(entity);
|
||
}
|
||
row.Title = title;
|
||
OnPropertyChanged(nameof(ComposedPreview));
|
||
}
|
||
|
||
[RelayCommand]
|
||
private async System.Threading.Tasks.Task AddSubtaskAsync()
|
||
{
|
||
if (Task is null) return;
|
||
var title = NewSubtaskTitle?.Trim();
|
||
if (string.IsNullOrEmpty(title)) return;
|
||
|
||
var entity = new ClaudeDo.Data.Models.SubtaskEntity
|
||
{
|
||
Id = Guid.NewGuid().ToString(),
|
||
TaskId = Task.Id,
|
||
Title = title,
|
||
Completed = false,
|
||
OrderNum = Subtasks.Count,
|
||
CreatedAt = DateTime.UtcNow,
|
||
};
|
||
|
||
await using var ctx = _dbFactory.CreateDbContext();
|
||
await new SubtaskRepository(ctx).AddAsync(entity);
|
||
|
||
Subtasks.Add(new SubtaskRowViewModel { Id = entity.Id, Title = entity.Title, Done = entity.Completed });
|
||
NewSubtaskTitle = "";
|
||
}
|
||
|
||
[RelayCommand]
|
||
private async System.Threading.Tasks.Task StopAsync()
|
||
{
|
||
if (Task == null) return;
|
||
await _worker.CancelTaskAsync(Task.Id);
|
||
}
|
||
|
||
[RelayCommand(CanExecute = nameof(CanEnqueue))]
|
||
private async System.Threading.Tasks.Task EnqueueAsync()
|
||
{
|
||
if (Task == null) return;
|
||
try
|
||
{
|
||
await _worker.SetTaskStatusAsync(Task.Id, ClaudeDo.Data.Models.TaskStatus.Queued);
|
||
AgentState = "queued";
|
||
}
|
||
catch { /* offline */ }
|
||
}
|
||
|
||
private bool CanEnqueue() =>
|
||
Task != null && _worker.IsConnected && IsIdle
|
||
&& (!Task.IsChild || Task.ParentFinalized);
|
||
|
||
[RelayCommand(CanExecute = nameof(CanDequeue))]
|
||
private async System.Threading.Tasks.Task DequeueAsync()
|
||
{
|
||
if (Task == null) return;
|
||
try
|
||
{
|
||
await _worker.SetTaskStatusAsync(Task.Id, ClaudeDo.Data.Models.TaskStatus.Idle);
|
||
AgentState = "idle";
|
||
}
|
||
catch { /* offline */ }
|
||
}
|
||
|
||
private bool CanDequeue() =>
|
||
Task != null && _worker.IsConnected && IsQueued;
|
||
|
||
[RelayCommand(CanExecute = nameof(CanContinue))]
|
||
private async System.Threading.Tasks.Task ContinueAsync()
|
||
{
|
||
if (Task == null) return;
|
||
await _worker.ContinueTaskAsync(Task.Id, "Continue working on this task.");
|
||
}
|
||
|
||
private bool CanContinue() =>
|
||
Task != null && _worker.IsConnected && ShowContinue && !string.IsNullOrEmpty(LatestRunSessionId);
|
||
|
||
[RelayCommand(CanExecute = nameof(CanResetAndRetry))]
|
||
private async System.Threading.Tasks.Task ResetAndRetryAsync()
|
||
{
|
||
if (Task == null) return;
|
||
if (ConfirmAsync == null) return;
|
||
|
||
var branchName = $"claudedo/{Task.Id.Replace("-", "")}";
|
||
var ok = await ConfirmAsync(
|
||
$"Reset and retry?\nThis discards branch {branchName} (and uncommitted changes), then queues the task to run from the beginning.");
|
||
if (!ok) return;
|
||
|
||
if (WorktreePath != null)
|
||
await _worker.ResetTaskAsync(Task.Id);
|
||
|
||
try
|
||
{
|
||
await _worker.SetTaskStatusAsync(Task.Id, ClaudeDo.Data.Models.TaskStatus.Queued);
|
||
AgentState = "queued";
|
||
}
|
||
catch { /* offline */ }
|
||
}
|
||
|
||
private bool CanResetAndRetry() =>
|
||
Task != null && _worker.IsConnected && ShowResetAndRetry;
|
||
|
||
[RelayCommand] private void ResetTaskModel() => TaskModelSelection = null;
|
||
[RelayCommand] private void ResetTaskTurns() => TaskMaxTurns = null;
|
||
[RelayCommand] private void ResetTaskAgent() => TaskSelectedAgent = TaskAgentOptions.Count > 0 ? TaskAgentOptions[0] : null;
|
||
|
||
// ── Review actions ──────────────────────────────────────────────────────────
|
||
[ObservableProperty] private string _reviewFeedback = "";
|
||
|
||
[RelayCommand]
|
||
private async System.Threading.Tasks.Task ApproveReviewAsync()
|
||
{
|
||
if (Task is null || !_worker.IsConnected) return;
|
||
try
|
||
{
|
||
var result = await _worker.ApproveReviewAsync(Task.Id, SelectedMergeTarget ?? "");
|
||
if (result?.Status == "conflict")
|
||
{
|
||
var (text, _, _) = MergePreviewPresenter.Describe(
|
||
new MergePreviewDto("conflict", result.ConflictFiles, 0));
|
||
MergePreviewText = text; MergeIsClean = false; MergeIsConflict = true;
|
||
}
|
||
}
|
||
catch { /* stale review action; broadcast reconciles */ }
|
||
}
|
||
|
||
[RelayCommand]
|
||
private async System.Threading.Tasks.Task RejectReviewAsync()
|
||
{
|
||
if (Task is null || !_worker.IsConnected) return;
|
||
var feedback = ReviewFeedback;
|
||
if (string.IsNullOrWhiteSpace(feedback)) return;
|
||
try { await _worker.RejectReviewToQueueAsync(Task.Id, feedback); }
|
||
catch { /* stale review action; broadcast reconciles */ return; }
|
||
ReviewFeedback = "";
|
||
}
|
||
|
||
[RelayCommand]
|
||
private async System.Threading.Tasks.Task ResetReviewAsync()
|
||
{
|
||
if (Task is null || !_worker.IsConnected || ConfirmAsync is null) return;
|
||
var branchName = $"claudedo/{Task.Id.Replace("-", "")}";
|
||
var ok = await ConfirmAsync(
|
||
$"Reset working tree?\nThis discards branch {branchName} (and all changes) and returns the task to Idle.");
|
||
if (!ok) return;
|
||
try { await _worker.ResetTaskAsync(Task.Id); }
|
||
catch { /* stale review action; broadcast reconciles */ }
|
||
}
|
||
|
||
[RelayCommand]
|
||
private async System.Threading.Tasks.Task CancelReviewAsync()
|
||
{
|
||
if (Task is null || !_worker.IsConnected) return;
|
||
try { await _worker.CancelReviewAsync(Task.Id); }
|
||
catch { /* stale review action; broadcast reconciles */ }
|
||
}
|
||
|
||
// ── Diff meter parser ───────────────────────────────────────────────────────
|
||
internal static (int Additions, int Deletions) ParseDiffStat(string? stat)
|
||
{
|
||
if (string.IsNullOrEmpty(stat)) return (0, 0);
|
||
int add = 0, del = 0;
|
||
var m1 = System.Text.RegularExpressions.Regex.Match(stat, @"(\d+)\s+insertion");
|
||
var m2 = System.Text.RegularExpressions.Regex.Match(stat, @"(\d+)\s+deletion");
|
||
if (m1.Success) int.TryParse(m1.Groups[1].Value, out add);
|
||
if (m2.Success) int.TryParse(m2.Groups[1].Value, out del);
|
||
return (add, del);
|
||
}
|
||
}
|
||
|
||
public sealed partial class SubtaskRowViewModel : ViewModelBase
|
||
{
|
||
public required string Id { get; init; }
|
||
[ObservableProperty] private string _title = "";
|
||
[ObservableProperty] private bool _done;
|
||
[ObservableProperty] private bool _isEditing;
|
||
[ObservableProperty] private ClaudeDo.Data.Models.TaskStatus _status;
|
||
[ObservableProperty] private ClaudeDo.Data.Models.WorktreeState _worktreeState = ClaudeDo.Data.Models.WorktreeState.Active;
|
||
}
|
||
|
||
// A suggested child's outcome on an improvement parent's review card. Observable so the
|
||
// row reflects the child's live status (Idle → Running → Done/Failed) as it executes.
|
||
public sealed partial class ChildOutcomeRowViewModel : ViewModelBase
|
||
{
|
||
public required string Id { get; init; }
|
||
public required string Title { get; init; }
|
||
|
||
[ObservableProperty]
|
||
[NotifyPropertyChangedFor(nameof(StatusLabel))]
|
||
private ClaudeDo.Data.Models.TaskStatus _status;
|
||
|
||
[ObservableProperty]
|
||
[NotifyPropertyChangedFor(nameof(HasRoadblock))]
|
||
[NotifyPropertyChangedFor(nameof(RoadblockText))]
|
||
private int _roadblockCount;
|
||
|
||
[ObservableProperty]
|
||
private ClaudeDo.Data.Models.WorktreeState _worktreeState = ClaudeDo.Data.Models.WorktreeState.Active;
|
||
|
||
public string StatusLabel => Status switch
|
||
{
|
||
ClaudeDo.Data.Models.TaskStatus.Done => Loc.T("vm.taskStatus.done"),
|
||
ClaudeDo.Data.Models.TaskStatus.Failed => Loc.T("vm.taskStatus.failed"),
|
||
ClaudeDo.Data.Models.TaskStatus.Cancelled => Loc.T("vm.taskStatus.cancelled"),
|
||
ClaudeDo.Data.Models.TaskStatus.Running => Loc.T("vm.taskStatus.running"),
|
||
ClaudeDo.Data.Models.TaskStatus.Queued => Loc.T("vm.taskStatus.queued"),
|
||
ClaudeDo.Data.Models.TaskStatus.WaitingForReview => Loc.T("vm.taskStatus.waitingForReview"),
|
||
ClaudeDo.Data.Models.TaskStatus.WaitingForChildren => Loc.T("vm.taskStatus.waitingForChildren"),
|
||
_ => Loc.T("vm.taskStatus.idle"),
|
||
};
|
||
|
||
public bool HasRoadblock => RoadblockCount > 0;
|
||
public string RoadblockText => RoadblockCount == 1 ? "1 roadblock" : $"{RoadblockCount} roadblocks";
|
||
}
|