@h-rig/contracts 0.0.6-alpha.18 → 0.0.6-alpha.181

package/dist/src/workflow-journal.d.ts

@@ -0,0 +1,125 @@
+import type { CapabilityId } from "./capability-id";
+export declare const RIG_WORKFLOW_STARTED: "rig.workflow.started";
+export declare const RIG_WORKFLOW_TARGET_SELECTED: "rig.workflow.target.selected";
+export declare const RIG_WORKFLOW_TASK_SELECTED: "rig.workflow.task.selected";
+export declare const RIG_WORKFLOW_STATUS_CHANGED: "rig.workflow.status.changed";
+export declare const RIG_WORKFLOW_OPERATOR_NOTE: "rig.workflow.operator.note";
+export declare const RIG_WORKFLOW_INBOX_REQUESTED: "rig.workflow.inbox.requested";
+export declare const RIG_WORKFLOW_INBOX_RESOLVED: "rig.workflow.inbox.resolved";
+export type RigWorkflowEntryType = typeof RIG_WORKFLOW_STARTED | typeof RIG_WORKFLOW_TARGET_SELECTED | typeof RIG_WORKFLOW_TASK_SELECTED | typeof RIG_WORKFLOW_STATUS_CHANGED | typeof RIG_WORKFLOW_OPERATOR_NOTE | typeof RIG_WORKFLOW_INBOX_REQUESTED | typeof RIG_WORKFLOW_INBOX_RESOLVED;
+export type RigWorkflowTarget = "local" | "remote";
+export type RigWorkflowOwner = {
+    githubUserId: string;
+    login: string;
+    namespaceKey: string;
+};
+export type RigWorkflowStarted = {
+    schemaVersion: 1;
+    workflowId: string;
+    target: RigWorkflowTarget;
+    selectedRepo: string;
+    owner: RigWorkflowOwner;
+    createdAt: string;
+};
+export type RigWorkflowTargetSelected = {
+    schemaVersion: 1;
+    target: RigWorkflowTarget;
+    reason?: string;
+    selectedAt: string;
+};
+export type RigWorkflowTaskSelected = {
+    schemaVersion: 1;
+    taskId: string;
+    title?: string;
+    selectedAt: string;
+};
+export type RigWorkflowStatus = "starting" | "running" | "waiting-approval" | "waiting-input" | "completed" | "failed" | "stopped";
+export type RigWorkflowStatusChanged = {
+    schemaVersion: 1;
+    status: RigWorkflowStatus;
+    detail?: string;
+    changedAt: string;
+};
+export type RigWorkflowOperatorNote = {
+    schemaVersion: 1;
+    noteId?: string;
+    note: string;
+    notedAt: string;
+};
+export type RigWorkflowStartedInput = Omit<RigWorkflowStarted, "schemaVersion" | "createdAt"> & {
+    createdAt?: string;
+};
+export type RigWorkflowTargetSelectedInput = Omit<RigWorkflowTargetSelected, "schemaVersion" | "selectedAt"> & {
+    selectedAt?: string;
+};
+export type RigWorkflowTaskSelectedInput = Omit<RigWorkflowTaskSelected, "schemaVersion" | "selectedAt"> & {
+    selectedAt?: string;
+};
+export type RigWorkflowStatusChangedInput = Omit<RigWorkflowStatusChanged, "schemaVersion" | "changedAt"> & {
+    changedAt?: string;
+};
+export type RigWorkflowOperatorNoteInput = Omit<RigWorkflowOperatorNote, "schemaVersion" | "notedAt"> & {
+    notedAt?: string;
+};
+/** Minimal writable session/custom-entry surface for workflow fact writers. */
+export interface RigWorkflowEntryAppender {
+    appendEntry<T = unknown>(customType: string, data?: T): void;
+}
+/**
+ * Owner-side workflow journal writer. Consumers pass an OMP/custom-entry appender
+ * and unversioned fact inputs; the owner mints wire entries and appends them.
+ */
+export interface RigWorkflowJournalWriterService {
+    appendStarted(appender: RigWorkflowEntryAppender, input: RigWorkflowStartedInput): void;
+    appendTargetSelected(appender: RigWorkflowEntryAppender, input: RigWorkflowTargetSelectedInput): void;
+    appendTaskSelected(appender: RigWorkflowEntryAppender, input: RigWorkflowTaskSelectedInput): void;
+    appendStatusChanged(appender: RigWorkflowEntryAppender, input: RigWorkflowStatusChangedInput): void;
+    appendOperatorNote(appender: RigWorkflowEntryAppender, input: RigWorkflowOperatorNoteInput): void;
+}
+export declare const RIG_WORKFLOW_JOURNAL_WRITER_CAPABILITY_ID = "rig.workflow.journal-writer";
+export declare const RIG_WORKFLOW_JOURNAL_WRITER: CapabilityId<RigWorkflowJournalWriterService>;
+export type RigWorkflowInboxRequested = {
+    schemaVersion: 1;
+    requestId: string;
+    kind: "approval" | "input";
+    title: string;
+    body?: string;
+    options?: readonly string[];
+    requestedAt: string;
+};
+export type RigWorkflowInboxResolved = {
+    schemaVersion: 1;
+    requestId: string;
+    decision: "approved" | "rejected" | "answered";
+    answer?: unknown;
+    resolvedAt: string;
+};
+export type RigWorkflowProjection = {
+    started: RigWorkflowStarted | null;
+    target: RigWorkflowTargetSelected | null;
+    task: RigWorkflowTaskSelected | null;
+    status: RigWorkflowStatusChanged | null;
+    notes: readonly RigWorkflowOperatorNote[];
+    inbox: readonly RigWorkflowInboxRequested[];
+    resolvedInbox: readonly RigWorkflowInboxResolved[];
+    updatedAt: string | null;
+};
+export type RigWorkflowCustomEntry = {
+    type: string;
+    customType?: string;
+    data?: unknown;
+};
+export type RigCollabWorkflowMarkerInput = {
+    sessionId: string;
+    sessionPath: string;
+    cwd: string;
+    title: string;
+    joinLink: string;
+    webLink: string;
+    relayUrl?: string;
+    selectedRepo?: string;
+    owner?: Partial<RigWorkflowOwner>;
+    startedAt: string;
+    updatedAt: string;
+    stale: boolean;
+};

package/dist/src/workflow-journal.js

@@ -0,0 +1,27 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/workflow-journal.ts
+var RIG_WORKFLOW_STARTED = "rig.workflow.started";
+var RIG_WORKFLOW_TARGET_SELECTED = "rig.workflow.target.selected";
+var RIG_WORKFLOW_TASK_SELECTED = "rig.workflow.task.selected";
+var RIG_WORKFLOW_STATUS_CHANGED = "rig.workflow.status.changed";
+var RIG_WORKFLOW_OPERATOR_NOTE = "rig.workflow.operator.note";
+var RIG_WORKFLOW_INBOX_REQUESTED = "rig.workflow.inbox.requested";
+var RIG_WORKFLOW_INBOX_RESOLVED = "rig.workflow.inbox.resolved";
+var RIG_WORKFLOW_JOURNAL_WRITER_CAPABILITY_ID = "rig.workflow.journal-writer";
+var RIG_WORKFLOW_JOURNAL_WRITER = makeCapabilityId(RIG_WORKFLOW_JOURNAL_WRITER_CAPABILITY_ID);
+export {
+  RIG_WORKFLOW_TASK_SELECTED,
+  RIG_WORKFLOW_TARGET_SELECTED,
+  RIG_WORKFLOW_STATUS_CHANGED,
+  RIG_WORKFLOW_STARTED,
+  RIG_WORKFLOW_OPERATOR_NOTE,
+  RIG_WORKFLOW_JOURNAL_WRITER_CAPABILITY_ID,
+  RIG_WORKFLOW_JOURNAL_WRITER,
+  RIG_WORKFLOW_INBOX_RESOLVED,
+  RIG_WORKFLOW_INBOX_REQUESTED
+};

package/dist/src/workspace-config.d.ts

@@ -0,0 +1,18 @@
+import type { CapabilityId } from "./capability-id";
+export type EnsureDeclarativeConfigInput = {
+    readonly projectRoot: string;
+    readonly repoSlug?: string;
+};
+export type EnsureDeclarativeConfigResult = {
+    /** True when this call wrote a new `.rig/rigfig.toml`. */
+    readonly created: boolean;
+    /** The rigfig path when one now exists (created or pre-existing), else null. */
+    readonly path: string | null;
+    /** Why nothing was created (code config present, no plugin produced a config, …). */
+    readonly reason?: string;
+};
+export interface WorkspaceConfigEnsureService {
+    ensureDeclarativeConfig(input: EnsureDeclarativeConfigInput): EnsureDeclarativeConfigResult;
+}
+export declare const WORKSPACE_CONFIG_ENSURE_CAPABILITY_ID = "workspace.config.ensure";
+export declare const WORKSPACE_CONFIG_ENSURE: CapabilityId<WorkspaceConfigEnsureService>;

package/dist/src/workspace-config.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/workspace-config.ts
+var WORKSPACE_CONFIG_ENSURE_CAPABILITY_ID = "workspace.config.ensure";
+var WORKSPACE_CONFIG_ENSURE = makeCapabilityId(WORKSPACE_CONFIG_ENSURE_CAPABILITY_ID);
+export {
+  WORKSPACE_CONFIG_ENSURE_CAPABILITY_ID,
+  WORKSPACE_CONFIG_ENSURE
+};

package/dist/src/workspace-service.d.ts

@@ -0,0 +1,16 @@
+/** Typed workspace-domain service seam owned by @rig/workspace-plugin. */
+import type { CapabilityId } from "./capability-id";
+export interface WorkspaceServiceFabricMutationInput {
+    readonly projectRoot: string;
+    readonly command: "up" | "verify" | "down";
+    readonly services?: readonly string[];
+}
+export interface WorkspaceService {
+    readonly readSummary: (projectRoot: string) => Promise<unknown>;
+    readonly readTopology: (projectRoot: string) => unknown;
+    readonly readRemoteFleet: (projectRoot: string) => unknown;
+    readonly readServiceFabric: (projectRoot: string) => Promise<unknown>;
+    readonly mutateServiceFabric: (input: WorkspaceServiceFabricMutationInput) => Promise<unknown>;
+}
+export declare const WORKSPACE_SERVICE_CAPABILITY_ID = "rig.workspace.service";
+export declare const WORKSPACE_SERVICE: CapabilityId<WorkspaceService>;

package/dist/src/workspace-service.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/workspace-service.ts
+var WORKSPACE_SERVICE_CAPABILITY_ID = "rig.workspace.service";
+var WORKSPACE_SERVICE = makeCapabilityId(WORKSPACE_SERVICE_CAPABILITY_ID);
+export {
+  WORKSPACE_SERVICE_CAPABILITY_ID,
+  WORKSPACE_SERVICE
+};

package/dist/src/workspace.d.ts

@@ -0,0 +1,204 @@
+import { Schema } from "effect";
+export declare const WorkspaceSourceKind: Schema.Literals<readonly ["native", "rig-import", "manual", "remote"]>;
+export type WorkspaceSourceKind = typeof WorkspaceSourceKind.Type;
+export declare const WorkspaceTopologyStatus: Schema.Literals<readonly ["empty", "ready", "degraded"]>;
+export type WorkspaceTopologyStatus = typeof WorkspaceTopologyStatus.Type;
+export declare const WorkspaceRemoteFleetStatus: Schema.Literals<readonly ["empty", "ready", "degraded"]>;
+export type WorkspaceRemoteFleetStatus = typeof WorkspaceRemoteFleetStatus.Type;
+export declare const WorkspaceServiceFabricStatus: Schema.Literals<readonly ["empty", "booting", "ready", "degraded", "stopped"]>;
+export type WorkspaceServiceFabricStatus = typeof WorkspaceServiceFabricStatus.Type;
+export declare const WorkspaceRemoteHostStatus: Schema.Literals<readonly ["registering", "ready", "busy", "degraded", "draining", "offline", "quarantined"]>;
+export type WorkspaceRemoteHostStatus = typeof WorkspaceRemoteHostStatus.Type;
+export declare const WorkspaceTopologyServiceSummary: Schema.Struct<{
+    readonly name: Schema.Trim;
+    readonly relativeRootPath: Schema.Trim;
+    readonly runtime: Schema.Trim;
+    readonly port: Schema.NullOr<Schema.Number>;
+    readonly healthcheck: Schema.NullOr<Schema.Trim>;
+    readonly sourceOfTruth: Schema.Struct<{
+        readonly code: Schema.NullOr<Schema.Trim>;
+        readonly tests: Schema.NullOr<Schema.Trim>;
+        readonly infra: Schema.NullOr<Schema.Trim>;
+        readonly deploy: Schema.NullOr<Schema.Trim>;
+        readonly dependencies: Schema.NullOr<Schema.Trim>;
+    }>;
+    readonly splitReadyChecklist: Schema.$Array<Schema.Trim>;
+}>;
+export type WorkspaceTopologyServiceSummary = typeof WorkspaceTopologyServiceSummary.Type;
+export declare const WorkspaceTopologySummary: Schema.Struct<{
+    readonly compiledAt: Schema.String;
+    readonly status: Schema.Literals<readonly ["empty", "ready", "degraded"]>;
+    readonly manifestCount: Schema.Number;
+    readonly serviceCount: Schema.Number;
+    readonly services: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.Trim;
+        readonly relativeRootPath: Schema.Trim;
+        readonly runtime: Schema.Trim;
+        readonly port: Schema.NullOr<Schema.Number>;
+        readonly healthcheck: Schema.NullOr<Schema.Trim>;
+        readonly sourceOfTruth: Schema.Struct<{
+            readonly code: Schema.NullOr<Schema.Trim>;
+            readonly tests: Schema.NullOr<Schema.Trim>;
+            readonly infra: Schema.NullOr<Schema.Trim>;
+            readonly deploy: Schema.NullOr<Schema.Trim>;
+            readonly dependencies: Schema.NullOr<Schema.Trim>;
+        }>;
+        readonly splitReadyChecklist: Schema.$Array<Schema.Trim>;
+    }>>;
+    readonly warnings: Schema.$Array<Schema.String>;
+}>;
+export type WorkspaceTopologySummary = typeof WorkspaceTopologySummary.Type;
+export declare const WorkspaceRemoteHostSummary: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly name: Schema.Trim;
+    readonly baseUrl: Schema.Trim;
+    readonly workspacePath: Schema.NullOr<Schema.Trim>;
+    readonly transport: Schema.Trim;
+    readonly hostname: Schema.NullOr<Schema.Trim>;
+    readonly region: Schema.NullOr<Schema.Trim>;
+    readonly labels: Schema.$Array<Schema.Trim>;
+    readonly capabilities: Schema.$Array<Schema.Trim>;
+    readonly runtimeAdapters: Schema.$Array<Schema.Literal<"pi">>;
+    readonly status: Schema.Literals<readonly ["registering", "ready", "busy", "degraded", "draining", "offline", "quarantined"]>;
+    readonly currentLeaseCount: Schema.Number;
+    readonly lastHeartbeatAt: Schema.NullOr<Schema.String>;
+    readonly registeredAt: Schema.String;
+    readonly manifestPath: Schema.Trim;
+}>;
+export type WorkspaceRemoteHostSummary = typeof WorkspaceRemoteHostSummary.Type;
+export declare const WorkspaceRemoteFleetSummary: Schema.Struct<{
+    readonly updatedAt: Schema.String;
+    readonly status: Schema.Literals<readonly ["empty", "ready", "degraded"]>;
+    readonly manifestCount: Schema.Number;
+    readonly hostCount: Schema.Number;
+    readonly onlineHostCount: Schema.Number;
+    readonly hosts: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.Trim;
+        readonly name: Schema.Trim;
+        readonly baseUrl: Schema.Trim;
+        readonly workspacePath: Schema.NullOr<Schema.Trim>;
+        readonly transport: Schema.Trim;
+        readonly hostname: Schema.NullOr<Schema.Trim>;
+        readonly region: Schema.NullOr<Schema.Trim>;
+        readonly labels: Schema.$Array<Schema.Trim>;
+        readonly capabilities: Schema.$Array<Schema.Trim>;
+        readonly runtimeAdapters: Schema.$Array<Schema.Literal<"pi">>;
+        readonly status: Schema.Literals<readonly ["registering", "ready", "busy", "degraded", "draining", "offline", "quarantined"]>;
+        readonly currentLeaseCount: Schema.Number;
+        readonly lastHeartbeatAt: Schema.NullOr<Schema.String>;
+        readonly registeredAt: Schema.String;
+        readonly manifestPath: Schema.Trim;
+    }>>;
+    readonly warnings: Schema.$Array<Schema.String>;
+}>;
+export type WorkspaceRemoteFleetSummary = typeof WorkspaceRemoteFleetSummary.Type;
+export declare const WorkspaceServiceFabricServiceSummary: Schema.Struct<{
+    readonly name: Schema.Trim;
+    readonly relativeRootPath: Schema.Trim;
+    readonly mode: Schema.Literals<readonly ["stub", "process"]>;
+    readonly port: Schema.Number;
+    readonly healthcheck: Schema.Trim;
+    readonly routePrefix: Schema.NullOr<Schema.Trim>;
+    readonly status: Schema.Literals<readonly ["planned", "booting", "healthy", "degraded", "failed", "stopped"]>;
+    readonly pid: Schema.NullOr<Schema.Number>;
+    readonly logPath: Schema.NullOr<Schema.Trim>;
+}>;
+export type WorkspaceServiceFabricServiceSummary = typeof WorkspaceServiceFabricServiceSummary.Type;
+export declare const WorkspaceServiceFabricSummary: Schema.Struct<{
+    readonly updatedAt: Schema.String;
+    readonly status: Schema.Literals<readonly ["empty", "booting", "ready", "degraded", "stopped"]>;
+    readonly serviceCount: Schema.Number;
+    readonly healthyServiceCount: Schema.Number;
+    readonly stateDir: Schema.Trim;
+    readonly services: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.Trim;
+        readonly relativeRootPath: Schema.Trim;
+        readonly mode: Schema.Literals<readonly ["stub", "process"]>;
+        readonly port: Schema.Number;
+        readonly healthcheck: Schema.Trim;
+        readonly routePrefix: Schema.NullOr<Schema.Trim>;
+        readonly status: Schema.Literals<readonly ["planned", "booting", "healthy", "degraded", "failed", "stopped"]>;
+        readonly pid: Schema.NullOr<Schema.Number>;
+        readonly logPath: Schema.NullOr<Schema.Trim>;
+    }>>;
+    readonly warnings: Schema.$Array<Schema.String>;
+}>;
+export type WorkspaceServiceFabricSummary = typeof WorkspaceServiceFabricSummary.Type;
+export declare const WorkspaceSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly title: Schema.Trim;
+    readonly rootPath: Schema.Trim;
+    readonly sourceKind: Schema.Literals<readonly ["native", "rig-import", "manual", "remote"]>;
+    readonly defaultRuntimeAdapter: Schema.optional<Schema.Literal<"pi">>;
+    readonly defaultProvider: Schema.optional<Schema.Literals<readonly ["codex", "claude"]>>;
+    readonly defaultModel: Schema.NullOr<Schema.Trim>;
+    readonly topology: Schema.optional<Schema.Struct<{
+        readonly compiledAt: Schema.String;
+        readonly status: Schema.Literals<readonly ["empty", "ready", "degraded"]>;
+        readonly manifestCount: Schema.Number;
+        readonly serviceCount: Schema.Number;
+        readonly services: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.Trim;
+            readonly relativeRootPath: Schema.Trim;
+            readonly runtime: Schema.Trim;
+            readonly port: Schema.NullOr<Schema.Number>;
+            readonly healthcheck: Schema.NullOr<Schema.Trim>;
+            readonly sourceOfTruth: Schema.Struct<{
+                readonly code: Schema.NullOr<Schema.Trim>;
+                readonly tests: Schema.NullOr<Schema.Trim>;
+                readonly infra: Schema.NullOr<Schema.Trim>;
+                readonly deploy: Schema.NullOr<Schema.Trim>;
+                readonly dependencies: Schema.NullOr<Schema.Trim>;
+            }>;
+            readonly splitReadyChecklist: Schema.$Array<Schema.Trim>;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.String>;
+    }>>;
+    readonly remoteFleet: Schema.optional<Schema.Struct<{
+        readonly updatedAt: Schema.String;
+        readonly status: Schema.Literals<readonly ["empty", "ready", "degraded"]>;
+        readonly manifestCount: Schema.Number;
+        readonly hostCount: Schema.Number;
+        readonly onlineHostCount: Schema.Number;
+        readonly hosts: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.Trim;
+            readonly name: Schema.Trim;
+            readonly baseUrl: Schema.Trim;
+            readonly workspacePath: Schema.NullOr<Schema.Trim>;
+            readonly transport: Schema.Trim;
+            readonly hostname: Schema.NullOr<Schema.Trim>;
+            readonly region: Schema.NullOr<Schema.Trim>;
+            readonly labels: Schema.$Array<Schema.Trim>;
+            readonly capabilities: Schema.$Array<Schema.Trim>;
+            readonly runtimeAdapters: Schema.$Array<Schema.Literal<"pi">>;
+            readonly status: Schema.Literals<readonly ["registering", "ready", "busy", "degraded", "draining", "offline", "quarantined"]>;
+            readonly currentLeaseCount: Schema.Number;
+            readonly lastHeartbeatAt: Schema.NullOr<Schema.String>;
+            readonly registeredAt: Schema.String;
+            readonly manifestPath: Schema.Trim;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.String>;
+    }>>;
+    readonly serviceFabric: Schema.optional<Schema.Struct<{
+        readonly updatedAt: Schema.String;
+        readonly status: Schema.Literals<readonly ["empty", "booting", "ready", "degraded", "stopped"]>;
+        readonly serviceCount: Schema.Number;
+        readonly healthyServiceCount: Schema.Number;
+        readonly stateDir: Schema.Trim;
+        readonly services: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.Trim;
+            readonly relativeRootPath: Schema.Trim;
+            readonly mode: Schema.Literals<readonly ["stub", "process"]>;
+            readonly port: Schema.Number;
+            readonly healthcheck: Schema.Trim;
+            readonly routePrefix: Schema.NullOr<Schema.Trim>;
+            readonly status: Schema.Literals<readonly ["planned", "booting", "healthy", "degraded", "failed", "stopped"]>;
+            readonly pid: Schema.NullOr<Schema.Number>;
+            readonly logPath: Schema.NullOr<Schema.Trim>;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.String>;
+    }>>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+}>;
+export type WorkspaceSummary = typeof WorkspaceSummary.Type;