929 lines
46 KiB
Markdown
929 lines
46 KiB
Markdown
# Unit-Branch Teil 1: Branch-Naming + Basis-Branch pro Liste — Implementation Plan
|
|
|
|
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
|
|
|
|
**Goal:** Task-Branches heißen `<typ>/<nummer>-<slug>` statt `claudedo/{nr}-{slug}`, Firmen-Repos werden über ein konfigurierbares Remote-Muster erkannt, und jede Liste kann einen Basis-Branch (z.B. `dev`) festlegen, der Basis neuer Worktrees und Default-Merge-Ziel ist.
|
|
|
|
**Architecture:** Erkennung = statischer Helper `CompanyRepo` über `git remote get-url origin` + `WorkerConfig.CompanyRemotePattern`. Naming bleibt in `WorktreeManager` (`NameFor` + `BranchTypeFor`). `list_config.base_branch` ist eine neue nullable Spalte, tri-state durch alle Writer gereicht; `WorktreeManager.ResolveBaseCommitAsync` und `TaskMergeService.ResolveTargetAsync` lesen sie.
|
|
|
|
**Tech Stack:** .NET 8, EF Core (SQLite), xUnit mit echtem git, Avalonia 12.
|
|
|
|
**Spec:** `docs/superpowers/specs/2026-10-01-unit-branch-draft-pr-design.md` (Abschnitt 1 + Basis-Branch). Teil 2 (Unit-Branch/Children) und Teil 3 (Firmen-Modus: Fetch, Push, Draft-PR) folgen als eigene Pläne.
|
|
|
|
**Abweichung von der Spec (bewusst):** Der Self-Heal in `WorktreeManager.CreateAsync` bekommt **keinen** zusätzlichen DB-Ownership-Guard. Er feuert nur, wenn auch der Id-suffixte Name schon existiert — und der enthält die Task-Id, gehört also per Konstruktion diesem Task. Ein fremder Branch mit dem Klarnamen wird schon vom Kollisionscheck auf das Suffix umgelenkt. Nötig ist nur, dass der Kollisionscheck den **vollen neuen** Branchnamen prüft (Task 3).
|
|
|
|
**Konventionen für jede Task:**
|
|
- Build: `dotnet build ClaudeDo.slnx -c Release` (nie Debug — ein laufender Worker lockt es).
|
|
- Tests: `dotnet test <projekt> -c Release --no-build --filter "<filter>"` — nie die volle Suite.
|
|
- Commit: `git add <pfade>` explizit, dann `git commit -m "..." -- <pfade>` (geteilter Checkout, nie `git add -A`). Kein Co-Authored-Trailer.
|
|
|
|
---
|
|
|
|
## Dateiübersicht
|
|
|
|
| Datei | Änderung |
|
|
|---|---|
|
|
| `src/ClaudeDo.Worker/Config/WorkerConfig.cs` | + `CompanyRemotePattern` (`company_remote_pattern`, Default `/_git/`) |
|
|
| `src/ClaudeDo.Data/Git/GitService.cs` | + `GetRemoteUrlAsync` |
|
|
| `src/ClaudeDo.Worker/Git/CompanyRepo.cs` | neu: `Matches`, `IsCompanyAsync` |
|
|
| `src/ClaudeDo.Worker/Runner/CommitMessageBuilder.cs` | `ToSlug` löst Umlaute auf |
|
|
| `src/ClaudeDo.Worker/Runner/WorktreeManager.cs` | `NameFor(task, ticketId, isCompany)`, `BranchTypeFor`, neuer Branchname, Ticket-Auflösung, Basis-Branch |
|
|
| `src/ClaudeDo.Worker/Lifecycle/UntrackedWorktreeRecovery.cs` | Pfad- statt Präfix-Filter |
|
|
| `src/ClaudeDo.Data/Models/ListConfigEntity.cs`, `Configuration/ListConfigEntityConfiguration.cs`, `Repositories/ListRepository.cs`, Migration | + `BaseBranch` |
|
|
| `src/ClaudeDo.Data/Wire.cs` | `UpdateListConfigDto` / `ListConfigDto` + `BaseBranch` |
|
|
| `src/ClaudeDo.Worker/Hub/WorkerHub.cs` | `UpdateListConfig` / `GetListConfig` |
|
|
| `src/ClaudeDo.Worker/External/ConfigMcpTools.cs` | erhält `BaseBranch` **und** `PowerUseAllowed` (Bestandsbug), `get_list_config` liefert `baseBranch` |
|
|
| `src/ClaudeDo.Worker/Lifecycle/TaskMergeService.cs` | `ResolveTargetAsync`, leeres Ziel zentral in `MergeAsync` aufgelöst |
|
|
| `src/ClaudeDo.Ui/ViewModels/Agent/AgentConfigEditorViewModel.cs`, `ViewModels/Modals/ListSettingsModalViewModel.cs`, `Views/Modals/ListSettingsModalView.axaml`, `locales/*.json` | Basis-Branch-Feld |
|
|
| `src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs` | echte Branchnamen in Dialogen, kein `← main` |
|
|
| `src/ClaudeDo.Worker/CLAUDE.md`, `src/ClaudeDo.Data/CLAUDE.md` | Doku |
|
|
|
|
---
|
|
|
|
### Task 1: Firmen-Repo-Erkennung
|
|
|
|
**Files:**
|
|
- Modify: `src/ClaudeDo.Worker/Config/WorkerConfig.cs` (nach `TicketApiBaseUrl`, ~Zeile 71)
|
|
- Modify: `src/ClaudeDo.Data/Git/GitService.cs` (neben `ListLocalBranchesAsync`, ~Zeile 404)
|
|
- Create: `src/ClaudeDo.Worker/Git/CompanyRepo.cs`
|
|
- Test: `tests/ClaudeDo.Worker.Tests/Git/CompanyRepoTests.cs`
|
|
|
|
- [ ] **Step 1: Failing test schreiben**
|
|
|
|
```csharp
|
|
using ClaudeDo.Data.Git;
|
|
using ClaudeDo.Worker.Git;
|
|
using ClaudeDo.Worker.Tests.Infrastructure;
|
|
|
|
namespace ClaudeDo.Worker.Tests.Git;
|
|
|
|
public sealed class CompanyRepoTests : IDisposable
|
|
{
|
|
private readonly GitRepoFixture _repo = new();
|
|
public void Dispose() => _repo.Dispose();
|
|
|
|
[Theory]
|
|
[InlineData("https://srv.local/Coll/Proj/_git/Repo", "/_git/", true)]
|
|
[InlineData("https://mika@srv.local/tfs/Coll/Proj/_git/Mein%20Repo.git", "/_git/", true)]
|
|
[InlineData("ssh://git@git.kuns.dev:22222/kuns/ClaudeDo.git", "/_git/", false)]
|
|
[InlineData(null, "/_git/", false)]
|
|
[InlineData("https://srv.local/Coll/Proj/_git/Repo", "", false)]
|
|
[InlineData("https://GITHUB.com/acme/repo.git", "github.com/acme", true)]
|
|
public void Matches(string? url, string pattern, bool expected)
|
|
=> Assert.Equal(expected, CompanyRepo.Matches(url, pattern));
|
|
|
|
[Fact]
|
|
public async Task IsCompanyAsync_reads_origin()
|
|
{
|
|
if (!GitRepoFixture.IsGitAvailable()) return;
|
|
var git = new GitService();
|
|
Assert.False(await CompanyRepo.IsCompanyAsync(git, _repo.RepoDir, "/_git/", CancellationToken.None));
|
|
|
|
GitRepoFixture.RunGit(_repo.RepoDir, "remote", "add", "origin", "https://srv.local/Coll/Proj/_git/Repo");
|
|
|
|
Assert.True(await CompanyRepo.IsCompanyAsync(git, _repo.RepoDir, "/_git/", CancellationToken.None));
|
|
Assert.Equal("https://srv.local/Coll/Proj/_git/Repo", await git.GetRemoteUrlAsync(_repo.RepoDir));
|
|
}
|
|
}
|
|
```
|
|
|
|
- [ ] **Step 2: Test laufen lassen — muss am Compiler scheitern**
|
|
|
|
Run: `dotnet build ClaudeDo.slnx -c Release`
|
|
Expected: FAIL, `CompanyRepo` / `GetRemoteUrlAsync` existieren nicht.
|
|
|
|
- [ ] **Step 3: Implementieren**
|
|
|
|
`WorkerConfig.cs`, direkt nach der `TicketApiBaseUrl`-Property:
|
|
|
|
```csharp
|
|
/// <summary>Teilstring der <c>origin</c>-URL, an dem ein Firmen-Repo erkannt wird. Nur per Hand editierbar.</summary>
|
|
[JsonPropertyName("company_remote_pattern")]
|
|
public string CompanyRemotePattern { get; set; } = "/_git/";
|
|
```
|
|
|
|
`GitService.cs`, neben `ListLocalBranchesAsync`:
|
|
|
|
```csharp
|
|
/// <summary>URL des Remotes <paramref name="remote"/>, oder null wenn es keins gibt.</summary>
|
|
public async Task<string?> GetRemoteUrlAsync(string repoDir, string remote = "origin", CancellationToken ct = default)
|
|
{
|
|
var (exitCode, stdout, _) = await RunGitAsync(repoDir, ["remote", "get-url", remote], ct);
|
|
return exitCode == 0 && !string.IsNullOrWhiteSpace(stdout) ? stdout.Trim() : null;
|
|
}
|
|
```
|
|
|
|
`src/ClaudeDo.Worker/Git/CompanyRepo.cs`:
|
|
|
|
```csharp
|
|
using ClaudeDo.Data.Git;
|
|
|
|
namespace ClaudeDo.Worker.Git;
|
|
|
|
/// <summary>Erkennt Firmen-Repos am <c>origin</c>-Remote; das Muster kommt aus <c>WorkerConfig.CompanyRemotePattern</c>.</summary>
|
|
public static class CompanyRepo
|
|
{
|
|
/// <summary>True wenn <paramref name="remoteUrl"/> das (nicht-leere) Muster enthält, ohne Groß-/Kleinschreibung.</summary>
|
|
public static bool Matches(string? remoteUrl, string? pattern) =>
|
|
!string.IsNullOrWhiteSpace(remoteUrl) && !string.IsNullOrWhiteSpace(pattern)
|
|
&& remoteUrl.Contains(pattern, StringComparison.OrdinalIgnoreCase);
|
|
|
|
/// <summary>Liest <c>origin</c> live (kein Cache — ein Remote kann sich jederzeit ändern).</summary>
|
|
public static async Task<bool> IsCompanyAsync(GitService git, string workingDir, string? pattern, CancellationToken ct) =>
|
|
Matches(await git.GetRemoteUrlAsync(workingDir, "origin", ct), pattern);
|
|
}
|
|
```
|
|
|
|
- [ ] **Step 4: Build + Test**
|
|
|
|
Run: `dotnet build ClaudeDo.slnx -c Release` → 0 Fehler.
|
|
Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --no-build --filter "FullyQualifiedName~CompanyRepoTests"`
|
|
Expected: PASS (7 Tests).
|
|
|
|
- [ ] **Step 5: Commit**
|
|
|
|
```bash
|
|
git add src/ClaudeDo.Worker/Config/WorkerConfig.cs src/ClaudeDo.Data/Git/GitService.cs src/ClaudeDo.Worker/Git/CompanyRepo.cs tests/ClaudeDo.Worker.Tests/Git/CompanyRepoTests.cs
|
|
git commit -m "feat(worker): detect company repos by origin remote pattern" -- src/ClaudeDo.Worker/Config/WorkerConfig.cs src/ClaudeDo.Data/Git/GitService.cs src/ClaudeDo.Worker/Git/CompanyRepo.cs tests/ClaudeDo.Worker.Tests/Git/CompanyRepoTests.cs
|
|
```
|
|
|
|
---
|
|
|
|
### Task 2: Naming-Bausteine (Typ, Nummer, Umlaute)
|
|
|
|
**Files:**
|
|
- Modify: `src/ClaudeDo.Worker/Runner/CommitMessageBuilder.cs:49-60` (`ToSlug`)
|
|
- Modify: `src/ClaudeDo.Worker/Runner/WorktreeManager.cs:41-47` (`NameFor`) + neues `BranchTypeFor`
|
|
- Test: `tests/ClaudeDo.Worker.Tests/Runner/WorktreeManagerTests.cs:82-89` (Theory ersetzen), `tests/ClaudeDo.Worker.Tests/Runner/CommitMessageBuilderTests.cs`
|
|
|
|
- [ ] **Step 1: Tests anpassen/ergänzen**
|
|
|
|
In `WorktreeManagerTests.cs` die Theory `NameFor_NumberPlusCappedTitleSlug` (Zeilen 82-89) ersetzen durch:
|
|
|
|
```csharp
|
|
[Theory]
|
|
[InlineData("Fix: Löschen des Tasks!", null, false, "7-fix-loeschen-des-tasks")]
|
|
[InlineData("äöü", null, false, "7-aeoeue")]
|
|
[InlineData("a very long title that goes well beyond the forty char cap", null, false, "7-a-very-long-title-that-goes-well-beyond")]
|
|
[InlineData("test task", 412, false, "412-test-task")]
|
|
[InlineData("test task", 412, true, "412-test-task")]
|
|
[InlineData("test task", null, true, "test-task")]
|
|
[InlineData("!!!", null, true, "7")]
|
|
public void NameFor_NumberRules(string title, int? ticketId, bool isCompany, string expected)
|
|
{
|
|
var task = new TaskEntity { Id = "x", ListId = "y", Title = title, Number = 7, CreatedAt = DateTime.UtcNow };
|
|
Assert.Equal(expected, WorktreeManager.NameFor(task, ticketId, isCompany));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("feat", "feature")]
|
|
[InlineData("fix", "fix")]
|
|
[InlineData("refactor", "refactor")]
|
|
[InlineData("docs", "docs")]
|
|
[InlineData("test", "test")]
|
|
[InlineData("chore", "chore")]
|
|
[InlineData("ci", "chore")]
|
|
[InlineData("perf", "chore")]
|
|
[InlineData(" FEAT ", "feature")]
|
|
[InlineData("", "chore")]
|
|
public void BranchTypeFor_maps_commit_types(string commitType, string expected)
|
|
=> Assert.Equal(expected, WorktreeManager.BranchTypeFor(commitType));
|
|
```
|
|
|
|
In `CommitMessageBuilderTests.cs` einen Test ergänzen:
|
|
|
|
```csharp
|
|
[Fact]
|
|
public void ToSlug_transliterates_umlauts()
|
|
{
|
|
Assert.Equal("aerger-ueber-groesse-strasse", CommitMessageBuilder.ToSlug("Ärger über Größe Straße"));
|
|
}
|
|
```
|
|
|
|
- [ ] **Step 2: Build — muss scheitern**
|
|
|
|
Run: `dotnet build ClaudeDo.slnx -c Release`
|
|
Expected: FAIL, `NameFor` hat keine 3-Parameter-Überladung, `BranchTypeFor` fehlt.
|
|
|
|
- [ ] **Step 3: Implementieren**
|
|
|
|
`CommitMessageBuilder.ToSlug` — erste Zeile ersetzen:
|
|
|
|
```csharp
|
|
// Umlaute auflösen statt strippen: "Löschen" -> "loeschen", nicht "lschen".
|
|
var lower = name.ToLowerInvariant()
|
|
.Replace("ä", "ae").Replace("ö", "oe").Replace("ü", "ue").Replace("ß", "ss");
|
|
```
|
|
|
|
`WorktreeManager.cs` — `NameFor` (Zeilen 41-47) ersetzen durch:
|
|
|
|
```csharp
|
|
/// <summary>
|
|
/// Branch leaf and folder name: <c>{nummer}-{slug}</c>. Nummer = Ticket-Id, sonst die Task-Nummer —
|
|
/// außer im Firmen-Repo ohne Ticket, dort sähe sie wie eine Ticket-Id aus und entfällt.
|
|
/// </summary>
|
|
public static string NameFor(TaskEntity task, int? ticketId, bool isCompanyRepo)
|
|
{
|
|
var titleSlug = CommitMessageBuilder.ToSlug(task.Title);
|
|
if (titleSlug.Length > 40) titleSlug = titleSlug[..40].TrimEnd('-');
|
|
var number = ticketId?.ToString() ?? (isCompanyRepo ? null : task.Number.ToString());
|
|
if (titleSlug.Length == 0) return number ?? task.Number.ToString();
|
|
return number is null ? titleSlug : $"{number}-{titleSlug}";
|
|
}
|
|
|
|
/// <summary>Branch-Präfix nach work-conventions: <c>feat</c> → <c>feature</c>, Typen ohne eigenes Präfix → <c>chore</c>.</summary>
|
|
public static string BranchTypeFor(string? commitType)
|
|
{
|
|
var t = (commitType ?? "").Trim().ToLowerInvariant();
|
|
return t switch
|
|
{
|
|
"feat" => "feature",
|
|
"fix" or "refactor" or "docs" or "test" or "chore" => t,
|
|
_ => "chore",
|
|
};
|
|
}
|
|
```
|
|
|
|
In `CreateAsync` vorerst nur den Aufruf kompilierbar machen (Zeile 62): `var name = NameFor(task, null, false);` — die echte Verdrahtung macht Task 3.
|
|
|
|
Die übrigen `NameFor(task)`-Aufrufe in `WorktreeManagerTests.cs` (Zeilen 131, 137, 160, 314, 320) auf `WorktreeManager.NameFor(task, null, false)` umstellen — sonst kompiliert das Testprojekt nicht. Die `claudedo/`-Literale dort bleiben in diesem Task stehen (Task 3 ändert sie).
|
|
|
|
- [ ] **Step 4: Build + Test**
|
|
|
|
Run: `dotnet build ClaudeDo.slnx -c Release` → 0 Fehler.
|
|
Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --no-build --filter "FullyQualifiedName~WorktreeManagerTests|FullyQualifiedName~CommitMessageBuilderTests"`
|
|
Expected: PASS.
|
|
|
|
- [ ] **Step 5: Commit**
|
|
|
|
```bash
|
|
git add src/ClaudeDo.Worker/Runner/CommitMessageBuilder.cs src/ClaudeDo.Worker/Runner/WorktreeManager.cs tests/ClaudeDo.Worker.Tests/Runner/WorktreeManagerTests.cs tests/ClaudeDo.Worker.Tests/Runner/CommitMessageBuilderTests.cs
|
|
git commit -m "feat(worker): branch type and number rules for task branches" -- src/ClaudeDo.Worker/Runner/CommitMessageBuilder.cs src/ClaudeDo.Worker/Runner/WorktreeManager.cs tests/ClaudeDo.Worker.Tests/Runner/WorktreeManagerTests.cs tests/ClaudeDo.Worker.Tests/Runner/CommitMessageBuilderTests.cs
|
|
```
|
|
|
|
---
|
|
|
|
### Task 3: `CreateAsync` nutzt das neue Schema
|
|
|
|
**Files:**
|
|
- Modify: `src/ClaudeDo.Worker/Runner/WorktreeManager.cs:49-90` (`CreateAsync`) + neue private `ResolveTicketIdAsync`
|
|
- Test: `tests/ClaudeDo.Worker.Tests/Runner/WorktreeManagerTests.cs`
|
|
|
|
- [ ] **Step 1: Tests anpassen + neue Tests**
|
|
|
|
Bestehende Literale umstellen (der Test-Task hat `CommitType = "chore"`, also Präfix `chore/`):
|
|
- Zeile 69: `Assert.StartsWith($"chore/{task.Number}-test-task", ctx.BranchName);`
|
|
- Zeile 131: `var foreign = $"chore/{WorktreeManager.NameFor(task, null, false)}";`
|
|
- Zeile 138: `Assert.Equal($"chore/{suffixed}", ctx.BranchName);`
|
|
- Zeile 160: `var branchName = $"chore/{WorktreeManager.NameFor(task, null, false)}";`
|
|
- Zeile 314: `var branchName = $"chore/{WorktreeManager.NameFor(task, null, false)}";`
|
|
|
|
Neue Tests in derselben Klasse (vor `MakeEntities`):
|
|
|
|
```csharp
|
|
[Fact]
|
|
public async Task CreateAsync_CompanyRepoWithTicket_UsesTicketIdAndFeaturePrefix()
|
|
{
|
|
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
|
|
|
|
var repo = CreateRepo();
|
|
GitRepoFixture.RunGit(repo.RepoDir, "remote", "add", "origin", "https://srv.local/Coll/Proj/_git/Repo");
|
|
var (task, list) = MakeEntities(repo.RepoDir);
|
|
task.CommitType = "feat";
|
|
task.TicketRef = "bandel:412";
|
|
var (mgr, _) = await CreateManagerAsync(task, list);
|
|
|
|
var ctx = await mgr.CreateAsync(task, list, CancellationToken.None);
|
|
_worktreeCleanups.Add((repo.RepoDir, ctx.WorktreePath));
|
|
|
|
Assert.StartsWith("feature/412-test-task", ctx.BranchName);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CreateAsync_CompanyRepoWithoutTicket_OmitsNumber()
|
|
{
|
|
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
|
|
|
|
var repo = CreateRepo();
|
|
GitRepoFixture.RunGit(repo.RepoDir, "remote", "add", "origin", "https://srv.local/Coll/Proj/_git/Repo");
|
|
var (task, list) = MakeEntities(repo.RepoDir);
|
|
var (mgr, _) = await CreateManagerAsync(task, list);
|
|
|
|
var ctx = await mgr.CreateAsync(task, list, CancellationToken.None);
|
|
_worktreeCleanups.Add((repo.RepoDir, ctx.WorktreePath));
|
|
|
|
Assert.StartsWith("chore/test-task", ctx.BranchName);
|
|
Assert.DoesNotContain($"/{task.Number}-", ctx.BranchName);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CreateAsync_ChildWithoutTicket_UsesParentTicket()
|
|
{
|
|
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
|
|
|
|
var repo = CreateRepo();
|
|
var (child, list) = MakeEntities(repo.RepoDir);
|
|
var parent = new TaskEntity
|
|
{
|
|
Id = Guid.NewGuid().ToString(), ListId = list.Id, Title = "parent", CommitType = "feat",
|
|
TicketRef = "bandel:77", CreatedAt = DateTime.UtcNow,
|
|
};
|
|
child.ParentTaskId = parent.Id;
|
|
|
|
var db = new DbFixture();
|
|
_dbFixtures.Add(db);
|
|
using (var seedCtx = db.CreateContext())
|
|
{
|
|
await new ListRepository(seedCtx).AddAsync(list);
|
|
await new TaskRepository(seedCtx).AddAsync(parent);
|
|
await new TaskRepository(seedCtx).AddAsync(child);
|
|
}
|
|
var mgr = new WorktreeManager(new GitService(), db.CreateFactory(),
|
|
new WorkerConfig { WorktreeRootStrategy = "sibling" }, NullLogger<WorktreeManager>.Instance);
|
|
|
|
var ctx = await mgr.CreateAsync(child, list, CancellationToken.None);
|
|
_worktreeCleanups.Add((repo.RepoDir, ctx.WorktreePath));
|
|
|
|
Assert.StartsWith("chore/77-test-task", ctx.BranchName);
|
|
}
|
|
```
|
|
|
|
- [ ] **Step 2: Test laufen lassen — muss scheitern**
|
|
|
|
Run: `dotnet build ClaudeDo.slnx -c Release && dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --no-build --filter "FullyQualifiedName~WorktreeManagerTests"`
|
|
Expected: FAIL — Branches heißen noch `claudedo/…`.
|
|
|
|
- [ ] **Step 3: Implementieren**
|
|
|
|
In `CreateAsync` Zeile 62 (`var name = NameFor(task, null, false);`) ersetzen durch:
|
|
|
|
```csharp
|
|
var isCompany = await CompanyRepo.IsCompanyAsync(_git, workingDir, _cfg.CompanyRemotePattern, ct);
|
|
var name = NameFor(task, await ResolveTicketIdAsync(task, ct), isCompany);
|
|
var branchType = BranchTypeFor(task.CommitType);
|
|
```
|
|
|
|
Kollisionscheck + Branchname (Zeilen 80-89) ersetzen durch:
|
|
|
|
```csharp
|
|
// Numbers restart after a DB reset, and without the claudedo/ prefix a taken name may also be
|
|
// the user's own branch — the self-heal below would force-delete it, the id suffix keeps it untouched.
|
|
if (Directory.Exists(Path.Combine(parentDir, name))
|
|
|| (await _git.ListLocalBranchesAsync(workingDir, ct)).Contains($"{branchType}/{name}"))
|
|
{
|
|
var id = task.Id.Replace("-", "");
|
|
name = $"{name}-{id[..Math.Min(8, id.Length)]}";
|
|
}
|
|
|
|
var branchName = $"{branchType}/{name}";
|
|
```
|
|
|
|
Neue private Methode (vor `ResolveBaseCommitAsync`):
|
|
|
|
```csharp
|
|
/// <summary>Ticket-Id des Tasks, sonst die seines Parents (Children erben das Ticket ihrer Unit).</summary>
|
|
private async Task<int?> ResolveTicketIdAsync(TaskEntity task, CancellationToken ct)
|
|
{
|
|
var own = TicketStatusMap.ParseBandelTicketId(task.TicketRef);
|
|
if (own is not null || task.ParentTaskId is null) return own;
|
|
using var ctx = _dbFactory.CreateDbContext();
|
|
var parentRef = await ctx.Tasks.AsNoTracking()
|
|
.Where(t => t.Id == task.ParentTaskId)
|
|
.Select(t => t.TicketRef)
|
|
.FirstOrDefaultAsync(ct);
|
|
return TicketStatusMap.ParseBandelTicketId(parentRef);
|
|
}
|
|
```
|
|
|
|
Usings ergänzen: `using ClaudeDo.Worker.Tickets;` (für `TicketStatusMap`). `ClaudeDo.Worker.Git` ist schon importiert.
|
|
|
|
- [ ] **Step 4: Build + Test**
|
|
|
|
Run: `dotnet build ClaudeDo.slnx -c Release && dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --no-build --filter "FullyQualifiedName~WorktreeManagerTests|FullyQualifiedName~InteractiveLaunchSpecServiceTests|FullyQualifiedName~TaskRunnerTests"`
|
|
Expected: PASS. Schlägt ein Test fehl, der einen `claudedo/{nummer}-…`-Namen **erwartet** (nicht nur als Fixture seedet), auf `chore/…` umstellen und im Bericht nennen.
|
|
|
|
- [ ] **Step 5: Commit**
|
|
|
|
```bash
|
|
git add src/ClaudeDo.Worker/Runner/WorktreeManager.cs tests/ClaudeDo.Worker.Tests/Runner/WorktreeManagerTests.cs
|
|
git commit -m "feat(worker): name task branches <type>/<number>-<slug>" -- src/ClaudeDo.Worker/Runner/WorktreeManager.cs tests/ClaudeDo.Worker.Tests/Runner/WorktreeManagerTests.cs
|
|
```
|
|
|
|
---
|
|
|
|
### Task 4: UntrackedWorktreeRecovery ohne Präfix
|
|
|
|
**Files:**
|
|
- Modify: `src/ClaudeDo.Worker/Lifecycle/UntrackedWorktreeRecovery.cs`
|
|
- Test: `tests/ClaudeDo.Worker.Tests/Lifecycle/UntrackedWorktreeRecoveryTests.cs` (bestehende Datei; per `Glob tests/**/UntrackedWorktreeRecoveryTests.cs` finden und dort ergänzen)
|
|
|
|
- [ ] **Step 1: Failing test**
|
|
|
|
```csharp
|
|
[Theory]
|
|
[InlineData(@"C:\src\.claudedo-worktrees\lager-app\412-fix", @"C:\Users\x\.claudeDo\worktrees", true)]
|
|
[InlineData(@"C:\src\.claudedo-worktrees\planning\abc123", @"C:\Users\x\.claudeDo\worktrees", false)]
|
|
[InlineData(@"C:\Users\x\.claudeDo\worktrees\lager-app\412-fix", @"C:\Users\x\.claudeDo\worktrees", true)]
|
|
[InlineData(@"C:\Users\x\.claudeDo\worktrees\planning\abc123", @"C:\Users\x\.claudeDo\worktrees", false)]
|
|
[InlineData(@"C:\src\my-own-worktree", @"C:\Users\x\.claudeDo\worktrees", false)]
|
|
public void IsTaskWorktreePath(string path, string centralRoot, bool expected)
|
|
{
|
|
if (!OperatingSystem.IsWindows()) return;
|
|
Assert.Equal(expected, UntrackedWorktreeRecovery.IsTaskWorktreePath(path, centralRoot));
|
|
}
|
|
```
|
|
|
|
- [ ] **Step 2: Build — scheitert** (`IsTaskWorktreePath` fehlt).
|
|
|
|
Run: `dotnet build ClaudeDo.slnx -c Release` → FAIL.
|
|
|
|
- [ ] **Step 3: Implementieren**
|
|
|
|
Konstante `BranchPrefix` löschen. Konstruktor um `WorkerConfig cfg` erweitern (Feld `_cfg`; `using ClaudeDo.Worker.Config;`). Klassen-Summary auf „ClaudeDo-Task-Worktrees (unter `.claudedo-worktrees` oder dem Central-Root, ohne Planning-Sessions)“ ändern.
|
|
|
|
In `StartAsync` nach dem Laden der Listen den Central-Root bestimmen:
|
|
|
|
```csharp
|
|
var settings = await new AppSettingsRepository(ctx).GetAsync(cancellationToken);
|
|
var centralRoot = !string.IsNullOrWhiteSpace(settings.CentralWorktreeRoot)
|
|
? settings.CentralWorktreeRoot
|
|
: _cfg.CentralWorktreeRoot;
|
|
```
|
|
|
|
Den Filter `claudedoPaths` ersetzen:
|
|
|
|
```csharp
|
|
var claudedoPaths = registered
|
|
.Where(w => w.Branch is not null && IsTaskWorktreePath(w.Path, centralRoot))
|
|
.Select(w => w.Path);
|
|
```
|
|
|
|
Neue statische Methode (neben `FindUntrackedPaths`):
|
|
|
|
```csharp
|
|
/// <summary>True für einen Pfad unter <c>.claudedo-worktrees</c> oder dem Central-Root, außer Planning-Session-Worktrees.</summary>
|
|
public static bool IsTaskWorktreePath(string path, string centralRoot)
|
|
{
|
|
var sep = Path.DirectorySeparatorChar;
|
|
var full = Normalize(path);
|
|
string? rest = null;
|
|
|
|
var central = Normalize(centralRoot);
|
|
if (full.StartsWith(central + sep, StringComparison.OrdinalIgnoreCase))
|
|
rest = full[(central.Length + 1)..];
|
|
else
|
|
{
|
|
var marker = $"{sep}.claudedo-worktrees{sep}";
|
|
var idx = full.IndexOf(marker, StringComparison.OrdinalIgnoreCase);
|
|
if (idx >= 0) rest = full[(idx + marker.Length)..];
|
|
}
|
|
|
|
return rest is not null && !rest.StartsWith($"planning{sep}", StringComparison.OrdinalIgnoreCase);
|
|
}
|
|
```
|
|
|
|
- [ ] **Step 4: Build + Test**
|
|
|
|
Run: `dotnet build ClaudeDo.slnx -c Release && dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --no-build --filter "FullyQualifiedName~UntrackedWorktreeRecovery"`
|
|
Expected: PASS.
|
|
|
|
- [ ] **Step 5: Commit**
|
|
|
|
```bash
|
|
git add src/ClaudeDo.Worker/Lifecycle/UntrackedWorktreeRecovery.cs tests/ClaudeDo.Worker.Tests/Lifecycle/UntrackedWorktreeRecoveryTests.cs
|
|
git commit -m "refactor(worker): detect untracked worktrees by path instead of branch prefix" -- src/ClaudeDo.Worker/Lifecycle/UntrackedWorktreeRecovery.cs tests/ClaudeDo.Worker.Tests/Lifecycle/UntrackedWorktreeRecoveryTests.cs
|
|
```
|
|
|
|
(Pfad der Testdatei an den tatsächlichen Fundort anpassen.)
|
|
|
|
---
|
|
|
|
### Task 5: `list_config.base_branch` durch alle Writer
|
|
|
|
**Files:**
|
|
- Modify: `src/ClaudeDo.Data/Models/ListConfigEntity.cs`, `src/ClaudeDo.Data/Configuration/ListConfigEntityConfiguration.cs`, `src/ClaudeDo.Data/Repositories/ListRepository.cs:161-180`
|
|
- Create: Migration `AddListBaseBranch` (generiert)
|
|
- Modify: `src/ClaudeDo.Data/Wire.cs:111,115`
|
|
- Modify: `src/ClaudeDo.Worker/Hub/WorkerHub.cs:577-647`
|
|
- Modify: `src/ClaudeDo.Worker/External/ConfigMcpTools.cs:13,53-59,104-139`
|
|
- Test: `tests/ClaudeDo.Worker.Tests/Hub/ListConfigBaseBranchTests.cs`
|
|
|
|
- [ ] **Step 1: Failing tests**
|
|
|
|
`tests/ClaudeDo.Worker.Tests/Hub/ListConfigBaseBranchTests.cs` — Hub-Aufbau 1:1 aus `tests/ClaudeDo.Worker.Tests/Tickets/ListConfigTicketProjectTests.cs` (gleicher `CreateHub`, `SeedListAsync`, `ReadConfigAsync`):
|
|
|
|
```csharp
|
|
using ClaudeDo.Data;
|
|
using ClaudeDo.Data.Models;
|
|
using ClaudeDo.Data.Repositories;
|
|
using ClaudeDo.Worker.External;
|
|
using ClaudeDo.Worker.Hub;
|
|
using ClaudeDo.Worker.Tests.Infrastructure;
|
|
using Xunit;
|
|
|
|
namespace ClaudeDo.Worker.Tests.Hub;
|
|
|
|
/// BaseBranch und PowerUseAllowed sitzen in der SetConfigAsync-kopiert-verbatim-Falle: jeder Writer,
|
|
/// der sie nicht durchreicht, setzt sie still zurück.
|
|
public sealed class ListConfigBaseBranchTests : IDisposable
|
|
{
|
|
private readonly DbFixture _db = new();
|
|
public void Dispose() => _db.Dispose();
|
|
|
|
private WorkerHub CreateHub()
|
|
{
|
|
var factory = _db.CreateFactory();
|
|
var broadcaster = new HubBroadcaster(new CapturingHubContext());
|
|
var hub = new WorkerHub(
|
|
null!, null!, null!, null!, broadcaster, factory,
|
|
null!, null!, null!, null!, null!, null!, null!, null!, null!, null!, null!, null!, null!,
|
|
null!, new ClaudeDo.Worker.Online.OnlineInboxConfig(), new ClaudeDo.Worker.OnlineRefreshTokenStore(new ClaudeDo.Worker.DpapiTokenStore("unused.token")),
|
|
new ClaudeDo.Worker.Runner.PendingQuestionRegistry(), null!);
|
|
hub.Clients = new FakeHubCallerClients(new RecordingClientProxy());
|
|
hub.Context = new FakeHubCallerContext();
|
|
return hub;
|
|
}
|
|
|
|
private async Task<string> SeedListAsync(string? baseBranch, bool powerUse = false)
|
|
{
|
|
var listId = Guid.NewGuid().ToString();
|
|
await using var ctx = _db.CreateContext();
|
|
var repo = new ListRepository(ctx);
|
|
await repo.AddAsync(new ListEntity { Id = listId, Name = "L", CreatedAt = DateTime.UtcNow });
|
|
await repo.SetConfigAsync(new ListConfigEntity { ListId = listId, BaseBranch = baseBranch, PowerUseAllowed = powerUse });
|
|
return listId;
|
|
}
|
|
|
|
private async Task<ListConfigEntity?> ReadConfigAsync(string listId)
|
|
{
|
|
await using var ctx = _db.CreateContext();
|
|
return await new ListRepository(ctx).GetConfigAsync(listId);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task set_list_config_preserves_BaseBranch_and_PowerUseAllowed()
|
|
{
|
|
var listId = await SeedListAsync("dev", powerUse: true);
|
|
var factory = _db.CreateFactory();
|
|
await using var ctx = factory.CreateDbContext();
|
|
var tool = new ConfigMcpTools(new ListRepository(ctx), new TaskRepository(ctx),
|
|
new HubBroadcaster(new CapturingHubContext()), factory);
|
|
|
|
await tool.SetListConfig(listId, model: "opus", cancellationToken: CancellationToken.None);
|
|
|
|
var cfg = await ReadConfigAsync(listId);
|
|
Assert.Equal("dev", cfg!.BaseBranch);
|
|
Assert.True(cfg.PowerUseAllowed);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task get_list_config_returns_BaseBranch()
|
|
{
|
|
var listId = await SeedListAsync("dev");
|
|
var factory = _db.CreateFactory();
|
|
await using var ctx = factory.CreateDbContext();
|
|
var tool = new ConfigMcpTools(new ListRepository(ctx), new TaskRepository(ctx),
|
|
new HubBroadcaster(new CapturingHubContext()), factory);
|
|
|
|
var result = await tool.GetListConfig(listId, CancellationToken.None);
|
|
|
|
Assert.Equal("dev", result.Config!.BaseBranch);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task UpdateListConfig_null_keeps_BaseBranch()
|
|
{
|
|
var listId = await SeedListAsync("dev");
|
|
await CreateHub().UpdateListConfig(new UpdateListConfigDto(listId, "opus", null, null));
|
|
Assert.Equal("dev", (await ReadConfigAsync(listId))!.BaseBranch);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task UpdateListConfig_empty_clears_BaseBranch()
|
|
{
|
|
var listId = await SeedListAsync("dev");
|
|
await CreateHub().UpdateListConfig(new UpdateListConfigDto(listId, "opus", null, null, BaseBranch: ""));
|
|
Assert.Null((await ReadConfigAsync(listId))!.BaseBranch);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task UpdateListConfig_sets_BaseBranch_and_GetListConfig_returns_it()
|
|
{
|
|
var listId = await SeedListAsync(null);
|
|
var hub = CreateHub();
|
|
await hub.UpdateListConfig(new UpdateListConfigDto(listId, null, null, null, BaseBranch: "dev"));
|
|
Assert.Equal("dev", (await hub.GetListConfig(listId))!.BaseBranch);
|
|
}
|
|
}
|
|
```
|
|
|
|
- [ ] **Step 2: Build — scheitert** (`BaseBranch` fehlt).
|
|
|
|
- [ ] **Step 3: Implementieren**
|
|
|
|
`ListConfigEntity.cs`, nach `PowerUseAllowed`:
|
|
|
|
```csharp
|
|
/// <summary>
|
|
/// Basis neuer Worktrees und Default-Merge-/PR-Ziel (z.B. <c>dev</c>). Null = ausgecheckter Branch
|
|
/// (privat) bzw. Default-Branch des Remotes (Firma). ⚠️ SetConfigAsync kopiert verbatim.
|
|
/// </summary>
|
|
public string? BaseBranch { get; set; }
|
|
```
|
|
|
|
`ListConfigEntityConfiguration.cs`: `builder.Property(c => c.BaseBranch).HasColumnName("base_branch");`
|
|
|
|
`ListRepository.SetConfigAsync`, im `else`-Zweig: `existing.BaseBranch = config.BaseBranch;`
|
|
|
|
Migration erzeugen:
|
|
|
|
```bash
|
|
dotnet ef migrations add AddListBaseBranch --project src/ClaudeDo.Data/ClaudeDo.Data.csproj --configuration Release
|
|
```
|
|
|
|
Erwartet: neue Migration mit genau einem `AddColumn<string>(name: "base_branch", table: "list_config", nullable: true)`. Steht mehr drin (fremde Snapshot-Drift), abbrechen und melden.
|
|
|
|
`Wire.cs` — Kommentar über `UpdateListConfigDto` um eine Zeile ergänzen: `// BaseBranch: null = keep stored, "" = clear, value = set.` Dann beide Records erweitern:
|
|
|
|
```csharp
|
|
public record UpdateListConfigDto(string ListId, string? Model, string? SystemPrompt, string? AgentPath, int? MaxTurns = null, List<string>? SessionSkills = null, string? VerifyCommand = null, string? PermissionMode = null, int? TicketProjectId = null, bool? PowerUseAllowed = null, string? BaseBranch = null);
|
|
```
|
|
|
|
```csharp
|
|
public record ListConfigDto(string? Model, string? SystemPrompt, string? AgentPath, int? MaxTurns = null, List<string>? SessionSkills = null, string? VerifyCommand = null, string? PermissionMode = null, int? TicketProjectId = null, bool PowerUseAllowed = false, string? BaseBranch = null);
|
|
```
|
|
|
|
`WorkerHub.UpdateListConfig` — nach der `powerUseAllowed`-Zeile:
|
|
|
|
```csharp
|
|
// Tri-State wie oben: null = behalten, "" = löschen.
|
|
var baseBranch = dto.BaseBranch is null ? existing?.BaseBranch : dto.BaseBranch.NullIfBlank();
|
|
```
|
|
|
|
Leer-Prüfung um `&& baseBranch is null` ergänzen, im `new ListConfigEntity { … }` `BaseBranch = baseBranch,` ergänzen. `GetListConfig`: `config.BaseBranch` als letztes Argument an `new ListConfigDto(…)` hängen.
|
|
|
|
`ConfigMcpTools.cs`:
|
|
- Zeile 13: `public sealed record ListConfigDto(string? Model, string? SystemPrompt, string? AgentPath, int? MaxTurns, string? VerifyCommand, string? BaseBranch = null);`
|
|
- `GetListConfig`: `new ListConfigDto(cfg.Model, cfg.SystemPrompt, cfg.AgentPath, cfg.MaxTurns, cfg.VerifyCommand, cfg.BaseBranch)`
|
|
- `hasUnrelatedSettings` erweitern:
|
|
|
|
```csharp
|
|
var hasUnrelatedSettings = existing is not null
|
|
&& (existing.SessionSkills is not null
|
|
|| existing.PermissionMode is not null || existing.TicketProjectId is not null
|
|
|| existing.BaseBranch is not null || existing.PowerUseAllowed);
|
|
```
|
|
|
|
- im `SetConfigAsync(new ListConfigEntity { … })` ergänzen: `BaseBranch = existing?.BaseBranch, PowerUseAllowed = existing?.PowerUseAllowed ?? false,`
|
|
- `config = allCleared ? null : new ListConfigDto(m, sp, ap, mt, vc, existing?.BaseBranch);`
|
|
|
|
- [ ] **Step 4: Build + Test**
|
|
|
|
Run: `dotnet build ClaudeDo.slnx -c Release && dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --no-build --filter "FullyQualifiedName~ListConfigBaseBranchTests|FullyQualifiedName~ListConfigTicketProjectTests|FullyQualifiedName~ListConfigHubTests|FullyQualifiedName~ExternalMcpToolSchemaTests"`
|
|
Run: `dotnet test tests/ClaudeDo.Data.Tests/ClaudeDo.Data.Tests.csproj -c Release --no-build --filter "FullyQualifiedName~Migration"`
|
|
Expected: PASS.
|
|
|
|
- [ ] **Step 5: Commit**
|
|
|
|
```bash
|
|
git add src/ClaudeDo.Data/Models/ListConfigEntity.cs src/ClaudeDo.Data/Configuration/ListConfigEntityConfiguration.cs src/ClaudeDo.Data/Repositories/ListRepository.cs src/ClaudeDo.Data/Migrations src/ClaudeDo.Data/Wire.cs src/ClaudeDo.Worker/Hub/WorkerHub.cs src/ClaudeDo.Worker/External/ConfigMcpTools.cs tests/ClaudeDo.Worker.Tests/Hub/ListConfigBaseBranchTests.cs
|
|
git commit -m "feat(data): per-list base branch, preserved by every config writer" -- src/ClaudeDo.Data/Models/ListConfigEntity.cs src/ClaudeDo.Data/Configuration/ListConfigEntityConfiguration.cs src/ClaudeDo.Data/Repositories/ListRepository.cs src/ClaudeDo.Data/Migrations src/ClaudeDo.Data/Wire.cs src/ClaudeDo.Worker/Hub/WorkerHub.cs src/ClaudeDo.Worker/External/ConfigMcpTools.cs tests/ClaudeDo.Worker.Tests/Hub/ListConfigBaseBranchTests.cs
|
|
```
|
|
|
|
---
|
|
|
|
### Task 6: Basis-Branch als Worktree-Basis und Merge-Ziel
|
|
|
|
**Files:**
|
|
- Modify: `src/ClaudeDo.Worker/Runner/WorktreeManager.cs` (`ResolveBaseCommitAsync`, Fallback-Zeile)
|
|
- Modify: `src/ClaudeDo.Worker/Lifecycle/TaskMergeService.cs` (`GetTargetsAsync` ~869, `PreviewAsync` ~910, `ApproveAndMergeAsync` ~1077, `MergeAsync` ~375)
|
|
- Test: `tests/ClaudeDo.Worker.Tests/Runner/WorktreeManagerTests.cs`, `tests/ClaudeDo.Worker.Tests/Services/TaskMergeServiceTests.cs`
|
|
|
|
- [ ] **Step 1: Failing tests**
|
|
|
|
`WorktreeManagerTests.cs`:
|
|
|
|
```csharp
|
|
[Fact]
|
|
public async Task CreateAsync_BaseBranchSet_BasesOnItEvenWhenAnotherBranchIsCheckedOut()
|
|
{
|
|
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
|
|
|
|
var repo = CreateRepo();
|
|
GitRepoFixture.RunGit(repo.RepoDir, "checkout", "-b", "dev");
|
|
File.WriteAllText(Path.Combine(repo.RepoDir, "dev.txt"), "dev");
|
|
GitRepoFixture.RunGit(repo.RepoDir, "add", "-A");
|
|
GitRepoFixture.RunGit(repo.RepoDir, "commit", "-m", "dev work");
|
|
var devHead = GitRepoFixture.RunGit(repo.RepoDir, "rev-parse", "HEAD").Trim();
|
|
GitRepoFixture.RunGit(repo.RepoDir, "checkout", "-b", "elsewhere", repo.BaseCommit);
|
|
|
|
var (task, list) = MakeEntities(repo.RepoDir);
|
|
var (mgr, db) = await CreateManagerAsync(task, list);
|
|
using (var ctx0 = db.CreateContext())
|
|
await new ListRepository(ctx0).SetConfigAsync(new ListConfigEntity { ListId = list.Id, BaseBranch = "dev" });
|
|
|
|
var ctx = await mgr.CreateAsync(task, list, CancellationToken.None);
|
|
_worktreeCleanups.Add((repo.RepoDir, ctx.WorktreePath));
|
|
|
|
Assert.Equal(devHead, ctx.BaseCommit);
|
|
}
|
|
```
|
|
|
|
`TaskMergeServiceTests.cs` — am vorhandenen Setup der Klasse orientieren (Repo + `SeedWorktree`-Helper, wie die übrigen Tests der Datei). Ein Test, der zeigt, dass `GetTargetsAsync` `BaseBranch` als Default liefert, auch wenn ein anderer Branch ausgecheckt ist:
|
|
|
|
```csharp
|
|
[Fact]
|
|
public async Task GetTargetsAsync_prefers_list_base_branch()
|
|
{
|
|
// Setup wie die anderen Tests dieser Datei: Repo, Liste, Task mit Worktree (SeedWorktree).
|
|
// Zusätzlich: Branch "dev" anlegen (`git branch dev`), list_config.BaseBranch = "dev" setzen,
|
|
// Main-Checkout bleibt auf seinem Default-Branch.
|
|
// Assert: targets.DefaultBranch == "dev".
|
|
}
|
|
```
|
|
|
|
Der Implementer schreibt diesen Test konkret mit dem Fixture-Setup, das in `TaskMergeServiceTests.cs` schon für `GetTargetsAsync`/Merge-Tests verwendet wird (per `Grep "GetTargetsAsync" tests/ClaudeDo.Worker.Tests` den nächstliegenden bestehenden Test kopieren und um `BaseBranch` ergänzen). Ein zweiter Test: `ApproveAndMergeAsync(taskId, "")` mit `BaseBranch = "dev"` merged auf `dev` (`git log dev --oneline` enthält den Merge-Commit, der vorher ausgecheckte Branch nicht).
|
|
|
|
- [ ] **Step 2: Tests laufen lassen — scheitern**
|
|
|
|
Run: `dotnet build ClaudeDo.slnx -c Release && dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --no-build --filter "FullyQualifiedName~BaseBranch|FullyQualifiedName~prefers_list_base_branch"`
|
|
Expected: FAIL.
|
|
|
|
- [ ] **Step 3: Implementieren**
|
|
|
|
`WorktreeManager.ResolveBaseCommitAsync` — die letzte Zeile `return await _git.RevParseHeadAsync(workingDir, ct);` ersetzen:
|
|
|
|
```csharp
|
|
using var cfgCtx = _dbFactory.CreateDbContext();
|
|
var baseBranch = await cfgCtx.ListConfigs.AsNoTracking()
|
|
.Where(c => c.ListId == task.ListId)
|
|
.Select(c => c.BaseBranch)
|
|
.FirstOrDefaultAsync(ct);
|
|
return string.IsNullOrWhiteSpace(baseBranch)
|
|
? await _git.RevParseHeadAsync(workingDir, ct)
|
|
: await _git.RevParseAsync(workingDir, baseBranch, ct);
|
|
```
|
|
|
|
(Ein nicht existierender Branch wirft aus `RevParseAsync` mit „git rev-parse 'dev' failed“ — gewollt, der Lauf scheitert mit lesbarer Meldung.)
|
|
|
|
`TaskMergeService` — neue öffentliche Methode (bei `GetTargetsAsync`):
|
|
|
|
```csharp
|
|
/// <summary>Leeres Ziel → <c>list_config.base_branch</c>, sonst der ausgecheckte Branch des Main-Checkouts.</summary>
|
|
public async Task<string> ResolveTargetAsync(ListEntity list, string? targetBranch, CancellationToken ct)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(targetBranch)) return targetBranch;
|
|
using var ctx = _dbFactory.CreateDbContext();
|
|
var baseBranch = await ctx.ListConfigs.AsNoTracking()
|
|
.Where(c => c.ListId == list.Id)
|
|
.Select(c => c.BaseBranch)
|
|
.FirstOrDefaultAsync(ct);
|
|
return string.IsNullOrWhiteSpace(baseBranch)
|
|
? await _git.GetCurrentBranchAsync(list.WorkingDir!, ct)
|
|
: baseBranch;
|
|
}
|
|
```
|
|
|
|
Aufrufer umstellen:
|
|
- `GetTargetsAsync`: `var current = await _git.GetCurrentBranchAsync(...)` → `var current = await ResolveTargetAsync(list, null, ct);`
|
|
- `PreviewAsync` (~910) und `ApproveAndMergeAsync` (~1077): die `var target = string.IsNullOrWhiteSpace(targetBranch) ? await _git.GetCurrentBranchAsync(...) : targetBranch;`-Blöcke → `var target = await ResolveTargetAsync(list, targetBranch, ct);`
|
|
- `MergeAsync`: direkt nachdem `list.WorkingDir` geprüft ist und **vor** dem `currentBranch`-Vergleich (~Zeile 414) `targetBranch = await ResolveTargetAsync(list, targetBranch, ct);` einfügen. Grund: `PlanningMergeOrchestrator.DrainAsync` reicht ein leeres Ziel (MCP `review_task` ohne `targetBranch`) unverändert durch, was heute in `git checkout ""` → Blocked endet. Mit der zentralen Auflösung ist das für alle Aufrufer behoben.
|
|
|
|
- [ ] **Step 4: Build + Test**
|
|
|
|
Run: `dotnet build ClaudeDo.slnx -c Release && dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --no-build --filter "FullyQualifiedName~WorktreeManagerTests|FullyQualifiedName~TaskMergeServiceTests|FullyQualifiedName~PlanningMergeOrchestratorTests"`
|
|
Expected: PASS.
|
|
|
|
- [ ] **Step 5: Commit**
|
|
|
|
```bash
|
|
git add src/ClaudeDo.Worker/Runner/WorktreeManager.cs src/ClaudeDo.Worker/Lifecycle/TaskMergeService.cs tests/ClaudeDo.Worker.Tests/Runner/WorktreeManagerTests.cs tests/ClaudeDo.Worker.Tests/Services/TaskMergeServiceTests.cs
|
|
git commit -m "feat(worker): use the list base branch as worktree base and default merge target" -- src/ClaudeDo.Worker/Runner/WorktreeManager.cs src/ClaudeDo.Worker/Lifecycle/TaskMergeService.cs tests/ClaudeDo.Worker.Tests/Runner/WorktreeManagerTests.cs tests/ClaudeDo.Worker.Tests/Services/TaskMergeServiceTests.cs
|
|
```
|
|
|
|
---
|
|
|
|
### Task 7: UI — Basis-Branch-Feld + echte Branchnamen
|
|
|
|
**Files:**
|
|
- Modify: `src/ClaudeDo.Ui/ViewModels/Agent/AgentConfigEditorViewModel.cs:216-231`
|
|
- Modify: `src/ClaudeDo.Ui/ViewModels/Modals/ListSettingsModalViewModel.cs` (Property ~57, Load ~276, Save ~375)
|
|
- Modify: `src/ClaudeDo.Ui/Views/Modals/ListSettingsModalView.axaml` (nach dem WorkingDir-StackPanel, ~Zeile 125)
|
|
- Modify: `src/ClaudeDo.Localization/locales/en.json`, `de.json` (Block `modals.listSettings`, nach `workingDirectoryPlaceholder`)
|
|
- Modify: `src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs:670,933,1223,1385`
|
|
- Test: `tests/ClaudeDo.Ui.Tests` — bestehende ListSettingsModal-Tests per `Grep "ListSettingsModalViewModel" tests/ClaudeDo.Ui.Tests` finden
|
|
|
|
- [ ] **Step 1: Failing test**
|
|
|
|
In der vorhandenen ListSettingsModal-Testklasse (gleiche Fake-`IWorkerClient`-Mechanik wie die dortigen Save-Tests, die `UpdateListConfigDto` mitschneiden):
|
|
|
|
```csharp
|
|
[Fact]
|
|
public async Task Save_sends_BaseBranch_explicitly()
|
|
{
|
|
// Arrange: VM wie in den Nachbartests laden; BaseBranch = "dev" setzen.
|
|
// Act: Save ausführen.
|
|
// Assert: der mitgeschnittene UpdateListConfigDto hat BaseBranch == "dev".
|
|
// Zweiter Fall: BaseBranch = "" → DTO.BaseBranch == "" (nicht null), damit Leeren wirklich löscht.
|
|
}
|
|
```
|
|
|
|
Der Implementer schreibt die beiden Fälle konkret gegen den Fake, den die Nachbartests (z.B. der PowerUseAllowed-Save-Test) verwenden.
|
|
|
|
- [ ] **Step 2: Build/Test — scheitert** (`BaseBranch` fehlt im VM).
|
|
|
|
- [ ] **Step 3: Implementieren**
|
|
|
|
`AgentConfigEditorViewModel.SaveAsync`: Signatur um `string? baseBranch = null` erweitern und im List-Zweig durchreichen:
|
|
|
|
```csharp
|
|
public async System.Threading.Tasks.Task SaveAsync(
|
|
string? verifyCommand = null, int? ticketProjectId = null, bool? powerUseAllowed = null, string? baseBranch = null)
|
|
```
|
|
|
|
```csharp
|
|
await _worker.UpdateListConfigAsync(new UpdateListConfigDto(TargetId, model, sp, ap, turns, skills, verifyCommand, permission, ticketProjectId, powerUseAllowed, baseBranch));
|
|
```
|
|
|
|
`ListSettingsModalViewModel`:
|
|
|
|
```csharp
|
|
// Basis neuer Worktrees und Default-Merge-Ziel; leer = ausgecheckter Branch.
|
|
[ObservableProperty] private string _baseBranch = "";
|
|
```
|
|
|
|
Load (nach `VerifyCommand = …`): `BaseBranch = cfg?.BaseBranch ?? "";`
|
|
Save: `await Agent.SaveAsync(…, PowerUseAllowed, BaseBranch.Trim());` — immer explizit, `""` löscht (das Modal besitzt das Feld).
|
|
|
|
View, nach dem WorkingDir-StackPanel:
|
|
|
|
```xml
|
|
<StackPanel Spacing="4" IsVisible="{Binding !IsFolder}">
|
|
<TextBlock Classes="field-label" Text="{loc:Tr modals.listSettings.baseBranch}"/>
|
|
<TextBox Text="{Binding BaseBranch, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
|
|
PlaceholderText="{loc:Tr modals.listSettings.baseBranchPlaceholder}"/>
|
|
<TextBlock Text="{loc:Tr modals.listSettings.baseBranchHint}"
|
|
Opacity="0.6" FontSize="12" TextWrapping="Wrap"/>
|
|
</StackPanel>
|
|
```
|
|
|
|
Locales (beide Dateien, gleiche Keys, direkt nach `workingDirectoryPlaceholder`):
|
|
|
|
en.json:
|
|
```json
|
|
"baseBranch": "Base branch",
|
|
"baseBranchPlaceholder": "(checked-out branch)",
|
|
"baseBranchHint": "New task branches start here and approved work merges back here, e.g. dev. Leave empty to use whatever branch is checked out.",
|
|
```
|
|
|
|
de.json:
|
|
```json
|
|
"baseBranch": "Basis-Branch",
|
|
"baseBranchPlaceholder": "(ausgecheckter Branch)",
|
|
"baseBranchHint": "Neue Task-Branches starten hier, und freigegebene Arbeit wird hierhin gemergt, z.B. dev. Leer = der gerade ausgecheckte Branch.",
|
|
```
|
|
|
|
Nach dem Editieren beide JSON-Dateien separat parsen (`python -c "import json;json.load(open('src/ClaudeDo.Localization/locales/de.json',encoding='utf-8'))"`), weil ein kaputtes `de.json` vom LocaleStore still geschluckt wird.
|
|
|
|
`DetailsIslandViewModel`:
|
|
- Zeilen 670 und 933: `BranchLine = entity.Worktree is { } w ? $"{w.BranchName} ← main" : null;` → `BranchLine = entity.Worktree?.BranchName;` (das Ziel ist nicht mehr immer `main`).
|
|
- Zeilen 1223 und 1385: `var branchName = $"claudedo/{Task.Id.Replace("-", "")}";` → `var branchName = BranchLine ?? "the task branch";`
|
|
|
|
- [ ] **Step 4: Build + Test**
|
|
|
|
Run: `dotnet build ClaudeDo.slnx -c Release && dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release --no-build --filter "FullyQualifiedName~ListSettings|FullyQualifiedName~DetailsIsland"`
|
|
Run: `dotnet test tests/ClaudeDo.Localization.Tests/ClaudeDo.Localization.Tests.csproj -c Release --no-build`
|
|
Expected: PASS.
|
|
|
|
- [ ] **Step 5: Commit**
|
|
|
|
```bash
|
|
git add src/ClaudeDo.Ui/ViewModels/Agent/AgentConfigEditorViewModel.cs src/ClaudeDo.Ui/ViewModels/Modals/ListSettingsModalViewModel.cs src/ClaudeDo.Ui/Views/Modals/ListSettingsModalView.axaml src/ClaudeDo.Localization/locales/en.json src/ClaudeDo.Localization/locales/de.json src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs <ui-testdatei>
|
|
git commit -m "feat(ui): base branch field in list settings, real branch names in dialogs" -- <dieselben pfade>
|
|
```
|
|
|
|
**Sichtprüfung offen (Mika):** Feld im Listen-Modal, Branchzeile im Detail-Pane.
|
|
|
|
---
|
|
|
|
### Task 8: Doku
|
|
|
|
**Files:**
|
|
- Modify: `src/ClaudeDo.Worker/CLAUDE.md` (Key Components → WorktreeManager; Notes → „Task worktree branches follow…“; External → „Task worktree branches and folders are named…“; Config → `company_remote_pattern`)
|
|
- Modify: `src/ClaudeDo.Data/CLAUDE.md` (list_config: `base_branch`)
|
|
|
|
- [ ] **Step 1: Texte ersetzen**
|
|
|
|
Überall `claudedo/{number}-{title-slug}` → `<typ>/<nummer>-<slug>` mit der Regel: Typ aus `WorktreeManager.BranchTypeFor` (`feat`→`feature`, sonst `fix/refactor/docs/test/chore`, Rest `chore`); Nummer = Ticket-Id (eigene oder des Parents), sonst Task-Nummer, im Firmen-Repo ohne Ticket keine. Planning bleibt `claudedo/planning/{guid}`.
|
|
|
|
Config-Abschnitt ergänzen: `` `company_remote_pattern` (`/_git/`) — Teilstring der origin-URL, an dem `CompanyRepo` ein Firmen-Repo erkennt; nur per Hand editierbar. ``
|
|
|
|
Data/CLAUDE.md: `list_config.base_branch` — Basis neuer Worktrees + Default-Merge-Ziel, tri-state in `UpdateListConfigDto`, ⚠️ verbatim-copy-Falle wie `ticket_project_id`.
|
|
|
|
- [ ] **Step 2: Commit**
|
|
|
|
```bash
|
|
git add src/ClaudeDo.Worker/CLAUDE.md src/ClaudeDo.Data/CLAUDE.md
|
|
git commit -m "docs(worker): document new branch naming and per-list base branch" -- src/ClaudeDo.Worker/CLAUDE.md src/ClaudeDo.Data/CLAUDE.md
|
|
```
|