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

package/dist/src/drift.d.ts

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+export declare const DriftKind: Schema.Literals<readonly ["deleted-reference", "stale-anchor", "semantic-mismatch", "issue-mismatch"]>;
+export type DriftKind = typeof DriftKind.Type;
+export declare const DriftConfidence: Schema.Literals<readonly ["high", "medium", "low"]>;
+export type DriftConfidence = typeof DriftConfidence.Type;
+export declare const DriftFinding: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["deleted-reference", "stale-anchor", "semantic-mismatch", "issue-mismatch"]>;
+    readonly docPath: Schema.Trim;
+    readonly line: Schema.NullOr<Schema.Int>;
+    readonly reference: Schema.NullOr<Schema.Trim>;
+    readonly detail: Schema.String;
+    readonly confidence: Schema.Literals<readonly ["high", "medium", "low"]>;
+}>;
+export type DriftFinding = typeof DriftFinding.Type;
+export declare const DriftReport: Schema.Struct<{
+    readonly generatedAt: Schema.String;
+    readonly scanned: Schema.Int;
+    readonly degraded: Schema.Boolean;
+    readonly findings: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["deleted-reference", "stale-anchor", "semantic-mismatch", "issue-mismatch"]>;
+        readonly docPath: Schema.Trim;
+        readonly line: Schema.NullOr<Schema.Int>;
+        readonly reference: Schema.NullOr<Schema.Trim>;
+        readonly detail: Schema.String;
+        readonly confidence: Schema.Literals<readonly ["high", "medium", "low"]>;
+    }>>;
+}>;
+export type DriftReport = typeof DriftReport.Type;

package/dist/src/drift.js

@@ -0,0 +1,69 @@
+// @bun
+// packages/contracts/src/drift.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/drift.ts
+var DriftKind = Schema2.Literals([
+  "deleted-reference",
+  "stale-anchor",
+  "semantic-mismatch",
+  "issue-mismatch"
+]);
+var DriftConfidence = Schema2.Literals(["high", "medium", "low"]);
+var DriftFinding = Schema2.Struct({
+  kind: DriftKind,
+  docPath: TrimmedNonEmptyString,
+  line: Schema2.NullOr(PositiveInt),
+  reference: Schema2.NullOr(TrimmedNonEmptyString),
+  detail: Schema2.String,
+  confidence: DriftConfidence
+});
+var DriftReport = Schema2.Struct({
+  generatedAt: IsoDateTime,
+  scanned: NonNegativeInt,
+  degraded: Schema2.Boolean,
+  findings: Schema2.Array(DriftFinding)
+});
+export {
+  DriftReport,
+  DriftKind,
+  DriftFinding,
+  DriftConfidence
+};

package/dist/src/editor.d.ts

@@ -0,0 +1,25 @@
+import { Schema } from "effect";
+export declare const EDITORS: readonly [{
+    readonly id: "cursor";
+    readonly label: "Cursor";
+    readonly command: "cursor";
+}, {
+    readonly id: "vscode";
+    readonly label: "VS Code";
+    readonly command: "code";
+}, {
+    readonly id: "zed";
+    readonly label: "Zed";
+    readonly command: "zed";
+}, {
+    readonly id: "file-manager";
+    readonly label: "File Manager";
+    readonly command: null;
+}];
+export declare const EditorId: Schema.Literals<("cursor" | "vscode" | "zed" | "file-manager")[]>;
+export type EditorId = typeof EditorId.Type;
+export declare const OpenInEditorInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly editor: Schema.Literals<("cursor" | "vscode" | "zed" | "file-manager")[]>;
+}>;
+export type OpenInEditorInput = typeof OpenInEditorInput.Type;

package/dist/src/editor.js

@@ -0,0 +1,58 @@
+// @bun
+// packages/contracts/src/editor.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/editor.ts
+var EDITORS = [
+  { id: "cursor", label: "Cursor", command: "cursor" },
+  { id: "vscode", label: "VS Code", command: "code" },
+  { id: "zed", label: "Zed", command: "zed" },
+  { id: "file-manager", label: "File Manager", command: null }
+];
+var EditorId = Schema2.Literals(EDITORS.map((e) => e.id));
+var OpenInEditorInput = Schema2.Struct({
+  cwd: TrimmedNonEmptyString,
+  editor: EditorId
+});
+export {
+  OpenInEditorInput,
+  EditorId,
+  EDITORS
+};

package/dist/src/errors.d.ts

@@ -0,0 +1,13 @@
+export declare class CliError extends Error {
+    readonly exitCode: number;
+    /**
+     * Optional remediation hint. Rendered on its own `Next: <hint>` line (and
+     * carried in the `--json` error payload) so a failure can name the next
+     * command to run. Pure vocab — the exec machinery (now in @rig/guard-plugin)
+     * throws this with a hint without importing a CLI-seed error class.
+     */
+    readonly hint?: string;
+    constructor(message: string, exitCode?: number, options?: {
+        readonly hint?: string;
+    });
+}

package/dist/src/errors.js

@@ -0,0 +1,17 @@
+// @bun
+// packages/contracts/src/errors.ts
+class CliError extends Error {
+  exitCode;
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
+export {
+  CliError
+};

package/dist/src/git.d.ts

@@ -0,0 +1,152 @@
+import { Schema } from "effect";
+export declare const GitStackedAction: Schema.Literals<readonly ["commit", "commit_push", "commit_push_pr"]>;
+export type GitStackedAction = typeof GitStackedAction.Type;
+export type GitWorkingTreeFileStatus = "added" | "copied" | "deleted" | "modified" | "renamed" | "type_changed" | "untracked" | "conflicted" | "unknown";
+export interface GitWorkingTreeFileChange {
+    readonly path: string;
+    readonly status: GitWorkingTreeFileStatus;
+    readonly staged: boolean;
+    readonly unstaged: boolean;
+    readonly previousPath?: string;
+}
+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

@@ -0,0 +1,196 @@
+// @bun
+// packages/contracts/src/git.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/git.ts
+var TrimmedNonEmptyStringSchema = TrimmedNonEmptyString;
+var GitStackedAction = Schema2.Literals(["commit", "commit_push", "commit_push_pr"]);
+var GitCommitStepStatus = Schema2.Literals(["created", "skipped_no_changes"]);
+var GitPushStepStatus = Schema2.Literals([
+  "pushed",
+  "skipped_not_requested",
+  "skipped_up_to_date"
+]);
+var GitBranchStepStatus = Schema2.Literals(["created", "skipped_not_requested"]);
+var GitPrStepStatus = Schema2.Literals([
+  "created",
+  "opened_existing",
+  "skipped_not_requested"
+]);
+var GitStatusPrState = Schema2.Literals(["open", "closed", "merged"]);
+var GitBranch = Schema2.Struct({
+  name: TrimmedNonEmptyStringSchema,
+  isRemote: Schema2.optional(Schema2.Boolean),
+  remoteName: Schema2.optional(TrimmedNonEmptyStringSchema),
+  current: Schema2.Boolean,
+  isDefault: Schema2.Boolean,
+  worktreePath: TrimmedNonEmptyStringSchema.pipe(Schema2.NullOr)
+});
+var GitWorktree = Schema2.Struct({
+  path: TrimmedNonEmptyStringSchema,
+  branch: TrimmedNonEmptyStringSchema
+});
+var GitStatusInput = Schema2.Struct({
+  cwd: TrimmedNonEmptyStringSchema
+});
+var GitPullInput = Schema2.Struct({
+  cwd: TrimmedNonEmptyStringSchema
+});
+var GitReadWorkingTreePatchInput = Schema2.Struct({
+  cwd: TrimmedNonEmptyStringSchema,
+  relativePath: Schema2.optional(TrimmedNonEmptyStringSchema)
+});
+var GitRunStackedActionInput = Schema2.Struct({
+  cwd: TrimmedNonEmptyStringSchema,
+  action: GitStackedAction,
+  commitMessage: Schema2.optional(TrimmedNonEmptyStringSchema.check(Schema2.isMaxLength(1e4))),
+  featureBranch: Schema2.optional(Schema2.Boolean)
+});
+var GitListBranchesInput = Schema2.Struct({
+  cwd: TrimmedNonEmptyStringSchema
+});
+var GitCreateWorktreeInput = Schema2.Struct({
+  cwd: TrimmedNonEmptyStringSchema,
+  branch: TrimmedNonEmptyStringSchema,
+  newBranch: TrimmedNonEmptyStringSchema,
+  path: Schema2.NullOr(TrimmedNonEmptyStringSchema)
+});
+var GitRemoveWorktreeInput = Schema2.Struct({
+  cwd: TrimmedNonEmptyStringSchema,
+  path: TrimmedNonEmptyStringSchema,
+  force: Schema2.optional(Schema2.Boolean)
+});
+var GitCreateBranchInput = Schema2.Struct({
+  cwd: TrimmedNonEmptyStringSchema,
+  branch: TrimmedNonEmptyStringSchema
+});
+var GitCheckoutInput = Schema2.Struct({
+  cwd: TrimmedNonEmptyStringSchema,
+  branch: TrimmedNonEmptyStringSchema
+});
+var GitInitInput = Schema2.Struct({
+  cwd: TrimmedNonEmptyStringSchema
+});
+var GitStatusPr = Schema2.Struct({
+  number: PositiveInt,
+  title: TrimmedNonEmptyStringSchema,
+  url: Schema2.String,
+  baseBranch: TrimmedNonEmptyStringSchema,
+  headBranch: TrimmedNonEmptyStringSchema,
+  state: GitStatusPrState
+});
+var GitStatusResult = Schema2.Struct({
+  branch: TrimmedNonEmptyStringSchema.pipe(Schema2.NullOr),
+  hasWorkingTreeChanges: Schema2.Boolean,
+  workingTree: Schema2.Struct({
+    files: Schema2.Array(Schema2.Struct({
+      path: TrimmedNonEmptyStringSchema,
+      insertions: NonNegativeInt,
+      deletions: NonNegativeInt
+    })),
+    insertions: NonNegativeInt,
+    deletions: NonNegativeInt
+  }),
+  hasUpstream: Schema2.Boolean,
+  aheadCount: NonNegativeInt,
+  behindCount: NonNegativeInt,
+  pr: Schema2.NullOr(GitStatusPr)
+});
+var GitListBranchesResult = Schema2.Struct({
+  branches: Schema2.Array(GitBranch),
+  isRepo: Schema2.Boolean
+});
+var GitCreateWorktreeResult = Schema2.Struct({
+  worktree: GitWorktree
+});
+var GitRunStackedActionResult = Schema2.Struct({
+  action: GitStackedAction,
+  branch: Schema2.Struct({
+    status: GitBranchStepStatus,
+    name: Schema2.optional(TrimmedNonEmptyStringSchema)
+  }),
+  commit: Schema2.Struct({
+    status: GitCommitStepStatus,
+    commitSha: Schema2.optional(TrimmedNonEmptyStringSchema),
+    subject: Schema2.optional(TrimmedNonEmptyStringSchema)
+  }),
+  push: Schema2.Struct({
+    status: GitPushStepStatus,
+    branch: Schema2.optional(TrimmedNonEmptyStringSchema),
+    upstreamBranch: Schema2.optional(TrimmedNonEmptyStringSchema),
+    setUpstream: Schema2.optional(Schema2.Boolean)
+  }),
+  pr: Schema2.Struct({
+    status: GitPrStepStatus,
+    url: Schema2.optional(Schema2.String),
+    number: Schema2.optional(PositiveInt),
+    baseBranch: Schema2.optional(TrimmedNonEmptyStringSchema),
+    headBranch: Schema2.optional(TrimmedNonEmptyStringSchema),
+    title: Schema2.optional(TrimmedNonEmptyStringSchema)
+  })
+});
+var GitPullResult = Schema2.Struct({
+  status: Schema2.Literals(["pulled", "skipped_up_to_date"]),
+  branch: TrimmedNonEmptyStringSchema,
+  upstreamBranch: TrimmedNonEmptyStringSchema.pipe(Schema2.NullOr)
+});
+var GitReadWorkingTreePatchResult = Schema2.Struct({
+  diff: Schema2.String
+});
+export {
+  GitStatusResult,
+  GitStatusInput,
+  GitStackedAction,
+  GitRunStackedActionResult,
+  GitRunStackedActionInput,
+  GitRemoveWorktreeInput,
+  GitReadWorkingTreePatchResult,
+  GitReadWorkingTreePatchInput,
+  GitPullResult,
+  GitPullInput,
+  GitListBranchesResult,
+  GitListBranchesInput,
+  GitInitInput,
+  GitCreateWorktreeResult,
+  GitCreateWorktreeInput,
+  GitCreateBranchInput,
+  GitCheckoutInput,
+  GitBranch
+};