t3code-cli 0.12.0 → 0.14.0

package/dist/client-runtime/state/vcs.d.ts

@@ -0,0 +1,442 @@
+import { $T as ThreadId, AS as GitPullRequestMaterializationError, BS as TextGenerationError, Ca as EnvironmentCacheStore, ES as GitManagerError, FS as GitRunStackedActionResult, Fl as ServerConfig, KS as VcsListRefsInput, PS as GitRunStackedActionInput, TS as GitCommandError, XS as VcsRef$1, _ as AtomCommandResult, _a as EnvironmentSupervisor, bS as VcsUnsupportedOperationError, bT as EnvironmentAuthorizationError, ba as ConnectionPersistenceError, cv as OrchestrationShellSnapshot, dS as VcsProcessOutputReadError, f as AtomCommand, fS as VcsProcessSpawnError, gv as OrchestrationThreadDetailSnapshot, hC as SourceControlProviderError, hS as VcsProcessTimeoutError, ha as EnvironmentRegistry, lS as VcsProcessMissingExitCodeError, mS as VcsProcessStdinWriteError, ma as EnvironmentNotRegisteredError, oS as VcsProcessExitError, on as EnvironmentRpcUnavailableError, qS as VcsListRefsResult, tC as VcsStatusResult, uS as VcsProcessOutputLimitError, vS as VcsRepositoryDetectionError, xS as GitActionProgressEvent, zS as GitStackedAction, zT as EnvironmentId } from "../../shared.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Schema from "effect/Schema";
+import * as Option from "effect/Option";
+import * as Cause from "effect/Cause";
+import { Atom, AtomRegistry } from "effect/unstable/reactivity";
+//#region upstream-t3code/packages/client-runtime/src/state/gitActions.d.ts
+type GitActionIconName = "commit" | "push" | "pr";
+type GitDialogAction = "commit" | "push" | "create_pr";
+interface GitActionMenuItem {
+  id: "commit" | "push" | "pr";
+  label: string;
+  disabled: boolean;
+  icon: GitActionIconName;
+  kind: "open_dialog" | "open_pr";
+  dialogAction?: GitDialogAction;
+}
+interface GitQuickAction {
+  label: string;
+  disabled: boolean;
+  kind: "run_action" | "run_pull" | "open_pr" | "show_hint";
+  action?: GitStackedAction;
+  hint?: string;
+}
+interface DefaultBranchActionDialogCopy {
+  title: string;
+  description: string;
+  continueLabel: string;
+}
+type DefaultBranchConfirmableAction = "push" | "create_pr" | "commit_push" | "commit_push_pr";
+type GitActionRequestInput = Pick<GitRunStackedActionInput, "action" | "commitMessage" | "featureBranch" | "filePaths">;
+declare function buildGitActionProgressStages(input: {
+  action: GitStackedAction;
+  hasCustomCommitMessage: boolean;
+  hasWorkingTreeChanges: boolean;
+  pushTarget?: string;
+  featureBranch?: boolean;
+  shouldPushBeforePr?: boolean;
+}): string[];
+declare function buildMenuItems(gitStatus: VcsStatusResult | null, isBusy: boolean, hasOriginRemote?: boolean): GitActionMenuItem[];
+declare function resolveQuickAction(gitStatus: VcsStatusResult | null, isBusy: boolean, isDefaultBranch?: boolean, hasOriginRemote?: boolean): GitQuickAction;
+declare function getGitActionDisabledReason(input: {
+  item: GitActionMenuItem;
+  gitStatus: VcsStatusResult | null;
+  isBusy: boolean;
+  hasOriginRemote: boolean;
+}): string | null;
+declare function requiresDefaultBranchConfirmation(action: GitStackedAction, isDefaultBranch: boolean): boolean;
+declare function resolveDefaultBranchActionDialogCopy(input: {
+  action: DefaultBranchConfirmableAction;
+  branchName: string;
+  includesCommit: boolean;
+}): DefaultBranchActionDialogCopy;
+declare function resolveThreadBranchUpdate(result: GitRunStackedActionResult): {
+  branch: string;
+} | null;
+declare function resolveLiveThreadBranchUpdate(input: {
+  threadBranch: string | null;
+  gitStatus: VcsStatusResult | null;
+}): {
+  branch: string | null;
+} | null;
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/vcsAction.d.ts
+declare const VcsActionOperation: Schema.Literals<readonly ["refresh_status", "run_change_request", "pull", "switch_ref", "create_ref", "create_worktree", "init", "publish_repository", "prepare_pull_request_thread"]>;
+type VcsActionOperation = typeof VcsActionOperation.Type;
+interface VcsActionState {
+  readonly isRunning: boolean;
+  readonly operation: VcsActionOperation | null;
+  readonly actionId: string | null;
+  readonly action: GitStackedAction | null;
+  readonly currentLabel: string | null;
+  readonly currentPhaseLabel: string | null;
+  readonly hookName: string | null;
+  readonly lastOutputLine: string | null;
+  readonly phaseStartedAtMs: number | null;
+  readonly hookStartedAtMs: number | null;
+  readonly error: string | null;
+}
+interface VcsActionTarget {
+  readonly environmentId: EnvironmentId | null;
+  readonly cwd: string | null;
+}
+interface ResolvedVcsActionTarget {
+  readonly environmentId: EnvironmentId;
+  readonly cwd: string;
+}
+interface BeginVcsActionInput {
+  readonly operation: VcsActionOperation;
+  readonly label: string;
+  readonly actionId?: string;
+}
+interface RunVcsStackedActionInput {
+  readonly actionId: string;
+  readonly action: GitStackedAction;
+  readonly commitMessage?: string;
+  readonly featureBranch?: boolean;
+  readonly filePaths?: ReadonlyArray<string>;
+  readonly onProgress?: (event: GitActionProgressEvent) => void;
+}
+declare const VcsActionUnavailableError_base: Schema.Class<VcsActionUnavailableError, Schema.TaggedStruct<"VcsActionUnavailableError", {
+  readonly operation: Schema.Literals<readonly ["refresh_status", "run_change_request", "pull", "switch_ref", "create_ref", "create_worktree", "init", "publish_repository", "prepare_pull_request_thread"]>;
+  readonly environmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+  readonly cwd: Schema.NullOr<Schema.String>;
+}>, Cause.YieldableError>;
+declare class VcsActionUnavailableError extends VcsActionUnavailableError_base {
+  get message(): string;
+}
+declare const VcsActionRemoteFailureError_base: Schema.Class<VcsActionRemoteFailureError, Schema.TaggedStruct<"VcsActionRemoteFailureError", {
+  readonly actionId: Schema.String;
+  readonly transportActionId: Schema.String;
+  readonly action: Schema.Literals<readonly ["commit", "push", "create_pr", "commit_push", "commit_push_pr"]>;
+  readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+  readonly cwd: Schema.String;
+  readonly phase: Schema.NullOr<Schema.Literals<readonly ["branch", "commit", "push", "pr"]>>;
+  readonly remoteMessageLength: Schema.Number;
+}>, Cause.YieldableError>;
+declare class VcsActionRemoteFailureError extends VcsActionRemoteFailureError_base {
+  get message(): string;
+}
+declare const VcsActionMissingTerminalEventError_base: Schema.Class<VcsActionMissingTerminalEventError, Schema.TaggedStruct<"VcsActionMissingTerminalEventError", {
+  readonly actionId: Schema.String;
+  readonly transportActionId: Schema.String;
+  readonly action: Schema.Literals<readonly ["commit", "push", "create_pr", "commit_push", "commit_push_pr"]>;
+  readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+  readonly cwd: Schema.String;
+}>, Cause.YieldableError>;
+declare class VcsActionMissingTerminalEventError extends VcsActionMissingTerminalEventError_base {
+  get message(): string;
+}
+declare const VcsActionTargetKeyParseError_base: Schema.Class<VcsActionTargetKeyParseError, Schema.TaggedStruct<"VcsActionTargetKeyParseError", {
+  readonly keyLength: Schema.Number;
+  readonly cause: Schema.Defect;
+}>, Cause.YieldableError>;
+declare class VcsActionTargetKeyParseError extends VcsActionTargetKeyParseError_base {
+  get message(): string;
+}
+declare const VcsActionExecutionError: Schema.Union<readonly [typeof VcsActionRemoteFailureError, typeof VcsActionMissingTerminalEventError]>;
+type VcsActionExecutionError = typeof VcsActionExecutionError.Type;
+declare const EMPTY_VCS_ACTION_STATE: Readonly<VcsActionState>;
+declare const vcsActionStateAtom: (arg: string) => Atom.Writable<Readonly<VcsActionState>, Readonly<VcsActionState>>;
+declare const EMPTY_VCS_ACTION_ATOM: Atom.Writable<Readonly<VcsActionState>, Readonly<VcsActionState>>;
+declare function getVcsActionTargetKey(target: VcsActionTarget): string | null;
+declare function parseVcsActionTargetKey(key: string): ResolvedVcsActionTarget;
+declare function getVcsActionStateAtom(target: VcsActionTarget): Atom.Writable<Readonly<VcsActionState>, Readonly<VcsActionState>>;
+declare function beginVcsActionState(input: BeginVcsActionInput): VcsActionState & {
+  readonly actionId: string;
+};
+declare function failVcsActionState(operation: VcsActionOperation, actionId: string, error: unknown): VcsActionState;
+declare function createVcsActionTransportId(target: ResolvedVcsActionTarget, actionId: string): string;
+declare function normalizeVcsActionProgressEvent(target: ResolvedVcsActionTarget, transportActionId: string, actionId: string, event: GitActionProgressEvent): GitActionProgressEvent | null;
+declare function consumeVcsActionProgress<E, R>(stream: Stream.Stream<GitActionProgressEvent, E, R>, input: {
+  readonly target: ResolvedVcsActionTarget;
+  readonly transportActionId: string;
+  readonly actionId: string;
+  readonly action: GitStackedAction;
+  readonly onProgress: (event: GitActionProgressEvent) => Effect.Effect<void>;
+}): Effect.Effect<GitRunStackedActionResult, E | VcsActionExecutionError, R>;
+declare function applyVcsActionProgressEvent(current: VcsActionState, event: GitActionProgressEvent): VcsActionState;
+declare function createVcsActionManager<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | EnvironmentCacheStore | R, E>): {
+  stateAtom: typeof getVcsActionStateAtom;
+  runStackedAction: (target: VcsActionTarget) => AtomCommand<RunVcsStackedActionInput, {
+    readonly action: "commit" | "commit_push" | "commit_push_pr" | "create_pr" | "push";
+    readonly branch: {
+      readonly status: "created" | "skipped_not_requested";
+      readonly name?: string | undefined;
+    };
+    readonly commit: {
+      readonly status: "created" | "skipped_no_changes" | "skipped_not_requested";
+      readonly commitSha?: string | undefined;
+      readonly subject?: string | undefined;
+    };
+    readonly push: {
+      readonly status: "pushed" | "skipped_not_requested" | "skipped_up_to_date";
+      readonly branch?: string | undefined;
+      readonly upstreamBranch?: string | undefined;
+      readonly setUpstream?: boolean | undefined;
+    };
+    readonly pr: {
+      readonly status: "created" | "opened_existing" | "skipped_not_requested";
+      readonly url?: string | undefined;
+      readonly number?: number | undefined;
+      readonly baseBranch?: string | undefined;
+      readonly headBranch?: string | undefined;
+      readonly title?: string | undefined;
+    };
+    readonly toast: {
+      readonly title: string;
+      readonly description?: string | undefined;
+      readonly cta: {
+        readonly kind: "none";
+      } | {
+        readonly kind: "open_pr";
+        readonly label: string;
+        readonly url: string;
+      } | {
+        readonly kind: "run_action";
+        readonly label: string;
+        readonly action: {
+          readonly kind: "commit" | "commit_push" | "commit_push_pr" | "create_pr" | "push";
+        };
+      };
+    };
+  }, unknown>;
+  track: <A, E_1>(registry: AtomRegistry.AtomRegistry, target: VcsActionTarget, input: BeginVcsActionInput, action: () => Promise<AtomCommandResult<A, E_1>>) => Promise<AtomCommandResult<A, E_1 | VcsActionUnavailableError>>;
+  resetError: (registry: AtomRegistry.AtomRegistry, target: VcsActionTarget, operation: VcsActionOperation) => void;
+};
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/vcsRef.d.ts
+interface VcsRefTarget {
+  readonly environmentId: EnvironmentId | null;
+  readonly cwd: string | null;
+  readonly query?: string | null;
+}
+type VcsRef = VcsRef$1;
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/vcsStatus.d.ts
+interface VcsStatusTarget {
+  readonly environmentId: EnvironmentId | null;
+  readonly cwd: string | null;
+}
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/vcs.d.ts
+declare const commitVcsRefsRefresh: (registry: AtomRegistry.AtomRegistry, cache: {
+  readonly loadShell: (environmentId: EnvironmentId) => Effect.Effect<Option.Option<OrchestrationShellSnapshot>, ConnectionPersistenceError>;
+  readonly saveShell: (environmentId: EnvironmentId, snapshot: OrchestrationShellSnapshot) => Effect.Effect<void, ConnectionPersistenceError>;
+  readonly loadThread: (environmentId: EnvironmentId, threadId: ThreadId) => Effect.Effect<Option.Option<OrchestrationThreadDetailSnapshot>, ConnectionPersistenceError>;
+  readonly saveThread: (environmentId: EnvironmentId, snapshot: OrchestrationThreadDetailSnapshot) => Effect.Effect<void, ConnectionPersistenceError>;
+  readonly removeThread: (environmentId: EnvironmentId, threadId: ThreadId) => Effect.Effect<void, ConnectionPersistenceError>;
+  readonly loadServerConfig: (environmentId: EnvironmentId) => Effect.Effect<Option.Option<ServerConfig>, ConnectionPersistenceError>;
+  readonly saveServerConfig: (environmentId: EnvironmentId, config: ServerConfig) => Effect.Effect<void, ConnectionPersistenceError>;
+  readonly loadVcsRefs: (environmentId: EnvironmentId, cwd: string) => Effect.Effect<Option.Option<VcsListRefsResult>, ConnectionPersistenceError>;
+  readonly saveVcsRefs: (environmentId: EnvironmentId, cwd: string, refs: VcsListRefsResult) => Effect.Effect<void, ConnectionPersistenceError>;
+  readonly removeVcsRefs: (environmentId: EnvironmentId, cwd: string) => Effect.Effect<void, ConnectionPersistenceError>;
+  readonly clearVcsRefs: (environmentId: EnvironmentId) => Effect.Effect<void, ConnectionPersistenceError>;
+  readonly clear: (environmentId: EnvironmentId) => Effect.Effect<void, ConnectionPersistenceError>;
+}, input: {
+  readonly environmentId: EnvironmentId;
+  readonly cwd: string;
+  readonly refs: VcsListRefsResult;
+  readonly expectedRevision: number;
+  readonly persist: boolean;
+}) => Effect.Effect<boolean, never, never>;
+/**
+ * Retains the last unfiltered branch-list response for the new-task picker.
+ * Filtered or paginated lists intentionally stay live-only: treating a
+ * partial result as a complete offline list would make branch selection
+ * misleading.
+ */
+declare const makeCachedVcsRefsChanges: (input: {
+  readonly cwd: string;
+  readonly query?: string | undefined;
+  readonly cursor?: number | undefined;
+  readonly includeMatchingRemoteRefs?: boolean | undefined;
+  readonly refKind?: "all" | "local" | "remote" | undefined;
+  readonly refresh?: boolean | undefined;
+  readonly limit?: number | undefined;
+}, expectedRevision?: number | undefined, registry?: AtomRegistry.AtomRegistry | undefined, persistedCacheReadable?: any) => Effect.Effect<Stream.Stream<{
+  readonly refs: readonly {
+    readonly name: string;
+    readonly isRemote?: boolean | undefined;
+    readonly remoteName?: string | undefined;
+    readonly current: boolean;
+    readonly isDefault: boolean;
+    readonly worktreePath: string | null;
+  }[];
+  readonly isRepo: boolean;
+  readonly hasPrimaryRemote: boolean;
+  readonly nextCursor: number | null;
+  readonly totalCount: number;
+}, EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | GitCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError, never>, never, EnvironmentCacheStore | EnvironmentSupervisor>;
+declare function cachedVcsRefsChanges(environmentId: EnvironmentId, input: VcsListRefsInput, expectedRevision: number, persistedCacheReadable: boolean): Stream.Stream<{
+  readonly refs: readonly {
+    readonly name: string;
+    readonly isRemote?: boolean | undefined;
+    readonly remoteName?: string | undefined;
+    readonly current: boolean;
+    readonly isDefault: boolean;
+    readonly worktreePath: string | null;
+  }[];
+  readonly isRepo: boolean;
+  readonly hasPrimaryRemote: boolean;
+  readonly nextCursor: number | null;
+  readonly totalCount: number;
+}, EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | GitCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError, AtomRegistry.AtomRegistry | EnvironmentCacheStore | EnvironmentRegistry>;
+declare function createVcsEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | EnvironmentCacheStore | R, E>): {
+  listRefs: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: VcsListRefsInput;
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly refs: readonly {
+      readonly name: string;
+      readonly isRemote?: boolean | undefined;
+      readonly remoteName?: string | undefined;
+      readonly current: boolean;
+      readonly isDefault: boolean;
+      readonly worktreePath: string | null;
+    }[];
+    readonly isRepo: boolean;
+    readonly hasPrimaryRemote: boolean;
+    readonly nextCursor: number | null;
+    readonly totalCount: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | GitCommandError | import("effect/Cause").NoSuchElementError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+  status: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
+      readonly cwd: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
+    }>;
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly isRepo: boolean;
+    readonly sourceControlProvider?: {
+      readonly kind: "azure-devops" | "bitbucket" | "github" | "gitlab" | "unknown";
+      readonly name: string;
+      readonly baseUrl: string;
+    } | undefined;
+    readonly hasPrimaryRemote: boolean;
+    readonly isDefaultRef: boolean;
+    readonly refName: string | null;
+    readonly hasWorkingTreeChanges: boolean;
+    readonly workingTree: {
+      readonly files: readonly {
+        readonly path: string;
+        readonly insertions: number;
+        readonly deletions: number;
+      }[];
+      readonly insertions: number;
+      readonly deletions: number;
+    };
+    readonly hasUpstream: boolean;
+    readonly aheadCount: number;
+    readonly behindCount: number;
+    readonly aheadOfDefaultCount?: number | undefined;
+    readonly pr: {
+      readonly number: number;
+      readonly title: string;
+      readonly url: string;
+      readonly baseRef: string;
+      readonly headRef: string;
+      readonly state: "closed" | "merged" | "open";
+    } | null;
+  }, E | EnvironmentAuthorizationError | GitCommandError | GitManagerError | GitPullRequestMaterializationError | import("effect/Cause").NoSuchElementError | import("effect/unstable/rpc/RpcClientError").RpcClientError | SourceControlProviderError | TextGenerationError>>;
+  pull: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
+      readonly cwd: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
+    }>;
+  }, {
+    readonly status: "pulled" | "skipped_up_to_date";
+    readonly refName: string;
+    readonly upstreamRef: string | null;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | GitCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  refreshStatus: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
+      readonly cwd: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
+    }>;
+  }, {
+    readonly isRepo: boolean;
+    readonly sourceControlProvider?: {
+      readonly kind: "azure-devops" | "bitbucket" | "github" | "gitlab" | "unknown";
+      readonly name: string;
+      readonly baseUrl: string;
+    } | undefined;
+    readonly hasPrimaryRemote: boolean;
+    readonly isDefaultRef: boolean;
+    readonly refName: string | null;
+    readonly hasWorkingTreeChanges: boolean;
+    readonly workingTree: {
+      readonly files: readonly {
+        readonly path: string;
+        readonly insertions: number;
+        readonly deletions: number;
+      }[];
+      readonly insertions: number;
+      readonly deletions: number;
+    };
+    readonly hasUpstream: boolean;
+    readonly aheadCount: number;
+    readonly behindCount: number;
+    readonly aheadOfDefaultCount?: number | undefined;
+    readonly pr: {
+      readonly number: number;
+      readonly title: string;
+      readonly url: string;
+      readonly baseRef: string;
+      readonly headRef: string;
+      readonly state: "closed" | "merged" | "open";
+    } | null;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | GitCommandError | GitManagerError | GitPullRequestMaterializationError | import("effect/unstable/rpc/RpcClientError").RpcClientError | SourceControlProviderError | TextGenerationError>;
+  createWorktree: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly cwd: string;
+      readonly refName: string;
+      readonly newRefName?: string | undefined;
+      readonly baseRefName?: string | undefined;
+      readonly path: string | null;
+    };
+  }, {
+    readonly worktree: {
+      readonly path: string;
+      readonly refName: string;
+    };
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | GitCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  removeWorktree: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly cwd: string;
+      readonly path: string;
+      readonly force?: boolean | undefined;
+    };
+  }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | GitCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  createRef: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly cwd: string;
+      readonly refName: string;
+      readonly switchRef?: boolean | undefined;
+    };
+  }, {
+    readonly refName: string;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | GitCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  switchRef: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
+      readonly cwd: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
+      readonly refName: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
+    }>;
+  }, {
+    readonly refName: string | null;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | GitCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  init: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly cwd: string;
+      readonly kind?: "git" | "jj" | "unknown" | undefined;
+    };
+  }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError | VcsProcessExitError | VcsProcessMissingExitCodeError | VcsProcessOutputLimitError | VcsProcessOutputReadError | VcsProcessSpawnError | VcsProcessStdinWriteError | VcsProcessTimeoutError | VcsRepositoryDetectionError | VcsUnsupportedOperationError>;
+};
+//#endregion
+export { BeginVcsActionInput, DefaultBranchActionDialogCopy, DefaultBranchConfirmableAction, EMPTY_VCS_ACTION_ATOM, EMPTY_VCS_ACTION_STATE, GitActionIconName, GitActionMenuItem, GitActionRequestInput, GitDialogAction, GitQuickAction, ResolvedVcsActionTarget, RunVcsStackedActionInput, VcsActionExecutionError, VcsActionMissingTerminalEventError, VcsActionOperation, VcsActionRemoteFailureError, VcsActionState, VcsActionTarget, VcsActionTargetKeyParseError, VcsActionUnavailableError, VcsRef, VcsRefTarget, VcsStatusTarget, applyVcsActionProgressEvent, beginVcsActionState, buildGitActionProgressStages, buildMenuItems, cachedVcsRefsChanges, commitVcsRefsRefresh, consumeVcsActionProgress, createVcsActionManager, createVcsActionTransportId, createVcsEnvironmentAtoms, failVcsActionState, getGitActionDisabledReason, getVcsActionStateAtom, getVcsActionTargetKey, makeCachedVcsRefsChanges, normalizeVcsActionProgressEvent, parseVcsActionTargetKey, requiresDefaultBranchConfirmation, resolveDefaultBranchActionDialogCopy, resolveLiveThreadBranchUpdate, resolveQuickAction, resolveThreadBranchUpdate, vcsActionStateAtom };