t3code-cli 0.12.0 → 0.14.0

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

@@ -0,0 +1,192 @@
+import { Ot as UpdateProjectInput, _x as ProjectReadFileResult, bT as EnvironmentAuthorizationError, c as normalizeProjectPathForDispatch, cv as OrchestrationShellSnapshot, dt as CreateProjectInput, f as AtomCommand, fx as ProjectListEntriesError, ha as EnvironmentRegistry, hx as ProjectReadFileError, jw as ScopedProjectRef, ma as EnvironmentNotRegisteredError, on as EnvironmentRpcUnavailableError, pt as DeleteProjectInput, r as isExplicitRelativePath, rt as EnvironmentProject, s as normalizeProjectPathForComparison, u as EnvironmentCatalogState, vx as ProjectSearchEntriesError, xx as ProjectWriteFileError, zT as EnvironmentId, z_ as OrchestrationDispatchCommandError } from "../../shared.js";
+import * as Crypto from "effect/Crypto";
+import { Atom } from "effect/unstable/reactivity";
+//#region upstream-t3code/packages/client-runtime/src/state/projectCommands.d.ts
+interface OptimisticProjectFile {
+  readonly data: ProjectReadFileResult;
+  readonly confirmedAgainst: object | null | undefined;
+}
+interface OptimisticProjectFileTarget {
+  readonly environmentId: EnvironmentId;
+  readonly cwd: string;
+  readonly relativePath: string;
+}
+declare function createProjectEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | Crypto.Crypto | R, E>): {
+  searchEntries: (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>;
+      readonly query: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
+      readonly limit: import("effect/Schema").Int;
+    }>;
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly entries: readonly {
+      readonly path: string;
+      readonly kind: "directory" | "file";
+    }[];
+    readonly truncated: boolean;
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | ProjectSearchEntriesError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+  listEntries: (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 entries: readonly {
+      readonly path: string;
+      readonly kind: "directory" | "file";
+    }[];
+    readonly truncated: boolean;
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | ProjectListEntriesError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+  readFile: (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>;
+      readonly relativePath: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
+    }>;
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly relativePath: string;
+    readonly contents: string;
+    readonly byteLength: number;
+    readonly truncated: boolean;
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | ProjectReadFileError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+  optimisticFile: (target: OptimisticProjectFileTarget) => Atom.Writable<OptimisticProjectFile | null, OptimisticProjectFile | null>;
+  create: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: CreateProjectInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  update: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: UpdateProjectInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  delete: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: DeleteProjectInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  writeFile: 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 relativePath: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
+      readonly contents: import("effect/Schema").String;
+    }>;
+  }, {
+    readonly relativePath: string;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | ProjectWriteFileError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+};
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/projectEntities.d.ts
+declare function createEnvironmentProjectAtoms(input: {
+  readonly catalogValueAtom: Atom.Atom<EnvironmentCatalogState>;
+  readonly snapshotAtom: (environmentId: EnvironmentId) => Atom.Atom<OrchestrationShellSnapshot | null>;
+}): {
+  environmentProjectsAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<readonly {
+    readonly id: string & import("effect/Brand").Brand<"ProjectId">;
+    readonly title: string;
+    readonly workspaceRoot: string;
+    readonly repositoryIdentity?: {
+      readonly canonicalKey: string;
+      readonly locator: {
+        readonly source: "git-remote";
+        readonly remoteName: string;
+        readonly remoteUrl: string;
+      };
+      readonly rootPath?: string;
+      readonly displayName?: string;
+      readonly provider?: string;
+      readonly owner?: string;
+      readonly name?: string;
+    } | null | undefined;
+    readonly defaultModelSelection: {
+      readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+      readonly model: string;
+      readonly options?: readonly {
+        readonly id: string;
+        readonly value: string | boolean;
+      }[];
+    } | null;
+    readonly scripts: readonly {
+      readonly id: string;
+      readonly name: string;
+      readonly command: string;
+      readonly icon: "build" | "configure" | "debug" | "lint" | "play" | "test";
+      readonly runOnWorktreeCreate: boolean;
+      readonly previewUrl?: string | undefined;
+      readonly autoOpenPreview?: boolean | undefined;
+    }[];
+    readonly createdAt: string;
+    readonly updatedAt: string;
+  }[]>;
+  environmentProjectIndexAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<ReadonlyMap<string & import("effect/Brand").Brand<"ProjectId">, {
+    readonly id: string & import("effect/Brand").Brand<"ProjectId">;
+    readonly title: string;
+    readonly workspaceRoot: string;
+    readonly repositoryIdentity?: {
+      readonly canonicalKey: string;
+      readonly locator: {
+        readonly source: "git-remote";
+        readonly remoteName: string;
+        readonly remoteUrl: string;
+      };
+      readonly rootPath?: string;
+      readonly displayName?: string;
+      readonly provider?: string;
+      readonly owner?: string;
+      readonly name?: string;
+    } | null | undefined;
+    readonly defaultModelSelection: {
+      readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+      readonly model: string;
+      readonly options?: readonly {
+        readonly id: string;
+        readonly value: string | boolean;
+      }[];
+    } | null;
+    readonly scripts: readonly {
+      readonly id: string;
+      readonly name: string;
+      readonly command: string;
+      readonly icon: "build" | "configure" | "debug" | "lint" | "play" | "test";
+      readonly runOnWorktreeCreate: boolean;
+      readonly previewUrl?: string | undefined;
+      readonly autoOpenPreview?: boolean | undefined;
+    }[];
+    readonly createdAt: string;
+    readonly updatedAt: string;
+  }>>;
+  environmentProjectRefsAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<readonly {
+    readonly environmentId: string & import("effect/Brand").Brand<"EnvironmentId">;
+    readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+  }[]>;
+  projectRefsAtom: Atom.Atom<readonly {
+    readonly environmentId: string & import("effect/Brand").Brand<"EnvironmentId">;
+    readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+  }[]>;
+  projectsAtom: Atom.Atom<readonly EnvironmentProject[]>;
+  projectAtom: (ref: ScopedProjectRef) => Atom.Atom<EnvironmentProject | null>;
+};
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/projects.d.ts
+declare function hasTrailingPathSeparator(value: string): boolean;
+declare function isFilesystemBrowseQuery(value: string, platform?: string): boolean;
+declare function isUnsupportedWindowsProjectPath(value: string, platform: string): boolean;
+declare function resolveProjectPathForDispatch(value: string, cwd?: string | null): string;
+declare function findProjectByPath<T extends {
+  workspaceRoot?: string;
+  cwd?: string;
+}>(projects: ReadonlyArray<T>, candidatePath: string): T | undefined;
+declare function inferProjectTitleFromPath(value: string): string;
+declare function appendBrowsePathSegment(currentPath: string, segment: string): string;
+declare function getBrowseLeafPathSegment(currentPath: string): string;
+declare function getBrowseDirectoryPath(currentPath: string): string;
+declare function ensureBrowseDirectoryPath(currentPath: string): string;
+declare function getBrowseParentPath(currentPath: string): string | null;
+declare function canNavigateUp(currentPath: string): boolean;
+//#endregion
+export { type CreateProjectInput, type DeleteProjectInput, OptimisticProjectFile, OptimisticProjectFileTarget, type UpdateProjectInput, appendBrowsePathSegment, canNavigateUp, createEnvironmentProjectAtoms, createProjectEnvironmentAtoms, ensureBrowseDirectoryPath, findProjectByPath, getBrowseDirectoryPath, getBrowseLeafPathSegment, getBrowseParentPath, hasTrailingPathSeparator, inferProjectTitleFromPath, isExplicitRelativePath as isExplicitRelativeProjectPath, isFilesystemBrowseQuery, isUnsupportedWindowsProjectPath, normalizeProjectPathForComparison, normalizeProjectPathForDispatch, resolveProjectPathForDispatch };

package/dist/client-runtime/state/projects.js

@@ -0,0 +1,2 @@
+import { Bt as inferProjectTitleFromPath, Ft as findProjectByPath, Ht as isUnsupportedWindowsProjectPath, It as getBrowseDirectoryPath, Lt as getBrowseLeafPathSegment, Mt as appendBrowsePathSegment, Nt as canNavigateUp, Pt as ensureBrowseDirectoryPath, Rt as getBrowseParentPath, Ut as resolveProjectPathForDispatch, Vt as isFilesystemBrowseQuery, Wt as createEnvironmentProjectAtoms, cn as normalizeProjectPathForComparison, in as isExplicitRelativePath, ln as normalizeProjectPathForDispatch, rn as createProjectEnvironmentAtoms, zt as hasTrailingPathSeparator } from "../../shared.js";
+export { appendBrowsePathSegment, canNavigateUp, createEnvironmentProjectAtoms, createProjectEnvironmentAtoms, ensureBrowseDirectoryPath, findProjectByPath, getBrowseDirectoryPath, getBrowseLeafPathSegment, getBrowseParentPath, hasTrailingPathSeparator, inferProjectTitleFromPath, isExplicitRelativePath as isExplicitRelativeProjectPath, isFilesystemBrowseQuery, isUnsupportedWindowsProjectPath, normalizeProjectPathForComparison, normalizeProjectPathForDispatch, resolveProjectPathForDispatch };

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

@@ -0,0 +1,10 @@
+import { ea as RelayEnvironmentDiscovery, f as AtomCommand, ta as RelayEnvironmentDiscoveryState } from "../../shared.js";
+import { AsyncResult, Atom } from "effect/unstable/reactivity";
+//#region upstream-t3code/packages/client-runtime/src/state/relayDiscovery.d.ts
+declare function createRelayEnvironmentDiscoveryAtoms<R, E>(runtime: Atom.AtomRuntime<RelayEnvironmentDiscovery | R, E>): {
+  stateAtom: Atom.Atom<AsyncResult.AsyncResult<RelayEnvironmentDiscoveryState, E | import("effect/Cause").NoSuchElementError>>;
+  stateValueAtom: Atom.Atom<RelayEnvironmentDiscoveryState>;
+  refresh: AtomCommand<void, void, E>;
+};
+//#endregion
+export { createRelayEnvironmentDiscoveryAtoms };

package/dist/client-runtime/state/relay.js

@@ -0,0 +1,19 @@
+import { $D as flatMap, Fk as getOrElse, Sv as changes, Xr as withLabel, aa as RelayEnvironmentDiscovery, gr as createRuntimeCommand, ia as EMPTY_RELAY_ENVIRONMENT_DISCOVERY_STATE, lD as unwrap, qr as make, ti as value, uO as map } from "../../shared.js";
+//#region upstream-t3code/packages/client-runtime/src/state/relayDiscovery.ts
+function createRelayEnvironmentDiscoveryAtoms(runtime) {
+	const stateAtom = runtime.atom(unwrap(RelayEnvironmentDiscovery.pipe(map((discovery) => changes(discovery.state)))), { initialValue: EMPTY_RELAY_ENVIRONMENT_DISCOVERY_STATE });
+	return {
+		stateAtom,
+		stateValueAtom: make((get) => getOrElse(value(get(stateAtom)), () => EMPTY_RELAY_ENVIRONMENT_DISCOVERY_STATE)).pipe(withLabel("relay-environment-discovery-value")),
+		refresh: createRuntimeCommand(runtime, {
+			label: "relay-environment-discovery:refresh",
+			concurrency: {
+				mode: "singleFlight",
+				key: () => "refresh"
+			},
+			execute: (_input) => RelayEnvironmentDiscovery.pipe(flatMap((discovery) => discovery.refresh))
+		})
+	};
+}
+//#endregion
+export { createRelayEnvironmentDiscoveryAtoms };

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

@@ -0,0 +1,28 @@
+import { TS as GitCommandError, bS as VcsUnsupportedOperationError, bT as EnvironmentAuthorizationError, dS as VcsProcessOutputReadError, fS as VcsProcessSpawnError, hS as VcsProcessTimeoutError, ha as EnvironmentRegistry, lS as VcsProcessMissingExitCodeError, mS as VcsProcessStdinWriteError, oS as VcsProcessExitError, on as EnvironmentRpcUnavailableError, uS as VcsProcessOutputLimitError, vS as VcsRepositoryDetectionError, zT as EnvironmentId } from "../../shared.js";
+import { Atom } from "effect/unstable/reactivity";
+//#region upstream-t3code/packages/client-runtime/src/state/review.d.ts
+declare function createReviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {
+  diffPreview: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly cwd: string;
+      readonly baseRef?: string | undefined;
+      readonly ignoreWhitespace?: boolean;
+    };
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly cwd: string;
+    readonly generatedAt: import("effect/DateTime").Utc;
+    readonly sources: readonly {
+      readonly id: string;
+      readonly kind: "branch-range" | "working-tree";
+      readonly title: string;
+      readonly baseRef: string | null;
+      readonly headRef: string | null;
+      readonly diff: string;
+      readonly diffHash: string;
+      readonly truncated: boolean;
+    }[];
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | GitCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError | VcsProcessExitError | VcsProcessMissingExitCodeError | VcsProcessOutputLimitError | VcsProcessOutputReadError | VcsProcessSpawnError | VcsProcessStdinWriteError | VcsProcessTimeoutError | VcsRepositoryDetectionError | VcsUnsupportedOperationError>>;
+};
+//#endregion
+export { createReviewEnvironmentAtoms };

package/dist/client-runtime/state/review.js

@@ -0,0 +1,11 @@
+import { Fs as WS_METHODS, fr as createEnvironmentRpcQueryAtomFamily } from "../../shared.js";
+//#region upstream-t3code/packages/client-runtime/src/state/review.ts
+function createReviewEnvironmentAtoms(runtime) {
+	return { diffPreview: createEnvironmentRpcQueryAtomFamily(runtime, {
+		label: "environment-data:review:diff-preview",
+		tag: WS_METHODS.reviewGetDiffPreview,
+		staleTimeMs: 5e3
+	}) };
+}
+//#endregion
+export { createReviewEnvironmentAtoms };

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

@@ -0,0 +1,2 @@
+import { A as environmentRpcKey, B as settleAsyncResult, C as createEnvironmentRpcCommand, D as createEnvironmentSubscriptionAtomFamily, E as createEnvironmentRpcSubscriptionAtomFamily, F as mapAtomCommandResult, H as squashAtomCommandFailure, I as reportAtomCommandResult, L as runAtomCommand, M as executeAtomQuery, N as followStreamInEnvironment, O as createRuntimeCommand, P as isAtomCommandInterrupted, R as runInEnvironment, S as createEnvironmentCommand, T as createEnvironmentRpcStreamCommand, V as settlePromise, _ as AtomCommandResult, b as SettledAsyncResult, f as AtomCommand, g as AtomCommandReporter, h as AtomCommandOptions, j as executeAtomCommand, k as createRuntimeStreamCommand, m as AtomCommandFailure, p as AtomCommandConcurrency, v as AtomCommandScheduler, w as createEnvironmentRpcQueryAtomFamily, x as createAtomCommandScheduler, y as AtomCommandSuccess, z as runStreamInEnvironment } from "../../shared.js";
+export { AtomCommand, AtomCommandConcurrency, AtomCommandFailure, AtomCommandOptions, AtomCommandReporter, AtomCommandResult, AtomCommandScheduler, AtomCommandSuccess, SettledAsyncResult, createAtomCommandScheduler, createEnvironmentCommand, createEnvironmentRpcCommand, createEnvironmentRpcQueryAtomFamily, createEnvironmentRpcStreamCommand, createEnvironmentRpcSubscriptionAtomFamily, createEnvironmentSubscriptionAtomFamily, createRuntimeCommand, createRuntimeStreamCommand, environmentRpcKey, executeAtomCommand, executeAtomQuery, followStreamInEnvironment, isAtomCommandInterrupted, mapAtomCommandResult, reportAtomCommandResult, runAtomCommand, runInEnvironment, runStreamInEnvironment, settleAsyncResult, settlePromise, squashAtomCommandFailure };

package/dist/client-runtime/state/runtime.js

@@ -0,0 +1,2 @@
+import { Ar as squashAtomCommandFailure, Cr as mapAtomCommandResult, Dr as runStreamInEnvironment, Er as runInEnvironment, Or as settleAsyncResult, Sr as isAtomCommandInterrupted, Tr as runAtomCommand, _r as createRuntimeStreamCommand, br as executeAtomQuery, dr as createEnvironmentRpcCommand, fr as createEnvironmentRpcQueryAtomFamily, gr as createRuntimeCommand, hr as createEnvironmentSubscriptionAtomFamily, kr as settlePromise, lr as createAtomCommandScheduler, mr as createEnvironmentRpcSubscriptionAtomFamily, pr as createEnvironmentRpcStreamCommand, ur as createEnvironmentCommand, vr as environmentRpcKey, wr as reportAtomCommandResult, xr as followStreamInEnvironment, yr as executeAtomCommand } from "../../shared.js";
+export { createAtomCommandScheduler, createEnvironmentCommand, createEnvironmentRpcCommand, createEnvironmentRpcQueryAtomFamily, createEnvironmentRpcStreamCommand, createEnvironmentRpcSubscriptionAtomFamily, createEnvironmentSubscriptionAtomFamily, createRuntimeCommand, createRuntimeStreamCommand, environmentRpcKey, executeAtomCommand, executeAtomQuery, followStreamInEnvironment, isAtomCommandInterrupted, mapAtomCommandResult, reportAtomCommandResult, runAtomCommand, runInEnvironment, runStreamInEnvironment, settleAsyncResult, settlePromise, squashAtomCommandFailure };