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

package/dist/src/kernel.js

@@ -0,0 +1,269 @@
+// @bun
+// packages/contracts/src/kernel.ts
+import { Schema as Schema3 } 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/stage.ts
+import { Schema as Schema2 } from "effect";
+var StageKind = Schema2.Literals(["transform", "gate", "observe"]);
+var StageId = TrimmedNonEmptyString.pipe(Schema2.brand("StageId"));
+var StageContext = Schema2.Struct({
+  runId: RunId,
+  taskId: Schema2.optional(Schema2.NullOr(TaskId)),
+  state: Schema2.Unknown,
+  metadata: Schema2.optional(Schema2.Record(Schema2.String, Schema2.Unknown))
+});
+var StageDescriptor = Schema2.Struct({
+  id: StageId,
+  kind: StageKind,
+  before: Schema2.optional(Schema2.Array(StageId)),
+  after: Schema2.optional(Schema2.Array(StageId)),
+  priority: Schema2.Number.pipe(Schema2.withDecodingDefault(() => 0)),
+  protected: Schema2.Boolean.pipe(Schema2.withDecodingDefault(() => false))
+});
+var StageContinueResult = Schema2.Struct({
+  kind: Schema2.Literal("continue"),
+  ctx: StageContext
+});
+var StageAllowResult = Schema2.Struct({
+  kind: Schema2.Literal("allow")
+});
+var StageBlockResult = Schema2.Struct({
+  kind: Schema2.Literal("block"),
+  reason: TrimmedNonEmptyString
+});
+var StageResult = Schema2.Union([
+  StageContinueResult,
+  StageAllowResult,
+  StageBlockResult
+]);
+var StageWrapperDescriptor = Schema2.Struct({
+  id: TrimmedNonEmptyString,
+  priority: Schema2.Number.pipe(Schema2.withDecodingDefault(() => 0))
+});
+var StageMutationOp = Schema2.Literals(["insert", "remove", "replace", "wrap", "reorder"]);
+var InsertStageMutation = Schema2.Struct({
+  op: Schema2.Literal("insert"),
+  stage: StageDescriptor,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var RemoveStageMutation = Schema2.Struct({
+  op: Schema2.Literal("remove"),
+  id: StageId,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var ReplaceStageMutation = Schema2.Struct({
+  op: Schema2.Literal("replace"),
+  id: StageId,
+  stage: StageDescriptor,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var WrapStageMutation = Schema2.Struct({
+  op: Schema2.Literal("wrap"),
+  id: StageId,
+  around: StageWrapperDescriptor,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var ReorderStageMutation = Schema2.Struct({
+  op: Schema2.Literal("reorder"),
+  id: StageId,
+  before: Schema2.optional(Schema2.Array(StageId)),
+  after: Schema2.optional(Schema2.Array(StageId)),
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var StageMutation = Schema2.Union([
+  InsertStageMutation,
+  RemoveStageMutation,
+  ReplaceStageMutation,
+  WrapStageMutation,
+  ReorderStageMutation
+]);
+var ResolutionGrantUse = Schema2.Struct({
+  kind: Schema2.Literal("kernel-replacement"),
+  target: TrimmedNonEmptyString,
+  pluginId: TrimmedNonEmptyString
+});
+var ResolutionRecordEntry = Schema2.Struct({
+  stageId: StageId,
+  contributedBy: TrimmedNonEmptyString,
+  removedBy: Schema2.optional(TrimmedNonEmptyString),
+  replacedBy: Schema2.optional(TrimmedNonEmptyString),
+  wrappedBy: Schema2.optional(Schema2.Array(TrimmedNonEmptyString)),
+  droppedAnchors: Schema2.optional(Schema2.Array(StageId)),
+  isProtected: Schema2.Boolean
+});
+var ResolvedPipeline = Schema2.Struct({
+  runId: Schema2.optional(RunId),
+  order: Schema2.Array(StageId),
+  record: Schema2.Array(ResolutionRecordEntry),
+  cycles: Schema2.Array(Schema2.Array(StageId)),
+  grantUses: Schema2.optional(Schema2.Array(ResolutionGrantUse)),
+  resolvedAt: Schema2.optional(IsoDateTime)
+});
+var StageRunOutcome = Schema2.Struct({
+  stageId: StageId,
+  result: StageResult,
+  startedAt: IsoDateTime,
+  finishedAt: IsoDateTime
+});
+
+// packages/contracts/src/kernel.ts
+var CapabilityTag = Schema3.Literals([
+  "kernel",
+  "journal",
+  "stage-runner",
+  "transport",
+  "loader-policy"
+]);
+var CapabilityProviderRef = Schema3.Struct({
+  capability: CapabilityTag,
+  pluginId: TrimmedNonEmptyString
+});
+var CapabilityReplacement = Schema3.Struct({
+  capability: CapabilityTag,
+  providerPluginId: TrimmedNonEmptyString
+});
+var CapabilityReplacementSpec = Schema3.Union([
+  CapabilityReplacement,
+  TrimmedNonEmptyString
+]);
+var PluginMeta = Schema3.Struct({
+  id: TrimmedNonEmptyString,
+  version: TrimmedNonEmptyString,
+  provides: Schema3.Array(CapabilityTag),
+  requires: Schema3.optional(Schema3.Array(CapabilityTag)),
+  replaces: Schema3.optional(Schema3.Array(CapabilityReplacementSpec))
+});
+var LoadedPluginDescriptor = Schema3.Struct({
+  meta: PluginMeta,
+  provides: Schema3.Array(CapabilityTag),
+  contributes: Schema3.Unknown,
+  runtime: Schema3.Unknown
+});
+var KernelReplacementGrant = Schema3.Struct({
+  pluginId: TrimmedNonEmptyString,
+  grantedBy: Schema3.optional(TrimmedNonEmptyString),
+  reason: Schema3.optional(Schema3.String)
+});
+var CapabilityGrants = Schema3.Struct({
+  capabilityPrecedence: Schema3.optional(Schema3.Record(Schema3.String, Schema3.Array(TrimmedNonEmptyString))),
+  kernelReplacementGrants: Schema3.optional(Schema3.Array(KernelReplacementGrant))
+});
+var KernelBootErrorCode = Schema3.Literals([
+  "BootIncoherent",
+  "AmbiguousCapability",
+  "MissingCapability",
+  "KernelReplacementDenied",
+  "PipelineUnresolvable"
+]);
+var KernelBootError = Schema3.Struct({
+  code: KernelBootErrorCode,
+  message: TrimmedNonEmptyString,
+  capability: Schema3.optional(CapabilityTag),
+  stageId: Schema3.optional(TrimmedNonEmptyString),
+  pluginIds: Schema3.optional(Schema3.Array(TrimmedNonEmptyString))
+});
+
+class BootIncoherent extends Error {
+  code = "BootIncoherent";
+}
+
+class AmbiguousCapability extends Error {
+  code = "AmbiguousCapability";
+}
+
+class MissingCapability extends Error {
+  code = "MissingCapability";
+}
+
+class KernelReplacementDenied extends Error {
+  code = "KernelReplacementDenied";
+}
+
+class PipelineUnresolvable extends Error {
+  code = "PipelineUnresolvable";
+}
+var CapabilityResolutionStatus = Schema3.Literals(["resolved", "ambiguous", "missing", "replaced"]);
+var CapabilityResolutionRecord = Schema3.Struct({
+  capability: CapabilityTag,
+  status: CapabilityResolutionStatus,
+  selectedPluginId: Schema3.NullOr(TrimmedNonEmptyString),
+  candidatePluginIds: Schema3.Array(TrimmedNonEmptyString),
+  precedenceUsed: Schema3.Boolean,
+  replacementUsed: Schema3.optional(CapabilityReplacement),
+  error: Schema3.optional(Schema3.String)
+});
+var KernelResolutionRecord = Schema3.Struct({
+  resolvedAt: IsoDateTime,
+  capabilities: Schema3.Array(CapabilityResolutionRecord),
+  pipeline: Schema3.optional(ResolvedPipeline)
+});
+var BootResultDescriptor = Schema3.Struct({
+  kernelPluginId: TrimmedNonEmptyString,
+  pluginIds: Schema3.Array(TrimmedNonEmptyString),
+  resolution: KernelResolutionRecord
+});
+var JournalEvent = Schema3.Struct({
+  type: TrimmedNonEmptyString,
+  runId: Schema3.optional(RunId),
+  at: IsoDateTime,
+  payload: Schema3.Unknown
+});
+export {
+  PluginMeta,
+  PipelineUnresolvable,
+  MissingCapability,
+  LoadedPluginDescriptor,
+  KernelResolutionRecord,
+  KernelReplacementGrant,
+  KernelReplacementDenied,
+  KernelBootErrorCode,
+  KernelBootError,
+  JournalEvent,
+  CapabilityTag,
+  CapabilityResolutionStatus,
+  CapabilityResolutionRecord,
+  CapabilityReplacementSpec,
+  CapabilityReplacement,
+  CapabilityProviderRef,
+  CapabilityGrants,
+  BootResultDescriptor,
+  BootIncoherent,
+  AmbiguousCapability
+};

package/dist/src/keybindings.d.ts

@@ -0,0 +1,71 @@
+import { Schema } from "effect";
+export declare const MAX_KEYBINDING_VALUE_LENGTH = 64;
+export declare const MAX_WHEN_EXPRESSION_DEPTH = 64;
+export declare const MAX_SCRIPT_ID_LENGTH = 24;
+export declare const MAX_KEYBINDINGS_COUNT = 256;
+export declare const SCRIPT_RUN_COMMAND_PATTERN: Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>;
+export declare const KeybindingCommand: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+export type KeybindingCommand = typeof KeybindingCommand.Type;
+export declare const KeybindingRule: Schema.Struct<{
+    readonly key: Schema.Trim;
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+    readonly when: Schema.optional<Schema.Trim>;
+}>;
+export type KeybindingRule = typeof KeybindingRule.Type;
+export declare const KeybindingsConfig: Schema.$Array<Schema.Struct<{
+    readonly key: Schema.Trim;
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+    readonly when: Schema.optional<Schema.Trim>;
+}>>;
+export type KeybindingsConfig = typeof KeybindingsConfig.Type;
+export declare const KeybindingShortcut: Schema.Struct<{
+    readonly key: Schema.Trim;
+    readonly metaKey: Schema.Boolean;
+    readonly ctrlKey: Schema.Boolean;
+    readonly shiftKey: Schema.Boolean;
+    readonly altKey: Schema.Boolean;
+    readonly modKey: Schema.Boolean;
+}>;
+export type KeybindingShortcut = typeof KeybindingShortcut.Type;
+export declare const KeybindingWhenNode: Schema.Schema<KeybindingWhenNode>;
+export type KeybindingWhenNode = {
+    type: "identifier";
+    name: string;
+} | {
+    type: "not";
+    node: KeybindingWhenNode;
+} | {
+    type: "and";
+    left: KeybindingWhenNode;
+    right: KeybindingWhenNode;
+} | {
+    type: "or";
+    left: KeybindingWhenNode;
+    right: KeybindingWhenNode;
+};
+export declare const ResolvedKeybindingRule: Schema.Struct<{
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+    readonly shortcut: Schema.Struct<{
+        readonly key: Schema.Trim;
+        readonly metaKey: Schema.Boolean;
+        readonly ctrlKey: Schema.Boolean;
+        readonly shiftKey: Schema.Boolean;
+        readonly altKey: Schema.Boolean;
+        readonly modKey: Schema.Boolean;
+    }>;
+    readonly whenAst: Schema.optional<Schema.Schema<KeybindingWhenNode>>;
+}>;
+export type ResolvedKeybindingRule = typeof ResolvedKeybindingRule.Type;
+export declare const ResolvedKeybindingsConfig: Schema.$Array<Schema.Struct<{
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+    readonly shortcut: Schema.Struct<{
+        readonly key: Schema.Trim;
+        readonly metaKey: Schema.Boolean;
+        readonly ctrlKey: Schema.Boolean;
+        readonly shiftKey: Schema.Boolean;
+        readonly altKey: Schema.Boolean;
+        readonly modKey: Schema.Boolean;
+    }>;
+    readonly whenAst: Schema.optional<Schema.Schema<KeybindingWhenNode>>;
+}>>;
+export type ResolvedKeybindingsConfig = typeof ResolvedKeybindingsConfig.Type;

package/dist/src/keybindings.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/model.d.ts

@@ -0,0 +1,77 @@
+import { Schema } from "effect";
+import { ProviderKind } from "./orchestration";
+export declare const CODEX_REASONING_EFFORT_OPTIONS: readonly ["xhigh", "high", "medium", "low"];
+export type CodexReasoningEffort = (typeof CODEX_REASONING_EFFORT_OPTIONS)[number];
+export declare const CodexModelOptions: Schema.Struct<{
+    readonly reasoningEffort: Schema.optional<Schema.Literals<readonly ["xhigh", "high", "medium", "low"]>>;
+    readonly fastMode: Schema.optional<Schema.Boolean>;
+}>;
+export type CodexModelOptions = typeof CodexModelOptions.Type;
+export declare const ClaudeModelOptions: Schema.Struct<{}>;
+export type ClaudeModelOptions = typeof ClaudeModelOptions.Type;
+export declare const ProviderModelOptions: Schema.Struct<{
+    readonly codex: Schema.optional<Schema.Struct<{
+        readonly reasoningEffort: Schema.optional<Schema.Literals<readonly ["xhigh", "high", "medium", "low"]>>;
+        readonly fastMode: Schema.optional<Schema.Boolean>;
+    }>>;
+    readonly claude: Schema.optional<Schema.Struct<{}>>;
+}>;
+export type ProviderModelOptions = typeof ProviderModelOptions.Type;
+export declare const MODEL_OPTIONS_BY_PROVIDER: {
+    readonly codex: readonly [{
+        readonly slug: "gpt-5.4";
+        readonly name: "GPT-5.4";
+    }, {
+        readonly slug: "gpt-5.3-codex";
+        readonly name: "GPT-5.3 Codex";
+    }, {
+        readonly slug: "gpt-5.3-codex-spark";
+        readonly name: "GPT-5.3 Codex Spark";
+    }, {
+        readonly slug: "gpt-5.2-codex";
+        readonly name: "GPT-5.2 Codex";
+    }, {
+        readonly slug: "gpt-5.2";
+        readonly name: "GPT-5.2";
+    }];
+    readonly claude: readonly [{
+        readonly slug: "claude-sonnet-4-6";
+        readonly name: "Claude Sonnet 4.6";
+    }, {
+        readonly slug: "claude-opus-4-1";
+        readonly name: "Claude Opus 4.1";
+    }, {
+        readonly slug: "claude-3-7-sonnet-latest";
+        readonly name: "Claude 3.7 Sonnet";
+    }];
+};
+export type ModelOptionsByProvider = typeof MODEL_OPTIONS_BY_PROVIDER;
+type BuiltInModelSlug = ModelOptionsByProvider[ProviderKind][number]["slug"];
+export type ModelSlug = BuiltInModelSlug | (string & {});
+export declare const DEFAULT_MODEL_BY_PROVIDER: {
+    readonly codex: "gpt-5.4";
+    readonly claude: "claude-sonnet-4-6";
+};
+export declare const MODEL_SLUG_ALIASES_BY_PROVIDER: {
+    readonly codex: {
+        readonly "5.4": "gpt-5.4";
+        readonly "5.3": "gpt-5.3-codex";
+        readonly "gpt-5.3": "gpt-5.3-codex";
+        readonly "5.3-spark": "gpt-5.3-codex-spark";
+        readonly "gpt-5.3-spark": "gpt-5.3-codex-spark";
+    };
+    readonly claude: {
+        readonly sonnet: "claude-sonnet-4-6";
+        readonly opus: "claude-opus-4-1";
+        readonly "3.7-sonnet": "claude-3-7-sonnet-latest";
+    };
+};
+export declare const REASONING_EFFORT_OPTIONS_BY_PROVIDER: {
+    readonly codex: readonly ["xhigh", "high", "medium", "low"];
+    readonly claude: readonly [];
+};
+export declare const DEFAULT_REASONING_EFFORT_BY_PROVIDER: {
+    readonly codex: "high";
+    readonly claude: null;
+};
+export {};