feat(ui): session skills registry tab + per-level selectors

2026-07-23 16:47:14 +02:00
parent b4c58087d2
commit 7c3c061428
12 changed files with 562 additions and 10 deletions
@@ -14,12 +14,14 @@ public class AgentConfigEditorViewModelTests
        public AppSettingsDto? App;
        public ListConfigDto? ListCfg;
        public List<AgentInfo> AgentList = new();
+        public List<SessionSkillDto> InstalledSkills = new();
        public UpdateListConfigDto? SavedListConfig;
        public UpdateTaskAgentSettingsDto? SavedTaskSettings;

        public override Task<AppSettingsDto?> GetAppSettingsAsync() => Task.FromResult(App);
        public override Task<ListConfigDto?> GetListConfigAsync(string listId) => Task.FromResult(ListCfg);
        public override Task<List<AgentInfo>> GetAgentsAsync() => Task.FromResult(AgentList);
+        public override Task<List<SessionSkillDto>> GetSessionSkillsAsync() => Task.FromResult(InstalledSkills);
        public override Task UpdateListConfigAsync(UpdateListConfigDto dto) { SavedListConfig = dto; return Task.CompletedTask; }
        public override Task UpdateTaskAgentSettingsAsync(UpdateTaskAgentSettingsDto dto) { SavedTaskSettings = dto; return Task.CompletedTask; }
    }
@@ -186,4 +188,102 @@ public class AgentConfigEditorViewModelTests
        await vm.SaveAsync();
        Assert.Null(w.SavedTaskSettings);
    }
+
+    // ── Session skills ──────────────────────────────────────────────────────
+
+    private static SessionSkillDto Skill(string name) => new(name, "desc-" + name, "url-" + name, "ref", DateTimeOffset.UtcNow);
+
+    [Fact]
+    public async Task List_load_reflects_selection_from_list_config()
+    {
+        var w = new FakeWorker
+        {
+            App = AppWith("haiku", 50),
+            ListCfg = new ListConfigDto(null, null, null, null, new List<string> { "skill-b" }),
+            InstalledSkills = new() { Skill("skill-a"), Skill("skill-b") },
+        };
+        var vm = new AgentConfigEditorViewModel(w, AgentConfigScope.List);
+
+        await vm.LoadForListAsync("l1");
+
+        Assert.Equal(2, vm.SessionSkills.Count);
+        Assert.False(vm.SessionSkills.Single(s => s.Name == "skill-a").IsSelected);
+        Assert.True(vm.SessionSkills.Single(s => s.Name == "skill-b").IsSelected);
+    }
+
+    [Fact]
+    public async Task List_save_includes_selected_skill_names()
+    {
+        var w = new FakeWorker
+        {
+            App = AppWith("haiku", 50),
+            ListCfg = new ListConfigDto(null, null, null, null, null),
+            InstalledSkills = new() { Skill("skill-a"), Skill("skill-b") },
+        };
+        var vm = new AgentConfigEditorViewModel(w, AgentConfigScope.List);
+        await vm.LoadForListAsync("l1");
+
+        vm.SessionSkills.Single(s => s.Name == "skill-a").IsSelected = true;
+        await vm.SaveAsync();
+
+        Assert.NotNull(w.SavedListConfig);
+        Assert.Equal(new List<string> { "skill-a" }, w.SavedListConfig!.SessionSkills);
+    }
+
+    [Fact]
+    public async Task Task_load_parses_session_skills_json_and_reflects_selection()
+    {
+        var w = new FakeWorker
+        {
+            App = AppWith("haiku", 50),
+            ListCfg = new ListConfigDto(null, null, null, null),
+            InstalledSkills = new() { Skill("skill-a"), Skill("skill-b") },
+        };
+        var vm = new AgentConfigEditorViewModel(w, AgentConfigScope.Task);
+        var entity = TaskWith(null, null, "", null);
+        entity.SessionSkills = "[\"skill-a\"]";
+
+        await vm.LoadForTaskAsync(entity);
+
+        Assert.True(vm.SessionSkills.Single(s => s.Name == "skill-a").IsSelected);
+        Assert.False(vm.SessionSkills.Single(s => s.Name == "skill-b").IsSelected);
+    }
+
+    [Fact]
+    public async Task Task_toggling_a_skill_auto_saves_selection()
+    {
+        var w = new FakeWorker
+        {
+            App = AppWith("haiku", 50),
+            ListCfg = new ListConfigDto(null, null, null, null),
+            InstalledSkills = new() { Skill("skill-a") },
+        };
+        var vm = new AgentConfigEditorViewModel(w, AgentConfigScope.Task);
+        await vm.LoadForTaskAsync(TaskWith(null, null, "", null));
+
+        vm.SessionSkills.Single(s => s.Name == "skill-a").IsSelected = true;
+        await Task.Delay(500);
+
+        Assert.NotNull(w.SavedTaskSettings);
+        Assert.Equal(new List<string> { "skill-a" }, w.SavedTaskSettings!.SessionSkills);
+    }
+
+    [Fact]
+    public async Task Clear_deselects_all_skills()
+    {
+        var w = new FakeWorker
+        {
+            App = AppWith("haiku", 50),
+            ListCfg = new ListConfigDto(null, null, null, null),
+            InstalledSkills = new() { Skill("skill-a") },
+        };
+        var vm = new AgentConfigEditorViewModel(w, AgentConfigScope.Task);
+        var entity = TaskWith(null, null, "", null);
+        entity.SessionSkills = "[\"skill-a\"]";
+        await vm.LoadForTaskAsync(entity);
+
+        vm.Clear();
+
+        Assert.All(vm.SessionSkills, s => Assert.False(s.IsSelected));
+    }
 }
@@ -0,0 +1,48 @@
+using ClaudeDo.Ui.Services;
+using ClaudeDo.Ui.ViewModels.Modals.Settings;
+using Xunit;
+
+namespace ClaudeDo.Ui.Tests.ViewModels;
+
+public class GeneralSettingsTabViewModelTests
+{
+    private sealed class FakeWorker : StubWorkerClient
+    {
+        public List<SessionSkillDto> Installed = new();
+        public override Task<List<SessionSkillDto>> GetSessionSkillsAsync() => Task.FromResult(Installed);
+    }
+
+    [Fact]
+    public async Task LoadSessionSkillsAsync_reflects_current_selection()
+    {
+        var w = new FakeWorker
+        {
+            Installed = new() { new SessionSkillDto("a", "", "url-a", "ref", DateTimeOffset.UtcNow),
+                                 new SessionSkillDto("b", "", "url-b", "ref", DateTimeOffset.UtcNow) },
+        };
+        var vm = new GeneralSettingsTabViewModel();
+
+        await vm.LoadSessionSkillsAsync(w, new List<string> { "b" });
+
+        Assert.Equal(2, vm.SessionSkills.Count);
+        Assert.False(vm.SessionSkills.Single(s => s.Name == "a").IsSelected);
+        Assert.True(vm.SessionSkills.Single(s => s.Name == "b").IsSelected);
+    }
+
+    [Fact]
+    public async Task SelectedSessionSkillNames_round_trips_through_toggle()
+    {
+        var w = new FakeWorker
+        {
+            Installed = new() { new SessionSkillDto("a", "", "url-a", "ref", DateTimeOffset.UtcNow) },
+        };
+        var vm = new GeneralSettingsTabViewModel();
+        await vm.LoadSessionSkillsAsync(w, null);
+
+        Assert.Null(vm.SelectedSessionSkillNames());
+
+        vm.SessionSkills.Single().IsSelected = true;
+
+        Assert.Equal(new List<string> { "a" }, vm.SelectedSessionSkillNames());
+    }
+}
@@ -0,0 +1,113 @@
+using ClaudeDo.Ui.Services;
+using ClaudeDo.Ui.ViewModels.Modals.Settings;
+using Xunit;
+
+namespace ClaudeDo.Ui.Tests.ViewModels;
+
+public class SessionSkillsSettingsTabViewModelTests
+{
+    private sealed class FakeWorker : StubWorkerClient
+    {
+        public List<SessionSkillDto> Installed = new();
+        public string? InstallUrlReceived;
+        public string? UpdatedSourceUrl;
+        public string? RemovedSourceUrl;
+        public Exception? InstallError;
+
+        public override Task<List<SessionSkillDto>> GetSessionSkillsAsync() => Task.FromResult(Installed);
+
+        public override Task<List<string>> InstallSessionSkillAsync(string url)
+        {
+            if (InstallError is not null) throw InstallError;
+            InstallUrlReceived = url;
+            Installed = Installed.Append(new SessionSkillDto("new-skill", "desc", url, "abc123", DateTimeOffset.UtcNow)).ToList();
+            return Task.FromResult(new List<string> { "new-skill" });
+        }
+
+        public override Task UpdateSessionSkillAsync(string sourceUrl) { UpdatedSourceUrl = sourceUrl; return Task.CompletedTask; }
+        public override Task RemoveSessionSkillAsync(string sourceUrl)
+        {
+            RemovedSourceUrl = sourceUrl;
+            Installed = Installed.Where(s => s.SourceUrl != sourceUrl).ToList();
+            return Task.CompletedTask;
+        }
+    }
+
+    [Fact]
+    public async Task LoadAsync_populates_skills_from_worker()
+    {
+        var w = new FakeWorker { Installed = new() { new SessionSkillDto("a", "desc-a", "url-a", "ref-a", DateTimeOffset.UtcNow) } };
+        var vm = new SessionSkillsSettingsTabViewModel(w);
+
+        await vm.LoadAsync();
+
+        Assert.Single(vm.Skills);
+        Assert.Equal("a", vm.Skills[0].Name);
+    }
+
+    [Fact]
+    public async Task InstallAsync_installs_then_refreshes_and_sets_status()
+    {
+        var w = new FakeWorker();
+        var vm = new SessionSkillsSettingsTabViewModel(w) { InstallUrl = "https://example.com/repo.git" };
+
+        await vm.InstallCommand.ExecuteAsync(null);
+
+        Assert.Equal("https://example.com/repo.git", w.InstallUrlReceived);
+        Assert.Single(vm.Skills);
+        Assert.Equal("new-skill", vm.Skills[0].Name);
+        Assert.Contains("new-skill", vm.StatusMessage);
+        Assert.Equal("", vm.InstallUrl);
+    }
+
+    [Fact]
+    public async Task InstallAsync_surfaces_exception_message_on_failure()
+    {
+        // The worker actually throws a HubException on a name collision; any Exception with a
+        // readable Message exercises the same catch-and-surface path in the view model.
+        var w = new FakeWorker { InstallError = new InvalidOperationException("Skill 'foo' already installed from a different source.") };
+        var vm = new SessionSkillsSettingsTabViewModel(w) { InstallUrl = "https://example.com/dup.git" };
+
+        await vm.InstallCommand.ExecuteAsync(null);
+
+        Assert.Contains("already installed", vm.StatusMessage);
+        Assert.Empty(vm.Skills);
+    }
+
+    [Fact]
+    public async Task InstallAsync_does_nothing_for_blank_url()
+    {
+        var w = new FakeWorker();
+        var vm = new SessionSkillsSettingsTabViewModel(w) { InstallUrl = "   " };
+
+        await vm.InstallCommand.ExecuteAsync(null);
+
+        Assert.Null(w.InstallUrlReceived);
+    }
+
+    [Fact]
+    public async Task RemoveAsync_removes_then_refreshes()
+    {
+        var w = new FakeWorker { Installed = new() { new SessionSkillDto("a", "", "url-a", "ref-a", DateTimeOffset.UtcNow) } };
+        var vm = new SessionSkillsSettingsTabViewModel(w);
+        await vm.LoadAsync();
+
+        await vm.RemoveCommand.ExecuteAsync("url-a");
+
+        Assert.Equal("url-a", w.RemovedSourceUrl);
+        Assert.Empty(vm.Skills);
+    }
+
+    [Fact]
+    public async Task UpdateAsync_calls_worker_then_refreshes()
+    {
+        var w = new FakeWorker { Installed = new() { new SessionSkillDto("a", "", "url-a", "ref-a", DateTimeOffset.UtcNow) } };
+        var vm = new SessionSkillsSettingsTabViewModel(w);
+        await vm.LoadAsync();
+
+        await vm.UpdateCommand.ExecuteAsync("url-a");
+
+        Assert.Equal("url-a", w.UpdatedSourceUrl);
+        Assert.NotEmpty(vm.StatusMessage);
+    }
+}