1{

2 "permissions": {

3 "allow": [

4 "Bash(dotnet build:*)",

5 "Bash(dotnet test:*)"

6 ]

7 }

8}

1**/bin/

2**/obj/

3**/.vs/

4**/node_modules/

5src - Kopie/

6tests/

7docs/

8*.md

9.git/

10.dockerignore

11Dockerfile

1<Solution>

2 <Folder Name="/src/">

3 <Project Path="src/Catena.Client/Catena.Client.csproj" />

4 <Project Path="src/Catena.Server/Catena.Server.csproj" />

5 <Project Path="src/Catena.Shared/Catena.Shared.csproj" />

6 <Project Path="src/Catena.Storage/Catena.Storage.csproj" />

7 <Project Path="src/Catena.Web/Catena.Web.csproj" />

8 </Folder>

9 <Folder Name="/tests/">

10 <Project Path="tests/Catena.Tests/Catena.Tests.csproj" />

11 </Folder>

12</Solution>

1FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build

2WORKDIR /src

4COPY src/Catena.Shared/Catena.Shared.csproj src/Catena.Shared/

5COPY src/Catena.Storage/Catena.Storage.csproj src/Catena.Storage/

6COPY src/Catena.Web/Catena.Web.csproj src/Catena.Web/

7COPY src/Catena.Server/Catena.Server.csproj src/Catena.Server/

8RUN dotnet restore src/Catena.Server/Catena.Server.csproj

10COPY src/ src/

11RUN dotnet publish src/Catena.Server/Catena.Server.csproj -c Release -o /app/publish --no-restore

13FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS runtime

14WORKDIR /app

15COPY --from=build /app/publish .

17ENV ASPNETCORE_URLS=http://+:8080

18ENV Catena__DataDir=/data

20EXPOSE 8080

21VOLUME /data

23ENTRYPOINT ["dotnet", "Catena.Server.dll"]

1@echo off

2setlocal

4set REGISTRY=docker.timelane.cloud

5set IMAGE=catena

7:: Date-based version: yyyy.MM.dd.BUILD

8for /f "tokens=1-3 delims=/" %%a in ("%date%") do (

9 set DAY=%%a

10 set MONTH=%%b

11 set YEAR=%%c

12)

14:: Fallback: use wmic for reliable date format

15for /f "tokens=2 delims==" %%i in ('wmic os get localdatetime /value') do set DT=%%i

16set YEAR=%DT:~0,4%

17set MONTH=%DT:~4,2%

18set DAY=%DT:~6,2%

20:: Build number: default 1, pass as argument to override

21set BUILD=%1

22if "%BUILD%"=="" set BUILD=1

24set TAG=%YEAR%.%MONTH%.%DAY%.%BUILD%

26echo Building %REGISTRY%/%IMAGE%:%TAG% ...

27docker build -t %REGISTRY%/%IMAGE%:%TAG% -t %REGISTRY%/%IMAGE%:latest .

29if %errorlevel% neq 0 (

30 echo Build failed!

31 exit /b 1

32)

34echo Pushing %REGISTRY%/%IMAGE%:%TAG% ...

35docker push %REGISTRY%/%IMAGE%:%TAG%

36docker push %REGISTRY%/%IMAGE%:latest

38if %errorlevel% neq 0 (

39 echo Push failed!

40 exit /b 1

41)

43echo Done: %REGISTRY%/%IMAGE%:%TAG%

1services:

2 catena:

3 image: docker.timelane.cloud/catena:latest

4 container_name: catena

5 ports:

6 - "18999:8080"

7 volumes:

8 - catena-data:/data

9 environment:

10 - Catena__DataDir=/data

11 - Catena__AuthEnabled=true

12 restart: unless-stopped

14volumes:

15 catena-data:

1<Project Sdk="Microsoft.NET.Sdk">

2

3 <ItemGroup>

4 <ProjectReference Include="..\Catena.Shared\Catena.Shared.csproj" />

5 </ItemGroup>

6

7 <PropertyGroup>

8 <OutputType>Exe</OutputType>

9 <TargetFramework>net10.0</TargetFramework>

10 <ImplicitUsings>enable</ImplicitUsings>

11 <Nullable>enable</Nullable>

12 <AssemblyName>catena</AssemblyName>

13 <PublishAot>true</PublishAot>

14 <DebuggerSupport>false</DebuggerSupport>

15 <OptimizationPreference>Size</OptimizationPreference>

16 <InvariantGlobalization>true</InvariantGlobalization>

17 <StackTraceSupport>false</StackTraceSupport>

18 <UseSystemResourceKeys>true</UseSystemResourceKeys>

19 </PropertyGroup>

20

21</Project>

1using System.Net.Http.Json;

2using System.Text.Json;

3using Catena.Shared.Dtos;

4using Catena.Shared.Models;

6namespace Catena.Client;

8public sealed class CatenaClient(HttpClient http)

9{

10 private static CatenaJsonContext Json => CatenaJsonContext.Default;

12 public async Task<ProjectResponse> CreateProjectAsync(string name, bool isPublic = false)

13 {

14 var response = await http.PostAsJsonAsync("/projects", new CreateProjectRequest(name, isPublic), Json.CreateProjectRequest);

15 response.EnsureSuccessStatusCode();

16 return (await response.Content.ReadFromJsonAsync(Json.ProjectResponse))!;

17 }

19 public async Task<ProjectResponse?> GetProjectAsync(string id)

20 {

21 return await http.GetFromJsonAsync($"/projects/{id}", Json.ProjectResponse);

22 }

24 public async Task<TrunkStateResponse> GetTrunkStateAsync(string projectId)

25 {

26 return (await http.GetFromJsonAsync($"/projects/{projectId}/trunk", Json.TrunkStateResponse))!;

27 }

29 public async Task<PatchResponse> CreatePatchAsync(string projectId, CreatePatchRequest request)

30 {

31 var response = await http.PostAsJsonAsync($"/projects/{projectId}/patches", request, Json.CreatePatchRequest);

32 response.EnsureSuccessStatusCode();

33 return (await response.Content.ReadFromJsonAsync(Json.PatchResponse))!;

34 }

36 public async Task<List<PatchResponse>> ListPatchesAsync(string projectId, Maturity? maturity = null, string? author = null)

37 {

38 var query = $"/projects/{projectId}/patches";

39 var parameters = new List<string>();

40 if (maturity.HasValue) parameters.Add($"maturity={maturity.Value}");

41 if (author is not null) parameters.Add($"author={author}");

42 if (parameters.Count > 0) query += "?" + string.Join("&", parameters);

44 return (await http.GetFromJsonAsync(query, Json.ListPatchResponse))!;

45 }

47 public async Task<(PatchResponse? Patch, string? Error)> UpdateMaturityAsync(string projectId, string patchId, Maturity maturity)

48 {

49 var response = await http.PutAsJsonAsync(

50 $"/projects/{projectId}/patches/{patchId}/maturity",

51 new UpdateMaturityRequest(maturity), Json.UpdateMaturityRequest);

53 if (response.IsSuccessStatusCode)

54 {

55 var patch = await response.Content.ReadFromJsonAsync(Json.PatchResponse);

56 return (patch, null);

57 }

59 var error = await response.Content.ReadAsStringAsync();

60 return (null, error);

61 }

63 public async Task<List<PatchResponse>> GetHistoryAsync(string projectId, string? file = null, string? author = null)

64 {

65 var query = $"/projects/{projectId}/trunk/history";

66 var parameters = new List<string>();

67 if (file is not null) parameters.Add($"file={Uri.EscapeDataString(file)}");

68 if (author is not null) parameters.Add($"author={Uri.EscapeDataString(author)}");

69 if (parameters.Count > 0) query += "?" + string.Join("&", parameters);

71 return (await http.GetFromJsonAsync(query, Json.ListPatchResponse))!;

72 }

74 public async Task<PatchDiffResponse?> GetDiffAsync(string projectId, string patchId)

75 {

76 return await http.GetFromJsonAsync($"/projects/{projectId}/patches/{patchId}/diff", Json.PatchDiffResponse);

77 }

79 public async Task<RevertResponse> RevertPatchAsync(string projectId, string patchId)

80 {

81 var response = await http.PostAsync($"/projects/{projectId}/patches/{patchId}/revert", null);

82 response.EnsureSuccessStatusCode();

83 return (await response.Content.ReadFromJsonAsync(Json.RevertResponse))!;

84 }

86 public async Task<ReleaseResponse> CreateReleaseAsync(string projectId, string version)

87 {

88 var response = await http.PostAsJsonAsync($"/projects/{projectId}/releases", new CreateReleaseRequest(version), Json.CreateReleaseRequest);

89 response.EnsureSuccessStatusCode();

90 return (await response.Content.ReadFromJsonAsync(Json.ReleaseResponse))!;

91 }

93 public async Task<List<ReleaseResponse>> ListReleasesAsync(string projectId)

94 {

95 return (await http.GetFromJsonAsync($"/projects/{projectId}/releases", Json.ListReleaseResponse))!;

96 }

98 public async Task<PatchDiffResponse?> GetPatchDiffAsync(string projectId, string patchId)

99 {

100 return await http.GetFromJsonAsync($"/projects/{projectId}/patches/{patchId}/diff", Json.PatchDiffResponse);

101 }

103 public async IAsyncEnumerable<FileContentResponse> DownloadFilesAsync(string projectId, List<string> files)

104 {

105 var response = await http.PostAsJsonAsync($"/projects/{projectId}/trunk/download", new BulkDownloadRequest(files), Json.BulkDownloadRequest);

106 response.EnsureSuccessStatusCode();

108 using var stream = await response.Content.ReadAsStreamAsync();

109 using var reader = new StreamReader(stream);

111 while (await reader.ReadLineAsync() is { } line)

112 {

113 if (string.IsNullOrWhiteSpace(line)) continue;

114 var entry = JsonSerializer.Deserialize(line, Json.FileContentResponse);

115 if (entry is not null)

116 yield return entry;

117 }

118 }

120 public async Task<byte[]?> DownloadPatchBlobAsync(string projectId, string patchId, int opIndex)

121 {

122 var response = await http.GetAsync($"/projects/{projectId}/patches/{patchId}/blobs/{opIndex}");

123 if (!response.IsSuccessStatusCode) return null;

124 return await response.Content.ReadAsByteArrayAsync();

125 }

126}

1using System.Text.Json.Serialization;

2using Catena.Client.Config;

3using Catena.Shared.Dtos;

5namespace Catena.Client;

7[JsonSerializable(typeof(WorkspaceConfig))]

8[JsonSerializable(typeof(CreateProjectRequest))]

9[JsonSerializable(typeof(ProjectResponse))]

10[JsonSerializable(typeof(TrunkStateResponse))]

11[JsonSerializable(typeof(CreatePatchRequest))]

12[JsonSerializable(typeof(PatchResponse))]

13[JsonSerializable(typeof(List<PatchResponse>), TypeInfoPropertyName = "ListPatchResponse")]

14[JsonSerializable(typeof(UpdateMaturityRequest))]

15[JsonSerializable(typeof(PatchDiffResponse))]

16[JsonSerializable(typeof(RevertResponse))]

17[JsonSerializable(typeof(CreateReleaseRequest))]

18[JsonSerializable(typeof(ReleaseResponse))]

19[JsonSerializable(typeof(List<ReleaseResponse>), TypeInfoPropertyName = "ListReleaseResponse")]

20[JsonSerializable(typeof(BulkDownloadRequest))]

21[JsonSerializable(typeof(FileContentResponse))]

22[JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase, WriteIndented = true)]

23internal sealed partial class CatenaJsonContext : JsonSerializerContext;

1using Catena.Shared.Models;

3namespace Catena.Client.Commands;

5public sealed class AcceptCommand(CatenaClient client, string projectId)

6{

7 public async Task<int> RunAsync(string? patchId)

8 {

9 if (patchId is null)

10 {

11 Console.Error.WriteLine("Patch ID is required. Usage: catena accept <id>");

12 return 1;

13 }

15 try

16 {

17 var (patch, error) = await client.UpdateMaturityAsync(projectId, patchId, Maturity.Accepted);

18 if (error is not null)

19 {

20 Console.Error.WriteLine($"Failed to accept: {error}");

21 return 1;

22 }

24 Console.WriteLine($"Patch {patch!.Id} accepted. Trunk updated.");

25 return 0;

26 }

27 catch (HttpRequestException ex)

28 {

29 Console.Error.WriteLine($"Cannot reach server: {ex.Message}");

30 return 1;

31 }

32 }

33}

1using Catena.Shared.Models;

3namespace Catena.Client.Commands;

5public sealed class DiffCommand(CatenaClient client, string projectId)

6{

7 public async Task<int> RunAsync(string? patchId)

8 {

9 try

10 {

11 if (patchId is null)

12 {

13 Console.Error.WriteLine("Patch ID required. Usage: catena diff <id>");

14 return 1;

15 }

17 var diff = await client.GetDiffAsync(projectId, patchId);

18 if (diff is null)

19 {

20 Console.Error.WriteLine($"Patch {patchId} not found.");

21 return 1;

22 }

24 Console.WriteLine($"Patch {diff.PatchId} {diff.Timestamp:yyyy-MM-dd HH:mm} {diff.Author}");

25 Console.WriteLine($" {diff.Description}");

26 Console.WriteLine();

28 foreach (var entry in diff.Entries)

29 {

30 var prefix = entry.Type switch

31 {

32 OpType.Insert => "+",

33 OpType.Modify => "~",

34 OpType.Delete => "-",

35 OpType.Rename => ">",

36 OpType.Move => ">",

37 _ => "?"

38 };

40 var size = entry.Bytes > 0 ? $" ({FormatBytes(entry.Bytes)})" : "";

41 var target = entry.NewPath is not null ? $" → {entry.NewPath}" : "";

43 Console.WriteLine($" {prefix} {entry.File}{target}{size}");

44 }

46 return 0;

47 }

48 catch (HttpRequestException ex)

49 {

50 Console.Error.WriteLine($"Cannot reach server: {ex.Message}");

51 return 1;

52 }

53 }

55 private static string FormatBytes(long bytes) => bytes switch

56 {

57 < 1024 => $"{bytes} B",

58 < 1024 * 1024 => $"{bytes / 1024.0:F1} KB",

59 _ => $"{bytes / (1024.0 * 1024.0):F1} MB"

60 };

61}

1using Catena.Shared.Dtos;

2using Catena.Shared.Models;

3using Catena.Shared.Tracking;

5namespace Catena.Client.Commands;

7public sealed class DraftCommand(CatenaClient client, string projectId)

8{

9 public async Task<int> RunAsync(string workspacePath, bool sync, string? description,

10 List<string>? dependsOn = null, List<string>? targets = null)

11 {

12 Dictionary<string, string> trunkFiles;

13 string trunkHash;

14 try

15 {

16 var trunk = await client.GetTrunkStateAsync(projectId);

17 trunkFiles = trunk.Files;

18 trunkHash = trunk.Hash;

19 }

20 catch (HttpRequestException ex)

21 {

22 Console.Error.WriteLine($"Cannot reach server: {ex.Message}");

23 return 1;

24 }

26 var filter = await IgnoreFilter.LoadAsync(workspacePath);

27 var localFiles = await WorkspaceScanner.ScanAsync(workspacePath, filter);

28 var diff = WorkspaceDiff.Compute(localFiles, trunkFiles);

30 if (!diff.HasChanges)

31 {

32 Console.WriteLine("No changes to draft.");

33 return 0;

34 }

36 var ops = new List<FileOperation>();

38 foreach (var file in diff.Added)

39 {

40 var content = await File.ReadAllBytesAsync(Path.Combine(workspacePath, file));

41 ops.Add(new FileOperation

42 {

43 Type = OpType.Insert,

44 File = file,

45 ContentBase64 = Convert.ToBase64String(content)

46 });

47 }

49 foreach (var file in diff.Modified)

50 {

51 var content = await File.ReadAllBytesAsync(Path.Combine(workspacePath, file));

52 ops.Add(new FileOperation

53 {

54 Type = OpType.Modify,

55 File = file,

56 ContentBase64 = Convert.ToBase64String(content)

57 });

58 }

60 foreach (var file in diff.Deleted)

61 {

62 ops.Add(new FileOperation

63 {

64 Type = OpType.Delete,

65 File = file

66 });

67 }

69 var maturity = sync ? Maturity.DraftSynced : Maturity.DraftLocal;

71 var request = new CreatePatchRequest

72 {

73 Author = Environment.UserName,

74 Description = description ?? $"Draft: {diff.Added.Count} added, {diff.Modified.Count} modified, {diff.Deleted.Count} deleted",

75 Maturity = maturity,

76 Dependencies = dependsOn ?? [],

77 Targets = targets is { Count: > 0 } ? targets : ["trunk"],

78 BaseHash = trunkHash,

79 Ops = ops

80 };

82 try

83 {

84 var patch = await client.CreatePatchAsync(projectId, request);

85 Console.WriteLine($"Patch created: {patch.Id}");

86 Console.WriteLine($" {patch.OpCount} operations, maturity: {patch.Maturity}");

87 return 0;

88 }

89 catch (HttpRequestException ex)

90 {

91 Console.Error.WriteLine($"Failed to create patch: {ex.Message}");

92 return 1;

93 }

94 }

95}

1using Catena.Client.Config;

3namespace Catena.Client.Commands;

5public static class InitCommand

6{

7 public static async Task<int> RunAsync(string serverUrl, string? newProjectName, string? projectId, string workspacePath, string? apiKey = null, bool isPublic = false)

8 {

9 if (newProjectName is null && projectId is null)

10 {

11 Console.Error.WriteLine("Either --new <name> or --project <id> is required.");

12 return 1;

13 }

15 var http = new HttpClient { BaseAddress = new Uri(serverUrl) };

16 if (apiKey is not null)

17 http.DefaultRequestHeaders.Add("X-Api-Key", apiKey);

18 var client = new CatenaClient(http);

20 string resolvedId;

22 try

23 {

24 if (newProjectName is not null)

25 {

26 var project = await client.CreateProjectAsync(newProjectName, isPublic);

27 resolvedId = project.Id;

28 Console.WriteLine($"Project created: {project.Name} ({project.Id})");

29 }

30 else

31 {

32 var project = await client.GetProjectAsync(projectId!);

33 if (project is null)

34 {

35 Console.Error.WriteLine($"Project {projectId} not found.");

36 return 1;

37 }

38 resolvedId = project.Id;

39 Console.WriteLine($"Connected to: {project.Name} ({project.Id})");

40 }

41 }

42 catch (HttpRequestException ex)

43 {

44 Console.Error.WriteLine($"Cannot reach server at {serverUrl}: {ex.Message}");

45 return 1;

46 }

48 var config = new WorkspaceConfig

49 {

50 ServerUrl = serverUrl,

51 ProjectId = resolvedId,

52 ApiKey = apiKey

53 };

54 await config.SaveAsync(workspacePath);

55 Console.WriteLine($"Workspace initialized in {Path.Combine(workspacePath, ".catena")}/");

56 return 0;

57 }

58}

1namespace Catena.Client.Commands;

3public sealed class LogCommand(CatenaClient client, string projectId)

4{

5 public async Task<int> RunAsync(string? file, string? author)

6 {

7 try

8 {

9 var history = await client.GetHistoryAsync(projectId, file, author);

11 if (history.Count == 0)

12 {

13 Console.WriteLine("No patches in history.");

14 return 0;

15 }

17 foreach (var patch in history)

18 {

19 Console.WriteLine($"{patch.Id} {patch.Timestamp:yyyy-MM-dd HH:mm} {patch.Author}");

20 Console.WriteLine($" {patch.Description} ({patch.OpCount} ops)");

21 Console.WriteLine();

22 }

24 return 0;

25 }

26 catch (HttpRequestException ex)

27 {

28 Console.Error.WriteLine($"Cannot reach server: {ex.Message}");

29 return 1;

30 }

31 }

32}

1using Catena.Shared.Models;

3namespace Catena.Client.Commands;

5public sealed class ProposeCommand(CatenaClient client, string projectId)

6{

7 public async Task<int> RunAsync(string? patchId)

8 {

9 try

10 {

11 if (patchId is null)

12 {

13 var patches = await client.ListPatchesAsync(projectId);

14 var draft = patches.FirstOrDefault(p =>

15 p.Maturity is Maturity.DraftSynced or Maturity.DraftShared);

17 if (draft is null)

18 {

19 Console.Error.WriteLine("No synced draft found to propose.");

20 return 1;

21 }

23 patchId = draft.Id;

24 }

26 var (patch, error) = await client.UpdateMaturityAsync(projectId, patchId, Maturity.Proposed);

27 if (error is not null)

28 {

29 Console.Error.WriteLine($"Failed to propose: {error}");

30 return 1;

31 }

33 Console.WriteLine($"Patch {patch!.Id} proposed.");

34 return 0;

35 }

36 catch (HttpRequestException ex)

37 {

38 Console.Error.WriteLine($"Cannot reach server: {ex.Message}");

39 return 1;

40 }

41 }

42}

1namespace Catena.Client.Commands;

3public sealed class ReleaseCommand(CatenaClient client, string projectId)

4{

5 public async Task<int> RunAsync(string? version)

6 {

7 if (version is null)

8 {

9 Console.Error.WriteLine("Version required. Usage: catena release v1.0.0");

10 return 1;

11 }

13 try

14 {

15 var release = await client.CreateReleaseAsync(projectId, version);

16 Console.WriteLine($"Release {release.Version} created.");

17 Console.WriteLine($" {release.FileCount} files, trunk hash: {release.TrunkHash}");

18 return 0;

19 }

20 catch (HttpRequestException ex)

21 {

22 Console.Error.WriteLine($"Failed to create release: {ex.Message}");

23 return 1;

24 }

25 }

26}

1namespace Catena.Client.Commands;

3public sealed class RevertCommand(CatenaClient client, string projectId)

4{

5 public async Task<int> RunAsync(string? patchId)

6 {

7 if (patchId is null)

8 {

9 Console.Error.WriteLine("Patch ID required. Usage: catena revert <id>");

10 return 1;

11 }

13 try

14 {

15 var result = await client.RevertPatchAsync(projectId, patchId);

16 Console.WriteLine($"Revert patch created: {result.RevertPatch.Id}");

17 Console.WriteLine($" Reverts: {result.OriginalPatchId}");

18 Console.WriteLine($" {result.RevertPatch.OpCount} ops, maturity: {result.RevertPatch.Maturity}");

19 Console.WriteLine(" Use 'catena propose' and 'catena accept' to apply.");

20 return 0;

21 }

22 catch (HttpRequestException ex)

23 {

24 Console.Error.WriteLine($"Failed to revert: {ex.Message}");

25 return 1;

26 }

27 }

28}

1using Catena.Shared.Tracking;

3namespace Catena.Client.Commands;

5public sealed class StatusCommand(CatenaClient client, string projectId)

6{

7 public async Task<int> RunAsync(string workspacePath)

8 {

9 Dictionary<string, string> trunkFiles;

10 try

11 {

12 var trunk = await client.GetTrunkStateAsync(projectId);

13 trunkFiles = trunk.Files;

14 }

15 catch (HttpRequestException ex)

16 {

17 Console.Error.WriteLine($"Cannot reach server: {ex.Message}");

18 return 1;

19 }

21 var filter = await IgnoreFilter.LoadAsync(workspacePath);

22 var localFiles = await WorkspaceScanner.ScanAsync(workspacePath, filter);

23 var diff = WorkspaceDiff.Compute(localFiles, trunkFiles);

25 if (!diff.HasChanges)

26 {

27 Console.WriteLine("Clean. No changes.");

28 return 0;

29 }

31 foreach (var file in diff.Added)

32 Console.WriteLine($" + {file}");

33 foreach (var file in diff.Modified)

34 Console.WriteLine($" ~ {file}");

35 foreach (var file in diff.Deleted)

36 Console.WriteLine($" - {file}");

38 Console.WriteLine();

39 Console.WriteLine($"{diff.Added.Count} added, {diff.Modified.Count} modified, {diff.Deleted.Count} deleted");

40 return 0;

41 }

42}

1using Catena.Shared.Dtos;

2using Catena.Shared.Models;

3using Catena.Shared.Tracking;

5namespace Catena.Client.Commands;

7public sealed class SyncCommand(CatenaClient client, string projectId)

8{

9 public async Task<int> RunAsync(string workspacePath, string direction, string? patchId,

10 string? description, bool explicitDown)

11 {

12 if (direction == "up")

13 return await SyncUp(workspacePath, description);

14 else

15 return await SyncDown(workspacePath, patchId, explicitDown);

16 }

18 private async Task<int> SyncDown(string workspacePath, string? patchId, bool explicitDown)

19 {

20 try

21 {

22 // Check for local changes first

23 var trunk = await client.GetTrunkStateAsync(projectId);

24 var targetFiles = new Dictionary<string, string>(trunk.Files);

26 Dictionary<string, (string PatchId, int OpIndex)>? patchBlobs = null;

27 if (patchId is not null)

28 {

29 var diff = await client.GetDiffAsync(projectId, patchId);

30 if (diff is null)

31 {

32 Console.Error.WriteLine($"Patch {patchId} not found.");

33 return 1;

34 }

36 patchBlobs = new();

37 for (int i = 0; i < diff.Entries.Count; i++)

38 {

39 var entry = diff.Entries[i];

40 switch (entry.Type)

41 {

42 case OpType.Insert:

43 case OpType.Modify:

44 targetFiles[entry.File] = $"patch:{patchId}:{i}";

45 patchBlobs[entry.File] = (patchId, i);

46 break;

47 case OpType.Delete:

48 targetFiles.Remove(entry.File);

49 break;

50 case OpType.Rename:

51 case OpType.Move:

52 if (entry.NewPath is not null && targetFiles.Remove(entry.File, out var hash))

53 targetFiles[entry.NewPath] = hash;

54 break;

55 }

56 }

57 }

59 var filter = await IgnoreFilter.LoadAsync(workspacePath);

60 var localFiles = await WorkspaceScanner.ScanAsync(workspacePath, filter);

62 var toDownload = new List<string>();

63 var toDownloadFromPatch = new List<(string File, string PatchId, int OpIndex)>();

64 var toDelete = new List<string>();

66 foreach (var (path, hash) in targetFiles)

67 {

68 if (!localFiles.TryGetValue(path, out var localHash) || localHash != hash)

69 {

70 if (patchBlobs is not null && patchBlobs.TryGetValue(path, out var blobRef))

71 toDownloadFromPatch.Add((path, blobRef.PatchId, blobRef.OpIndex));

72 else

73 toDownload.Add(path);

74 }

75 }

77 foreach (var path in localFiles.Keys)

78 {

79 if (!targetFiles.ContainsKey(path))

80 toDelete.Add(path);

81 }

83 if (toDownload.Count == 0 && toDownloadFromPatch.Count == 0 && toDelete.Count == 0)

84 {

85 Console.WriteLine("Already up to date.");

86 return 0;

87 }

89 // If direction was implicit (just `catena sync`), warn and confirm

90 if (!explicitDown)

91 {

92 var localChanges = WorkspaceDiff.Compute(localFiles, trunk.Files);

93 if (localChanges.HasChanges)

94 {

95 Console.WriteLine($"Warning: you have local changes ({localChanges.Added.Count} added, {localChanges.Modified.Count} modified, {localChanges.Deleted.Count} deleted).");

96 Console.WriteLine("Sync down will overwrite them. Use 'catena sync up' to push first.");

97 Console.Write("Continue? [y/N] ");

98 var answer = Console.ReadLine()?.Trim().ToLower();

99 if (answer is not "y" and not "yes")

100 {

101 Console.WriteLine("Aborted.");

102 return 0;

103 }

104 }

105 }

107 // Download

108 if (toDownload.Count > 0)

109 {

110 Console.WriteLine($"Downloading {toDownload.Count} files from trunk...");

111 await foreach (var file in client.DownloadFilesAsync(projectId, toDownload))

112 {

113 var fullPath = Path.Combine(workspacePath, file.Path.Replace('/', Path.DirectorySeparatorChar));

114 Directory.CreateDirectory(Path.GetDirectoryName(fullPath)!);

115 var content = Convert.FromBase64String(file.ContentBase64);

116 await File.WriteAllBytesAsync(fullPath, content);

117 }

118 }

120 foreach (var (file, pid, opIndex) in toDownloadFromPatch)

121 {

122 Console.WriteLine($" + {file} (from patch)");

123 var blob = await client.DownloadPatchBlobAsync(projectId, pid, opIndex);

124 if (blob is null) continue;

125 var fullPath = Path.Combine(workspacePath, file.Replace('/', Path.DirectorySeparatorChar));

126 Directory.CreateDirectory(Path.GetDirectoryName(fullPath)!);

127 await File.WriteAllBytesAsync(fullPath, blob);

128 }

130 foreach (var path in toDelete)

131 {

132 var fullPath = Path.Combine(workspacePath, path.Replace('/', Path.DirectorySeparatorChar));

133 if (File.Exists(fullPath))

134 {

135 File.Delete(fullPath);

136 Console.WriteLine($" - {path}");

137 }

138 }

140 var total = toDownload.Count + toDownloadFromPatch.Count;

141 Console.WriteLine($"Synced down: {total} downloaded, {toDelete.Count} deleted.");

142 return 0;

143 }

144 catch (HttpRequestException ex)

145 {

146 Console.Error.WriteLine($"Cannot reach server: {ex.Message}");

147 return 1;

148 }

149 }

151 private async Task<int> SyncUp(string workspacePath, string? description)

152 {

153 try

154 {

155 var trunk = await client.GetTrunkStateAsync(projectId);

156 var filter = await IgnoreFilter.LoadAsync(workspacePath);

157 var localFiles = await WorkspaceScanner.ScanAsync(workspacePath, filter);

158 var diff = WorkspaceDiff.Compute(localFiles, trunk.Files);

160 if (!diff.HasChanges)

161 {

162 Console.WriteLine("No changes to push.");

163 return 0;

164 }

166 Console.WriteLine($"Pushing: {diff.Added.Count} added, {diff.Modified.Count} modified, {diff.Deleted.Count} deleted");

168 var ops = new List<FileOperation>();

170 foreach (var file in diff.Added)

171 {

172 var content = await File.ReadAllBytesAsync(Path.Combine(workspacePath, file));

173 ops.Add(new FileOperation { Type = OpType.Insert, File = file, ContentBase64 = Convert.ToBase64String(content) });

174 }

176 foreach (var file in diff.Modified)

177 {

178 var content = await File.ReadAllBytesAsync(Path.Combine(workspacePath, file));

179 ops.Add(new FileOperation { Type = OpType.Modify, File = file, ContentBase64 = Convert.ToBase64String(content) });

180 }

182 foreach (var file in diff.Deleted)

183 {

184 ops.Add(new FileOperation { Type = OpType.Delete, File = file });

185 }

187 var request = new CreatePatchRequest

188 {

189 Author = Environment.UserName,

190 Description = description ?? $"Sync: {diff.Added.Count} added, {diff.Modified.Count} modified, {diff.Deleted.Count} deleted",

191 Maturity = Maturity.DraftSynced,

192 BaseHash = trunk.Hash,

193 Ops = ops

194 };

196 var patch = await client.CreatePatchAsync(projectId, request);

197 Console.WriteLine($"Synced up: patch {patch.Id} created ({patch.OpCount} ops)");

198 return 0;

199 }

200 catch (HttpRequestException ex)

201 {

202 Console.Error.WriteLine($"Cannot reach server: {ex.Message}");

203 return 1;

204 }

205 }

206}

1using Catena.Shared.Models;

3namespace Catena.Client.Commands;

5public sealed class WithdrawCommand(CatenaClient client, string projectId)

6{

7 public async Task<int> RunAsync(string? patchId)

8 {

9 if (patchId is null)

10 {

11 Console.Error.WriteLine("Patch ID required. Usage: catena withdraw <id>");

12 return 1;

13 }

15 try

16 {

17 var (patch, error) = await client.UpdateMaturityAsync(projectId, patchId, Maturity.DraftSynced);

18 if (error is not null)

19 {

20 Console.Error.WriteLine($"Failed to withdraw: {error}");

21 return 1;

22 }

24 Console.WriteLine($"Patch {patch!.Id} withdrawn to draft. You can now make changes and re-propose.");

25 return 0;

26 }

27 catch (HttpRequestException ex)

28 {

29 Console.Error.WriteLine($"Cannot reach server: {ex.Message}");

30 return 1;

31 }

32 }

33}

1using System.Text.Json;

3namespace Catena.Client.Config;

5public sealed record WorkspaceConfig

6{

7 public required string ServerUrl { get; init; }

8 public required string ProjectId { get; init; }

9 public string? ApiKey { get; init; }

11 public static string ConfigDir(string workspacePath) =>

12 Path.Combine(workspacePath, ".catena");

14 public static string ConfigFile(string workspacePath) =>

15 Path.Combine(ConfigDir(workspacePath), "config.json");

17 public async Task SaveAsync(string workspacePath)

18 {

19 Directory.CreateDirectory(ConfigDir(workspacePath));

20 await File.WriteAllTextAsync(ConfigFile(workspacePath), JsonSerializer.Serialize(this, CatenaJsonContext.Default.WorkspaceConfig));

21 }

23 public static async Task<WorkspaceConfig?> LoadAsync(string workspacePath)

24 {

25 var file = ConfigFile(workspacePath);

26 if (!File.Exists(file)) return null;

27 var json = await File.ReadAllTextAsync(file);

28 return JsonSerializer.Deserialize(json, CatenaJsonContext.Default.WorkspaceConfig);

29 }

30}

1using Catena.Client;

2using Catena.Client.Commands;

3using Catena.Client.Config;

5if (args.Length == 0)

6{

7 PrintUsage();

8 return 1;

9}

11var command = args[0];

13// init is special — no config exists yet

14if (command == "init")

15 return await HandleInit(args);

17if (command is "--help" or "-h")

18 return PrintUsage();

20// All other commands need an existing workspace

21var path = ParsePath(args);

22var config = await WorkspaceConfig.LoadAsync(path);

23if (config is null)

24{

25 Console.Error.WriteLine("Not a catena workspace. Run 'catena init' first.");

26 return 1;

27}

29var client = BuildClient(config);

31return command switch

32{

33 "status" => await new StatusCommand(client, config.ProjectId).RunAsync(path),

34 "draft" => await HandleDraft(args, client, config.ProjectId, path),

35 "propose" => await new ProposeCommand(client, config.ProjectId).RunAsync(ParsePositional(args)),

36 "accept" => await new AcceptCommand(client, config.ProjectId).RunAsync(ParsePositional(args)),

37 "log" => await HandleLog(args, client, config.ProjectId),

38 "diff" => await new DiffCommand(client, config.ProjectId).RunAsync(ParsePositional(args)),

39 "release" => await new ReleaseCommand(client, config.ProjectId).RunAsync(ParsePositional(args)),

40 "withdraw" => await new WithdrawCommand(client, config.ProjectId).RunAsync(ParsePositional(args)),

41 "sync" => await HandleSync(args, client, config.ProjectId, path),

42 _ => PrintUnknown(command)

43};

45// === Helpers ===

47static CatenaClient BuildClient(WorkspaceConfig config)

48{

49 var http = new HttpClient { BaseAddress = new Uri(config.ServerUrl) };

50 if (config.ApiKey is not null)

51 http.DefaultRequestHeaders.Add("X-Api-Key", config.ApiKey);

52 return new CatenaClient(http);

53}

55static string ParsePath(string[] args)

56{

57 for (int i = 1; i < args.Length; i++)

58 {

59 if (args[i] == "--path" && i + 1 < args.Length)

60 return Path.GetFullPath(args[i + 1]);

61 }

62 return Directory.GetCurrentDirectory();

63}

65static string? ParsePositional(string[] args)

66{

67 for (int i = 1; i < args.Length; i++)

68 {

69 if (args[i].StartsWith("--"))

70 {

71 i++; // skip flag value

72 continue;

73 }

74 return args[i];

75 }

76 return null;

77}

79static async Task<int> HandleInit(string[] args)

80{

81 string? serverUrl = null;

82 string? newName = null;

83 string? projectId = null;

84 string? path = null;

85 string? apiKey = null;

86 bool isPublic = false;

88 for (int i = 1; i < args.Length; i++)

89 {

90 switch (args[i])

91 {

92 case "--server" when i + 1 < args.Length: serverUrl = args[++i]; break;

93 case "--new" when i + 1 < args.Length: newName = args[++i]; break;

94 case "--project" when i + 1 < args.Length: projectId = args[++i]; break;

95 case "--path" when i + 1 < args.Length: path = args[++i]; break;

96 case "--api-key" when i + 1 < args.Length: apiKey = args[++i]; break;

97 case "--public": isPublic = true; break;

98 }

99 }

101 serverUrl ??= "http://localhost:5000";

102 path = Path.GetFullPath(path ?? Directory.GetCurrentDirectory());

103 return await InitCommand.RunAsync(serverUrl, newName, projectId, path, apiKey, isPublic);

104}

106static async Task<int> HandleDraft(string[] args, CatenaClient client, string projectId, string path)

107{

108 string? description = null;

109 bool sync = false;

110 var dependsOn = new List<string>();

111 var targets = new List<string>();

113 for (int i = 1; i < args.Length; i++)

114 {

115 switch (args[i])

116 {

117 case "--sync": sync = true; break;

118 case "-m" when i + 1 < args.Length: description = args[++i]; break;

119 case "--depends-on" when i + 1 < args.Length: dependsOn.Add(args[++i]); break;

120 case "--target" when i + 1 < args.Length: targets.Add(args[++i]); break;

121 }

122 }

124 return await new DraftCommand(client, projectId).RunAsync(path, sync, description, dependsOn, targets);

125}

127static async Task<int> HandleLog(string[] args, CatenaClient client, string projectId)

128{

129 string? file = null;

130 string? author = null;

132 for (int i = 1; i < args.Length; i++)

133 {

134 switch (args[i])

135 {

136 case "--file" when i + 1 < args.Length: file = args[++i]; break;

137 case "--author" when i + 1 < args.Length: author = args[++i]; break;

138 }

139 }

141 return await new LogCommand(client, projectId).RunAsync(file, author);

142}

144static async Task<int> HandleSync(string[] args, CatenaClient client, string projectId, string path)

145{

146 string? patchId = null;

147 string? description = null;

148 string direction = "down";

149 bool explicitDown = false;

151 for (int i = 1; i < args.Length; i++)

152 {

153 switch (args[i])

154 {

155 case "up": direction = "up"; break;

156 case "down": direction = "down"; explicitDown = true; break;

157 case "--patch" when i + 1 < args.Length: patchId = args[++i]; break;

158 case "-m" when i + 1 < args.Length: description = args[++i]; break;

159 }

160 }

162 return await new SyncCommand(client, projectId).RunAsync(path, direction, patchId, description, explicitDown);

163}

165static int PrintUsage()

166{

167 Console.WriteLine("""

168 catena - Patch-based version control

170 Usage: catena <command> [options]

172 Commands:

173 init Initialize workspace

174 --new <name> Create new project on server

175 --project <id> Connect to existing project

176 --server <url> Server URL (default: http://localhost:5000)

177 --path <dir> Workspace directory (default: current dir)

178 --api-key <key> API key for authentication

180 status Show workspace status

181 draft Create a draft patch

182 --sync Sync to server

183 -m <message> Description

184 propose Submit patch for validation

185 accept Accept a patch into trunk

186 log Show patch history

187 --file <path> Filter by file

188 --author <name> Filter by author

189 diff Show patch changes

190 revert Create inverse patch

191 release Create release snapshot

192 sync Sync workspace to trunk

193 --patch <id> Overlay a specific patch

194 server Start server

196 Global options:

197 --path <dir> Workspace directory (default: current dir)

198 """);

199 return 0;

200}

202static int PrintUnknown(string command)

203{

204 Console.Error.WriteLine($"Unknown command: {command}. Run 'catena --help' for usage.");

205 return 1;

206}

1using System.Security.Claims;

2using Catena.Shared.Dtos;

3using Catena.Storage;

4using Microsoft.AspNetCore.Authentication;

5using Microsoft.AspNetCore.Authentication.Cookies;

7namespace Catena.Server.Api;

9public static class AuthEndpoints

10{

11 public static void MapAuthApi(this WebApplication app)

12 {

13 var group = app.MapGroup("/auth");

15 group.MapPost("/login", async (LoginRequest request, UserStore userStore, HttpContext ctx) =>

16 {

17 if (string.IsNullOrWhiteSpace(request.ApiKey))

18 return Results.BadRequest("API key is required.");

20 var user = await userStore.GetByApiKeyAsync(request.ApiKey);

21 if (user is null)

22 return Results.Unauthorized();

24 var claims = new[]

25 {

26 new Claim(ClaimTypes.NameIdentifier, user.Id),

27 new Claim(ClaimTypes.Name, user.Name),

28 new Claim(ClaimTypes.Role, user.Role.ToString())

29 };

30 var identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);

31 var principal = new ClaimsPrincipal(identity);

33 await ctx.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, principal);

35 return Results.Ok(new LoginResponse(user.Id, user.Name, user.Role));

36 });

38 // Web login — form POST from /login page, sets cookie and redirects

39 group.MapPost("/web-login", async (HttpContext ctx, UserStore userStore) =>

40 {

41 var form = await ctx.Request.ReadFormAsync();

42 var apiKey = form["apiKey"].ToString();

44 if (string.IsNullOrWhiteSpace(apiKey))

45 return Results.Redirect("/login?error=1");

47 var user = await userStore.GetByApiKeyAsync(apiKey);

48 if (user is null)

49 return Results.Redirect("/login?error=1");

51 var claims = new[]

52 {

53 new Claim(ClaimTypes.NameIdentifier, user.Id),

54 new Claim(ClaimTypes.Name, user.Name),

55 new Claim(ClaimTypes.Role, user.Role.ToString())

56 };

57 var identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);

58 var principal = new ClaimsPrincipal(identity);

60 await ctx.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, principal);

61 return Results.Redirect("/app");

62 }).DisableAntiforgery();

64 group.MapGet("/logout", async (HttpContext ctx) =>

65 {

66 await ctx.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);

67 return Results.Redirect("/");

68 });

70 group.MapGet("/me", (HttpContext ctx) =>

71 {

72 if (ctx.User.Identity?.IsAuthenticated != true)

73 return Results.Unauthorized();

75 return Results.Ok(new LoginResponse(

76 ctx.User.FindFirstValue(ClaimTypes.NameIdentifier)!,

77 ctx.User.FindFirstValue(ClaimTypes.Name)!,

78 Enum.Parse<Catena.Shared.Models.UserRole>(ctx.User.FindFirstValue(ClaimTypes.Role)!)

79 ));

80 });

81 }

82}

1using Catena.Storage;

2using Catena.Shared.Dtos;

3using Catena.Shared.Models;

4using Catena.Shared.Overlap;

6namespace Catena.Server.Api;

8public static class OverlapEndpoints

9{

10 public static void MapOverlapApi(this WebApplication app)

11 {

12 var group = app.MapGroup("/projects/{projectId}");

14 group.MapGet("/overlaps", async (string projectId, PatchStore patchStore, ProjectStore projectStore) =>

15 {

16 var project = await projectStore.GetAsync(projectId);

17 if (project is null) return Results.NotFound("Project not found.");

19 var proposed = await patchStore.ListAsync(projectId, maturityFilter: Maturity.Proposed);

20 if (proposed.Count < 2)

21 return Results.Ok(Array.Empty<OverlapReportResponse>());

23 var reports = new List<OverlapReportResponse>();

25 for (int i = 0; i < proposed.Count; i++)

26 {

27 for (int j = i + 1; j < proposed.Count; j++)

28 {

29 var report = OverlapDetector.Detect(proposed[i], proposed[j]);

30 if (report.Results.Count == 0) continue;

32 reports.Add(new OverlapReportResponse

33 {

34 PatchIdA = report.PatchIdA,

35 PatchIdB = report.PatchIdB,

36 HasConflicts = report.HasConflicts,

37 Items = report.Results.Select(r => new OverlapItemResponse

38 {

39 Kind = r.Kind,

40 FileA = r.FileA,

41 FileB = r.FileB,

42 OpIndexA = r.OpIndexA,

43 OpIndexB = r.OpIndexB,

44 Reason = r.Reason

45 }).ToList()

46 });

47 }

48 }

50 return Results.Ok(reports);

51 });

53 group.MapGet("/patches/{patchId}/conflicts", async (string projectId, string patchId,

54 PatchStore patchStore) =>

55 {

56 var patch = await patchStore.GetAsync(projectId, patchId);

57 if (patch is null) return Results.NotFound("Patch not found.");

59 var proposed = await patchStore.ListAsync(projectId, maturityFilter: Maturity.Proposed);

60 var others = proposed.Where(p => p.Id != patchId).ToList();

62 var conflicts = new List<OverlapReportResponse>();

64 foreach (var other in others)

65 {

66 var report = OverlapDetector.Detect(patch, other);

67 if (!report.HasConflicts) continue;

69 conflicts.Add(new OverlapReportResponse

70 {

71 PatchIdA = report.PatchIdA,

72 PatchIdB = report.PatchIdB,

73 HasConflicts = true,

74 Items = report.Conflicts.Select(r => new OverlapItemResponse

75 {

76 Kind = r.Kind,

77 FileA = r.FileA,

78 FileB = r.FileB,

79 OpIndexA = r.OpIndexA,

80 OpIndexB = r.OpIndexB,

81 Reason = r.Reason

82 }).ToList()

83 });

84 }

86 return Results.Ok(conflicts);

87 });

88 }

89}

1using Catena.Server.Auth;

2using Catena.Storage;

3using Catena.Shared.Dtos;

4using Catena.Shared.Models;

6namespace Catena.Server.Api;

8public static class PatchEndpoints

9{

10 public static void MapPatchApi(this WebApplication app)

11 {

12 var group = app.MapGroup("/projects/{projectId}/patches");

14 group.MapPost("/", async (string projectId, CreatePatchRequest request, PatchStore store, ProjectStore projectStore, CatenaEvents events, HttpContext ctx) =>

15 {

16 var project = await projectStore.GetAsync(projectId);

17 if (project is null) return Results.NotFound("Project not found.");

19 var author = ctx.GetUserId() is not null ? ctx.GetUserName() : request.Author;

20 if (string.IsNullOrWhiteSpace(author))

21 return Results.BadRequest("Author is required.");

22 if (request.Ops.Count == 0)

23 return Results.BadRequest("At least one operation is required.");

25 var authenticatedRequest = request with { Author = author };

26 var patch = await store.CreateAsync(projectId, authenticatedRequest);

27 events.NotifyPatchChanged(projectId);

28 return Results.Created($"/projects/{projectId}/patches/{patch.Id}", ToPatchResponse(patch));

29 });

31 group.MapGet("/", async (string projectId, PatchStore store, ProjectStore projectStore, Maturity? maturity, string? author) =>

32 {

33 var project = await projectStore.GetAsync(projectId);

34 if (project is null) return Results.NotFound("Project not found.");

36 var patches = await store.ListAsync(projectId, maturity, author);

37 return Results.Ok(patches.Select(ToPatchResponse));

38 });

40 group.MapGet("/{patchId}", async (string projectId, string patchId, PatchStore store) =>

41 {

42 var patch = await store.GetAsync(projectId, patchId);

43 return patch is null ? Results.NotFound() : Results.Ok(ToPatchResponse(patch));

44 });

46 group.MapPut("/{patchId}/maturity", async (string projectId, string patchId,

47 UpdateMaturityRequest request, PatchStore store, TrunkState trunk, ReleaseStore releaseStore, CatenaEvents events, HttpContext ctx) =>

48 {

49 if (request.Maturity == Maturity.Accepted && !ctx.CanAccept())

50 return Results.Forbid();

52 var (patch, error) = await store.UpdateMaturityAsync(projectId, patchId, request.Maturity);

53 if (error is not null)

54 return patch is null ? Results.NotFound(error) : Results.BadRequest(error);

56 if (request.Maturity == Maturity.Accepted)

57 {

58 await trunk.ApplyPatchAsync(projectId, patch!, store);

59 events.NotifyTrunkChanged(projectId);

61 foreach (var target in patch!.Targets.Where(t => t != "trunk"))

62 {

63 await releaseStore.ApplyPatchAsync(projectId, target, patch, store);

64 events.NotifyReleaseChanged(projectId);

65 }

66 }

68 events.NotifyPatchChanged(projectId);

69 return Results.Ok(ToPatchResponse(patch!));

70 });

72 group.MapGet("/{patchId}/diff", async (string projectId, string patchId, PatchStore store) =>

73 {

74 var patch = await store.GetAsync(projectId, patchId);

75 if (patch is null) return Results.NotFound();

77 return Results.Ok(new PatchDiffResponse

78 {

79 PatchId = patch.Id,

80 Author = patch.Author,

81 Description = patch.Description,

82 Timestamp = patch.Timestamp,

83 Entries = patch.Ops.Select(op => new DiffEntry

84 {

85 Type = op.Type,

86 File = op.File,

87 Bytes = op.EndByte - op.StartByte,

88 LinesAdded = op.LinesAdded,

89 LinesDeleted = op.LinesDeleted,

90 NewPath = op.NewPath

91 }).ToList()

92 });

93 });

95 group.MapGet("/{patchId}/blobs/{opIndex:int}", async (string projectId, string patchId, int opIndex, PatchStore store) =>

96 {

97 var blob = await store.GetBlobAsync(projectId, patchId, opIndex);

98 if (blob is null) return Results.NotFound();

99 return Results.Bytes(blob, contentType: "application/octet-stream");

100 });

101 }

103 private static PatchResponse ToPatchResponse(Patch patch) => new()

104 {

105 Id = patch.Id,

106 Author = patch.Author,

107 ProjectId = patch.ProjectId,

108 Maturity = patch.Maturity,

109 Timestamp = patch.Timestamp,

110 Description = patch.Description,

111 Dependencies = patch.Dependencies,

112 Targets = patch.Targets,

113 OpCount = patch.Ops.Count

114 };

115}

1using Catena.Server.Auth;

2using Catena.Storage;

3using Catena.Shared.Dtos;

5namespace Catena.Server.Api;

7public static class ProjectEndpoints

8{

9 public static void MapProjectApi(this WebApplication app)

10 {

11 var group = app.MapGroup("/projects");

13 group.MapPost("/", async (CreateProjectRequest request, ProjectStore store, HttpContext ctx) =>

14 {

15 if (!ctx.IsAuthenticated())

16 return Results.Unauthorized();

17 if (string.IsNullOrWhiteSpace(request.Name))

18 return Results.BadRequest("Project name is required.");

20 var project = await store.CreateAsync(request.Name, request.IsPublic);

21 return Results.Created($"/projects/{project.Id}",

22 new ProjectResponse(project.Id, project.Name, project.IsPublic, project.CreatedAt));

23 });

25 group.MapGet("/", async (ProjectStore store, HttpContext ctx) =>

26 {

27 var projects = await store.ListAsync();

28 var isAuthenticated = ctx.User.Identity?.IsAuthenticated == true;

30 if (!isAuthenticated)

31 projects = projects.Where(p => p.IsPublic).ToList();

33 return Results.Ok(projects.Select(p =>

34 new ProjectResponse(p.Id, p.Name, p.IsPublic, p.CreatedAt)));

35 });

37 group.MapGet("/{id}", async (string id, ProjectStore store, HttpContext ctx) =>

38 {

39 var project = await store.GetAsync(id);

40 if (project is null) return Results.NotFound();

42 var isAuthenticated = ctx.User.Identity?.IsAuthenticated == true;

43 if (!project.IsPublic && !isAuthenticated)

44 return Results.NotFound();

46 return Results.Ok(new ProjectResponse(project.Id, project.Name, project.IsPublic, project.CreatedAt));

47 });

48 }

49}

1using Catena.Server.Auth;

2using Catena.Storage;

3using Catena.Shared.Dtos;

5namespace Catena.Server.Api;

7public static class ReleaseEndpoints

8{

9 public static void MapReleaseApi(this WebApplication app)

10 {

11 var group = app.MapGroup("/projects/{projectId}/releases");

13 group.MapPost("/", async (string projectId, CreateReleaseRequest request,

14 ReleaseStore releaseStore, ProjectStore projectStore, PatchStore patchStore, TrunkState trunk, HttpContext ctx) =>

15 {

16 if (!ctx.CanAccept())

17 return Results.Forbid();

19 var project = await projectStore.GetAsync(projectId);

20 if (project is null) return Results.NotFound("Project not found.");

22 if (string.IsNullOrWhiteSpace(request.Version))

23 return Results.BadRequest("Version is required.");

25 if (releaseStore.Exists(projectId, request.Version))

26 return Results.Conflict($"Release {request.Version} already exists.");

28 var files = await trunk.GetFilesAsync(projectId);

29 var hash = TrunkState.ComputeHash(files);

31 // Collect accepted patch IDs for this release

32 var accepted = await patchStore.ListAsync(projectId, maturityFilter: Catena.Shared.Models.Maturity.Accepted);

33 var patchIds = accepted.Select(p => p.Id).ToList();

34 var basePatchId = accepted.FirstOrDefault()?.Id;

36 var release = await releaseStore.CreateAsync(projectId, request.Version, files, hash, patchIds, basePatchId);

38 return Results.Created($"/projects/{projectId}/releases/{release.Version}",

39 ToResponse(release));

40 });

42 group.MapGet("/", async (string projectId, ReleaseStore releaseStore, ProjectStore projectStore) =>

43 {

44 var project = await projectStore.GetAsync(projectId);

45 if (project is null) return Results.NotFound("Project not found.");

47 var releases = await releaseStore.ListAsync(projectId);

48 return Results.Ok(releases.Select(ToResponse));

49 });

51 group.MapGet("/{version}", async (string projectId, string version, ReleaseStore releaseStore) =>

52 {

53 var release = await releaseStore.GetAsync(projectId, version);

54 return release is null ? Results.NotFound() : Results.Ok(ToResponse(release));

55 });

57 group.MapGet("/{version}/files", async (string projectId, string version, ReleaseStore releaseStore) =>

58 {

59 var release = await releaseStore.GetAsync(projectId, version);

60 return release is null ? Results.NotFound() : Results.Ok(release.Files);

61 });

62 }

64 private static ReleaseResponse ToResponse(Catena.Shared.Models.Release release) => new()

65 {

66 Version = release.Version,

67 ProjectId = release.ProjectId,

68 CreatedAt = release.CreatedAt,

69 FileCount = release.Files.Count,

70 TrunkHash = release.TrunkHash

71 };

72}

1using Catena.Server.Auth;

2using Catena.Shared.Dtos;

3using Catena.Storage;

5namespace Catena.Server.Api;

7public static class ReviewEndpoints

8{

9 public static void MapReviewApi(this WebApplication app)

10 {

11 var group = app.MapGroup("/projects/{projectId}/patches/{patchId}/reviews");

13 group.MapPost("/", async (string projectId, string patchId, CreateReviewRequest request,

14 PatchStore patchStore, ReviewStore reviewStore, CatenaEvents events, HttpContext ctx) =>

15 {

16 var patch = await patchStore.GetAsync(projectId, patchId);

17 if (patch is null) return Results.NotFound("Patch not found.");

19 var userId = ctx.GetUserId() ?? "anonymous";

20 var userName = ctx.GetUserName();

22 var review = await reviewStore.CreateAsync(projectId, patchId, userId, userName,

23 request.FilePath, request.LineNumber, request.Comment);

24 events.NotifyReviewChanged(projectId);

25 return Results.Created($"/projects/{projectId}/patches/{patchId}/reviews/{review.Id}",

26 ToResponse(review));

27 });

29 group.MapGet("/", async (string projectId, string patchId, ReviewStore reviewStore) =>

30 {

31 var reviews = await reviewStore.ListForPatchAsync(projectId, patchId);

32 return Results.Ok(reviews.Select(ToResponse));

33 });

34 }

36 private static ReviewResponse ToResponse(Catena.Shared.Models.Review r) =>

37 new(r.Id, r.PatchId, r.ReviewerId, r.ReviewerName, r.Status, r.Comment,

38 r.FilePath, r.LineNumber, r.CreatedAt, r.UpdatedAt);

39}

1using Catena.Server.Auth;

2using Catena.Storage;

3using Catena.Shared.Dtos;

4using Catena.Shared.Models;

6namespace Catena.Server.Api;

8public static class TrunkEndpoints

9{

10 public static void MapTrunkApi(this WebApplication app)

11 {

12 var group = app.MapGroup("/projects/{projectId}/trunk");

14 group.MapGet("/", async (string projectId, TrunkState trunk, ProjectStore projectStore, HttpContext ctx) =>

15 {

16 var (project, accessError) = await ProjectAccessHelper.GetReadableProjectAsync(projectStore, projectId, ctx);

17 if (accessError is not null) return accessError;

19 var files = await trunk.GetFilesAsync(projectId);

20 return Results.Ok(new TrunkStateResponse

21 {

22 Files = files,

23 Hash = TrunkState.ComputeHash(files)

24 });

25 });

27 group.MapGet("/history", async (string projectId, PatchStore patchStore, ProjectStore projectStore,

28 HttpContext ctx, string? file, string? author) =>

29 {

30 var (project, accessError) = await ProjectAccessHelper.GetReadableProjectAsync(projectStore, projectId, ctx);

31 if (accessError is not null) return accessError;

33 var accepted = await patchStore.ListAsync(projectId, maturityFilter: Maturity.Accepted, authorFilter: author);

35 if (file is not null)

36 {

37 accepted = accepted

38 .Where(p => p.Ops.Any(op => op.File == file || op.NewPath == file))

39 .ToList();

40 }

42 return Results.Ok(accepted.Select(p => new PatchResponse

43 {

44 Id = p.Id,

45 Author = p.Author,

46 ProjectId = p.ProjectId,

47 Maturity = p.Maturity,

48 Timestamp = p.Timestamp,

49 Description = p.Description,

50 Dependencies = p.Dependencies,

51 Targets = p.Targets,

52 OpCount = p.Ops.Count

53 }));

54 });

56 group.MapGet("/tree", async (string projectId, TrunkState trunk, ProjectStore projectStore, HttpContext ctx) =>

57 {

58 var (project, accessError) = await ProjectAccessHelper.GetReadableProjectAsync(projectStore, projectId, ctx);

59 if (accessError is not null) return accessError;

61 var files = await trunk.GetFilesAsync(projectId);

62 var root = new List<FileTreeEntry>();

64 foreach (var filePath in files.Keys.OrderBy(f => f))

65 {

66 var parts = filePath.Split('/');

67 var current = root;

69 for (int i = 0; i < parts.Length; i++)

70 {

71 var part = parts[i];

72 var isFile = i == parts.Length - 1;

73 var fullPath = string.Join("/", parts[..( i + 1)]);

75 var existing = current.FirstOrDefault(e => e.Name == part);

76 if (existing is null)

77 {

78 existing = new FileTreeEntry

79 {

80 Name = part,

81 Path = isFile ? fullPath : fullPath + "/",

82 IsDirectory = !isFile

83 };

84 current.Add(existing);

85 }

86 current = existing.Children;

87 }

88 }

90 return Results.Ok(root);

91 });

93 group.MapGet("/files/{**path}", async (string projectId, string path,

94 TrunkState trunk, PatchStore patchStore) =>

95 {

96 var blobIndex = await trunk.GetBlobIndexAsync(projectId);

97 if (!blobIndex.TryGetValue(path, out var blobRef))

98 return Results.NotFound("File not found in trunk.");

100 var blob = await patchStore.GetBlobAsync(projectId, blobRef.PatchId, blobRef.OpIndex);

101 if (blob is null) return Results.NotFound("Blob missing.");

103 return Results.Bytes(blob, contentType: "application/octet-stream", fileDownloadName: Path.GetFileName(path));

104 });

106 group.MapPost("/download", async (string projectId, BulkDownloadRequest? request,

107 TrunkState trunk, PatchStore patchStore, HttpResponse response) =>

108 {

109 if (request?.Files is null || request.Files.Count == 0)

110 {

111 response.StatusCode = 400;

112 return;

113 }

115 var blobIndex = await trunk.GetBlobIndexAsync(projectId);

117 response.ContentType = "application/x-ndjson";

118 response.StatusCode = 200;

120 await using var writer = new StreamWriter(response.Body);

122 foreach (var filePath in request.Files)

123 {

124 if (!blobIndex.TryGetValue(filePath, out var blobRef)) continue;

125 var blob = await patchStore.GetBlobAsync(projectId, blobRef.PatchId, blobRef.OpIndex);

126 if (blob is null) continue;

128 var entry = new FileContentResponse

129 {

130 Path = filePath,

131 ContentBase64 = Convert.ToBase64String(blob)

132 };

133 await writer.WriteLineAsync(System.Text.Json.JsonSerializer.Serialize(entry));

134 await writer.FlushAsync();

135 }

136 });

137 }

138}

1using Catena.Shared.Dtos;

2using Catena.Shared.Models;

3using Catena.Storage;

5namespace Catena.Server.Api;

7public static class UserEndpoints

8{

9 public static void MapUserApi(this WebApplication app)

10 {

11 var group = app.MapGroup("/users").RequireAuthorization("AdminOnly");

13 group.MapPost("/", async (CreateUserRequest request, UserStore store) =>

14 {

15 if (string.IsNullOrWhiteSpace(request.Name))

16 return Results.BadRequest("Name is required.");

18 var (user, plainKey) = await store.CreateAsync(request.Name, request.Role);

19 return Results.Created($"/users/{user.Id}",

20 new CreateUserResponse(user.Id, user.Name, user.Role, plainKey));

21 });

23 group.MapGet("/", async (UserStore store) =>

24 {

25 var users = await store.ListAsync();

26 return Results.Ok(users.Select(u =>

27 new UserResponse(u.Id, u.Name, u.Role, u.CreatedAt)));

28 });

30 group.MapPut("/{id}/role", async (string id, UpdateRoleRequest request, UserStore store) =>

31 {

32 var updated = await store.UpdateRoleAsync(id, request.Role);

33 return updated is null

34 ? Results.NotFound()

35 : Results.Ok(new UserResponse(updated.Id, updated.Name, updated.Role, updated.CreatedAt));

36 });

38 group.MapDelete("/{id}", (string id, UserStore store) =>

39 {

40 return store.DeleteUser(id) ? Results.NoContent() : Results.NotFound();

41 });

43 // Public user lookup (any authenticated user)

44 app.MapGet("/users/{id}", async (string id, UserStore store) =>

45 {

46 var user = await store.GetAsync(id);

47 return user is null ? Results.NotFound()

48 : Results.Ok(new UserResponse(user.Id, user.Name, user.Role, user.CreatedAt));

49 });

50 }

51}

1using Catena.Shared.Dtos;

2using Catena.Storage;

4namespace Catena.Server.Api;

6public static class WebhookEndpoints

7{

8 public static void MapWebhookApi(this WebApplication app)

9 {

10 var group = app.MapGroup("/projects/{projectId}/webhooks").RequireAuthorization("MaintainerOrAdmin");

12 group.MapPost("/", async (string projectId, CreateWebhookRequest request,

13 WebhookStore store, ProjectStore projectStore) =>

14 {

15 var project = await projectStore.GetAsync(projectId);

16 if (project is null) return Results.NotFound("Project not found.");

18 if (string.IsNullOrWhiteSpace(request.Event) || string.IsNullOrWhiteSpace(request.Url))

19 return Results.BadRequest("Event and URL are required.");

21 var webhook = await store.CreateAsync(projectId, request.Event, request.Url);

22 return Results.Created($"/projects/{projectId}/webhooks/{webhook.Id}",

23 new WebhookResponse(webhook.Id, webhook.ProjectId, webhook.Event, webhook.Url, webhook.CreatedAt));

24 });

26 group.MapGet("/", async (string projectId, WebhookStore store, ProjectStore projectStore) =>

27 {

28 var project = await projectStore.GetAsync(projectId);

29 if (project is null) return Results.NotFound("Project not found.");

31 var hooks = await store.ListAsync(projectId);

32 return Results.Ok(hooks.Select(h =>

33 new WebhookResponse(h.Id, h.ProjectId, h.Event, h.Url, h.CreatedAt)));

34 });

36 group.MapDelete("/{id}", (string projectId, string id, WebhookStore store) =>

37 {

38 return store.Delete(projectId, id) ? Results.Ok() : Results.NotFound();

39 });

40 }

41}

1using System.Security.Claims;

2using System.Text.Encodings.Web;

3using Catena.Storage;

4using Microsoft.AspNetCore.Authentication;

5using Microsoft.Extensions.Options;

7namespace Catena.Server.Auth;

9public sealed class ApiKeyAuthHandler : AuthenticationHandler<AuthenticationSchemeOptions>

10{

11 private readonly UserStore _userStore;

12 public const string SchemeName = "ApiKey";

13 public const string HeaderName = "X-Api-Key";

15 public ApiKeyAuthHandler(

16 IOptionsMonitor<AuthenticationSchemeOptions> options,

17 ILoggerFactory logger,

18 UrlEncoder encoder,

19 UserStore userStore) : base(options, logger, encoder)

20 {

21 _userStore = userStore;

22 }

24 protected override async Task<AuthenticateResult> HandleAuthenticateAsync()

25 {

26 if (!Request.Headers.TryGetValue(HeaderName, out var keyValues))

27 return AuthenticateResult.NoResult();

29 var apiKey = keyValues.FirstOrDefault();

30 if (string.IsNullOrWhiteSpace(apiKey))

31 return AuthenticateResult.Fail("Empty API key.");

33 var user = await _userStore.GetByApiKeyAsync(apiKey);

34 if (user is null)

35 return AuthenticateResult.Fail("Invalid API key.");

37 var claims = new[]

38 {

39 new Claim(ClaimTypes.NameIdentifier, user.Id),

40 new Claim(ClaimTypes.Name, user.Name),

41 new Claim(ClaimTypes.Role, user.Role.ToString())

42 };

44 var identity = new ClaimsIdentity(claims, SchemeName);

45 var principal = new ClaimsPrincipal(identity);

46 var ticket = new AuthenticationTicket(principal, SchemeName);

48 return AuthenticateResult.Success(ticket);

49 }

50}

1using System.Security.Claims;

3namespace Catena.Server.Auth;

5public static class AuthExtensions

6{

7 public static string? GetUserId(this HttpContext ctx) =>

8 ctx.User.FindFirstValue(ClaimTypes.NameIdentifier);

10 public static string GetUserName(this HttpContext ctx) =>

11 ctx.User.FindFirstValue(ClaimTypes.Name) ?? "anonymous";

13 public static bool IsInRole(this HttpContext ctx, string role) =>

14 ctx.User.IsInRole(role);

16 public static bool IsMaintainerOrAdmin(this HttpContext ctx) =>

17 ctx.User.IsInRole("Maintainer") || ctx.User.IsInRole("Admin");

19 /// <summary>Returns true if auth is disabled (tests, dev). Skips all auth checks.</summary>

20 public static bool IsAuthDisabled(this HttpContext ctx) =>

21 ctx.RequestServices.GetService<IConfiguration>()?.GetValue("Catena:AuthEnabled", true) == false;

23 /// <summary>Returns true if the request is authenticated OR auth is disabled.</summary>

24 public static bool IsAuthenticated(this HttpContext ctx) =>

25 ctx.IsAuthDisabled() || ctx.GetUserId() is not null;

27 /// <summary>Returns true if the user has Maintainer/Admin role OR auth is disabled.</summary>

28 public static bool CanAccept(this HttpContext ctx) =>

29 ctx.IsAuthDisabled() || ctx.IsMaintainerOrAdmin();

30}

1using Catena.Shared.Models;

2using Catena.Storage;

4namespace Catena.Server.Auth;

6public static class ProjectAccessHelper

7{

8 public static async Task<(Project? Project, IResult? Error)> GetReadableProjectAsync(

9 ProjectStore store, string projectId, HttpContext ctx)

10 {

11 var project = await store.GetAsync(projectId);

12 if (project is null) return (null, Results.NotFound("Project not found."));

14 if (!project.IsPublic && !ctx.IsAuthenticated())

15 return (null, Results.NotFound("Project not found."));

17 return (project, null);

18 }

20 public static async Task<(Project? Project, IResult? Error)> GetWritableProjectAsync(

21 ProjectStore store, string projectId, HttpContext ctx)

22 {

23 var project = await store.GetAsync(projectId);

24 if (project is null) return (null, Results.NotFound("Project not found."));

26 if (!ctx.IsAuthenticated())

27 return (null, Results.Unauthorized());

29 return (project, null);

30 }

31}

1<Project Sdk="Microsoft.NET.Sdk.Web">

2

3 <ItemGroup>

4 <ProjectReference Include="..\Catena.Shared\Catena.Shared.csproj" />

5 <ProjectReference Include="..\Catena.Storage\Catena.Storage.csproj" />

6 </ItemGroup>

7

8 <PropertyGroup>

9 <TargetFramework>net10.0</TargetFramework>

10 <Nullable>enable</Nullable>

11 <ImplicitUsings>enable</ImplicitUsings>

12 </PropertyGroup>

13

14</Project>

1<!DOCTYPE html>

2<html lang="en">

3<head>

4 <meta charset="utf-8" />

5 <meta name="viewport" content="width=device-width, initial-scale=1.0" />

6 <base href="/" />

7 <title>Catena</title>

8 <link rel="icon" type="image/svg+xml" href="favicon.svg" />

9 <HeadOutlet @rendermode="RenderMode.InteractiveServer" />

10 <link rel="stylesheet" href="css/app.css" />

11 <style>

12 #components-reconnect-modal {

13 display:none;position:fixed;inset:0;z-index:9999;

14 background:rgba(9,9,11,.92);backdrop-filter:blur(8px);

15 }

16 #components-reconnect-modal.components-reconnect-show,

17 #components-reconnect-modal.components-reconnect-failed,

18 #components-reconnect-modal.components-reconnect-rejected {

19 display:flex;align-items:center;justify-content:center;

20 }

21 .rc-term {

22 background:#0a0a0c;border:1px solid #27272a;border-radius:8px;

23 padding:16px;width:320px;font-family:'JetBrains Mono',monospace;font-size:12px;

24 }

25 .rc-bar { display:flex;gap:6px;margin-bottom:12px }

26 .rc-dot { width:10px;height:10px;border-radius:50% }

27 .rc-line { color:#52525b;margin-bottom:4px;line-height:1.6 }

28 .rc-line .prompt { color:#22c55e }

29 .rc-line .cmd { color:#a1a1aa }

30 .rc-line .err { color:#ef4444 }

31 .rc-typing {

32 color:#22c55e;overflow:hidden;white-space:nowrap;

33 border-right:2px solid #22c55e;width:0;max-width:280px;

34 animation:rctype 2s steps(28) infinite, rcblink .6s step-end infinite alternate;

35 }

36 @@keyframes rctype { 0%{width:0} 50%,100%{width:220px} }

37 @@keyframes rcblink { 50%{border-color:transparent} }

39 /* Failed state */

40 .rc-connecting { display:block }

41 .rc-failed { display:none }

42 .components-reconnect-failed .rc-connecting,

43 .components-reconnect-rejected .rc-connecting { display:none }

44 .components-reconnect-failed .rc-failed,

45 .components-reconnect-rejected .rc-failed { display:block }

46 .rc-reload {

47 color:#22c55e;cursor:pointer;text-decoration:none;

48 }

49 .rc-reload:hover { text-decoration:underline }

50 </style>

51</head>

52<body>

53 <div id="components-reconnect-modal">

54 <div class="rc-term">

55 <div class="rc-bar">

56 <div class="rc-dot" style="background:#ef4444"></div>

57 <div class="rc-dot" style="background:#f59e0b"></div>

58 <div class="rc-dot" style="background:#22c55e"></div>

59 </div>

60 <div class="rc-line"><span class="prompt">$</span> <span class="cmd">catena status</span></div>

61 <div class="rc-line"><span class="err">connection lost</span></div>

62 <div class="rc-connecting">

63 <div class="rc-line"><span class="prompt">$</span> <span class="cmd">catena reconnect</span></div>

64 <div class="rc-typing">attempting to reach server...</div>

65 </div>

66 <div class="rc-failed">

67 <div class="rc-line"><span class="err">server unreachable.</span></div>

68 <div class="rc-line"><span class="prompt">$</span> <a class="rc-reload" onclick="location.reload()">catena reload</a></div>

69 </div>

70 </div>

71 </div>

72 <Routes @rendermode="RenderMode.InteractiveServer" />

73 <script src="_framework/blazor.web.js"></script>

74 <script src="js/timeline.js"></script>

75</body>

76</html>

1<section id="cli">

2 <h2>CLI Reference</h2>

3 <div class="docs-cli-grid">

4 <div class="docs-cli-cmd"><code>catena init</code><span>Create or connect a workspace</span></div>

5 <div class="docs-cli-cmd"><code>catena status</code><span>Show local changes</span></div>

6 <div class="docs-cli-cmd"><code>catena sync up</code><span>Push changes to server</span></div>

7 <div class="docs-cli-cmd"><code>catena sync down</code><span>Pull trunk state</span></div>

8 <div class="docs-cli-cmd"><code>catena propose</code><span>Submit patch for review</span></div>

9 <div class="docs-cli-cmd"><code>catena accept &lt;id&gt;</code><span>Accept patch into trunk</span></div>

10 <div class="docs-cli-cmd"><code>catena withdraw &lt;id&gt;</code><span>Pull back a proposed patch</span></div>

11 <div class="docs-cli-cmd"><code>catena log</code><span>Show patch history</span></div>

12 <div class="docs-cli-cmd"><code>catena diff &lt;id&gt;</code><span>Show patch details</span></div>

13 <div class="docs-cli-cmd"><code>catena release &lt;v&gt;</code><span>Create release snapshot</span></div>

14 <div class="docs-cli-cmd"><code>catena draft</code><span>Set dependencies / targets</span></div>

15 </div>

16</section>

1<section id="concepts">

2 <h2>Core Concepts</h2>

4 <h3>Patches</h3>

5 <p>A patch is a collection of file operations:</p>

6 <div class="docs-ops">

7 <span class="docs-op docs-op-insert">+ Insert</span>

8 <span class="docs-op docs-op-modify">~ Modify</span>

9 <span class="docs-op docs-op-delete">- Delete</span>

10 <span class="docs-op docs-op-rename">&gt; Rename</span>

11 </div>

12 <p>Every patch has an author, description, timestamp, and a <strong>Maturity</strong> level.</p>

14 <h3>Trunk</h3>

15 <p>The trunk is the current, correct state of the project. No <code>main</code> branch, no <code>develop</code>. Just the trunk. When a patch is accepted, the trunk grows — patch by patch, linearly.</p>

16</section>

1<section id="dependencies">

2 <h3>Dependencies</h3>

3 <p>Patches can depend on each other. A patch can only be accepted once all its dependencies are accepted.</p>

5 <div class="docs-dep-chain">

6 <div class="docs-dep-node" style="border-color:#3b82f6"><span style="color:#3b82f6">Frontend Types</span></div>

7 <div class="docs-dep-line"></div>

8 <div class="docs-dep-node" style="border-color:#3b82f6"><span style="color:#3b82f6">API Auth Refactor</span></div>

9 <div class="docs-dep-line"></div>

10 <div class="docs-dep-multi">

11 <div class="docs-dep-node" style="border-color:#f59e0b"><span style="color:#f59e0b">Payment Retry</span></div>

12 <div class="docs-dep-node" style="border-color:#f59e0b"><span style="color:#f59e0b">Email Notify</span></div>

13 </div>

14 <div class="docs-dep-line" style="background:var(--accent)"></div>

15 <div class="docs-dep-node docs-dep-trunk"><span style="color:var(--accent)">Trunk (accepted)</span></div>

16 </div>

17 <p class="docs-muted" style="text-align:center;margin-top:8px">Accept order: Payment + Email → API Auth → Frontend Types</p>

18</section>

1<section id="design">

2 <h2>Design Decisions</h2>

4 <h3>Trunk, not Branches</h3>

5 <p>Catena has one trunk — the single source of truth. Parallel work happens through proposed patches: they live side by side, not in separate histories. Overlap detection shows immediately when two patches collide.</p>

7 <h3>Online-first</h3>

8 <p>The server is the source of truth. Sync is trivial, overlaps are instantly visible, comments are native. You can still work offline: <code>catena draft</code> creates local drafts.</p>

10 <h3>Linear History</h3>

11 <p>Every patch is atomic — either fully in trunk or not at all. The history is a chain, not a graph. This makes it easier to understand and debug.</p>

12</section>

14<footer class="docs-footer">

15 <span>Catena — Patch-based version control for teams that ship.</span>

16 <a href="/">← Back to Catena</a>

17</footer>

1<section id="flows">

2 <h2>Workflows</h2>

4 <div id="daily">

5 <h3>Daily Workflow</h3>

6 <div class="docs-flow-vertical">

7 <div class="docs-fv-step"><span class="docs-fv-cmd">catena sync down</span><span class="docs-muted">Pull trunk state</span></div>

8 <div class="docs-fv-arrow">↓</div>

9 <div class="docs-fv-step"><span class="docs-fv-action">Edit files</span></div>

10 <div class="docs-fv-arrow">↓</div>

11 <div class="docs-fv-step"><span class="docs-fv-cmd">catena status</span><span class="docs-muted">What changed?</span></div>

12 <div class="docs-fv-arrow">↓</div>

13 <div class="docs-fv-step"><span class="docs-fv-cmd">catena sync up -m "..."</span><span class="docs-muted">Push changes</span></div>

14 <div class="docs-fv-arrow">↓</div>

15 <div class="docs-fv-step"><span class="docs-fv-cmd">catena propose</span><span class="docs-muted">Submit for review</span></div>

16 <div class="docs-fv-arrow">↓</div>

17 <div class="docs-fv-step"><span class="docs-fv-action">Team comments inline</span></div>

18 <div class="docs-fv-arrow">↓</div>

19 <div class="docs-fv-step"><span class="docs-fv-cmd">catena accept &lt;id&gt;</span><span class="docs-muted">Maintainer accepts</span></div>

20 </div>

21 </div>

23 <div id="conflict">

24 <h3>Resolving Conflicts</h3>

25 <div class="docs-term"><div class="docs-term-bar"><span class="docs-dot-r"></span><span class="docs-dot-y"></span><span class="docs-dot-g"></span></div>

26 <div class="docs-term-body">

27 <div class="docs-term-line" style="color:var(--text3)"># Alice and Bob modify the same file</div>

28 <div class="docs-term-line" style="color:#ef4444">OVERLAP detected: Payment Retry × Email Notifications</div>

29 <div class="docs-term-line"></div>

30 <div class="docs-term-line" style="color:var(--text3)"># Bob withdraws, Alice gets accepted</div>

31 <div class="docs-term-line"><span class="docs-prompt">$</span> catena withdraw &lt;bob-id&gt;</div>

32 <div class="docs-term-line"><span class="docs-prompt">$</span> catena accept &lt;alice-id&gt;</div>

33 <div class="docs-term-line"></div>

34 <div class="docs-term-line" style="color:var(--text3)"># Bob syncs, adjusts, re-proposes</div>

35 <div class="docs-term-line"><span class="docs-prompt">$</span> catena sync down</div>

36 <div class="docs-term-line"><span class="docs-prompt">$</span> catena sync up -m "Email v2"</div>

37 <div class="docs-term-line"><span class="docs-prompt">$</span> catena propose</div>

38 </div></div>

39 </div>

41 <div id="dep-flow">

42 <h3>Building on a Patch</h3>

43 <div class="docs-term"><div class="docs-term-bar"><span class="docs-dot-r"></span><span class="docs-dot-y"></span><span class="docs-dot-g"></span></div>

44 <div class="docs-term-body">

45 <div class="docs-term-line" style="color:var(--text3)"># Pull Alice's patch as your base</div>

46 <div class="docs-term-line"><span class="docs-prompt">$</span> catena sync down --patch &lt;alice-id&gt;</div>

47 <div class="docs-term-line"></div>

48 <div class="docs-term-line" style="color:var(--text3)"># Work on top, push with dependency</div>

49 <div class="docs-term-line"><span class="docs-prompt">$</span> catena sync up -m "Auth service"</div>

50 <div class="docs-term-line"><span class="docs-prompt">$</span> catena draft --depends-on &lt;alice-id&gt;</div>

51 <div class="docs-term-line"><span class="docs-prompt">$</span> catena propose</div>

52 <div class="docs-term-line"></div>

53 <div class="docs-term-line" style="color:var(--text3)"># Accept enforces order: Alice → Bob</div>

54 </div></div>

55 </div>

57 <div id="hotfix">

58 <h3>Hotfix on Release + Trunk</h3>

59 <div class="docs-term"><div class="docs-term-bar"><span class="docs-dot-r"></span><span class="docs-dot-y"></span><span class="docs-dot-g"></span></div>

60 <div class="docs-term-body">

61 <div class="docs-term-line"><span class="docs-prompt">$</span> catena release v1.0.0</div>

62 <div class="docs-term-line"></div>

63 <div class="docs-term-line" style="color:var(--text3)"># Hotfix targeting both</div>

64 <div class="docs-term-line"><span class="docs-prompt">$</span> catena sync up -m "Hotfix login"</div>

65 <div class="docs-term-line"><span class="docs-prompt">$</span> catena draft --target trunk --target v1.0.0</div>

66 <div class="docs-term-line"></div>

67 <div class="docs-term-line" style="color:#f97316"># After accept: patch applied to trunk + release</div>

68 </div></div>

69 </div>

70</section>

1<section class="docs-hero">

2 <h1>How it Works</h1>

3 <p class="docs-lead">Everything you need to know to work with Catena.</p>

4</section>

1<section id="maturity">

2 <h3>Maturity — The Lifecycle of a Patch</h3>

4 <div class="docs-flow">

5 <div class="docs-flow-node docs-flow-draft">DraftLocal</div>

6 <div class="docs-flow-arrow">→</div>

7 <div class="docs-flow-node docs-flow-synced">DraftSynced</div>

8 <div class="docs-flow-arrow">→</div>

9 <div class="docs-flow-node docs-flow-shared">DraftShared</div>

10 <div class="docs-flow-arrow">→</div>

11 <div class="docs-flow-node docs-flow-proposed">Proposed</div>

12 <div class="docs-flow-arrow">→</div>

13 <div class="docs-flow-node docs-flow-accepted">Accepted</div>

14 </div>

15 <div class="docs-flow-withdraw">

16 <svg width="340" height="36" viewBox="0 0 340 36" style="display:block;margin:0 auto">

17 <path d="M 255 4 C 255 28, 80 28, 80 4" stroke="#3b82f6" stroke-width="1.5" fill="none" stroke-dasharray="4,3"/>

18 <text x="168" y="30" text-anchor="middle" font-size="10" fill="#3b82f6" font-family="'JetBrains Mono',monospace">← withdraw</text>

19 </svg>

20 </div>

22 <div class="docs-stages">

23 <div class="docs-stage"><span class="docs-badge docs-badge-draft">DraftLocal</span> Created locally, not yet synced</div>

24 <div class="docs-stage"><span class="docs-badge docs-badge-synced">DraftSynced</span> Saved on server, only visible to you</div>

25 <div class="docs-stage"><span class="docs-badge docs-badge-shared">DraftShared</span> Shared with team, others can build dependencies on it</div>

26 <div class="docs-stage"><span class="docs-badge docs-badge-proposed">Proposed</span> Submitted for review — candidate for the trunk</div>

27 <div class="docs-stage"><span class="docs-badge docs-badge-accepted">Accepted</span> Merged into trunk — now part of the truth</div>

28 </div>

30 <div class="docs-callout">

31 <strong>Withdraw:</strong> A proposed patch can be pulled back to DraftSynced with <code>catena withdraw</code> to continue working on it.

32 </div>

33</section>

1<section id="overlaps">

2 <h3>Overlaps (Conflicts)</h3>

3 <p>When two proposed patches modify the same file, Catena detects it <strong>immediately</strong>:</p>

5 <div class="docs-overlap-diagram">

6 <div class="docs-overlap-patch" style="border-color:#f59e0b">

7 <span class="docs-overlap-dot" style="background:#451a03;border-color:#f59e0b"></span>

8 <span>Payment Retry</span>

9 </div>

10 <div class="docs-overlap-line">

11 <div class="docs-overlap-hline"></div>

12 <div class="docs-overlap-badge">overlap</div>

13 </div>

14 <div class="docs-overlap-patch" style="border-color:#f59e0b">

15 <span class="docs-overlap-dot" style="background:#451a03;border-color:#f59e0b"></span>

16 <span>Email Notifications</span>

17 </div>

18 </div>

20 <div class="docs-overlap-results">

21 <div class="docs-overlap-result"><span style="color:var(--accent)">●</span> <strong>Auto-Apply</strong> — Different files, no problem</div>

22 <div class="docs-overlap-result"><span style="color:var(--text3)">●</span> <strong>Deduplicated</strong> — Same change, merged automatically</div>

23 <div class="docs-overlap-result"><span style="color:#ef4444">●</span> <strong>Conflict</strong> — Same file, different change → must be resolved</div>

24 </div>

26 <p>Overlaps are highlighted in red on the Timeline and in the Patches view.</p>

27</section>

1<section id="roles">

2 <h2>Roles</h2>

3 <div class="docs-roles">

4 <div class="docs-role">

5 <span class="docs-badge docs-badge-accepted">Developer</span>

6 <span>Create patches, propose, withdraw, view status</span>

7 </div>

8 <div class="docs-role">

9 <span class="docs-badge docs-badge-proposed">Maintainer</span>

10 <span>+ Accept patches, create releases</span>

11 </div>

12 <div class="docs-role">

13 <span class="docs-badge" style="background:#450a0a;color:#ef4444">Admin</span>

14 <span>+ Manage users, assign roles</span>

15 </div>

16 </div>

17</section>

1<section id="start">

2 <h2>Getting Started</h2>

4 <div class="docs-steps">

5 <div class="docs-step">

6 <div class="docs-step-num">1</div>

7 <div class="docs-step-content">

8 <h4>Start the server</h4>

9 <div class="docs-term"><div class="docs-term-bar"><span class="docs-dot-r"></span><span class="docs-dot-y"></span><span class="docs-dot-g"></span></div>

10 <div class="docs-term-body"><div class="docs-term-line"><span class="docs-prompt">$</span> dotnet run --project src/Catena.Server</div>

11 <div class="docs-term-line" style="color:var(--accent)">Admin API Key: xxxxxxxx</div></div></div>

12 <p class="docs-muted">On first run an admin key is displayed. Save it!</p>

13 </div>

14 </div>

16 <div class="docs-step">

17 <div class="docs-step-num">2</div>

18 <div class="docs-step-content">

19 <h4>Create a project</h4>

20 <div class="docs-term"><div class="docs-term-bar"><span class="docs-dot-r"></span><span class="docs-dot-y"></span><span class="docs-dot-g"></span></div>

21 <div class="docs-term-body"><div class="docs-term-line"><span class="docs-prompt">$</span> catena init --new "My Project" --api-key &lt;KEY&gt;</div>

22 <div class="docs-term-line" style="color:var(--text3)">Workspace initialized in .catena/</div></div></div>

23 </div>

24 </div>

26 <div class="docs-step">

27 <div class="docs-step-num">3</div>

28 <div class="docs-step-content">

29 <h4>Make changes &amp; check status</h4>

30 <div class="docs-term"><div class="docs-term-bar"><span class="docs-dot-r"></span><span class="docs-dot-y"></span><span class="docs-dot-g"></span></div>

31 <div class="docs-term-body">

32 <div class="docs-term-line"><span class="docs-prompt">$</span> echo "Hello" > hello.txt</div>

33 <div class="docs-term-line"><span class="docs-prompt">$</span> catena status</div>

34 <div class="docs-term-line" style="color:var(--accent)"> + hello.txt</div>

35 <div class="docs-term-line" style="color:var(--text3)">1 added, 0 modified, 0 deleted</div>

36 </div></div>

37 </div>

38 </div>

40 <div class="docs-step">

41 <div class="docs-step-num">4</div>

42 <div class="docs-step-content">

43 <h4>Push changes</h4>

44 <div class="docs-term"><div class="docs-term-bar"><span class="docs-dot-r"></span><span class="docs-dot-y"></span><span class="docs-dot-g"></span></div>

45 <div class="docs-term-body"><div class="docs-term-line"><span class="docs-prompt">$</span> catena sync up -m "Add hello"</div>

46 <div class="docs-term-line" style="color:var(--text3)">Synced up: patch abc123 created (1 ops)</div></div></div>

47 </div>

48 </div>

50 <div class="docs-step">

51 <div class="docs-step-num">5</div>

52 <div class="docs-step-content">

53 <h4>Propose &amp; Accept</h4>

54 <div class="docs-term"><div class="docs-term-bar"><span class="docs-dot-r"></span><span class="docs-dot-y"></span><span class="docs-dot-g"></span></div>

55 <div class="docs-term-body">

56 <div class="docs-term-line"><span class="docs-prompt">$</span> catena propose</div>

57 <div class="docs-term-line" style="color:#f59e0b">Patch abc123 proposed.</div>

58 <div class="docs-term-line"><span class="docs-prompt">$</span> catena accept abc123</div>

59 <div class="docs-term-line" style="color:var(--accent)">Patch abc123 accepted. Trunk updated.</div>

60 </div></div>

61 </div>

62 </div>

63 </div>

64</section>

1<section id="sync">

2 <h3>Sync</h3>

4 <div class="docs-sync-diagram">

5 <div class="docs-sync-box">

6 <div class="docs-sync-label">Your Workspace</div>

7 <div class="docs-sync-icon">💻</div>

8 </div>

9 <div class="docs-sync-arrows">

10 <div class="docs-sync-arrow-up">sync up ↑</div>

11 <div class="docs-sync-arrow-down">↓ sync down</div>

12 </div>

13 <div class="docs-sync-box">

14 <div class="docs-sync-label">Server (Trunk)</div>

15 <div class="docs-sync-icon">☁️</div>

16 </div>

17 </div>

19 <div class="docs-term">

20 <div class="docs-term-bar"><span class="docs-dot-r"></span><span class="docs-dot-y"></span><span class="docs-dot-g"></span></div>

21 <div class="docs-term-body">

22 <div class="docs-term-line"><span class="docs-prompt">$</span> catena sync down <span class="docs-comment"># Server → Local (Pull)</span></div>

23 <div class="docs-term-line"><span class="docs-prompt">$</span> catena sync up -m "My fix" <span class="docs-comment"># Local → Server (Push)</span></div>

24 <div class="docs-term-line"><span class="docs-prompt">$</span> catena sync down --patch abc123 <span class="docs-comment"># Trunk + test a patch</span></div>

25 </div>

26 </div>

28 <div class="docs-callout">

29 <strong>Safety:</strong> <code>catena sync</code> without <code>down</code> asks for confirmation if you have local changes. With explicit <code>catena sync down</code> it doesn't ask — you know what you're doing.

30 </div>

31</section>

1<section id="webui">

2 <h2>Web UI</h2>

3 <p>Available at <code>/app</code> after login.</p>

4 <div class="docs-ui-grid">

5 <div class="docs-ui-card">

6 <div class="docs-ui-card-icon">■</div>

7 <h4>Dashboard</h4>

8 <p>Overview: stats, activity feed, overlap count</p>

9 </div>

10 <div class="docs-ui-card">

11 <div class="docs-ui-card-icon">▶</div>

12 <h4>Patches</h4>

13 <p>Master-detail with diff, inline comments, overlaps</p>

14 </div>

15 <div class="docs-ui-card">

16 <div class="docs-ui-card-icon">⋮</div>

17 <h4>Timeline</h4>

18 <p>Patch chain graph with dependencies and overlaps</p>

19 </div>

20 <div class="docs-ui-card">

21 <div class="docs-ui-card-icon">☰</div>

22 <h4>Files</h4>

23 <p>Trunk file tree with code viewer</p>

24 </div>

25 <div class="docs-ui-card">

26 <div class="docs-ui-card-icon">●</div>

27 <h4>Releases</h4>

28 <p>Frozen snapshots with version tags</p>

29 </div>

30 <div class="docs-ui-card">

31 <div class="docs-ui-card-icon">⚙</div>

32 <h4>Settings</h4>

33 <p>Team, roles, API keys, webhooks</p>

34 </div>

35 </div>

36 <p>The UI updates <strong>live</strong> — when someone creates or accepts a patch via CLI or API, you see it instantly in the browser.</p>

37</section>

1<section id="what">

2 <h2>What is Catena?</h2>

3 <p>Catena is a patch-based version control system. Every change is a <strong>Patch</strong> — an atomic package of file operations. Patches are chained together in a linear sequence.</p>

5 <div class="docs-features">

6 <div class="docs-feature">

7 <div class="docs-feature-icon" style="color:var(--accent)">+</div>

8 <div><strong>Patches, not Commits</strong><br/><span class="docs-muted">Every change is a self-contained, reviewable package</span></div>

9 </div>

10 <div class="docs-feature">

11 <div class="docs-feature-icon" style="color:var(--accent)">│</div>

12 <div><strong>Trunk, not Branches</strong><br/><span class="docs-muted">One single truth, no diverging histories</span></div>

13 </div>

14 <div class="docs-feature">

15 <div class="docs-feature-icon" style="color:#ef4444">!</div>

16 <div><strong>Overlap Detection</strong><br/><span class="docs-muted">Conflicts are detected immediately, not at integration time</span></div>

17 </div>

18 <div class="docs-feature">

19 <div class="docs-feature-icon" style="color:#3b82f6">↕</div>

20 <div><strong>Online-first</strong><br/><span class="docs-muted">The server is the source of truth, sync is trivial</span></div>

21 </div>

22 <div class="docs-feature">

23 <div class="docs-feature-icon" style="color:#f59e0b">💬</div>

24 <div><strong>Inline Comments</strong><br/><span class="docs-muted">Comment directly on code lines in a patch</span></div>

25 </div>

26 </div>

27</section>

1@inherits LayoutComponentBase

3@Body

1@inherits LayoutComponentBase

2@using Microsoft.AspNetCore.Components.Authorization

3@using System.Security.Claims

4@inject ProjectStore ProjectStore

5@inject PatchStore PatchStore

6@inject NavigationManager Nav

7@inject AuthenticationStateProvider AuthState

9<div class="app-shell">

10 <div class="sidebar">

11 <a href="/" class="sidebar-brand">CATENA<span>.</span></a>

13 @if (_projects is not null && _projects.Count > 0)

14 {

15 <a href="/app" class="project-select">@(_activeProject?.Name ?? "Select project")</a>

16 }

18 @if (_activeProjectId is not null)

19 {

20 <div class="nav">

21 <a href="/app/projects/@_activeProjectId" class="nav-item @IsActive("dashboard")">

22 <span class="nav-icon">&#9632;</span> Dashboard

23 </a>

24 <a href="/app/projects/@_activeProjectId/patches" class="nav-item @IsActive("patches")">

25 <span class="nav-icon">&#9654;</span> Patches

26 @if (_overlapCount > 0)

27 {

28 <span class="nav-badge">@_overlapCount</span>

29 }

30 </a>

31 <a href="/app/projects/@_activeProjectId/timeline" class="nav-item @IsActive("timeline")">

32 <span class="nav-icon">&#8942;</span> Timeline

33 </a>

34 <a href="/app/projects/@_activeProjectId/files" class="nav-item @IsActive("files")">

35 <span class="nav-icon">&#9783;</span> Files

36 </a>

37 <a href="/app/projects/@_activeProjectId/releases" class="nav-item @IsActive("releases")">

38 <span class="nav-icon">&#9679;</span> Releases

39 </a>

40 <a href="/app/projects/@_activeProjectId/settings" class="nav-item @IsActive("settings")">

41 <span class="nav-icon">&#9881;</span> Settings

42 </a>

43 </div>

44 }

46 @if (_userName is not null)

47 {

48 <div class="sidebar-footer">

49 <div class="user-dot">@_userInitials</div>

50 <div style="flex:1">

51 <div style="font-size:12px;color:var(--text2)">@_userName</div>

52 <div style="font-size:10px;color:var(--text3)">@_userRole</div>

53 </div>

54 <a href="/auth/logout" style="font-size:10px;color:var(--text3);text-decoration:none;opacity:.6;padding:4px" title="Logout">&#x2715;</a>

55 </div>

56 }

57 else

58 {

59 <div class="sidebar-footer">

60 <a href="/login" style="color:var(--text2);text-decoration:none;font-size:12px">Sign in</a>

61 </div>

62 }

63 </div>

65 <div class="main-content">

66 @Body

67 </div>

68</div>

70@code {

71 private List<Catena.Shared.Models.Project>? _projects;

72 private Catena.Shared.Models.Project? _activeProject;

73 private string? _activeProjectId;

74 private string? _userName;

75 private string? _userInitials;

76 private string? _userRole;

77 private int _overlapCount;

79 protected override async Task OnInitializedAsync()

80 {

81 _projects = await ProjectStore.ListAsync();

83 var uri = Nav.ToAbsoluteUri(Nav.Uri);

84 var path = uri.AbsolutePath;

85 if (path.StartsWith("/app/projects/") && path.Length > 15)

86 {

87 var rest = path["/app/projects/".Length..];

88 _activeProjectId = rest.Contains('/') ? rest[..rest.IndexOf('/')] : rest;

89 _activeProject = await ProjectStore.GetAsync(_activeProjectId);

90 }

91 else if (_projects.Count > 0)

92 {

93 _activeProject = _projects[0];

94 _activeProjectId = _activeProject.Id;

95 }

97 if (_activeProjectId is not null)

98 {

99 var proposed = await PatchStore.ListAsync(_activeProjectId, maturityFilter: Catena.Shared.Models.Maturity.Proposed);

100 var overlaps = 0;

101 for (int i = 0; i < proposed.Count; i++)

102 for (int j = i + 1; j < proposed.Count; j++)

103 {

104 var report = Catena.Shared.Overlap.OverlapDetector.Detect(proposed[i], proposed[j]);

105 if (report.HasConflicts) overlaps++;

106 }

107 _overlapCount = overlaps;

108 }

110 var authState = await AuthState.GetAuthenticationStateAsync();

111 if (authState.User.Identity?.IsAuthenticated == true)

112 {

113 _userName = authState.User.FindFirstValue(ClaimTypes.Name);

114 _userRole = authState.User.FindFirstValue(ClaimTypes.Role);

115 _userInitials = _userName?.Length >= 2

116 ? _userName[..1].ToUpper() + _userName[1..2].ToUpper()

117 : _userName?.ToUpper();

118 }

119 }

121 private string IsActive(string page)

122 {

123 var path = Nav.ToAbsoluteUri(Nav.Uri).AbsolutePath;

124 if (page == "dashboard" && path == $"/app/projects/{_activeProjectId}") return "active";

125 return path.Contains($"/{page}") ? "active" : "";

126 }

127}

1<ul class="nav-menu">

2 <li><NavLink href="/app" Match="NavLinkMatch.All">Projects</NavLink></li>

3</ul>

5<AuthorizeView Roles="Admin">

6 <Authorized>

7 <hr />

8 <ul class="nav-menu">

9 <li><NavLink href="/app/admin/users">Users</NavLink></li>

10 </ul>

11 </Authorized>

12</AuthorizeView>

14<hr />

15<ul class="nav-menu">

16 <li><a href="/docs" class="nav-item" style="font-size:11px;color:var(--text3)">How it Works</a></li>

17</ul>

1@page "/app"

2@layout Catena.Server.Components.Layout.MainLayout

3@inject ProjectStore ProjectStore

4@inject NavigationManager Nav

6@if (!_empty)

7{

8 <div class="topbar">

9 <span class="topbar-title">Loading...</span>

10 </div>

11}

12else

13{

14 <div class="topbar">

15 <span class="topbar-title">Welcome</span>

16 </div>

17 <div class="dashboard-content">

18 <div style="text-align:center;padding:80px 24px">

19 <div style="font-size:24px;font-weight:500;margin-bottom:12px">No projects yet</div>

20 <div style="font-size:13px;color:var(--text3);margin-bottom:24px">Create your first project via the CLI:</div>

21 <div style="font-family:var(--mono);font-size:12px;color:var(--accent);background:var(--surface);border:1px solid var(--border);border-radius:8px;padding:14px;display:inline-block">

22 catena init --new "My Project" --api-key &lt;key&gt;

23 </div>

24 </div>

25 </div>

26}

28@code {

29 private bool _empty;

31 protected override async Task OnInitializedAsync()

32 {

33 var projects = await ProjectStore.ListAsync();

34 if (projects.Count > 0)

35 Nav.NavigateTo($"/app/projects/{projects[0].Id}", replace: true);

36 else

37 _empty = true;

38 }

39}

1@page "/docs"

2@page "/how-it-works"

3@layout Catena.Server.Components.Layout.EmptyLayout

4@using Catena.Server.Components.Docs

6<div class="docs">

7 <nav class="docs-toc">

8 <div class="docs-toc-brand"><a href="/">CATENA<span>.</span></a></div>

9 <a href="#what" class="docs-toc-item">What is Catena?</a>

10 <a href="#concepts" class="docs-toc-item">Core Concepts</a>

11 <a href="#maturity" class="docs-toc-item docs-toc-sub">Maturity Flow</a>

12 <a href="#overlaps" class="docs-toc-item docs-toc-sub">Overlaps</a>

13 <a href="#dependencies" class="docs-toc-item docs-toc-sub">Dependencies</a>

14 <a href="#sync" class="docs-toc-item docs-toc-sub">Sync</a>

15 <a href="#roles" class="docs-toc-item">Roles</a>

16 <a href="#start" class="docs-toc-item">Getting Started</a>

17 <a href="#flows" class="docs-toc-item">Workflows</a>

18 <a href="#daily" class="docs-toc-item docs-toc-sub">Daily Workflow</a>

19 <a href="#conflict" class="docs-toc-item docs-toc-sub">Resolving Conflicts</a>

20 <a href="#dep-flow" class="docs-toc-item docs-toc-sub">Building on Patches</a>

21 <a href="#hotfix" class="docs-toc-item docs-toc-sub">Hotfix</a>

22 <a href="#cli" class="docs-toc-item">CLI Reference</a>

23 <a href="#webui" class="docs-toc-item">Web UI</a>

24 <a href="#design" class="docs-toc-item">Design Decisions</a>

25 </nav>

27 <main class="docs-content">

28 <DocsHero />

29 <DocsWhat />

30 <DocsConcepts />

31 <DocsMaturity />

32 <DocsOverlaps />

33 <DocsDependencies />

34 <DocsSync />

35 <DocsRoles />

36 <DocsStart />

37 <DocsFlows />

38 <DocsCli />

39 <DocsWebUi />

40 <DocsDesign />

41 </main>

42</div>

44<style>

45.docs{display:flex;min-height:100vh;background:var(--bg)}

46.docs-toc{width:240px;position:sticky;top:0;height:100vh;overflow-y:auto;border-right:1px solid var(--border);padding:20px 0;flex-shrink:0}

47.docs-toc-brand{padding:0 20px 16px;border-bottom:1px solid var(--border);margin-bottom:12px}

48.docs-toc-brand a{font-size:15px;font-weight:600;letter-spacing:1px;color:var(--text);text-decoration:none}

49.docs-toc-brand a span{color:var(--accent)}

50.docs-toc-item{display:block;padding:6px 20px;font-size:13px;color:var(--text2);text-decoration:none;transition:color .1s}

51.docs-toc-item:hover{color:var(--text)}

52.docs-toc-sub{padding-left:32px;font-size:12px;color:var(--text3)}

53.docs-content{flex:1;max-width:800px;margin:0 auto;padding:40px 40px 80px}

54.docs-hero{margin-bottom:48px}

55.docs-hero h1{font-size:28px;font-weight:500;margin-bottom:8px}

56.docs-lead{font-size:15px;color:var(--text2)}

57section{margin-bottom:40px}

58h2{font-size:20px;font-weight:500;margin-bottom:16px;padding-bottom:8px;border-bottom:1px solid var(--border)}

59h3{font-size:16px;font-weight:500;margin:24px 0 12px;color:var(--text2)}

60h4{font-size:14px;font-weight:500;margin-bottom:8px}

61p{font-size:14px;color:var(--text2);line-height:1.7;margin-bottom:12px}

62code{font-family:var(--mono);font-size:12px;color:var(--accent);background:var(--surface2);padding:2px 6px;border-radius:3px}

63.docs-muted{font-size:12px;color:var(--text3)}

64.docs-features{display:flex;flex-direction:column;gap:12px;margin:16px 0}

65.docs-feature{display:flex;align-items:flex-start;gap:12px;padding:12px;background:var(--surface);border:1px solid var(--border);border-radius:8px}

66.docs-feature-icon{width:28px;height:28px;border-radius:6px;background:var(--surface2);display:flex;align-items:center;justify-content:center;font-family:var(--mono);font-size:14px;flex-shrink:0}

67.docs-ops{display:flex;gap:8px;margin:12px 0}

68.docs-op{font-family:var(--mono);font-size:11px;padding:4px 10px;border-radius:4px}

69.docs-op-insert{background:#052e16;color:var(--accent)}

70.docs-op-modify{background:#451a03;color:#f59e0b}

71.docs-op-delete{background:#450a0a;color:#ef4444}

72.docs-op-rename{background:#172554;color:#3b82f6}

73.docs-flow{display:flex;align-items:center;gap:0;margin:20px 0 8px;flex-wrap:wrap;justify-content:center}

74.docs-flow-node{padding:8px 14px;border-radius:6px;font-size:12px;font-family:var(--mono);font-weight:500}

75.docs-flow-draft{background:var(--surface2);color:var(--text3)}

76.docs-flow-synced{background:#172554;color:#3b82f6}

77.docs-flow-shared{background:#172554;color:#3b82f6;border:1px solid #3b82f6}

78.docs-flow-proposed{background:#451a03;color:#f59e0b}

79.docs-flow-accepted{background:#052e16;color:var(--accent)}

80.docs-flow-arrow{color:var(--text3);padding:0 6px;font-size:16px}

81.docs-flow-withdraw{text-align:center;margin:0 0 16px}

82.docs-badge{font-size:10px;font-family:var(--mono);padding:3px 8px;border-radius:4px;font-weight:500;white-space:nowrap}

83.docs-badge-draft{background:var(--surface2);color:var(--text3)}

84.docs-badge-synced{background:#172554;color:#3b82f6}

85.docs-badge-shared{background:#172554;color:#3b82f6}

86.docs-badge-proposed{background:#451a03;color:#f59e0b}

87.docs-badge-accepted{background:#052e16;color:var(--accent)}

88.docs-stages{display:flex;flex-direction:column;gap:8px}

89.docs-stage{font-size:13px;color:var(--text2);display:flex;align-items:center;gap:10px}

90.docs-overlap-diagram{display:flex;align-items:center;justify-content:center;gap:0;margin:20px 0}

91.docs-overlap-patch{display:flex;align-items:center;gap:8px;padding:8px 14px;background:var(--surface);border:1px solid;border-radius:8px;font-size:12px;font-weight:500}

92.docs-overlap-dot{width:10px;height:10px;border-radius:50%;border:2px solid;flex-shrink:0}

93.docs-overlap-line{display:flex;flex-direction:column;align-items:center;gap:0;padding:0 4px}

94.docs-overlap-hline{width:40px;height:2px;background:#ef4444}

95.docs-overlap-badge{font-size:9px;font-family:var(--mono);padding:2px 8px;border-radius:8px;background:#450a0a;color:#ef4444;border:1px solid #991b1b;margin-top:4px}

96.docs-overlap-results{display:flex;flex-direction:column;gap:6px;margin-top:12px}

97.docs-overlap-result{font-size:13px;color:var(--text2);display:flex;gap:8px;align-items:center}

98.docs-dep-chain{display:flex;flex-direction:column;align-items:center;gap:0;margin:20px 0}

99.docs-dep-node{padding:8px 16px;border:1px solid;border-radius:8px;font-size:12px;font-weight:500;background:var(--surface)}

100.docs-dep-trunk{background:#052e16;border-color:#166534}

101.docs-dep-line{width:2px;height:16px;background:#3b82f6;opacity:.5}

102.docs-dep-multi{display:flex;gap:12px}

103.docs-sync-diagram{display:flex;align-items:center;justify-content:center;gap:24px;margin:20px 0}

104.docs-sync-box{text-align:center;padding:16px 24px;background:var(--surface);border:1px solid var(--border);border-radius:8px}

105.docs-sync-label{font-size:11px;color:var(--text3);margin-bottom:4px}

106.docs-sync-icon{font-size:24px}

107.docs-sync-arrows{display:flex;flex-direction:column;gap:4px;font-family:var(--mono);font-size:11px}

108.docs-sync-arrow-up{color:var(--accent)}

109.docs-sync-arrow-down{color:#3b82f6}

110.docs-term{background:#0a0a0c;border:1px solid var(--border);border-radius:8px;overflow:hidden;margin:12px 0}

111.docs-term-bar{display:flex;gap:6px;padding:8px 12px;border-bottom:1px solid var(--border)}

112.docs-dot-r{width:10px;height:10px;border-radius:50%;background:#ef4444}

113.docs-dot-y{width:10px;height:10px;border-radius:50%;background:#f59e0b}

114.docs-dot-g{width:10px;height:10px;border-radius:50%;background:var(--accent)}

115.docs-term-body{padding:12px 14px;font-family:var(--mono);font-size:12px;line-height:1.8}

116.docs-term-line{color:var(--text2)}

117.docs-prompt{color:var(--accent);margin-right:6px}

118.docs-comment{color:var(--text3)}

119.docs-callout{background:var(--surface);border:1px solid var(--border);border-left:3px solid var(--accent);border-radius:4px;padding:12px 16px;font-size:13px;color:var(--text2);margin:12px 0}

120.docs-roles{display:flex;flex-direction:column;gap:8px}

121.docs-role{display:flex;align-items:center;gap:12px;font-size:13px;color:var(--text2)}

122.docs-steps{display:flex;flex-direction:column;gap:24px}

123.docs-step{display:flex;gap:16px}

124.docs-step-num{width:32px;height:32px;border-radius:50%;background:var(--accent-dim);border:1.5px solid #166534;display:flex;align-items:center;justify-content:center;font-size:14px;font-weight:600;color:var(--accent);flex-shrink:0}

125.docs-step-content{flex:1}

126.docs-flow-vertical{display:flex;flex-direction:column;align-items:center;gap:0;margin:16px 0}

127.docs-fv-step{display:flex;align-items:center;gap:12px;padding:8px 16px;background:var(--surface);border:1px solid var(--border);border-radius:6px;font-size:13px}

128.docs-fv-cmd{font-family:var(--mono);color:var(--accent);font-size:12px}

129.docs-fv-action{color:var(--text2);font-style:italic}

130.docs-fv-arrow{color:var(--text3);font-size:14px;padding:2px 0}

131.docs-cli-grid{display:grid;grid-template-columns:repeat(2,1fr);gap:8px;margin:12px 0}

132.docs-cli-cmd{display:flex;flex-direction:column;gap:2px;padding:10px 14px;background:var(--surface);border:1px solid var(--border);border-radius:6px}

133.docs-cli-cmd code{background:transparent;padding:0;font-size:12px}

134.docs-cli-cmd span{font-size:11px;color:var(--text3)}

135.docs-ui-grid{display:grid;grid-template-columns:repeat(3,1fr);gap:12px;margin:16px 0}

136.docs-ui-card{padding:16px;background:var(--surface);border:1px solid var(--border);border-radius:8px}

137.docs-ui-card-icon{font-size:16px;margin-bottom:8px;opacity:.5}

138.docs-ui-card h4{font-size:13px;margin-bottom:4px}

139.docs-ui-card p{font-size:11px;color:var(--text3);margin:0}

140.docs-footer{margin-top:60px;padding-top:20px;border-top:1px solid var(--border);display:flex;justify-content:space-between;font-size:12px;color:var(--text3)}

141.docs-footer a{color:var(--accent);text-decoration:none}

142</style>

1@page "/app/projects/{ProjectId}/files"

2@layout Catena.Server.Components.Layout.MainLayout

3@inject TrunkState TrunkState

4@inject PatchStore PatchStore

6<div class="topbar">

7 <span class="topbar-title">Files</span>

8 <span class="topbar-sub">trunk-head · @_fileCount files</span>

9</div>

11<div class="files-layout">

12 <div class="file-tree">

13 @foreach (var path in _filePaths)

14 {

15 var depth = path.Count(c => c == '/');

16 var name = path.Contains('/') ? path[(path.LastIndexOf('/') + 1)..] : path;

17 var dir = path.Contains('/') ? path[..path.LastIndexOf('/')] : "";

19 @if (dir != _lastDir && dir != "")

20 {

21 <div class="file-item folder" style="padding-left:20px">@dir/</div>

22 _lastDir = dir;

23 }

25 <div class="file-item @(_selectedFile == path ? "selected" : "")"

26 style="padding-left:@(20 + depth * 20)px"

27 @onclick="() => SelectFile(path)">

28 @name

29 </div>

30 }

31 </div>

33 <div class="file-viewer">

34 @if (_selectedFile is not null)

35 {

36 <div class="file-viewer-header">@_selectedFile</div>

37 <div class="file-viewer-meta">

38 @if (_lastPatchAuthor is not null)

39 {

40 <span>Last changed by: <span style="color:var(--proposed)">@_lastPatchDesc</span> (@_lastPatchAuthor)</span>

41 }

42 </div>

43 <div class="file-code">@((MarkupString)_fileContent)</div>

44 }

45 else

46 {

47 <div style="color:var(--text3);font-size:14px;padding:20px">Select a file to view contents</div>

48 }

49 </div>

50</div>

52@code {

53 [Parameter] public string ProjectId { get; set; } = "";

55 private int _fileCount;

56 private List<string> _filePaths = [];

57 private string? _selectedFile;

58 private string _fileContent = "";

59 private string? _lastPatchAuthor;

60 private string? _lastPatchDesc;

61 private string _lastDir = "";

63 protected override async Task OnInitializedAsync()

64 {

65 var files = await TrunkState.GetFilesAsync(ProjectId);

66 _fileCount = files.Count;

67 _filePaths = files.Keys.OrderBy(f => f).ToList();

68 }

70 private async Task SelectFile(string path)

71 {

72 _selectedFile = path;

73 _fileContent = "";

74 _lastPatchAuthor = null;

75 _lastPatchDesc = null;

77 var blobIndex = await TrunkState.GetBlobIndexAsync(ProjectId);

78 if (blobIndex.TryGetValue(path, out var blobRef))

79 {

80 var blob = await PatchStore.GetBlobAsync(ProjectId, blobRef.PatchId, blobRef.OpIndex);

81 if (blob is not null)

82 {

83 try

84 {

85 var text = System.Text.Encoding.UTF8.GetString(blob);

86 var lines = text.Split('\n');

87 var sb = new System.Text.StringBuilder();

88 for (int i = 0; i < lines.Length; i++)

89 {

90 sb.Append($"<span class=\"ln\">{i + 1,3}</span>");

91 sb.AppendLine(System.Net.WebUtility.HtmlEncode(lines[i]));

92 }

93 _fileContent = sb.ToString();

94 }

95 catch { _fileContent = $"(binary file, {blob.Length} bytes)"; }

96 }

98 var patch = await PatchStore.GetAsync(ProjectId, blobRef.PatchId);

99 if (patch is not null)

100 {

101 _lastPatchAuthor = patch.Author;

102 _lastPatchDesc = patch.Description;

103 }

104 }

105 }

106}

1@page "/app/projects/{ProjectId}/history"

2@layout Catena.Server.Components.Layout.MainLayout

3@inject PatchStore PatchStore

5<h1>History</h1>

7<div class="filters">

8 <input type="text" @bind="_fileFilter" placeholder="Filter by file..." />

9 <input type="text" @bind="_authorFilter" placeholder="Filter by author..." />

10 <button class="btn" @onclick="LoadHistory">Filter</button>

11</div>

13@if (_patches is null)

14{

15 <p>Loading...</p>

16}

17else if (_patches.Count == 0)

18{

19 <p>No patches in history.</p>

20}

21else

22{

23 <table class="data-table">

24 <thead>

25 <tr><th>ID</th><th>Author</th><th>Description</th><th>Ops</th><th>Time</th></tr>

26 </thead>

27 <tbody>

28 @foreach (var p in _patches)

29 {

30 <tr>

31 <td><a href="/app/projects/@ProjectId/patches/@p.Id"><code>@p.Id[..8]</code></a></td>

32 <td>@p.Author</td>

33 <td>@p.Description</td>

34 <td>@p.Ops.Count</td>

35 <td>@p.Timestamp.ToString("yyyy-MM-dd HH:mm")</td>

36 </tr>

37 }

38 </tbody>

39 </table>

40}

42@code {

43 [Parameter] public string ProjectId { get; set; } = "";

45 private List<Patch>? _patches;

46 private string _fileFilter = "";

47 private string _authorFilter = "";

49 protected override async Task OnInitializedAsync()

50 {

51 await LoadHistory();

52 }

54 private async Task LoadHistory()

55 {

56 var all = await PatchStore.ListAsync(ProjectId, maturityFilter: Maturity.Accepted,

57 authorFilter: string.IsNullOrWhiteSpace(_authorFilter) ? null : _authorFilter);

59 if (!string.IsNullOrWhiteSpace(_fileFilter))

60 {

61 all = all.Where(p => p.Ops.Any(op => op.File.Contains(_fileFilter, StringComparison.OrdinalIgnoreCase))).ToList();

62 }

64 _patches = all;

65 }

66}

1@page "/"

2@layout Catena.Server.Components.Layout.EmptyLayout

3@inject ProjectStore ProjectStore

4@using Microsoft.AspNetCore.Components.Authorization

5@inject AuthenticationStateProvider AuthState

7<div class="landing">

8 <header class="landing-hero">

9 <div class="landing-brand">CATENA<span class="dot">.</span></div>

10 <p class="landing-tagline">Patch-based version control for teams that ship.</p>

11 <p class="landing-sub">No branches. No merges. Just patches, applied in order.</p>

12 <div class="landing-actions">

13 @if (_isAuthenticated)

14 {

15 <a href="/app" class="btn-primary">Open Dashboard</a>

16 }

17 else

18 {

19 <a href="/login" class="btn-primary">Sign In</a>

20 }

21 <a href="/docs" class="btn-primary" style="background:transparent;border:1px solid var(--border);color:var(--text2)">How it Works</a>

22 </div>

23 </header>

25 @if (_publicProjects is not null && _publicProjects.Count > 0)

26 {

27 <section class="landing-projects">

28 <h2>Public Projects</h2>

29 <div class="project-grid">

30 @foreach (var p in _publicProjects)

31 {

32 <a href="/app/projects/@p.Id" class="project-card">

33 <div class="project-card-name">@p.Name</div>

34 <div class="project-card-meta">

35 <code>@p.Id</code>

36 <span>@p.CreatedAt.ToString("MMM dd, yyyy")</span>

37 </div>

38 </a>

39 }

40 </div>

41 </section>

42 }

44 <section class="landing-features">

45 <div class="feature">

46 <div class="feature-icon">+</div>

47 <h3>Patch-Chain</h3>

48 <p>Immutable, append-only patches. Every change is a first-class object with author, dependencies, and targets.</p>

49 </div>

50 <div class="feature">

51 <div class="feature-icon">~</div>

52 <h3>Overlap Detection</h3>

53 <p>Deterministic conflict detection before merge. No surprises, no broken builds. Auto-apply when safe, block when not.</p>

54 </div>

55 <div class="feature">

56 <div class="feature-icon">&gt;</div>

57 <h3>Views, not Branches</h3>

58 <p>Trunk is the only truth. Proposed patches are candidates, not parallel universes. Accept what's ready, revert what's not.</p>

59 </div>

60 </section>

62 <footer class="landing-footer">

63 <span>Catena VCS</span>

64 </footer>

65</div>

67@code {

68 private List<Catena.Shared.Models.Project>? _publicProjects;

69 private bool _isAuthenticated;

71 protected override async Task OnInitializedAsync()

72 {

73 var projects = await ProjectStore.ListAsync();

74 _publicProjects = projects.Where(p => p.IsPublic).ToList();

76 var authState = await AuthState.GetAuthenticationStateAsync();

77 _isAuthenticated = authState.User.Identity?.IsAuthenticated == true;

78 }

79}

1@page "/login"

2@layout Catena.Server.Components.Layout.EmptyLayout

4<div class="login-fullscreen">

5 <div class="login-left">

6 <a href="/" class="login-hero-brand">CATENA<span>.</span></a>

7 <div class="login-hero-text">

8 <p>Patch-based version control</p>

9 <p>for teams that ship.</p>

10 </div>

11 <div class="login-hero-features">

12 <div class="login-feature"><span class="login-feature-icon">+</span> Immutable patch chains</div>

13 <div class="login-feature"><span class="login-feature-icon">~</span> Deterministic overlap detection</div>

14 <div class="login-feature"><span class="login-feature-icon">&gt;</span> No branches, no merges</div>

15 </div>

16 </div>

18 <div class="login-right">

19 <div class="login-terminal">

20 <div class="login-term-bar">

21 <div class="login-term-dot" style="background:var(--danger)"></div>

22 <div class="login-term-dot" style="background:var(--proposed)"></div>

23 <div class="login-term-dot" style="background:var(--accent)"></div>

24 <span style="flex:1"></span>

25 <span style="font-size:10px;color:var(--text3);font-family:var(--mono)">authenticate</span>

26 </div>

28 <div class="login-term-body">

29 <div class="login-term-line"><span class="login-prompt">$</span> <span style="color:var(--text2)">catena auth login</span></div>

31 @if (_hasError)

32 {

33 <div class="login-term-line"><span style="color:var(--danger)">error: invalid api key</span></div>

34 <div class="login-term-line"><span class="login-prompt">$</span> <span style="color:var(--text2)">catena auth login --retry</span></div>

35 }

36 else

37 {

38 <div class="login-term-line"><span style="color:var(--accent)">ready.</span> <span style="color:var(--text3)">paste your api key below</span></div>

39 }

41 <form method="post" action="/auth/web-login" class="login-term-form">

42 <div class="login-input-row">

43 <span class="login-prompt">$</span>

44 <input type="password" name="apiKey" placeholder="cat_••••••••••••••••" required autocomplete="off" />

45 </div>

46 <button type="submit">

47 authenticate <span style="opacity:.5;margin-left:8px">↵</span>

48 </button>

49 </form>

50 </div>

51 </div>

53 <div class="login-hint">

54 Don't have a key? Ask your team admin.

55 </div>

56 </div>

57</div>

59<style>

60.login-fullscreen {

61 display:flex;height:100vh;overflow:hidden;

62}

64.login-left {

65 flex:1;display:flex;flex-direction:column;justify-content:center;

66 padding:60px;

67 background:radial-gradient(ellipse at 30% 50%,rgba(34,197,94,.04) 0%,transparent 70%);

68}

70.login-hero-brand {

71 font-size:36px;font-weight:700;letter-spacing:-1.5px;

72 color:var(--text);text-decoration:none;margin-bottom:24px;display:block;

73}

74.login-hero-brand span { color:var(--accent) }

76.login-hero-text {

77 font-size:20px;font-weight:300;color:var(--text2);line-height:1.5;margin-bottom:40px;

78}

80.login-hero-features {

81 display:flex;flex-direction:column;gap:12px;

82}

84.login-feature {

85 font-size:13px;color:var(--text3);display:flex;align-items:center;gap:10px;

86}

88.login-feature-icon {

89 width:28px;height:28px;border-radius:6px;

90 background:var(--accent-dim);border:1px solid #166534;

91 display:flex;align-items:center;justify-content:center;

92 font-family:var(--mono);font-size:14px;color:var(--accent);

93}

95.login-right {

96 width:480px;display:flex;flex-direction:column;justify-content:center;

97 padding:60px;border-left:1px solid var(--border);

98 background:var(--surface);

99}

101.login-terminal {

102 background:#0a0a0c;border:1px solid var(--border);border-radius:10px;overflow:hidden;

103}

105.login-term-bar {

106 display:flex;align-items:center;gap:6px;

107 padding:10px 14px;border-bottom:1px solid var(--border);

108}

110.login-term-dot { width:10px;height:10px;border-radius:50% }

112.login-term-body {

113 padding:16px;font-family:var(--mono);font-size:12px;line-height:1.8;

114}

116.login-term-line { margin-bottom:2px; }

117.login-prompt { color:var(--accent);margin-right:6px }

119.login-term-form {

120 margin-top:12px;display:flex;flex-direction:column;gap:10px;max-width:100%;

121}

123.login-input-row {

124 display:flex;align-items:center;gap:0;

125 background:var(--surface2);border:1px solid var(--border);border-radius:6px;

126 padding:0 12px;

127}

129.login-input-row input {

130 flex:1;background:transparent;border:none;outline:none;

131 color:var(--accent);font-family:var(--mono);font-size:12px;

132 padding:10px 8px;

133}

135.login-input-row input::placeholder { color:var(--text3);opacity:.6 }

137.login-term-form button {

138 background:var(--accent-dim);color:var(--accent);border:1px solid #166534;

139 border-radius:6px;padding:8px 16px;cursor:pointer;

140 font-family:var(--mono);font-size:12px;font-weight:500;

141 transition:background .15s;

142}

144.login-term-form button:hover { background:#0a3d1a }

146.login-hint {

147 margin-top:20px;font-size:11px;color:var(--text3);line-height:1.5;

148}

149</style>

151@code {

152 private bool _hasError;

154 [SupplyParameterFromQuery(Name = "error")]

155 public string? Error { get; set; }

157 protected override void OnInitialized()

158 {

159 _hasError = Error is not null;

160 }

161}

1@page "/app/projects/{ProjectId}/overlaps"

2@layout Catena.Server.Components.Layout.MainLayout

3@using Catena.Shared.Overlap

4@inject PatchStore PatchStore

6<h1>Overlaps</h1>

8@if (_reports is null)

9{

10 <p>Loading...</p>

11}

12else if (_reports.Count == 0)

13{

14 <p>No overlaps between proposed patches.</p>

15}

16else

17{

18 <table class="data-table">

19 <thead>

20 <tr><th>Patch A</th><th>Patch B</th><th>Conflicts</th><th>Auto-Apply</th><th>Deduplicated</th></tr>

21 </thead>

22 <tbody>

23 @foreach (var r in _reports)

24 {

25 <tr class="@(r.HasConflicts ? "row-conflict" : "")">

26 <td><a href="/app/projects/@ProjectId/patches/@r.PatchIdA"><code>@r.PatchIdA[..8]</code></a></td>

27 <td><a href="/app/projects/@ProjectId/patches/@r.PatchIdB"><code>@r.PatchIdB[..8]</code></a></td>

28 <td class="@(r.Conflicts.Any() ? "text-red" : "")">@r.Conflicts.Count()</td>

29 <td>@r.AutoApplies.Count()</td>

30 <td>@r.Deduplications.Count()</td>

31 </tr>

32 }

33 </tbody>

34 </table>

35}

37@code {

38 [Parameter] public string ProjectId { get; set; } = "";

40 private List<PatchOverlapReport>? _reports;

42 protected override async Task OnInitializedAsync()

43 {

44 var proposed = await PatchStore.ListAsync(ProjectId, maturityFilter: Maturity.Proposed);

45 _reports = [];

47 for (int i = 0; i < proposed.Count; i++)

48 {

49 for (int j = i + 1; j < proposed.Count; j++)

50 {

51 var report = OverlapDetector.Detect(proposed[i], proposed[j]);

52 if (report.Results.Count > 0)

53 _reports.Add(report);

54 }

55 }

56 }

57}

1@page "/app/projects/{ProjectId}/patches"

2@layout Catena.Server.Components.Layout.MainLayout

3@implements IDisposable

4@inject PatchStore PatchStore

5@inject ReviewStore ReviewStore

6@inject TrunkState TrunkState

7@using Catena.Shared.Overlap

8@using Microsoft.AspNetCore.Components.Authorization

9@using System.Security.Claims

10@inject AuthenticationStateProvider AuthState

12<div class="topbar">

13 <span class="topbar-title">Patches</span>

14 <span class="topbar-sub">@_patches?.Count active</span>

15</div>

17<div class="patches-layout">

18 <!-- LEFT: Patch list -->

19 <div class="patch-list">

20 <div class="patch-filters">

21 @foreach (var f in _filters)

22 {

23 <button class="filter-pill @(f == _activeFilter ? "active" : "")" @onclick="() => SetFilter(f)">@f</button>

24 }

25 </div>

27 @if (_filteredPatches is not null)

28 {

29 @foreach (var p in _filteredPatches)

30 {

31 <div class="patch-item @(p.Id == _selectedId ? "selected" : "")" @onclick="() => SelectPatch(p.Id)">

32 <div class="patch-header">

33 <span class="patch-name">@p.Description</span>

34 <span class="patch-status @StatusClass(p.Maturity)">@StatusText(p.Maturity)</span>

35 </div>

36 <div class="patch-meta">@p.Author · @p.Ops.Count files · @PatchTime(p)</div>

37 @{var overlaps = GetOverlapsFor(p.Id);}

38 @if (overlaps.Count > 0)

39 {

40 <div class="patch-overlap">@overlaps.Count overlap@(overlaps.Count > 1 ? "s" : "") with @string.Join(", ", overlaps)</div>

41 }

42 </div>

43 }

44 }

45 </div>

47 <!-- RIGHT: Patch detail -->

48 <div class="patch-detail">

49 @if (_selected is not null)

50 {

51 <div class="patch-detail-header">

52 <div style="display:flex;justify-content:space-between;align-items:flex-start">

53 <div>

54 <div class="pd-title">@_selected.Description</div>

55 <div class="pd-meta">@_selected.Author · @StatusText(_selected.Maturity) @FormatTimeAgo(_selected.Timestamp) · base: trunk-head</div>

56 </div>

57 @if (!_isReadonly)

58 {

59 <div style="display:flex;gap:6px">

60 @if (_selected.Maturity == Maturity.Proposed && _isMaintainer)

61 {

62 <button class="btn btn-accent" @onclick="AcceptPatch">Accept</button>

63 }

64 @if (_selected.Maturity == Maturity.Proposed)

65 {

66 <button class="btn" @onclick="WithdrawPatch">Withdraw</button>

67 }

68 @if (_selected.Maturity is Maturity.DraftSynced or Maturity.DraftShared)

69 {

70 <button class="btn btn-accent" @onclick="ProposePatch">Propose</button>

71 }

72 </div>

73 }

74 </div>

75 <div class="pd-tags">

76 @{var selOverlaps = GetOverlapsFor(_selected.Id);}

77 @if (selOverlaps.Count > 0)

78 {

79 <span class="pd-tag" style="background:var(--danger-dim);color:var(--danger)">@selOverlaps.Count overlap: @string.Join(", ", selOverlaps)</span>

80 }

81 <span class="pd-tag" style="background:var(--surface2);color:var(--text3)">@_selected.Ops.Count files changed</span>

82 @{var la = _selected.Ops.Sum(o => o.LinesAdded); var ld = _selected.Ops.Sum(o => o.LinesDeleted);}

83 <span class="pd-tag" style="background:var(--surface2);color:var(--text3)">+@la -@ld lines</span>

84 </div>

85 </div>

87 <!-- TABS -->

88 <div class="patch-tabs">

89 <div class="patch-tab @(_activeTab == "diff" ? "active" : "")" @onclick='() => _activeTab = "diff"'>Diff</div>

90 <div class="patch-tab @(_activeTab == "files" ? "active" : "")" @onclick='() => _activeTab = "files"'>Files (@_selected.Ops.Count)</div>

91 <div class="patch-tab @(_activeTab == "review" ? "active" : "")" @onclick='() => _activeTab = "review"'>Review (@_reviews.Count)</div>

92 <div class="patch-tab @(_activeTab == "overlaps" ? "active" : "")" style="@(selOverlaps.Count > 0 ? "color:var(--danger)" : "")" @onclick='() => _activeTab = "overlaps"'>Overlaps (@selOverlaps.Count)</div>

93 </div>

95 <div class="patch-tab-content">

96 @* ===== DIFF TAB ===== *@

97 @if (_activeTab == "diff")

98 {

99 @foreach (var op in _selected.Ops)

100 {

101 var currentFile = op.File;

102 <div class="diff-file">

103 <div class="diff-file-header">

104 @OpPrefix(op.Type) @op.File

105 @if (op.NewPath is not null) { <span> &rarr; @op.NewPath</span> }

106 </div>

107 <div class="diff-lines">

108 @if (op.Type == OpType.Insert && _blobContents.TryGetValue(op.File, out var content))

109 {

110 var lines = content.Split('\n');

111 @for (int i = 0; i < lines.Length; i++)

112 {

113 var lineNum = i + 1;

114 var cf = currentFile;

115 var ln = lineNum;

116 <div class="diff-line add">

117 @if (_isReadonly) { <span class="ln">@ln</span> } else { <span class="ln ln-clickable" @onclick="() => OpenLineComment(cf, ln)" title="Comment on line @ln">@ln</span> }@lines[i]

118 </div>

119 @foreach (var c in _reviews.Where(r => r.FilePath == cf && r.LineNumber == ln && !string.IsNullOrEmpty(r.Comment)))

120 {

121 <div class="diff-comment">

122 <div class="diff-comment-head">

123 <div class="diff-comment-avatar">@c.ReviewerName[..1].ToUpper()</div>

124 <span class="diff-comment-author">@c.ReviewerName</span>

125 <span class="diff-comment-time">@FormatTimeAgo(c.CreatedAt)</span>

126 </div>

127 <div class="diff-comment-text">@c.Comment</div>

128 </div>

129 }

130 @if (_inlineCommentFile == cf && _inlineCommentLine == ln)

131 {

132 <div class="diff-comment" style="border-color:var(--accent);border-style:dashed">

133 <div style="display:flex;gap:6px">

134 <input type="text" @bind="_inlineCommentText" @onkeydown="InlineCommentKeyDown" placeholder="Comment on line @ln..."

135 style="flex:1;padding:6px 10px;background:var(--bg);border:1px solid var(--border);border-radius:4px;color:var(--text);font-size:12px;font-family:var(--mono)" />

136 <button class="btn btn-accent" style="font-size:11px;padding:4px 10px" @onclick="SubmitInlineComment">Send</button>

137 <button class="btn" style="font-size:11px;padding:4px 10px" @onclick="() => _inlineCommentFile = null">&#x2715;</button>

138 </div>

139 </div>

140 }

141 }

142 }

143 else if (op.Type == OpType.Insert)

144 {

145 <div class="diff-line add"><span class="ln">+</span>new file (@op.EndByte bytes)</div>

146 }

147 else if (op.Type == OpType.Delete)

148 {

149 <div class="diff-line del"><span class="ln">-</span>file deleted</div>

150 }

151 else if (op.Type == OpType.Modify && _blobContents.TryGetValue(op.File, out var mc))

152 {

153 <div class="diff-line del"><span class="ln">-</span>previous content</div>

154 var mlines = mc.Split('\n');

155 @for (int i = 0; i < mlines.Length; i++)

156 {

157 var lineNum = i + 1;

158 var cf2 = currentFile;

159 var ln2 = lineNum;

160 <div class="diff-line add">

161 @if (_isReadonly) { <span class="ln">@ln2</span> } else { <span class="ln ln-clickable" @onclick="() => OpenLineComment(cf2, ln2)" title="Comment on line @ln2">@ln2</span> }@mlines[i]

162 </div>

163 @foreach (var c in _reviews.Where(r => r.FilePath == cf2 && r.LineNumber == ln2 && !string.IsNullOrEmpty(r.Comment)))

164 {

165 <div class="diff-comment">

166 <div class="diff-comment-head">

167 <div class="diff-comment-avatar">@c.ReviewerName[..1].ToUpper()</div>

168 <span class="diff-comment-author">@c.ReviewerName</span>

169 <span class="diff-comment-time">@FormatTimeAgo(c.CreatedAt)</span>

170 </div>

171 <div class="diff-comment-text">@c.Comment</div>

172 </div>

173 }

174 @if (_inlineCommentFile == cf2 && _inlineCommentLine == ln2)

175 {

176 <div class="diff-comment" style="border-color:var(--accent);border-style:dashed">

177 <div style="display:flex;gap:6px">

178 <input type="text" @bind="_inlineCommentText" @onkeydown="InlineCommentKeyDown" placeholder="Comment on line @ln2..."

179 style="flex:1;padding:6px 10px;background:var(--bg);border:1px solid var(--border);border-radius:4px;color:var(--text);font-size:12px;font-family:var(--mono)" />

180 <button class="btn btn-accent" style="font-size:11px;padding:4px 10px" @onclick="SubmitInlineComment">Send</button>

181 <button class="btn" style="font-size:11px;padding:4px 10px" @onclick="() => _inlineCommentFile = null">&#x2715;</button>

182 </div>

183 </div>

184 }

185 }

186 }

187 else if (op.Type == OpType.Modify)

188 {

189 <div class="diff-line del"><span class="ln">-</span>modified (@op.EndByte bytes)</div>

190 }

191 else if (op.Type is OpType.Rename or OpType.Move)

192 {

193 <div class="diff-line ctx"><span class="ln">&gt;</span>@op.File &rarr; @op.NewPath</div>

194 }

195 </div>

197 @* File-level comments (no line number) *@

198 @foreach (var review in _reviews.Where(r => r.FilePath == currentFile && r.LineNumber is null && !string.IsNullOrEmpty(r.Comment)))

199 {

200 <div class="diff-comment">

201 <div class="diff-comment-head">

202 <div class="diff-comment-avatar">@review.ReviewerName[..1].ToUpper()</div>

203 <span class="diff-comment-author">@review.ReviewerName</span>

204 <span class="diff-comment-time">@FormatTimeAgo(review.CreatedAt)</span>

205 </div>

206 <div class="diff-comment-text">@review.Comment</div>

207 </div>

208 }

209 </div>

210 }

211 }

213 @* ===== FILES TAB ===== *@

214 @if (_activeTab == "files")

215 {

216 <table style="width:100%;border-collapse:collapse">

217 <thead>

218 <tr style="font-size:11px;color:var(--text3);text-transform:uppercase;letter-spacing:.5px">

219 <th style="text-align:left;padding:8px 0">Type</th>

220 <th style="text-align:left;padding:8px 0">File</th>

221 <th style="text-align:right;padding:8px 0">Lines</th>

222 <th style="text-align:right;padding:8px 0">Size</th>

223 </tr>

224 </thead>

225 <tbody>

226 @foreach (var op in _selected.Ops)

227 {

228 <tr style="border-bottom:1px solid var(--border);font-size:13px">

229 <td style="padding:8px 0;width:30px">

230 <span style="color:@OpColor(op.Type);font-family:var(--mono);font-weight:500">@OpPrefix(op.Type)</span>

231 </td>

232 <td style="padding:8px 0;font-family:var(--mono);font-size:12px">

233 @op.File

234 @if (op.NewPath is not null) { <span style="color:var(--text3)"> &rarr; @op.NewPath</span> }

235 </td>

236 <td style="padding:8px 0;text-align:right;font-family:var(--mono);font-size:11px">

237 @if (op.LinesAdded > 0) { <span style="color:var(--accent)">+@op.LinesAdded</span> }

238 @if (op.LinesDeleted > 0) { <span style="color:var(--danger)"> -@op.LinesDeleted</span> }

239 </td>

240 <td style="padding:8px 0;text-align:right;font-size:11px;color:var(--text3)">

241 @FormatBytes(op.EndByte - op.StartByte)

242 </td>

243 </tr>

244 }

245 </tbody>

246 </table>

247 }

249 @* ===== REVIEW TAB ===== *@

250 @if (_activeTab == "review")

251 {

252 <div style="font-size:12px;color:var(--text3);margin-bottom:16px">All comments across this patch. Click line numbers in the Diff tab to add inline comments.</div>

254 @if (_reviews.Count > 0)

255 {

256 @foreach (var review in _reviews.Where(r => !string.IsNullOrEmpty(r.Comment)))

257 {

258 <div style="display:flex;gap:10px;padding:12px 0;border-bottom:1px solid var(--border)">

259 <div class="diff-comment-avatar">@review.ReviewerName[..1].ToUpper()</div>

260 <div style="flex:1">

261 <div style="display:flex;align-items:center;gap:8px;margin-bottom:4px">

262 <span style="font-size:13px;font-weight:500">@review.ReviewerName</span>

263 @if (review.FilePath is not null)

264 {

265 <span style="font-size:10px;font-family:var(--mono);color:var(--accent)">@review.FilePath@(review.LineNumber.HasValue ? $":@review.LineNumber" : "")</span>

266 }

267 else

268 {

269 <span style="font-size:10px;font-family:var(--mono);color:var(--text3)">general</span>

270 }

271 <span style="font-size:10px;color:var(--text3);margin-left:auto">@FormatTimeAgo(review.CreatedAt)</span>

272 </div>

273 <div style="font-size:12px;color:var(--text2)">@review.Comment</div>

274 </div>

275 </div>

276 }

277 }

278 else

279 {

280 <div style="color:var(--text3);font-size:13px;padding:20px 0">No comments yet.</div>

281 }

282 }

284 @* ===== OVERLAPS TAB ===== *@

285 @if (_activeTab == "overlaps")

286 {

287 var patchOverlaps = GetOverlapsFor(_selected.Id);

288 if (patchOverlaps.Count > 0)

289 {

290 var proposed = _patches?.Where(p => p.Maturity == Maturity.Proposed && p.Id != _selected.Id).ToList() ?? [];

291 foreach (var other in proposed)

292 {

293 var report = OverlapDetector.Detect(_selected, other);

294 @if (report.HasConflicts)

295 {

296 <div style="background:var(--surface);border:1px solid var(--border);border-radius:8px;padding:14px;margin-bottom:12px">

297 <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:10px">

298 <div>

299 <span style="font-size:13px;font-weight:500">@other.Description</span>

300 <span style="font-size:11px;color:var(--text3);margin-left:8px">by @other.Author</span>

301 </div>

302 <span class="patch-status status-conflict">conflict</span>

303 </div>

304 @foreach (var conflict in report.Conflicts)

305 {

306 <div style="display:flex;align-items:center;gap:8px;padding:6px 0;border-top:1px solid var(--border);font-size:12px">

307 <span style="color:var(--danger);font-family:var(--mono)">!</span>

308 <span style="font-family:var(--mono);color:var(--text2)">@conflict.FileA</span>

309 <span style="color:var(--text3);font-size:11px">@conflict.Reason</span>

310 </div>

311 }

312 </div>

313 }

314 }

315 }

316 else

317 {

318 <div style="color:var(--text3);font-size:13px;padding:20px 0">No overlaps detected.</div>

319 }

320 }

321 </div>

322 }

323 else

324 {

325 <div style="padding:40px;color:var(--text3);font-size:14px">Select a patch to view details</div>

326 }

327 </div>

328</div>

330<ConfirmModal @ref="_confirmModal" />

332@if (_message is not null)

333{

334 <div style="position:fixed;bottom:20px;right:20px;padding:10px 16px;background:var(--surface2);border:1px solid var(--border);border-radius:6px;font-size:12px;color:var(--text2);z-index:100">@_message</div>

335}

337@code {

338 [Parameter] public string ProjectId { get; set; } = "";

340 private readonly string[] _filters = ["All", "Mine", "Team", "Proposed", "Draft"];

341 private string _activeFilter = "All";

342 private string _activeTab = "diff";

343 private List<Patch>? _patches;

344 private List<Patch>? _filteredPatches;

345 private string? _selectedId;

346 private Patch? _selected;

347 private Dictionary<string, string> _blobContents = new();

348 private List<Review> _reviews = [];

349 private Dictionary<string, List<string>> _overlapMap = new();

350 private bool _isAuthenticated, _isMaintainer;

351 private string? _userName;

352 private string? _userId;

353 private string? _message;

354 private bool _isReadonly => !_isAuthenticated || _selected?.Maturity == Maturity.Accepted;

356 private ConfirmModal _confirmModal = default!;

358 // Inline comment state

359 private string? _inlineCommentFile;

360 private int? _inlineCommentLine;

361 private string _inlineCommentText = "";

364 [Inject] CatenaEvents Events { get; set; } = default!;

366 protected override async Task OnInitializedAsync()

367 {

368 Events.PatchChanged += OnChanged;

369 Events.ReviewChanged += OnChanged;

371 var authState = await AuthState.GetAuthenticationStateAsync();

372 _isAuthenticated = authState.User.Identity?.IsAuthenticated == true;

373 _isMaintainer = authState.User.IsInRole("Maintainer") || authState.User.IsInRole("Admin");

374 _userName = authState.User.FindFirstValue(ClaimTypes.Name);

375 _userId = authState.User.FindFirstValue(ClaimTypes.NameIdentifier);

377 await Reload();

378 }

380 private async Task SelectPatch(string id)

381 {

382 _selectedId = id;

383 _selected = _patches?.FirstOrDefault(p => p.Id == id);

384 _blobContents.Clear();

385 _reviews = [];

386 _activeTab = "diff";

388 if (_selected is not null)

389 {

390 _reviews = await ReviewStore.ListForPatchAsync(ProjectId, _selected.Id);

392 for (int i = 0; i < _selected.Ops.Count; i++)

393 {

394 var op = _selected.Ops[i];

395 if (op.Type is OpType.Insert or OpType.Modify)

396 {

397 var blob = await PatchStore.GetBlobAsync(ProjectId, _selected.Id, i);

398 if (blob is not null)

399 {

400 try { _blobContents[op.File] = System.Text.Encoding.UTF8.GetString(blob); }

401 catch { _blobContents[op.File] = $"(binary, {blob.Length} bytes)"; }

402 }

403 }

404 }

405 }

406 }

408 private void SetFilter(string filter)

409 {

410 _activeFilter = filter;

411 var source = filter switch

412 {

413 "Proposed" => _patches?.Where(p => p.Maturity == Maturity.Proposed),

414 "Draft" => _patches?.Where(p => p.Maturity is Maturity.DraftLocal or Maturity.DraftSynced or Maturity.DraftShared),

415 "Mine" => _patches?.Where(p => p.Author == _userName),

416 "Team" => _patches?.Where(p => p.Author != _userName),

417 _ => _patches?.AsEnumerable()

418 };

419 // Sort: proposed first, then drafts, then accepted. Newest first within each group.

420 _filteredPatches = source?

421 .OrderBy(p => p.Maturity switch { Maturity.Proposed => 0, Maturity.DraftShared => 1, Maturity.DraftSynced => 2, Maturity.DraftLocal => 3, _ => 4 })

422 .ThenByDescending(p => p.Maturity == Maturity.Accepted ? p.AcceptedAt ?? p.Timestamp : p.Timestamp)

423 .ToList();

424 }

426 private List<string> GetOverlapsFor(string patchId) =>

427 _overlapMap.TryGetValue(patchId, out var list) ? list : [];

429 private void OpenLineComment(string file, int line)

430 {

431 if (!_isAuthenticated) return;

432 _inlineCommentFile = file;

433 _inlineCommentLine = line;

434 _inlineCommentText = "";

435 }

437 private async Task SubmitInlineComment()

438 {

439 if (_selected is null || _inlineCommentFile is null || string.IsNullOrWhiteSpace(_inlineCommentText)) return;

440 await ReviewStore.CreateAsync(ProjectId, _selected.Id, _userId ?? "anon", _userName ?? "anonymous",

441 _inlineCommentFile, _inlineCommentLine, _inlineCommentText);

442 _inlineCommentText = "";

443 _inlineCommentFile = null;

444 _inlineCommentLine = null;

445 _reviews = await ReviewStore.ListForPatchAsync(ProjectId, _selected.Id);

446 }

448 private async Task InlineCommentKeyDown(KeyboardEventArgs e)

449 {

450 if (e.Key == "Enter") await SubmitInlineComment();

451 }

453 private async Task AcceptPatch()

454 {

455 if (_selected is null) return;

456 if (!await _confirmModal.ShowAsync($"accept {_selected.Id[..8]}", $"Accept \"{_selected.Description}\" into trunk? This updates the trunk state.", "var(--accent)")) return;

457 var (updated, error) = await PatchStore.UpdateMaturityAsync(ProjectId, _selected.Id, Maturity.Accepted);

458 if (error is not null) { _message = error; return; }

459 await TrunkState.ApplyPatchAsync(ProjectId, updated!, PatchStore);

460 Events.NotifyTrunkChanged(ProjectId);

461 Events.NotifyPatchChanged(ProjectId);

462 _message = "Patch accepted.";

463 await Reload();

464 }

466 private async Task ProposePatch()

467 {

468 if (_selected is null) return;

469 if (!await _confirmModal.ShowAsync($"propose {_selected.Id[..8]}", $"Propose \"{_selected.Description}\" for review?", "#f59e0b")) return;

470 var (_, error) = await PatchStore.UpdateMaturityAsync(ProjectId, _selected.Id, Maturity.Proposed);

471 if (error is not null) { _message = error; return; }

472 Events.NotifyPatchChanged(ProjectId);

473 _message = "Patch proposed.";

474 await Reload();

475 }

477 private async Task WithdrawPatch()

478 {

479 if (_selected is null) return;

480 if (!await _confirmModal.ShowAsync($"withdraw {_selected.Id[..8]}", $"Withdraw \"{_selected.Description}\" back to draft?", "#3b82f6")) return;

481 var (_, error) = await PatchStore.UpdateMaturityAsync(ProjectId, _selected.Id, Maturity.DraftSynced);

482 if (error is not null) { _message = error; return; }

483 Events.NotifyPatchChanged(ProjectId);

484 _message = "Patch withdrawn to draft.";

485 await Reload();

486 }

488 private void RejectPatch()

489 {

490 _message = "Reject not yet implemented — revert the patch instead.";

491 }

493 private void OnChanged(string pid)

494 {

495 if (pid != ProjectId) return;

496 _ = InvokeAsync(async () => { await Reload(); StateHasChanged(); });

497 }

499 private async Task Reload()

500 {

501 _patches = await PatchStore.ListAsync(ProjectId);

503 // Rebuild overlap map

504 _overlapMap.Clear();

505 var proposed = _patches.Where(p => p.Maturity == Maturity.Proposed).ToList();

506 foreach (var p in proposed) _overlapMap[p.Id] = [];

507 for (int i = 0; i < proposed.Count; i++)

508 for (int j = i + 1; j < proposed.Count; j++)

509 {

510 var report = OverlapDetector.Detect(proposed[i], proposed[j]);

511 if (report.HasConflicts)

512 {

513 _overlapMap.GetValueOrDefault(proposed[i].Id)?.Add(proposed[j].Description);

514 _overlapMap.GetValueOrDefault(proposed[j].Id)?.Add(proposed[i].Description);

515 }

516 }

518 SetFilter(_activeFilter);

519 if (_selectedId is not null)

520 await SelectPatch(_selectedId);

521 else if (_filteredPatches?.Count > 0)

522 await SelectPatch(_filteredPatches[0].Id);

523 }

525 public void Dispose()

526 {

527 Events.PatchChanged -= OnChanged;

528 Events.ReviewChanged -= OnChanged;

529 }

531 static string StatusClass(Maturity m) => m switch

532 {

533 Maturity.Accepted => "status-accepted",

534 Maturity.Proposed => "status-proposed",

535 _ => "status-draft"

536 };

538 static string StatusText(Maturity m) => m switch

539 {

540 Maturity.Accepted => "accepted",

541 Maturity.Proposed => "proposed",

542 Maturity.DraftShared => "shared",

543 Maturity.DraftSynced => "synced",

544 _ => "draft"

545 };

547 static string OpPrefix(OpType t) => t switch

548 {

549 OpType.Insert => "+",

550 OpType.Modify => "~",

551 OpType.Delete => "-",

552 OpType.Rename or OpType.Move => ">",

553 _ => "?"

554 };

556 static string OpColor(OpType t) => t switch

557 {

558 OpType.Insert => "var(--accent)",

559 OpType.Modify => "var(--proposed)",

560 OpType.Delete => "var(--danger)",

561 _ => "var(--draft)"

562 };

564 static string PatchTime(Patch p) => p.Maturity switch

565 {

566 Maturity.Accepted when p.AcceptedAt.HasValue => $"accepted {FormatTimeAgo(p.AcceptedAt.Value)}",

567 Maturity.Proposed when p.ProposedAt.HasValue => $"proposed {FormatTimeAgo(p.ProposedAt.Value)}",

568 _ => FormatTimeAgo(p.Timestamp)

569 };

571 static string FormatTimeAgo(DateTime ts)

572 {

573 var d = DateTime.UtcNow - ts;

574 if (d.TotalMinutes < 60) return $"{(int)d.TotalMinutes}m ago";

575 if (d.TotalHours < 24) return $"{(int)d.TotalHours}h ago";

576 if (d.TotalDays < 7) return $"{(int)d.TotalDays}d ago";

577 return ts.ToString("MMM dd");

578 }

580 static string FormatBytes(long bytes) => bytes switch

581 {

582 0 => "",

583 < 1024 => $"{bytes} B",

584 < 1024 * 1024 => $"{bytes / 1024.0:F1} KB",

585 _ => $"{bytes / (1024.0 * 1024.0):F1} MB"

586 };

587}