@h-rig/contracts 0.0.0-e2e-live.20260630085347

package/dist/src/plugin.js

@@ -0,0 +1,384 @@
+// @bun
+// packages/contracts/src/plugin.ts
+import { Schema as Schema4 } from "effect";
+
+// 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/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// 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 Stage = StageDescriptor;
+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 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))
+});
+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
+});
+var PLACEMENT_RUN_TRANSPORT = makeCapabilityId("transport.placement-run");
+
+// packages/contracts/src/plugin.ts
+var ValidatorCategory = Schema4.Literals([
+  "boundary",
+  "contract",
+  "integration",
+  "regression",
+  "external",
+  "custom"
+]);
+var ValidatorRegistration = Schema4.Struct({
+  id: Schema4.String,
+  category: ValidatorCategory,
+  description: Schema4.optional(Schema4.String)
+});
+var AgentSessionHookEvent = Schema4.Literals([
+  "PreToolUse",
+  "PostToolUse",
+  "UserPromptSubmit",
+  "Stop",
+  "SessionStart",
+  "SessionEnd"
+]);
+var HookEvent = AgentSessionHookEvent;
+var HookMatcher = Schema4.Union([
+  Schema4.Struct({ kind: Schema4.Literal("all") }),
+  Schema4.Struct({ kind: Schema4.Literal("tool"), name: Schema4.String }),
+  Schema4.Struct({ kind: Schema4.Literal("glob"), pattern: Schema4.String })
+]);
+var HookRegistration = Schema4.Struct({
+  id: Schema4.String,
+  event: AgentSessionHookEvent,
+  matcher: HookMatcher,
+  command: Schema4.optional(Schema4.String),
+  description: Schema4.optional(Schema4.String)
+});
+var SkillRegistration = Schema4.Struct({
+  id: Schema4.String,
+  path: Schema4.String,
+  description: Schema4.optional(Schema4.String)
+});
+var RepoSourceRegistration = Schema4.Struct({
+  id: Schema4.String,
+  url: Schema4.String,
+  defaultPath: Schema4.optional(Schema4.String),
+  description: Schema4.optional(Schema4.String),
+  defaultBranch: Schema4.optional(Schema4.String),
+  remoteEnvVar: Schema4.optional(Schema4.String),
+  checkoutEnvVar: Schema4.optional(Schema4.String)
+});
+var AgentRoleRegistration = Schema4.Struct({
+  id: Schema4.String,
+  defaultModel: Schema4.optional(Schema4.String),
+  description: Schema4.optional(Schema4.String)
+});
+var TaskFieldExtension = Schema4.Struct({
+  id: Schema4.String,
+  fieldName: Schema4.String,
+  schemaJson: Schema4.String
+});
+var TaskSourceKind = Schema4.String;
+var TaskSourceRegistration = Schema4.Struct({
+  id: Schema4.String,
+  kind: Schema4.String,
+  description: Schema4.optional(Schema4.String)
+});
+var CliCommandRegistration = Schema4.Struct({
+  id: Schema4.String,
+  family: Schema4.optional(Schema4.String),
+  command: Schema4.optional(Schema4.String),
+  description: Schema4.optional(Schema4.String),
+  usage: Schema4.optional(Schema4.String),
+  aliases: Schema4.optional(Schema4.Array(Schema4.String)),
+  projectRequired: Schema4.optional(Schema4.Boolean),
+  rootDefault: Schema4.optional(Schema4.Boolean),
+  productRoot: Schema4.optional(Schema4.Boolean),
+  subcommands: Schema4.optional(Schema4.Array(Schema4.String))
+});
+var CapabilityRunSchema = Schema4.declare((u) => typeof u === "function", { identifier: "CapabilityRun" });
+var ProductCapabilityRegistration = Schema4.Struct({
+  id: Schema4.String,
+  title: Schema4.String,
+  description: Schema4.optional(Schema4.String),
+  commandId: Schema4.optional(Schema4.String),
+  panelId: Schema4.optional(Schema4.String),
+  run: Schema4.optional(CapabilityRunSchema)
+});
+var PanelRegistration = Schema4.Struct({
+  id: Schema4.String,
+  slot: Schema4.String,
+  title: Schema4.String,
+  capabilityId: Schema4.optional(Schema4.String),
+  badge: Schema4.optional(Schema4.String),
+  disabled: Schema4.optional(Schema4.Boolean),
+  description: Schema4.optional(Schema4.String)
+});
+var BlockerClassifierRegistration = Schema4.Struct({
+  id: Schema4.String,
+  description: Schema4.optional(Schema4.String),
+  priority: Schema4.optional(Schema4.Number)
+});
+var SessionExtensionRegistration = Schema4.Struct({
+  id: Schema4.String,
+  description: Schema4.optional(Schema4.String)
+});
+var SeedEntrypointRegistration = Schema4.Struct({
+  id: Schema4.String,
+  description: Schema4.optional(Schema4.String),
+  basename: Schema4.optional(Schema4.String),
+  workerArg: Schema4.optional(Schema4.String),
+  insidePty: Schema4.optional(Schema4.Boolean)
+});
+var PluginContributes = Schema4.Struct({
+  validators: Schema4.optional(Schema4.Array(ValidatorRegistration)),
+  hooks: Schema4.optional(Schema4.Array(HookRegistration)),
+  skills: Schema4.optional(Schema4.Array(SkillRegistration)),
+  repoSources: Schema4.optional(Schema4.Array(RepoSourceRegistration)),
+  agentRoles: Schema4.optional(Schema4.Array(AgentRoleRegistration)),
+  taskFieldSchemas: Schema4.optional(Schema4.Array(TaskFieldExtension)),
+  taskSources: Schema4.optional(Schema4.Array(TaskSourceRegistration)),
+  cliCommands: Schema4.optional(Schema4.Array(CliCommandRegistration)),
+  stages: Schema4.optional(Schema4.Array(Stage)),
+  stageMutations: Schema4.optional(Schema4.Array(StageMutation)),
+  capabilities: Schema4.optional(Schema4.Array(ProductCapabilityRegistration)),
+  panels: Schema4.optional(Schema4.Array(PanelRegistration)),
+  blockerClassifiers: Schema4.optional(Schema4.Array(BlockerClassifierRegistration)),
+  sessionExtensions: Schema4.optional(Schema4.Array(SessionExtensionRegistration)),
+  seedEntrypoints: Schema4.optional(Schema4.Array(SeedEntrypointRegistration))
+});
+var RigPlugin = Schema4.Struct({
+  name: Schema4.String,
+  version: Schema4.String,
+  provides: Schema4.optional(Schema4.Array(CapabilityTag)),
+  requires: Schema4.optional(Schema4.Array(CapabilityTag)),
+  replaces: Schema4.optional(Schema4.Array(CapabilityReplacementSpec)),
+  contributes: Schema4.optional(PluginContributes)
+});
+export {
+  ValidatorRegistration,
+  ValidatorCategory,
+  TaskSourceRegistration,
+  TaskSourceKind,
+  TaskFieldExtension,
+  SkillRegistration,
+  SessionExtensionRegistration,
+  SeedEntrypointRegistration,
+  RigPlugin,
+  RepoSourceRegistration,
+  ProductCapabilityRegistration,
+  PluginContributes,
+  PanelRegistration,
+  HookRegistration,
+  HookMatcher,
+  HookEvent,
+  CliCommandRegistration,
+  CapabilityRunSchema,
+  BlockerClassifierRegistration,
+  AgentSessionHookEvent,
+  AgentRoleRegistration
+};

package/dist/src/policy.d.ts

@@ -0,0 +1,16 @@
+import { Schema } from "effect";
+export declare const PolicyDecision: Schema.Literals<readonly ["allow", "warn", "block"]>;
+export type PolicyDecision = typeof PolicyDecision.Type;
+export declare const PolicyMode: Schema.Literals<readonly ["off", "observe", "enforce"]>;
+export type PolicyMode = typeof PolicyMode.Type;
+export declare const PolicyDecisionSummary: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly actionId: Schema.NullOr<Schema.brand<Schema.Trim, "ActionId">>;
+    readonly decision: Schema.Literals<readonly ["allow", "warn", "block"]>;
+    readonly mode: Schema.Literals<readonly ["off", "observe", "enforce"]>;
+    readonly matchedRules: Schema.$Array<Schema.Trim>;
+    readonly reason: Schema.String;
+    readonly createdAt: Schema.String;
+}>;
+export type PolicyDecisionSummary = typeof PolicyDecisionSummary.Type;

package/dist/src/policy.js

@@ -0,0 +1,59 @@
+// @bun
+// packages/contracts/src/policy.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/policy.ts
+var PolicyDecision = Schema2.Literals(["allow", "warn", "block"]);
+var PolicyMode = Schema2.Literals(["off", "observe", "enforce"]);
+var PolicyDecisionSummary = Schema2.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  actionId: Schema2.NullOr(ActionId),
+  decision: PolicyDecision,
+  mode: PolicyMode,
+  matchedRules: Schema2.Array(TrimmedNonEmptyString),
+  reason: Schema2.String,
+  createdAt: IsoDateTime
+});
+export {
+  PolicyMode,
+  PolicyDecisionSummary,
+  PolicyDecision
+};

package/dist/src/product-entrypoint.d.ts

@@ -0,0 +1,22 @@
+/**
+ * product-entrypoint.ts — pure capability vocabulary for product-owned session entrypoints.
+ *
+ * The implementation lives in @rig/product-entrypoint-plugin. CLI consumers resolve
+ * this capability from the project plugin host instead of importing product runtime
+ * entrypoint code directly.
+ */
+import type { CapabilityId } from "./capability-id";
+export interface ProductEntrypointJoinSessionInput {
+    readonly projectRoot: string;
+    readonly link: string;
+}
+export interface ProductEntrypointJoinSessionResult {
+    readonly ok: true;
+    readonly group: "product";
+    readonly command: "join";
+}
+export interface ProductEntrypointService {
+    readonly joinSession: (input: ProductEntrypointJoinSessionInput) => Promise<ProductEntrypointJoinSessionResult>;
+}
+export declare const PRODUCT_ENTRYPOINT_CAPABILITY_ID = "rig.product.entrypoint";
+export declare const PRODUCT_ENTRYPOINT: CapabilityId<ProductEntrypointService>;

package/dist/src/product-entrypoint.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/product-entrypoint.ts
+var PRODUCT_ENTRYPOINT_CAPABILITY_ID = "rig.product.entrypoint";
+var PRODUCT_ENTRYPOINT = makeCapabilityId(PRODUCT_ENTRYPOINT_CAPABILITY_ID);
+export {
+  PRODUCT_ENTRYPOINT_CAPABILITY_ID,
+  PRODUCT_ENTRYPOINT
+};

package/dist/src/project.d.ts

@@ -0,0 +1,71 @@
+import { Schema } from "effect";
+export declare const ProjectSearchEntriesInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly query: Schema.Trim;
+    readonly limit: Schema.Int;
+}>;
+export type ProjectSearchEntriesInput = typeof ProjectSearchEntriesInput.Type;
+export declare const ProjectEntry: Schema.Struct<{
+    readonly path: Schema.Trim;
+    readonly kind: Schema.Literals<readonly ["file", "directory"]>;
+    readonly parentPath: Schema.optional<Schema.Trim>;
+}>;
+export type ProjectEntry = typeof ProjectEntry.Type;
+export declare const ProjectSearchEntriesResult: Schema.Struct<{
+    readonly entries: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.Trim;
+        readonly kind: Schema.Literals<readonly ["file", "directory"]>;
+        readonly parentPath: Schema.optional<Schema.Trim>;
+    }>>;
+    readonly truncated: Schema.Boolean;
+}>;
+export type ProjectSearchEntriesResult = typeof ProjectSearchEntriesResult.Type;
+export declare const ProjectListDirectoryInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly relativePath: Schema.Trim;
+    readonly limit: Schema.Int;
+}>;
+export type ProjectListDirectoryInput = typeof ProjectListDirectoryInput.Type;
+export declare const ProjectDirectoryEntry: Schema.Struct<{
+    readonly name: Schema.Trim;
+    readonly relativePath: Schema.Trim;
+    readonly kind: Schema.Literals<readonly ["file", "directory"]>;
+    readonly sizeBytes: Schema.optional<Schema.Int>;
+    readonly modifiedAt: Schema.optional<Schema.String>;
+}>;
+export type ProjectDirectoryEntry = typeof ProjectDirectoryEntry.Type;
+export declare const ProjectListDirectoryResult: Schema.Struct<{
+    readonly entries: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.Trim;
+        readonly relativePath: Schema.Trim;
+        readonly kind: Schema.Literals<readonly ["file", "directory"]>;
+        readonly sizeBytes: Schema.optional<Schema.Int>;
+        readonly modifiedAt: Schema.optional<Schema.String>;
+    }>>;
+    readonly truncated: Schema.Boolean;
+}>;
+export type ProjectListDirectoryResult = typeof ProjectListDirectoryResult.Type;
+export declare const ProjectWriteFileInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly relativePath: Schema.Trim;
+    readonly contents: Schema.String;
+}>;
+export type ProjectWriteFileInput = typeof ProjectWriteFileInput.Type;
+export declare const ProjectWriteFileResult: Schema.Struct<{
+    readonly relativePath: Schema.Trim;
+}>;
+export type ProjectWriteFileResult = typeof ProjectWriteFileResult.Type;
+export declare const ProjectReadFileInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly relativePath: Schema.Trim;
+}>;
+export type ProjectReadFileInput = typeof ProjectReadFileInput.Type;
+export declare const ProjectReadFileResult: Schema.Struct<{
+    readonly relativePath: Schema.Trim;
+    readonly contents: Schema.String;
+    readonly truncated: Schema.Boolean;
+    readonly sizeBytes: Schema.Int;
+    readonly maxBytes: Schema.Int;
+}>;
+export type ProjectReadFileResult = typeof ProjectReadFileResult.Type;
+export declare const PROJECT_READ_FILE_MAX_BYTES_VALUE: number;

package/dist/src/project.js

@@ -0,0 +1,110 @@
+// @bun
+// packages/contracts/src/project.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/project.ts
+var PROJECT_SEARCH_ENTRIES_MAX_LIMIT = 200;
+var PROJECT_LIST_DIRECTORY_MAX_LIMIT = 500;
+var PROJECT_WRITE_FILE_PATH_MAX_LENGTH = 512;
+var PROJECT_READ_FILE_MAX_BYTES = 512 * 1024;
+var ProjectSearchEntriesInput = Schema2.Struct({
+  cwd: TrimmedNonEmptyString,
+  query: TrimmedNonEmptyString.check(Schema2.isMaxLength(256)),
+  limit: PositiveInt.check(Schema2.isLessThanOrEqualTo(PROJECT_SEARCH_ENTRIES_MAX_LIMIT))
+});
+var ProjectEntryKind = Schema2.Literals(["file", "directory"]);
+var ProjectEntry = Schema2.Struct({
+  path: TrimmedNonEmptyString,
+  kind: ProjectEntryKind,
+  parentPath: Schema2.optional(TrimmedNonEmptyString)
+});
+var ProjectSearchEntriesResult = Schema2.Struct({
+  entries: Schema2.Array(ProjectEntry),
+  truncated: Schema2.Boolean
+});
+var ProjectListDirectoryInput = Schema2.Struct({
+  cwd: TrimmedNonEmptyString,
+  relativePath: TrimmedNonEmptyString.check(Schema2.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH)),
+  limit: PositiveInt.check(Schema2.isLessThanOrEqualTo(PROJECT_LIST_DIRECTORY_MAX_LIMIT))
+});
+var ProjectDirectoryEntry = Schema2.Struct({
+  name: TrimmedNonEmptyString,
+  relativePath: TrimmedNonEmptyString,
+  kind: ProjectEntryKind,
+  sizeBytes: Schema2.optional(NonNegativeInt),
+  modifiedAt: Schema2.optional(Schema2.String)
+});
+var ProjectListDirectoryResult = Schema2.Struct({
+  entries: Schema2.Array(ProjectDirectoryEntry),
+  truncated: Schema2.Boolean
+});
+var ProjectWriteFileInput = Schema2.Struct({
+  cwd: TrimmedNonEmptyString,
+  relativePath: TrimmedNonEmptyString.check(Schema2.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH)),
+  contents: Schema2.String
+});
+var ProjectWriteFileResult = Schema2.Struct({
+  relativePath: TrimmedNonEmptyString
+});
+var ProjectReadFileInput = Schema2.Struct({
+  cwd: TrimmedNonEmptyString,
+  relativePath: TrimmedNonEmptyString.check(Schema2.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH))
+});
+var ProjectReadFileResult = Schema2.Struct({
+  relativePath: TrimmedNonEmptyString,
+  contents: Schema2.String,
+  truncated: Schema2.Boolean,
+  sizeBytes: NonNegativeInt,
+  maxBytes: PositiveInt
+});
+var PROJECT_READ_FILE_MAX_BYTES_VALUE = PROJECT_READ_FILE_MAX_BYTES;
+export {
+  ProjectWriteFileResult,
+  ProjectWriteFileInput,
+  ProjectSearchEntriesResult,
+  ProjectSearchEntriesInput,
+  ProjectReadFileResult,
+  ProjectReadFileInput,
+  ProjectListDirectoryResult,
+  ProjectListDirectoryInput,
+  ProjectEntry,
+  ProjectDirectoryEntry,
+  PROJECT_READ_FILE_MAX_BYTES_VALUE
+};