dotPilot/DotPilot.Runtime/Features/RuntimeFoundation/RuntimeFoundationCatalog.cs at 7213a37061b3ce9255179364aeca3b0b0189f8ce · managedcode/dotPilot · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
using DotPilot.Core.Features.ControlPlaneDomain;
using DotPilot.Core.Features.RuntimeFoundation;

namespace DotPilot.Runtime.Features.RuntimeFoundation;

public sealed class RuntimeFoundationCatalog : IRuntimeFoundationCatalog
{
    private const string EpicSummary =
        "The embedded runtime stays local-first by isolating contracts, host wiring, orchestration, policy, and durable session archives away from the Uno presentation layer.";
    private const string EpicLabelValue = "LOCAL RUNTIME READINESS";
    private const string DeterministicProbePrompt =
        "Summarize the runtime foundation readiness for a local-first session that may require approval.";
    private const string DeterministicClientStatusSummary = "Always available for in-repo and CI validation.";
    private const string DomainModelLabel = "DOMAIN";
    private const string DomainModelName = "Domain contracts";
    private const string DomainModelSummary =
        "Typed identifiers and durable agent, session, fleet, provider, and runtime contracts live outside the Uno app.";
    private const string CommunicationLabel = "CONTRACTS";
    private const string CommunicationName = "Communication contracts";
    private const string CommunicationSummary =
        "Public result and problem boundaries are isolated so later provider and orchestration slices share one contract language.";
    private const string HostLabel = "HOST";
    private const string HostName = "Embedded host";
    private const string HostSummary =
        "The Orleans host integration point is sequenced behind dedicated runtime contracts instead of being baked into page code.";
    private const string OrchestrationLabel = "ORCHESTRATION";
    private const string OrchestrationName = "Orchestration runtime";
    private const string OrchestrationSummary =
        "Agent Framework orchestrates local runs, approvals, and checkpoints without moving execution logic into the Uno app.";
    private const string TrafficPolicyName = "Traffic policy";
    private const string TrafficPolicySummary =
        "Allowed grain transitions are explicit, testable, and surfaced through the embedded traffic-policy Mermaid catalog instead of hidden conventions.";
    private const string SessionPersistenceName = "Session persistence";
    private const string SessionPersistenceSummary =
        "Checkpoint, replay, and resume data survive host restarts in local session archives without changing the Orleans storage topology.";
    private readonly IReadOnlyList<ProviderDescriptor> _providers;

    public RuntimeFoundationCatalog() => _providers = Array.AsReadOnly(CreateProviders());

    public RuntimeFoundationSnapshot GetSnapshot()
    {
        return new(
            EpicLabelValue,
            EpicSummary,
            ProviderToolchainNames.DeterministicClientDisplayName,
            DeterministicProbePrompt,
            CreateSlices(),
            _providers);
    }

    private static IReadOnlyList<RuntimeSliceDescriptor> CreateSlices()
    {
        return
        [
            new(
                RuntimeFoundationIssues.DomainModel,
                DomainModelLabel,
                DomainModelName,
                DomainModelSummary,
                RuntimeSliceState.ReadyForImplementation),
            new(
                RuntimeFoundationIssues.CommunicationContracts,
                CommunicationLabel,
                CommunicationName,
                CommunicationSummary,
                RuntimeSliceState.Sequenced),
            new(
                RuntimeFoundationIssues.EmbeddedOrleansHost,
                HostLabel,
                HostName,
                HostSummary,
                RuntimeSliceState.Sequenced),
            new(
                RuntimeFoundationIssues.AgentFrameworkRuntime,
                OrchestrationLabel,
                OrchestrationName,
                OrchestrationSummary,
                RuntimeSliceState.Sequenced),
            new(
                RuntimeFoundationIssues.GrainTrafficPolicy,
                RuntimeFoundationIssues.FormatIssueLabel(RuntimeFoundationIssues.GrainTrafficPolicy),
                TrafficPolicyName,
                TrafficPolicySummary,
                RuntimeSliceState.Sequenced),
            new(
                RuntimeFoundationIssues.SessionPersistence,
                RuntimeFoundationIssues.FormatIssueLabel(RuntimeFoundationIssues.SessionPersistence),
                SessionPersistenceName,
                SessionPersistenceSummary,
                RuntimeSliceState.Sequenced),
        ];
    }

    private static ProviderDescriptor[] CreateProviders()
    {
        return
        [
            new ProviderDescriptor
            {
                Id = RuntimeFoundationDeterministicIdentity.CreateProviderId(ProviderToolchainNames.DeterministicClientCommandName),
                DisplayName = ProviderToolchainNames.DeterministicClientDisplayName,
                CommandName = ProviderToolchainNames.DeterministicClientCommandName,
                Status = ProviderConnectionStatus.Available,
                StatusSummary = DeterministicClientStatusSummary,
                RequiresExternalToolchain = false,
            },
        ];
    }
}