@h-rig/contracts 0.0.6-alpha.15 → 0.0.6-alpha.150

package/dist/src/engine.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");
@@ -136,6 +139,114 @@ var QueueEntry = Schema3.Struct({
   unblockCount: NonNegativeInt,
   position: NonNegativeInt
 });
+var DependencyEdgeType = Schema3.Literals(["blocks", "parent-child", "related"]);
+var DependencyEdge = Schema3.Struct({
+  fromTaskId: TaskId,
+  toTaskId: TaskId,
+  type: DependencyEdgeType
+});
+var BlockerClass = Schema3.Literals([
+  "not-blocked",
+  "task-blocked",
+  "human-decision",
+  "human-approval",
+  "external-input",
+  "unknown"
+]);
+var ActionRiskTier = Schema3.Literals(["t1-read", "t2-reversible", "t3-external", "t4-irreversible"]);
+var BlockerClassification = Schema3.Struct({
+  taskId: TaskId,
+  blockerClass: BlockerClass,
+  actionRiskTier: Schema3.NullOr(ActionRiskTier),
+  rationale: Schema3.String,
+  source: Schema3.Literals(["elimination", "label", "status", "llm"]),
+  autoApplied: Schema3.Boolean
+});
+var DependencyNode = Schema3.Struct({
+  taskId: TaskId,
+  title: TrimmedNonEmptyString,
+  status: TaskStatus,
+  priority: Schema3.NullOr(PositiveInt),
+  assignee: Schema3.NullOr(TrimmedNonEmptyString),
+  blockedBy: Schema3.Array(TaskId),
+  blocks: Schema3.Array(TaskId),
+  blockingDepth: NonNegativeInt,
+  blockerClass: Schema3.NullOr(BlockerClass),
+  actionRiskTier: Schema3.NullOr(ActionRiskTier),
+  epicKey: Schema3.NullOr(TrimmedNonEmptyString),
+  groupKey: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  externalId: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  sourceIssueId: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  scope: Schema3.optional(Schema3.Array(TrimmedNonEmptyString)),
+  validationKeys: Schema3.optional(Schema3.Array(TrimmedNonEmptyString))
+});
+var TaskGraphLane = Schema3.Struct({
+  key: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  rowIndex: NonNegativeInt,
+  x: Schema3.Number,
+  y: Schema3.Number,
+  width: NonNegativeInt,
+  height: NonNegativeInt,
+  color: Schema3.String,
+  taskCount: NonNegativeInt
+});
+var TaskGraphStage = Schema3.Struct({
+  index: NonNegativeInt,
+  label: TrimmedNonEmptyString,
+  x: Schema3.Number,
+  width: NonNegativeInt
+});
+var TaskGraphNode = Schema3.Struct({
+  id: TrimmedNonEmptyString,
+  taskId: TaskId,
+  task: Schema3.optional(TaskSummary),
+  rowKey: TrimmedNonEmptyString,
+  rowLabel: TrimmedNonEmptyString,
+  rowIndex: NonNegativeInt,
+  stage: NonNegativeInt,
+  x: Schema3.Number,
+  y: Schema3.Number,
+  width: NonNegativeInt,
+  height: NonNegativeInt,
+  color: Schema3.optional(Schema3.String),
+  taskCode: Schema3.optional(Schema3.NullOr(Schema3.String)),
+  strippedTitle: Schema3.optional(Schema3.String),
+  depsIn: Schema3.optional(NonNegativeInt),
+  depsOut: Schema3.optional(NonNegativeInt),
+  runCount: Schema3.optional(NonNegativeInt),
+  hasApprovals: Schema3.optional(Schema3.Boolean),
+  hasPendingUserInput: Schema3.optional(Schema3.Boolean),
+  hasRejectedReview: Schema3.optional(Schema3.Boolean),
+  hasFailedValidations: Schema3.optional(Schema3.Boolean),
+  artifactCount: Schema3.optional(NonNegativeInt)
+});
+var TaskGraphEdge = Schema3.Struct({
+  id: TrimmedNonEmptyString,
+  sourceId: TrimmedNonEmptyString,
+  targetId: TrimmedNonEmptyString,
+  color: Schema3.String,
+  kind: Schema3.Literals(["blocking", "parent-child"])
+});
+var TaskGraphLayout = Schema3.Struct({
+  lanes: Schema3.Array(TaskGraphLane),
+  stages: Schema3.Array(TaskGraphStage),
+  nodes: Schema3.Array(TaskGraphNode),
+  edges: Schema3.Array(TaskGraphEdge),
+  totalWidth: NonNegativeInt,
+  totalHeight: NonNegativeInt,
+  taskCount: NonNegativeInt
+});
+var DependencyGraphModel = Schema3.Struct({
+  graphId: GraphId,
+  nodes: Schema3.Array(DependencyNode),
+  edges: Schema3.Array(DependencyEdge),
+  layout: TaskGraphLayout,
+  cycles: Schema3.Array(Schema3.Array(TaskId)),
+  unresolvedRefs: Schema3.Array(TrimmedNonEmptyString),
+  degraded: Schema3.Boolean,
+  generatedAt: IsoDateTime
+});
 
 // packages/contracts/src/policy.ts
 import { Schema as Schema4 } from "effect";
@@ -1069,12 +1180,14 @@ var RunStatus = Schema9.Literals([
   "running",
   "waiting-approval",
   "waiting-user-input",
+  "paused",
   "validating",
   "reviewing",
+  "closing-out",
+  "needs-attention",
   "completed",
   "failed",
-  "cancelled",
-  "paused"
+  "stopped"
 ]);
 var EngineSandboxMode = Schema9.Literals([
   "read-only",
@@ -1102,7 +1215,7 @@ var RunSummary = Schema9.Struct({
   runtimeMode: RuntimeMode,
   interactionMode: ProviderInteractionMode,
   status: RunStatus,
-  runtimeAdapter: TrimmedNonEmptyString,
+  runtimeAdapter: Schema9.Literal("pi"),
   model: Schema9.NullOr(TrimmedNonEmptyString),
   initialPrompt: Schema9.NullOr(Schema9.String),
   executionTarget: Schema9.optional(RunExecutionTarget),
@@ -1125,7 +1238,7 @@ var RuntimeSummary = Schema9.Struct({
   id: EngineRuntimeId,
   workspaceId: WorkspaceId,
   runId: RunId,
-  adapterKind: TrimmedNonEmptyString,
+  adapterKind: Schema9.Literal("pi"),
   executionTarget: Schema9.optional(RunExecutionTarget),
   remoteHostId: Schema9.optional(Schema9.NullOr(TrimmedNonEmptyString)),
   status: RuntimeStatus,
@@ -1252,7 +1365,7 @@ var WorkspaceRemoteHostSummary = Schema11.Struct({
   region: Schema11.NullOr(TrimmedNonEmptyString),
   labels: Schema11.Array(TrimmedNonEmptyString),
   capabilities: Schema11.Array(TrimmedNonEmptyString),
-  runtimeAdapters: Schema11.Array(TrimmedNonEmptyString),
+  runtimeAdapters: Schema11.Array(Schema11.Literal("pi")),
   status: WorkspaceRemoteHostStatus,
   currentLeaseCount: Schema11.Number,
   lastHeartbeatAt: Schema11.NullOr(IsoDateTime),
@@ -1293,7 +1406,7 @@ var WorkspaceSummary = Schema11.Struct({
   title: TrimmedNonEmptyString,
   rootPath: TrimmedNonEmptyString,
   sourceKind: WorkspaceSourceKind,
-  defaultRuntimeAdapter: Schema11.optional(TrimmedNonEmptyString),
+  defaultRuntimeAdapter: Schema11.optional(Schema11.Literal("pi")),
   defaultProvider: Schema11.optional(ProviderKind),
   defaultModel: Schema11.NullOr(TrimmedNonEmptyString),
   topology: Schema11.optional(WorkspaceTopologySummary),
@@ -1304,6 +1417,7 @@ var WorkspaceSummary = Schema11.Struct({
 });
 
 // packages/contracts/src/remote.ts
+var RemoteRuntimeAdapter = Schema12.Literal("pi");
 var RemoteEndpoint = Schema12.Struct({
   id: RemoteEndpointId,
   alias: TrimmedNonEmptyString,
@@ -1388,7 +1502,7 @@ var RemoteRunnerRegisterInput = Schema12.Struct({
   region: Schema12.optional(TrimmedNonEmptyString),
   labels: Schema12.optional(Schema12.Array(TrimmedNonEmptyString)),
   capabilities: Schema12.optional(Schema12.Array(TrimmedNonEmptyString)),
-  runtimeAdapters: Schema12.optional(Schema12.Array(TrimmedNonEmptyString)),
+  runtimeAdapters: Schema12.optional(Schema12.Array(RemoteRuntimeAdapter)),
   status: Schema12.optional(WorkspaceRemoteHostStatus),
   currentLeaseCount: Schema12.optional(Schema12.Number)
 });
@@ -1409,14 +1523,14 @@ var RemoteRunnerLifecycleResult = Schema12.Struct({
 var RemoteRunClaimInput = Schema12.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
-  runtimeAdapters: Schema12.optional(Schema12.Array(TrimmedNonEmptyString))
+  runtimeAdapters: Schema12.optional(Schema12.Array(RemoteRuntimeAdapter))
 });
 var RemoteRunLeaseSummary = Schema12.Struct({
   leaseId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   workspaceId: WorkspaceId,
   title: TrimmedNonEmptyString,
-  runtimeAdapter: TrimmedNonEmptyString,
+  runtimeAdapter: RemoteRuntimeAdapter,
   model: Schema12.NullOr(TrimmedNonEmptyString),
   runtimeMode: RuntimeMode,
   interactionMode: ProviderInteractionMode,
@@ -1434,7 +1548,7 @@ var RemoteRunExecutionBundle = Schema12.Struct({
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString,
   workspacePath: Schema12.NullOr(TrimmedNonEmptyString),
-  runtimeAdapter: TrimmedNonEmptyString,
+  runtimeAdapter: RemoteRuntimeAdapter,
   model: Schema12.NullOr(TrimmedNonEmptyString),
   runtimeMode: RuntimeMode,
   interactionMode: ProviderInteractionMode,
@@ -1595,7 +1709,7 @@ var EngineReadModel = Schema13.Struct({
   remoteOrchestrations: Schema13.Array(RemoteOrchestrationSummary),
   updatedAt: IsoDateTime
 });
-var RuntimeAdapterKind = Schema13.Literals(["codex", "claude-code", "pi"]);
+var RuntimeAdapterKind = Schema13.Literal("pi");
 var WorkspaceRegisterCommand = Schema13.Struct({
   type: Schema13.Literal("workspace.register"),
   commandId: CommandId,
@@ -1788,7 +1902,7 @@ var WorkspaceRegisterRemoteHostCommand = Schema13.Struct({
     region: Schema13.NullOr(TrimmedNonEmptyString),
     labels: Schema13.Array(TrimmedNonEmptyString),
     capabilities: Schema13.Array(TrimmedNonEmptyString),
-    runtimeAdapters: Schema13.Array(TrimmedNonEmptyString),
+    runtimeAdapters: Schema13.Array(RuntimeAdapterKind),
     status: Schema13.Literals([
       "registering",
       "ready",
@@ -2201,7 +2315,7 @@ var EngineRpcSchemas = {
   }
 };
 var EngineRuntimeDefaults = Schema13.Struct({
-  runtimeAdapter: TrimmedNonEmptyString,
+  runtimeAdapter: RuntimeAdapterKind,
   runMode: RunMode,
   sandboxMode: EngineSandboxMode,
   isolationMode: IsolationMode

package/dist/src/git.d.ts

@@ -0,0 +1,144 @@
+import { Schema } from "effect";
+export declare const GitStackedAction: Schema.Literals<readonly ["commit", "commit_push", "commit_push_pr"]>;
+export type GitStackedAction = typeof GitStackedAction.Type;
+export declare const GitBranch: Schema.Struct<{
+    readonly name: Schema.Trim;
+    readonly isRemote: Schema.optional<Schema.Boolean>;
+    readonly remoteName: Schema.optional<Schema.Trim>;
+    readonly current: Schema.Boolean;
+    readonly isDefault: Schema.Boolean;
+    readonly worktreePath: Schema.NullOr<Schema.Trim>;
+}>;
+export type GitBranch = typeof GitBranch.Type;
+export declare const GitStatusInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+}>;
+export type GitStatusInput = typeof GitStatusInput.Type;
+export declare const GitPullInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+}>;
+export type GitPullInput = typeof GitPullInput.Type;
+export declare const GitReadWorkingTreePatchInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly relativePath: Schema.optional<Schema.Trim>;
+}>;
+export type GitReadWorkingTreePatchInput = typeof GitReadWorkingTreePatchInput.Type;
+export declare const GitRunStackedActionInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly action: Schema.Literals<readonly ["commit", "commit_push", "commit_push_pr"]>;
+    readonly commitMessage: Schema.optional<Schema.Trim>;
+    readonly featureBranch: Schema.optional<Schema.Boolean>;
+}>;
+export type GitRunStackedActionInput = typeof GitRunStackedActionInput.Type;
+export declare const GitListBranchesInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+}>;
+export type GitListBranchesInput = typeof GitListBranchesInput.Type;
+export declare const GitCreateWorktreeInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly branch: Schema.Trim;
+    readonly newBranch: Schema.Trim;
+    readonly path: Schema.NullOr<Schema.Trim>;
+}>;
+export type GitCreateWorktreeInput = typeof GitCreateWorktreeInput.Type;
+export declare const GitRemoveWorktreeInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly path: Schema.Trim;
+    readonly force: Schema.optional<Schema.Boolean>;
+}>;
+export type GitRemoveWorktreeInput = typeof GitRemoveWorktreeInput.Type;
+export declare const GitCreateBranchInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly branch: Schema.Trim;
+}>;
+export type GitCreateBranchInput = typeof GitCreateBranchInput.Type;
+export declare const GitCheckoutInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly branch: Schema.Trim;
+}>;
+export type GitCheckoutInput = typeof GitCheckoutInput.Type;
+export declare const GitInitInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+}>;
+export type GitInitInput = typeof GitInitInput.Type;
+export declare const GitStatusResult: Schema.Struct<{
+    readonly branch: Schema.NullOr<Schema.Trim>;
+    readonly hasWorkingTreeChanges: Schema.Boolean;
+    readonly workingTree: Schema.Struct<{
+        readonly files: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.Trim;
+            readonly insertions: Schema.Int;
+            readonly deletions: Schema.Int;
+        }>>;
+        readonly insertions: Schema.Int;
+        readonly deletions: Schema.Int;
+    }>;
+    readonly hasUpstream: Schema.Boolean;
+    readonly aheadCount: Schema.Int;
+    readonly behindCount: Schema.Int;
+    readonly pr: Schema.NullOr<Schema.Struct<{
+        readonly number: Schema.Int;
+        readonly title: Schema.Trim;
+        readonly url: Schema.String;
+        readonly baseBranch: Schema.Trim;
+        readonly headBranch: Schema.Trim;
+        readonly state: Schema.Literals<readonly ["open", "closed", "merged"]>;
+    }>>;
+}>;
+export type GitStatusResult = typeof GitStatusResult.Type;
+export declare const GitListBranchesResult: Schema.Struct<{
+    readonly branches: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.Trim;
+        readonly isRemote: Schema.optional<Schema.Boolean>;
+        readonly remoteName: Schema.optional<Schema.Trim>;
+        readonly current: Schema.Boolean;
+        readonly isDefault: Schema.Boolean;
+        readonly worktreePath: Schema.NullOr<Schema.Trim>;
+    }>>;
+    readonly isRepo: Schema.Boolean;
+}>;
+export type GitListBranchesResult = typeof GitListBranchesResult.Type;
+export declare const GitCreateWorktreeResult: Schema.Struct<{
+    readonly worktree: Schema.Struct<{
+        readonly path: Schema.Trim;
+        readonly branch: Schema.Trim;
+    }>;
+}>;
+export type GitCreateWorktreeResult = typeof GitCreateWorktreeResult.Type;
+export declare const GitRunStackedActionResult: Schema.Struct<{
+    readonly action: Schema.Literals<readonly ["commit", "commit_push", "commit_push_pr"]>;
+    readonly branch: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["created", "skipped_not_requested"]>;
+        readonly name: Schema.optional<Schema.Trim>;
+    }>;
+    readonly commit: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["created", "skipped_no_changes"]>;
+        readonly commitSha: Schema.optional<Schema.Trim>;
+        readonly subject: Schema.optional<Schema.Trim>;
+    }>;
+    readonly push: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["pushed", "skipped_not_requested", "skipped_up_to_date"]>;
+        readonly branch: Schema.optional<Schema.Trim>;
+        readonly upstreamBranch: Schema.optional<Schema.Trim>;
+        readonly setUpstream: Schema.optional<Schema.Boolean>;
+    }>;
+    readonly pr: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["created", "opened_existing", "skipped_not_requested"]>;
+        readonly url: Schema.optional<Schema.String>;
+        readonly number: Schema.optional<Schema.Int>;
+        readonly baseBranch: Schema.optional<Schema.Trim>;
+        readonly headBranch: Schema.optional<Schema.Trim>;
+        readonly title: Schema.optional<Schema.Trim>;
+    }>;
+}>;
+export type GitRunStackedActionResult = typeof GitRunStackedActionResult.Type;
+export declare const GitPullResult: Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["pulled", "skipped_up_to_date"]>;
+    readonly branch: Schema.Trim;
+    readonly upstreamBranch: Schema.NullOr<Schema.Trim>;
+}>;
+export type GitPullResult = typeof GitPullResult.Type;
+export declare const GitReadWorkingTreePatchResult: Schema.Struct<{
+    readonly diff: Schema.String;
+}>;
+export type GitReadWorkingTreePatchResult = typeof GitReadWorkingTreePatchResult.Type;

package/dist/src/git.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");