t3code-cli 0.1.0

package/src/config/error.ts

@@ -0,0 +1,21 @@
+import * as Cause from "effect/Cause";
+import * as Schema from "effect/Schema";
+import { PlatformError } from "effect/PlatformError";
+
+const ConfigErrorCauseSchema = Schema.Union([
+  Schema.instanceOf(PlatformError),
+  Schema.instanceOf(Schema.SchemaError),
+]);
+
+export class UrlError extends Schema.TaggedErrorClass<UrlError>()("UrlError", {
+  message: Schema.String,
+  protocol: Schema.optionalKey(Schema.String),
+  cause: Schema.optionalKey(Schema.instanceOf(Cause.IllegalArgumentError)),
+}) {}
+
+export class ConfigError extends Schema.TaggedErrorClass<ConfigError>()("ConfigError", {
+  message: Schema.String,
+  cause: Schema.optionalKey(ConfigErrorCauseSchema),
+}) {}
+
+export type ConfigServiceError = ConfigError | UrlError;

package/src/config/layer.ts

@@ -0,0 +1,103 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Filter from "effect/Filter";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+
+import { Environment, type EnvironmentShape } from "../environment/service.ts";
+import { ConfigError } from "./error.ts";
+import { T3Config, type StoredConfig } from "./service.ts";
+import { normalizeHttpBaseUrl } from "./url.ts";
+
+export const makeT3Config = Effect.fn("makeT3Config")(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const environment = yield* Environment;
+  const configFilePath = resolveConfigPath(path, environment);
+  const readStored = Effect.fn("T3ConfigLive.readStored")(function* () {
+    const raw = yield* fs.readFileString(configFilePath).pipe(
+      Effect.catchFilter(Filter.reason("PlatformError", "NotFound"), () =>
+        Effect.succeed(undefined),
+      ),
+      Effect.mapError(
+        (error) => new ConfigError({ message: "failed to read config", cause: error }),
+      ),
+    );
+    if (raw === undefined) {
+      return {};
+    }
+    return yield* parseStoredConfig(raw);
+  });
+  const writeStored = Effect.fn("T3ConfigLive.writeStored")(function* (config: StoredConfig) {
+    yield* fs
+      .makeDirectory(path.dirname(configFilePath), { recursive: true, mode: 0o700 })
+      .pipe(
+        Effect.mapError(
+          (error) => new ConfigError({ message: "failed to write config", cause: error }),
+        ),
+      );
+    yield* fs
+      .writeFileString(configFilePath, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 })
+      .pipe(
+        Effect.mapError(
+          (error) => new ConfigError({ message: "failed to write config", cause: error }),
+        ),
+      );
+  });
+  const resolve = Effect.fn("T3ConfigLive.resolve")(function* () {
+    const stored = yield* readStored();
+    const envUrl = environment.env["T3CODE_URL"];
+    const envToken = environment.env["T3CODE_TOKEN"];
+    const envUrlValue = envUrl?.trim();
+    const envTokenValue = envToken?.trim();
+    const url = envUrlValue !== undefined && envUrlValue.length > 0 ? envUrlValue : stored.url;
+    const token =
+      envTokenValue !== undefined && envTokenValue.length > 0 ? envTokenValue : stored.token;
+    if (url === undefined || url.length === 0 || token === undefined || token.length === 0) {
+      return yield* Effect.fail(
+        new ConfigError({ message: "not authenticated. run: t3cli auth pair <pairing-url>" }),
+      );
+    }
+    const source: "env" | "config" =
+      (envUrlValue !== undefined && envUrlValue.length > 0) ||
+      (envTokenValue !== undefined && envTokenValue.length > 0)
+        ? "env"
+        : "config";
+    const normalizedUrl = yield* normalizeHttpBaseUrl(url);
+    return {
+      url: normalizedUrl,
+      token,
+      source,
+    };
+  });
+
+  return {
+    readStored,
+    writeStored,
+    resolve,
+  };
+});
+
+export const T3ConfigLive = Layer.effect(T3Config, makeT3Config());
+
+const StoredConfigSchema = Schema.Struct({
+  url: Schema.optionalKey(Schema.String),
+  token: Schema.optionalKey(Schema.String),
+});
+
+function parseStoredConfig(raw: string) {
+  return Schema.decodeUnknownEffect(Schema.fromJsonString(StoredConfigSchema))(raw).pipe(
+    Effect.mapError((error) => new ConfigError({ message: "failed to read config", cause: error })),
+  );
+}
+
+function resolveConfigPath(path: Path.Path, environment: EnvironmentShape) {
+  const xdgConfigHome = environment.env["XDG_CONFIG_HOME"];
+  const xdgConfigHomeValue = xdgConfigHome?.trim();
+  const root =
+    xdgConfigHomeValue !== undefined && xdgConfigHomeValue.length > 0
+      ? xdgConfigHomeValue
+      : path.join(environment.homeDir, ".config");
+  return path.join(root, "t3cli", "config.json");
+}

package/src/config/service.ts

@@ -0,0 +1,24 @@
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+
+import type { ConfigError, ConfigServiceError } from "./error.ts";
+
+export type StoredConfig = {
+  readonly url?: string;
+  readonly token?: string;
+};
+
+export type ResolvedConfig = {
+  readonly url: string;
+  readonly token: string;
+  readonly source: "env" | "config";
+};
+
+export class T3Config extends Context.Service<
+  T3Config,
+  {
+    readonly readStored: () => Effect.Effect<StoredConfig, ConfigError>;
+    readonly writeStored: (config: StoredConfig) => Effect.Effect<void, ConfigError>;
+    readonly resolve: () => Effect.Effect<ResolvedConfig, ConfigServiceError>;
+  }
+>()("t3cli/T3Config") {}

package/src/config/url.ts

@@ -0,0 +1,55 @@
+import * as Effect from "effect/Effect";
+import { Url } from "effect/unstable/http";
+
+import { UrlError } from "./error.ts";
+
+export function normalizeHttpBaseUrl(value: string) {
+  return parseUrl(value).pipe(Effect.flatMap((url) => Effect.succeed(normalizeBaseUrl(url))));
+}
+
+export function toWebSocketBaseUrl(httpBaseUrl: string) {
+  return parseUrl(httpBaseUrl).pipe(
+    Effect.flatMap((url) => {
+      if (url.protocol === "http:") {
+        return Effect.succeed(makeWebSocketUrl(url, "ws:"));
+      }
+      if (url.protocol === "https:") {
+        return Effect.succeed(makeWebSocketUrl(url, "wss:"));
+      }
+      return Effect.fail(
+        new UrlError({
+          message: `unsupported server url protocol: ${url.protocol}`,
+          protocol: url.protocol,
+        }),
+      );
+    }),
+  );
+}
+
+function parseUrl(value: string): Effect.Effect<URL, UrlError> {
+  return Effect.fromResult(Url.fromString(value)).pipe(
+    Effect.catchTags({
+      IllegalArgumentError: (error) =>
+        Effect.fail(new UrlError({ message: "invalid url", cause: error })),
+    }),
+  );
+}
+
+function normalizeBaseUrl(url: URL) {
+  return Url.mutate(url, (current) => {
+    current.hash = "";
+    current.search = "";
+    current.pathname = "";
+  })
+    .toString()
+    .replace(/\/$/, "");
+}
+
+function makeWebSocketUrl(url: URL, protocol: "ws:" | "wss:") {
+  return Url.mutate(url, (current) => {
+    current.protocol = protocol;
+    current.pathname = "/ws";
+    current.search = "";
+    current.hash = "";
+  }).toString();
+}

package/src/domain/command-schema.ts

@@ -0,0 +1,82 @@
+import * as Schema from "effect/Schema";
+
+import { ModelSelectionSchema } from "./schema.ts";
+
+export const DispatchResultSchema = Schema.Struct({
+  sequence: Schema.Number,
+});
+export type DispatchResult = typeof DispatchResultSchema.Type;
+
+export const ProjectCreateCommandSchema = Schema.Struct({
+  type: Schema.Literal("project.create"),
+  commandId: Schema.String,
+  projectId: Schema.String,
+  title: Schema.String,
+  workspaceRoot: Schema.String,
+  createdAt: Schema.String,
+});
+export type ProjectCreateCommand = typeof ProjectCreateCommandSchema.Type;
+
+export const ThreadCreateCommandSchema = Schema.Struct({
+  type: Schema.Literal("thread.create"),
+  commandId: Schema.String,
+  threadId: Schema.String,
+  projectId: Schema.String,
+  title: Schema.String,
+  modelSelection: ModelSelectionSchema,
+  runtimeMode: Schema.Literal("full-access"),
+  interactionMode: Schema.Literal("default"),
+  branch: Schema.Null,
+  worktreePath: Schema.NullOr(Schema.String),
+  createdAt: Schema.String,
+});
+export type ThreadCreateCommand = typeof ThreadCreateCommandSchema.Type;
+
+export const ThreadTurnStartCommandSchema = Schema.Struct({
+  type: Schema.Literal("thread.turn.start"),
+  commandId: Schema.String,
+  threadId: Schema.String,
+  message: Schema.Struct({
+    messageId: Schema.String,
+    role: Schema.Literal("user"),
+    text: Schema.String,
+    attachments: Schema.Array(Schema.Never),
+  }),
+  modelSelection: Schema.optionalKey(ModelSelectionSchema),
+  titleSeed: Schema.optionalKey(Schema.String),
+  runtimeMode: Schema.Literal("full-access"),
+  interactionMode: Schema.Literal("default"),
+  bootstrap: Schema.optionalKey(
+    Schema.Struct({
+      createThread: Schema.optionalKey(
+        Schema.Struct({
+          projectId: Schema.String,
+          title: Schema.String,
+          modelSelection: ModelSelectionSchema,
+          runtimeMode: Schema.Literal("full-access"),
+          interactionMode: Schema.Literal("default"),
+          branch: Schema.Null,
+          worktreePath: Schema.NullOr(Schema.String),
+          createdAt: Schema.String,
+        }),
+      ),
+    }),
+  ),
+  createdAt: Schema.String,
+});
+export type ThreadTurnStartCommand = typeof ThreadTurnStartCommandSchema.Type;
+
+export const ThreadArchiveCommandSchema = Schema.Struct({
+  type: Schema.Literal("thread.archive"),
+  commandId: Schema.String,
+  threadId: Schema.String,
+});
+export type ThreadArchiveCommand = typeof ThreadArchiveCommandSchema.Type;
+
+export const ClientOrchestrationCommandSchema = Schema.Union([
+  ProjectCreateCommandSchema,
+  ThreadArchiveCommandSchema,
+  ThreadCreateCommandSchema,
+  ThreadTurnStartCommandSchema,
+]);
+export type ClientOrchestrationCommand = typeof ClientOrchestrationCommandSchema.Type;

package/src/domain/error.ts

@@ -0,0 +1,46 @@
+import * as Schema from "effect/Schema";
+
+export class ProjectLookupError extends Schema.TaggedErrorClass<ProjectLookupError>()(
+  "ProjectLookupError",
+  {
+    message: Schema.String,
+    ref: Schema.String,
+  },
+) {}
+
+export class ModelSelectionError extends Schema.TaggedErrorClass<ModelSelectionError>()(
+  "ModelSelectionError",
+  {
+    message: Schema.String,
+  },
+) {}
+
+export class ThreadEventError extends Schema.TaggedErrorClass<ThreadEventError>()(
+  "ThreadEventError",
+  {
+    message: Schema.String,
+  },
+) {}
+
+export class ThreadSessionError extends Schema.TaggedErrorClass<ThreadSessionError>()(
+  "ThreadSessionError",
+  {
+    message: Schema.String,
+    threadId: Schema.String,
+  },
+) {}
+
+export class ProjectCreateVisibilityError extends Schema.TaggedErrorClass<ProjectCreateVisibilityError>()(
+  "ProjectCreateVisibilityError",
+  {
+    message: Schema.String,
+    projectId: Schema.String,
+  },
+) {}
+
+export type DomainError =
+  | ProjectLookupError
+  | ModelSelectionError
+  | ThreadEventError
+  | ThreadSessionError
+  | ProjectCreateVisibilityError;

package/src/domain/helpers.ts

@@ -0,0 +1,23 @@
+import type * as Path from "effect/Path";
+
+import { ProjectLookupError } from "./error.ts";
+import type { ProjectShell, ShellSnapshot } from "./schema.ts";
+
+export function resolveProject(snapshot: ShellSnapshot, ref: string, path: Path.Path, cwd: string) {
+  const byId = findProjectById(snapshot, ref);
+  if (byId !== null) {
+    return byId;
+  }
+  const absolute = path.resolve(cwd, ref);
+  const byPath = snapshot.projects.find(
+    (project) => path.resolve(cwd, project.workspaceRoot) === absolute,
+  );
+  if (byPath !== undefined) {
+    return byPath;
+  }
+  throw new ProjectLookupError({ message: `project not found: ${ref}`, ref });
+}
+
+export function findProjectById(snapshot: ShellSnapshot, projectId: string): ProjectShell | null {
+  return snapshot.projects.find((project) => project.id === projectId) ?? null;
+}

package/src/domain/model-config.ts

@@ -0,0 +1,40 @@
+import type { ServerProvider } from "./schema.ts";
+
+export function isSelectableProvider(provider: ServerProvider) {
+  return provider.status === "ready" && provider.models.length > 0;
+}
+
+export function firstSelectableProvider(providers: ReadonlyArray<ServerProvider>) {
+  return providers.find(isSelectableProvider);
+}
+
+export function firstSelectableModel(provider: ServerProvider) {
+  return provider.models[0];
+}
+
+export function findSelectableProvider(
+  providers: ReadonlyArray<ServerProvider>,
+  instanceId: string,
+) {
+  return providers.find(
+    (provider) => provider.instanceId === instanceId && isSelectableProvider(provider),
+  );
+}
+
+export function filterProvidersForModelListing(input: {
+  readonly providers: ReadonlyArray<ServerProvider>;
+  readonly all: boolean;
+  readonly provider?: string;
+}) {
+  return input.providers
+    .filter((provider) => input.provider === undefined || provider.instanceId === input.provider)
+    .flatMap((provider) => {
+      if (input.all) {
+        return [provider];
+      }
+      if (!isSelectableProvider(provider)) {
+        return [];
+      }
+      return [provider];
+    });
+}

package/src/domain/schema.ts

@@ -0,0 +1,162 @@
+import * as Schema from "effect/Schema";
+
+export type Format = "human" | "json" | "ndjson";
+
+export const FormatSchema = Schema.Literals(["human", "json", "ndjson"]);
+
+export const ModelSelectionSchema = Schema.Struct({
+  instanceId: Schema.String,
+  model: Schema.String,
+  options: Schema.optionalKey(
+    Schema.Array(
+      Schema.Struct({
+        id: Schema.String,
+        value: Schema.Unknown,
+      }),
+    ),
+  ),
+});
+export type ModelSelection = typeof ModelSelectionSchema.Type;
+
+export const ProjectShellSchema = Schema.Struct({
+  id: Schema.String,
+  title: Schema.String,
+  workspaceRoot: Schema.String,
+  defaultModelSelection: Schema.NullOr(ModelSelectionSchema),
+  createdAt: Schema.String,
+  updatedAt: Schema.String,
+});
+export type ProjectShell = typeof ProjectShellSchema.Type;
+
+export const ThreadMessageSchema = Schema.Struct({
+  id: Schema.optionalKey(Schema.String),
+  messageId: Schema.optionalKey(Schema.String),
+  role: Schema.Literals(["user", "assistant", "system"]),
+  text: Schema.String,
+  streaming: Schema.optionalKey(Schema.Boolean),
+  turnId: Schema.optionalKey(Schema.NullOr(Schema.String)),
+  createdAt: Schema.String,
+  updatedAt: Schema.String,
+});
+export type ThreadMessage = typeof ThreadMessageSchema.Type;
+
+export const ThreadSessionSchema = Schema.Struct({
+  threadId: Schema.String,
+  status: Schema.Literals([
+    "idle",
+    "starting",
+    "running",
+    "ready",
+    "interrupted",
+    "stopped",
+    "error",
+  ]),
+  lastError: Schema.NullOr(Schema.String),
+  updatedAt: Schema.String,
+});
+export type ThreadSession = typeof ThreadSessionSchema.Type;
+
+export const ThreadShellSchema = Schema.Struct({
+  id: Schema.String,
+  projectId: Schema.String,
+  title: Schema.String,
+  modelSelection: ModelSelectionSchema,
+  runtimeMode: Schema.String,
+  interactionMode: Schema.String,
+  branch: Schema.NullOr(Schema.String),
+  worktreePath: Schema.NullOr(Schema.String),
+  latestTurn: Schema.NullOr(Schema.Struct({ state: Schema.String })),
+  createdAt: Schema.String,
+  updatedAt: Schema.String,
+  session: Schema.NullOr(ThreadSessionSchema),
+  latestUserMessageAt: Schema.optionalKey(Schema.NullOr(Schema.String)),
+});
+export type ThreadShell = typeof ThreadShellSchema.Type;
+
+export const ThreadDetailSchema = Schema.Struct({
+  id: Schema.String,
+  projectId: Schema.String,
+  title: Schema.String,
+  modelSelection: ModelSelectionSchema,
+  runtimeMode: Schema.String,
+  interactionMode: Schema.String,
+  branch: Schema.NullOr(Schema.String),
+  worktreePath: Schema.NullOr(Schema.String),
+  latestTurn: Schema.NullOr(Schema.Struct({ state: Schema.String })),
+  createdAt: Schema.String,
+  updatedAt: Schema.String,
+  session: Schema.NullOr(ThreadSessionSchema),
+  latestUserMessageAt: Schema.optionalKey(Schema.NullOr(Schema.String)),
+  messages: Schema.Array(ThreadMessageSchema),
+  activities: Schema.optionalKey(Schema.Array(Schema.Unknown)),
+});
+export type ThreadDetail = typeof ThreadDetailSchema.Type;
+
+export const ShellSnapshotSchema = Schema.Struct({
+  snapshotSequence: Schema.Number,
+  projects: Schema.Array(ProjectShellSchema),
+  threads: Schema.Array(ThreadShellSchema),
+  updatedAt: Schema.String,
+});
+export type ShellSnapshot = typeof ShellSnapshotSchema.Type;
+
+export const ServerProviderSchema = Schema.Struct({
+  instanceId: Schema.String,
+  displayName: Schema.optionalKey(Schema.String),
+  enabled: Schema.Boolean,
+  installed: Schema.Boolean,
+  status: Schema.Literals(["ready", "warning", "error", "disabled"]),
+  auth: Schema.Struct({
+    status: Schema.Literals(["authenticated", "unauthenticated", "unknown"]),
+  }),
+  models: Schema.Array(
+    Schema.Struct({
+      slug: Schema.String,
+      name: Schema.String,
+    }),
+  ),
+});
+export type ServerProvider = typeof ServerProviderSchema.Type;
+export type ServerProviderModel = NonNullable<ServerProvider["models"]>[number];
+
+export const ServerConfigSchema = Schema.Struct({
+  providers: Schema.optionalKey(Schema.Array(ServerProviderSchema)),
+});
+export type ServerConfig = typeof ServerConfigSchema.Type;
+
+export const ThreadMessageSentEventSchema = Schema.Struct({
+  type: Schema.Literal("thread.message-sent"),
+  payload: Schema.Struct({
+    messageId: Schema.String,
+    role: Schema.Literals(["user", "assistant", "system"]),
+    text: Schema.String,
+    turnId: Schema.NullOr(Schema.String),
+    streaming: Schema.optionalKey(Schema.Boolean),
+    createdAt: Schema.String,
+    updatedAt: Schema.String,
+  }),
+});
+export type ThreadMessageSentEvent = typeof ThreadMessageSentEventSchema.Type;
+
+export const ThreadSessionSetEventSchema = Schema.Struct({
+  type: Schema.Literal("thread.session-set"),
+  payload: Schema.Struct({
+    session: Schema.NullOr(ThreadSessionSchema),
+  }),
+});
+export type ThreadSessionSetEvent = typeof ThreadSessionSetEventSchema.Type;
+
+export const UnknownThreadEventSchema = Schema.Struct({
+  type: Schema.String,
+  payload: Schema.Record(Schema.String, Schema.Unknown),
+});
+export type UnknownThreadEvent = typeof UnknownThreadEventSchema.Type;
+
+export const ThreadEventSchema = Schema.Union([
+  ThreadMessageSentEventSchema,
+  ThreadSessionSetEventSchema,
+  UnknownThreadEventSchema,
+]);
+export type ThreadEvent = typeof ThreadEventSchema.Type;
+
+export const decodeModelSelection = Schema.decodeUnknownSync(ModelSelectionSchema);

package/src/domain/thread-lifecycle.ts

@@ -0,0 +1,97 @@
+import * as Schema from "effect/Schema";
+
+import {
+  type ThreadDetail,
+  type ThreadEvent,
+  type ThreadMessage,
+  type ThreadShell,
+  ThreadMessageSchema,
+  ThreadMessageSentEventSchema,
+  ThreadSessionSetEventSchema,
+} from "./schema.ts";
+
+const isThreadMessageSentEvent = Schema.is(ThreadMessageSentEventSchema);
+const isThreadSessionSetEvent = Schema.is(ThreadSessionSetEventSchema);
+
+export function isThreadActive(thread: ThreadShell | ThreadDetail) {
+  return (
+    thread.session?.status === "starting" ||
+    thread.session?.status === "running" ||
+    thread.latestTurn?.state === "running" ||
+    isPendingStart(thread)
+  );
+}
+
+export function threadStatus(thread: ThreadShell | ThreadDetail) {
+  if (isPendingStart(thread)) {
+    return "pending";
+  }
+  return thread.session?.status ?? thread.latestTurn?.state ?? "unknown";
+}
+
+export function latestAssistantMessage(thread: ThreadDetail) {
+  return thread.messages.toReversed().find((message) => message.role === "assistant");
+}
+
+export function isThreadCompleteEnough(thread: ThreadDetail) {
+  if (thread.session?.status === "error" || thread.session?.status === "interrupted") {
+    return true;
+  }
+  const lastUserIndex = thread.messages.findLastIndex((message) => message.role === "user");
+  if (lastUserIndex === -1) {
+    return true;
+  }
+  return thread.messages.slice(lastUserIndex + 1).some((message) => message.role === "assistant");
+}
+
+export function applyThreadEvent(
+  current: ThreadDetail,
+  event: ThreadEvent,
+  messages: Map<string, ThreadMessage>,
+) {
+  const message = messageFromEvent(event, messages);
+  if (message !== null) {
+    messages.set(messageKey(message), message);
+    return { ...current, messages: [...messages.values()] };
+  }
+  if (isThreadSessionSetEvent(event)) {
+    return {
+      ...current,
+      session: event.payload.session,
+    };
+  }
+  return current;
+}
+
+export function messageFromEvent(
+  event: ThreadEvent,
+  existingMessages: Map<string, ThreadMessage> = new Map(),
+): ThreadMessage | null {
+  if (!isThreadMessageSentEvent(event)) {
+    return null;
+  }
+  const payload = event.payload;
+  const id = payload.messageId;
+  const previous = existingMessages.get(id);
+  const text = payload.text;
+  return Schema.decodeUnknownSync(ThreadMessageSchema)({
+    id,
+    role: payload.role,
+    text: text.length > 0 || previous === undefined ? text : previous.text,
+    turnId: payload.turnId,
+    ...(payload.streaming !== undefined ? { streaming: payload.streaming } : {}),
+    createdAt: payload.createdAt,
+    updatedAt: payload.updatedAt,
+  });
+}
+
+export function messageKey(message: ThreadMessage) {
+  return message.id ?? message.messageId ?? `${message.role}:${message.createdAt}`;
+}
+
+function isPendingStart(thread: ThreadShell | ThreadDetail) {
+  if (thread.session !== null || thread.latestTurn !== null || !("messages" in thread)) {
+    return false;
+  }
+  return thread.messages.at(-1)?.role === "user";
+}

package/src/environment/layer.ts

@@ -0,0 +1,12 @@
+import { homedir } from "node:os";
+import * as Layer from "effect/Layer";
+
+import { Environment } from "./service.ts";
+
+export const NodeEnvironmentLive = Layer.succeed(Environment)({
+  cwd: process.cwd(),
+  homeDir: homedir(),
+  env: process.env,
+  stdoutIsTTY: process.stdout.isTTY ?? false,
+  stderrIsTTY: process.stderr.isTTY ?? false,
+});

package/src/environment/service.ts

@@ -0,0 +1,13 @@
+import * as Context from "effect/Context";
+
+export type EnvironmentShape = {
+  readonly cwd: string;
+  readonly homeDir: string;
+  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly stdoutIsTTY: boolean;
+  readonly stderrIsTTY: boolean;
+};
+
+export class Environment extends Context.Service<Environment, EnvironmentShape>()(
+  "t3cli/Environment",
+) {}