@h-rig/contracts 0.0.6-alpha.17 → 0.0.6-alpha.170

package/dist/src/review.d.ts

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+export declare const ReviewMode: Schema.Literals<readonly ["off", "advisory", "required"]>;
+export type ReviewMode = typeof ReviewMode.Type;
+export declare const ReviewStatus: Schema.Literals<readonly ["pending", "running", "approved", "rejected", "error"]>;
+export type ReviewStatus = typeof ReviewStatus.Type;
+export declare const ReviewSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "ReviewResultId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly provider: Schema.Trim;
+    readonly mode: Schema.Literals<readonly ["off", "advisory", "required"]>;
+    readonly status: Schema.Literals<readonly ["pending", "running", "approved", "rejected", "error"]>;
+    readonly summary: Schema.NullOr<Schema.String>;
+    readonly output: Schema.Unknown;
+    readonly createdAt: Schema.String;
+    readonly completedAt: Schema.NullOr<Schema.String>;
+}>;
+export type ReviewSummary = typeof ReviewSummary.Type;

package/dist/src/review.js

@@ -16,6 +16,9 @@ var WorkspaceId = makeEntityId("WorkspaceId");
 var GraphId = makeEntityId("GraphId");
 var TaskId = makeEntityId("TaskId");
 var RunId = makeEntityId("RunId");
+var SafePathSegment = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafePathSegment"));
+var SafeRunId = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)).pipe(Schema.brand("SafeRunId"));
+var SafeGitRefComponent = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafeGitRefComponent"));
 var EngineRuntimeId = makeEntityId("EngineRuntimeId");
 var ConversationId = makeEntityId("ConversationId");
 var ActionId = makeEntityId("ActionId");

package/dist/src/rollups.d.ts

@@ -0,0 +1,41 @@
+import { Schema } from "effect";
+export declare const PercentComplete: Schema.Int;
+export type PercentComplete = typeof PercentComplete.Type;
+export declare const EpicRollup: Schema.Struct<{
+    readonly epicKey: Schema.Trim;
+    readonly total: Schema.Int;
+    readonly percentComplete: Schema.Int;
+    readonly blockedCount: Schema.Int;
+    readonly humanBlockedCount: Schema.Int;
+    readonly inFlightCount: Schema.Int;
+    readonly byStatus: Schema.$Record<Schema.String, Schema.Int>;
+}>;
+export type EpicRollup = typeof EpicRollup.Type;
+export declare const AssigneeRollup: Schema.Struct<{
+    readonly assignee: Schema.Trim;
+    readonly openTaskCount: Schema.Int;
+    readonly inFlightRunCount: Schema.Int;
+    readonly prsAwaitingReview: Schema.Int;
+    readonly blockers: Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>;
+}>;
+export type AssigneeRollup = typeof AssigneeRollup.Type;
+export declare const WorkspaceRollups: Schema.Struct<{
+    readonly epics: Schema.$Array<Schema.Struct<{
+        readonly epicKey: Schema.Trim;
+        readonly total: Schema.Int;
+        readonly percentComplete: Schema.Int;
+        readonly blockedCount: Schema.Int;
+        readonly humanBlockedCount: Schema.Int;
+        readonly inFlightCount: Schema.Int;
+        readonly byStatus: Schema.$Record<Schema.String, Schema.Int>;
+    }>>;
+    readonly assignees: Schema.$Array<Schema.Struct<{
+        readonly assignee: Schema.Trim;
+        readonly openTaskCount: Schema.Int;
+        readonly inFlightRunCount: Schema.Int;
+        readonly prsAwaitingReview: Schema.Int;
+        readonly blockers: Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>;
+    }>>;
+    readonly generatedAt: Schema.String;
+}>;
+export type WorkspaceRollups = typeof WorkspaceRollups.Type;

package/dist/src/rollups.js

@@ -0,0 +1,70 @@
+// @bun
+// packages/contracts/src/rollups.ts
+import { Schema as Schema2 } from "effect";
+
+// packages/contracts/src/baseSchemas.ts
+import { Schema } from "effect";
+var TrimmedString = Schema.Trim;
+var TrimmedNonEmptyString = TrimmedString.check(Schema.isNonEmpty());
+var NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+var PositiveInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1));
+var IsoDateTime = Schema.String;
+var makeEntityId = (brand) => TrimmedNonEmptyString.pipe(Schema.brand(brand));
+var ThreadId = makeEntityId("ThreadId");
+var ProjectId = makeEntityId("ProjectId");
+var WorkspaceId = makeEntityId("WorkspaceId");
+var GraphId = makeEntityId("GraphId");
+var TaskId = makeEntityId("TaskId");
+var RunId = makeEntityId("RunId");
+var SafePathSegment = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafePathSegment"));
+var SafeRunId = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)).pipe(Schema.brand("SafeRunId"));
+var SafeGitRefComponent = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafeGitRefComponent"));
+var EngineRuntimeId = makeEntityId("EngineRuntimeId");
+var ConversationId = makeEntityId("ConversationId");
+var ActionId = makeEntityId("ActionId");
+var ArtifactId = makeEntityId("ArtifactId");
+var WorktreeId = makeEntityId("WorktreeId");
+var ValidationResultId = makeEntityId("ValidationResultId");
+var ReviewResultId = makeEntityId("ReviewResultId");
+var CommandId = makeEntityId("CommandId");
+var EventId = makeEntityId("EventId");
+var MessageId = makeEntityId("MessageId");
+var TurnId = makeEntityId("TurnId");
+var ProviderItemId = makeEntityId("ProviderItemId");
+var RuntimeSessionId = makeEntityId("RuntimeSessionId");
+var RuntimeItemId = makeEntityId("RuntimeItemId");
+var RuntimeRequestId = makeEntityId("RuntimeRequestId");
+var RuntimeTaskId = makeEntityId("RuntimeTaskId");
+var ApprovalRequestId = makeEntityId("ApprovalRequestId");
+var CheckpointRef = makeEntityId("CheckpointRef");
+var RemoteEndpointId = makeEntityId("RemoteEndpointId");
+
+// packages/contracts/src/rollups.ts
+var PercentComplete = NonNegativeInt.check(Schema2.isLessThanOrEqualTo(100));
+var EpicRollup = Schema2.Struct({
+  epicKey: TrimmedNonEmptyString,
+  total: NonNegativeInt,
+  percentComplete: PercentComplete,
+  blockedCount: NonNegativeInt,
+  humanBlockedCount: NonNegativeInt,
+  inFlightCount: NonNegativeInt,
+  byStatus: Schema2.Record(Schema2.String, NonNegativeInt)
+});
+var AssigneeRollup = Schema2.Struct({
+  assignee: TrimmedNonEmptyString,
+  openTaskCount: NonNegativeInt,
+  inFlightRunCount: NonNegativeInt,
+  prsAwaitingReview: NonNegativeInt,
+  blockers: Schema2.Array(TaskId)
+});
+var WorkspaceRollups = Schema2.Struct({
+  epics: Schema2.Array(EpicRollup),
+  assignees: Schema2.Array(AssigneeRollup),
+  generatedAt: IsoDateTime
+});
+export {
+  WorkspaceRollups,
+  PercentComplete,
+  EpicRollup,
+  AssigneeRollup
+};

package/dist/src/run-discovery.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Run-discovery capability seam.
+ *
+ * Contracts-native types for the RUN_DISCOVERY service: inline structural
+ * equivalents of the @oh-my-pi and @rig/relay-registry types. We define
+ * them here rather than importing from those packages to keep @rig/contracts
+ * floor-neutral (@rig/relay-registry depends on @rig/contracts — importing
+ * relay-registry here would be circular; @oh-my-pi is a vendor package that
+ * doesn't belong on the floor).
+ *
+ * TypeScript's structural type system makes these compatible with the
+ * corresponding @oh-my-pi / relay-registry types at the impl site.
+ *
+ * Pure: types + one branded id, no behaviour.
+ */
+import type { CapabilityId } from "./capability-id";
+import type { Stream } from "effect";
+/** Structural equivalent of @oh-my-pi CollabRegistryFilter. */
+export interface RunDiscoveryFilter {
+    githubUserId?: string;
+    namespaceKey?: string;
+    selectedRepo?: string;
+    cwd?: string;
+}
+/** Structural equivalent of @oh-my-pi LiveCollabOwner. */
+export interface RunDiscoveryOwner {
+    githubUserId?: string;
+    login?: string;
+    namespaceKey?: string;
+}
+/** Structural equivalent of @oh-my-pi LiveCollabProjection. */
+export interface LiveRunCollabProjection {
+    sessionId: string;
+    sessionPath: string;
+    cwd: string;
+    title: string;
+    joinLink: string;
+    webLink: string;
+    relayUrl?: string;
+    owner?: RunDiscoveryOwner;
+    selectedRepo?: string;
+    startedAt: string;
+    updatedAt: string;
+    pid?: number;
+    stale: boolean;
+}
+/** Input for attaching to a run via the relay (structural equiv of AttachViaRelayInput). */
+export interface RigRunAttachInput {
+    readonly runId: string;
+    readonly taskId?: string | null;
+    readonly identityFilter: RunDiscoveryFilter;
+    readonly timeoutMs?: number;
+    readonly projectRoot?: string;
+}
+/** Result of a relay attach (structural equiv of RigExtensionAttachResult). */
+export interface RigRunAttachResult {
+    readonly sessionPath: string | null;
+    readonly joinLink: string | null;
+    readonly collabSessionId: string | null;
+}
+/**
+ * The run-discovery service surface: the unified active-run list (local FS +
+ * remote registry) and relay attach. registrySnapshotStream is intentionally
+ * omitted — its entry type (`RegistrySnapshotFrame` from @rig/relay-registry)
+ * cannot be referenced here without creating a circular dep; consumers that
+ * need snapshot frames must cast through the transport-plugin's richer type.
+ */
+export interface RunDiscoveryService {
+    readonly listActiveRunCollab: (projectRoot: string, filter: RunDiscoveryFilter) => Promise<readonly LiveRunCollabProjection[]>;
+    readonly runDiscoveryStream: (projectRoot: string) => Stream.Stream<void>;
+    readonly attachViaRelay: (input: RigRunAttachInput) => Promise<RigRunAttachResult | null>;
+}
+/** Stable id string for the run-discovery service capability. */
+export declare const RUN_DISCOVERY_CAPABILITY_ID = "rig.runs.discovery";
+/**
+ * The branded run-discovery capability id. `defineCapability(RUN_DISCOVERY)`
+ * (provider and consumers independently) resolves to a `RunDiscoveryService`.
+ */
+export declare const RUN_DISCOVERY: CapabilityId<RunDiscoveryService>;

package/dist/src/run-discovery.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/run-discovery.ts
+var RUN_DISCOVERY_CAPABILITY_ID = "rig.runs.discovery";
+var RUN_DISCOVERY = makeCapabilityId(RUN_DISCOVERY_CAPABILITY_ID);
+export {
+  RUN_DISCOVERY_CAPABILITY_ID,
+  RUN_DISCOVERY
+};

package/dist/src/run-dispatch.d.ts

@@ -0,0 +1,34 @@
+/**
+ * run-dispatch.ts — pure capability vocabulary for placement-aware run dispatch.
+ *
+ * The dispatch IMPL (local + remote placement, run-process spawn, session-id
+ * wait) lives in @rig/transport-plugin (`./dispatch`, the `transport` backbone).
+ * Programmatic consumers (rig-extension, supervisor) resolve it off a project's
+ * plugin host under {@link RUN_DISPATCH_CAPABILITY_ID} — WITHOUT importing the
+ * transport plugin's impl. This file holds ONLY the pure id + interface shared
+ * by the provider and its consumers (no IO, no plugin imports).
+ */
+import type { CapabilityId } from "./capability-id";
+/** The placement-aware run dispatch input (plain, OMP-type-free). */
+export interface RunDispatchInput {
+    readonly projectRoot: string;
+    readonly taskId: string;
+    readonly title?: string | null;
+    readonly model?: string | null;
+    readonly prompt?: string | null;
+    readonly force?: boolean;
+}
+/**
+ * The host-resolved run-dispatch surface: dispatch a run (resolving local vs
+ * remote/fleet placement at dispatch time) and resolve once an OMP session id
+ * has appeared. Mirrors `dispatchRun` in @rig/transport-plugin.
+ */
+export interface RunDispatchService {
+    readonly dispatchRun: (input: RunDispatchInput) => Promise<{
+        readonly runId: string;
+    }>;
+}
+/** The capability id the transport plugin registers its run dispatcher under. */
+export declare const RUN_DISPATCH_CAPABILITY_ID = "rig.runs.dispatch";
+/** Phantom-typed id; string value is {@link RUN_DISPATCH_CAPABILITY_ID}. */
+export declare const RUN_DISPATCH: CapabilityId<RunDispatchService>;

package/dist/src/run-dispatch.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/run-dispatch.ts
+var RUN_DISPATCH_CAPABILITY_ID = "rig.runs.dispatch";
+var RUN_DISPATCH = makeCapabilityId(RUN_DISPATCH_CAPABILITY_ID);
+export {
+  RUN_DISPATCH_CAPABILITY_ID,
+  RUN_DISPATCH
+};

package/dist/src/run-identity.d.ts

@@ -0,0 +1,47 @@
+/**
+ * cap:run-identity-env — GitHub/Rig run identity capability seam.
+ *
+ * The CLI seed and sibling plugins must not implement GitHub identity policy or
+ * import a provider implementation directly. The identity owner
+ * (`@rig/github-provider-plugin`) registers this capability with public
+ * identity-env hydration, run-child credential stripping, and runtime identity
+ * resolution. This file holds ONLY pure seam vocabulary — no IO.
+ */
+import type { CapabilityId } from "./capability-id";
+import type { RigIdentityContext, RigResolvedIdentity } from "./identity";
+/** Structural mirror of `@rig/relay-registry`'s `CollabRegistryFilter` (no transport dep). */
+export type IdentityRegistryFilter = {
+    readonly cwd?: string;
+    readonly selectedRepo?: string;
+    readonly githubUserId?: string;
+    readonly namespaceKey?: string;
+};
+/** Capability id the identity owner registers its run identity policy under. */
+export declare const RUN_IDENTITY_ENV_CAPABILITY_ID = "cap:run-identity-env";
+/** GitHub/Rig identity operations consumers resolve through the provider capability. */
+export interface RunIdentityEnvService {
+    /**
+     * Resolve public identity env vars for `workspaceRoot` without mutating
+     * process.env.
+     */
+    resolveIdentityEnv(workspaceRoot: string): Partial<Record<"RIG_SELECTED_REPO" | "RIG_GITHUB_USER_ID" | "RIG_GITHUB_LOGIN" | "RIG_GITHUB_NAMESPACE_KEY", string>>;
+    /**
+     * Hydrate the public-identity env vars for `workspaceRoot` into process.env
+     * (RIG_SELECTED_REPO / RIG_GITHUB_USER_ID / RIG_GITHUB_LOGIN / namespace key /
+     * auth-state-file pointer). Returns a restore closure that reverts the change.
+     */
+    applyIdentityEnv(workspaceRoot: string): () => void;
+    /** Build a registry discovery filter from the current public identity env. */
+    identityFilterFromEnv(): IdentityRegistryFilter;
+    /**
+     * Return a copy of `env` (default process.env) with the run-scoped credential
+     * tokens removed, for use as a spawned run-host child's environment.
+     */
+    stripRunChildCredentialEnv(env?: Record<string, string | undefined>): Record<string, string | undefined>;
+    /** Resolve the current Rig run identity from the OMP session/auth context. */
+    resolveRigIdentity(ctx: RigIdentityContext): RigResolvedIdentity | null;
+    /** Resolve the registry filter corresponding to the current Rig run identity. */
+    resolveRigIdentityFilter(ctx: RigIdentityContext): IdentityRegistryFilter | null;
+}
+/** Typed capability id; string value is {@link RUN_IDENTITY_ENV_CAPABILITY_ID}. */
+export declare const RUN_IDENTITY_ENV: CapabilityId<RunIdentityEnvService>;

package/dist/src/run-identity.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/run-identity.ts
+var RUN_IDENTITY_ENV_CAPABILITY_ID = "cap:run-identity-env";
+var RUN_IDENTITY_ENV = makeCapabilityId(RUN_IDENTITY_ENV_CAPABILITY_ID);
+export {
+  RUN_IDENTITY_ENV_CAPABILITY_ID,
+  RUN_IDENTITY_ENV
+};