t3code-cli 0.1.0

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "t3code-cli",
+  "version": "0.1.0",
+  "description": "CLI for t3code",
+  "keywords": [
+    "claude",
+    "cli",
+    "codex",
+    "t3code"
+  ],
+  "homepage": "https://github.com/tarik02/t3cli#readme",
+  "bugs": {
+    "url": "https://github.com/tarik02/t3cli/issues"
+  },
+  "license": "MIT",
+  "author": "tarik02 <taras.fomin@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tarik02/t3cli.git"
+  },
+  "bin": {
+    "t3cli": "./dist/bin.js"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./src/index.ts"
+    }
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.31.0",
+    "@effect/platform-node": "4.0.0-beta.74",
+    "@types/node": "^25.9.1",
+    "effect": "4.0.0-beta.74",
+    "typescript": "^6.0.3",
+    "vite-plus": "^0.1.24"
+  },
+  "engines": {
+    "node": "^24.0.0"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "check": "vp check",
+    "format": "vp fmt",
+    "format:check": "vp fmt --check",
+    "lint": "vp lint",
+    "lint:fix": "vp lint --fix",
+    "changeset": "changeset",
+    "release:check": "pnpm check && pnpm typecheck && pnpm pack --dry-run",
+    "release:publish": "pnpm publish --access public --no-git-checks",
+    "release:publish:dry-run": "pnpm publish --access public --dry-run --no-git-checks",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/application/error.ts

@@ -0,0 +1,4 @@
+import type { DomainError } from "../domain/error.ts";
+import type { RpcError } from "../rpc/error.ts";
+
+export type ApplicationError = DomainError | RpcError;

package/src/application/layer.ts

@@ -0,0 +1,20 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import { makeModelsApplication } from "./models.ts";
+import { makeProjectApplication } from "./projects.ts";
+import { T3Application } from "./service.ts";
+import { makeThreadApplication } from "./threads.ts";
+
+export const makeT3Application = Effect.fn("makeT3Application")(function* () {
+  const models = yield* makeModelsApplication();
+  const projects = yield* makeProjectApplication();
+  const threads = yield* makeThreadApplication();
+  return {
+    ...models,
+    ...projects,
+    ...threads,
+  };
+});
+
+export const T3ApplicationLive = Layer.effect(T3Application, makeT3Application());

package/src/application/model-selection.ts

@@ -0,0 +1,109 @@
+import * as Effect from "effect/Effect";
+
+import { ModelSelectionError } from "../domain/error.ts";
+import {
+  findSelectableProvider,
+  firstSelectableModel,
+  firstSelectableProvider,
+} from "../domain/model-config.ts";
+import {
+  decodeModelSelection,
+  type ModelSelection,
+  type ProjectShell,
+  type ServerConfig,
+} from "../domain/schema.ts";
+import type { StartThreadInput } from "./service.ts";
+
+export function resolveModelSelection(input: {
+  readonly start: StartThreadInput;
+  readonly project: ProjectShell;
+  readonly serverConfig: ServerConfig;
+}) {
+  return Effect.gen(function* () {
+    if (input.start.provider !== undefined && input.start.model !== undefined) {
+      return withModelOptions(input.start, {
+        instanceId: input.start.provider,
+        model: input.start.model,
+      });
+    }
+    if (input.start.provider !== undefined) {
+      const provider = yield* findProvider(input.serverConfig, input.start.provider);
+      const model = firstSelectableModel(provider);
+      if (model === undefined) {
+        return yield* failNoAvailableModel();
+      }
+      return withModelOptions(input.start, {
+        instanceId: input.start.provider,
+        model: model.slug,
+      });
+    }
+    if (input.start.model !== undefined) {
+      const provider = yield* firstAvailableModel(input.serverConfig);
+      return withModelOptions(input.start, {
+        instanceId: provider.instanceId,
+        model: input.start.model,
+      });
+    }
+    if (input.project.defaultModelSelection !== null) {
+      return withModelOptions(input.start, input.project.defaultModelSelection);
+    }
+    const provider = yield* firstAvailableModel(input.serverConfig);
+    const model = firstSelectableModel(provider);
+    if (model === undefined) {
+      return yield* failNoAvailableModel();
+    }
+    return withModelOptions(input.start, {
+      instanceId: provider.instanceId,
+      model: model.slug,
+    });
+  });
+}
+
+export function mergeModelOptions(
+  selection: ModelSelection,
+  options: NonNullable<ModelSelection["options"]>,
+): ModelSelection {
+  if (options.length === 0) {
+    return selection;
+  }
+  const optionsById = new Map((selection.options ?? []).map((option) => [option.id, option]));
+  for (const option of options) {
+    optionsById.set(option.id, option);
+  }
+  return decodeModelSelection({
+    ...selection,
+    options: [...optionsById.values()],
+  });
+}
+
+function withModelOptions(input: StartThreadInput, selection: ModelSelection): ModelSelection {
+  if (input.options === undefined || input.options.length === 0) {
+    return selection;
+  }
+  return mergeModelOptions(selection, input.options);
+}
+
+function firstAvailableModel(serverConfig: ServerConfig) {
+  const providers = serverConfig.providers ?? [];
+  const provider = firstSelectableProvider(providers);
+  if (provider === undefined) {
+    return failNoAvailableModel();
+  }
+  return Effect.succeed(provider);
+}
+
+function findProvider(serverConfig: ServerConfig, instanceId: string) {
+  const provider = findSelectableProvider(serverConfig.providers ?? [], instanceId);
+  if (provider === undefined) {
+    return failNoAvailableModel();
+  }
+  return Effect.succeed(provider);
+}
+
+function failNoAvailableModel() {
+  return Effect.fail(
+    new ModelSelectionError({
+      message: "no available provider model found; pass --provider and --model",
+    }),
+  );
+}

package/src/application/models.ts

@@ -0,0 +1,26 @@
+import * as Effect from "effect/Effect";
+
+import { filterProvidersForModelListing } from "../domain/model-config.ts";
+import { T3Orchestration } from "../orchestration/service.ts";
+
+export const makeModelsApplication = Effect.fn("makeModelsApplication")(function* () {
+  const orchestration = yield* T3Orchestration;
+
+  const listModels = Effect.fn("T3Application.listModels")(function* (input: {
+    readonly all?: boolean;
+    readonly provider?: string;
+  }) {
+    const config = yield* orchestration.getServerConfig();
+    return filterProvidersForModelListing({
+      providers: config.providers ?? [],
+      all: input.all === true,
+      ...(input.provider !== undefined && input.provider.length > 0
+        ? { provider: input.provider }
+        : {}),
+    });
+  });
+
+  return {
+    listModels,
+  };
+});

package/src/application/project-commands.ts

@@ -0,0 +1,28 @@
+import * as Crypto from "effect/Crypto";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as Path from "effect/Path";
+
+import { Environment } from "../environment/service.ts";
+import type { ProjectCreateCommand } from "../domain/command-schema.ts";
+
+export const makeProjectCreateCommand = Effect.fn("makeProjectCreateCommand")(function* (input: {
+  readonly path: string;
+  readonly title?: string;
+}) {
+  const path = yield* Path.Path;
+  const crypto = yield* Crypto.Crypto;
+  const environment = yield* Environment;
+  const workspaceRoot = path.resolve(environment.cwd, input.path);
+  const projectId = yield* crypto.randomUUIDv4.pipe(Effect.orDie);
+  const title = input.title?.trim();
+  const createdAt = DateTime.formatIso(yield* DateTime.now);
+  return {
+    type: "project.create",
+    commandId: `t3cli:project-create:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    projectId,
+    title: title !== undefined && title.length > 0 ? title : path.basename(workspaceRoot),
+    workspaceRoot,
+    createdAt,
+  } satisfies ProjectCreateCommand & { readonly projectId: string };
+});

package/src/application/projects.ts

@@ -0,0 +1,50 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Path from "effect/Path";
+
+import { Environment } from "../environment/service.ts";
+import { T3Orchestration } from "../orchestration/service.ts";
+import { ProjectCreateVisibilityError } from "../domain/error.ts";
+import { findProjectById } from "../domain/helpers.ts";
+import { makeProjectCreateCommand } from "./project-commands.ts";
+import { waitForShellSequence } from "./shell-sequence.ts";
+
+export const makeProjectApplication = Effect.fn("makeProjectApplication")(function* () {
+  const orchestration = yield* T3Orchestration;
+  const crypto = yield* Crypto.Crypto;
+  const path = yield* Path.Path;
+  const environment = yield* Environment;
+  const loadShell = Effect.fn("T3ApplicationLive.loadShell")(function* () {
+    return yield* orchestration.getShellSnapshot();
+  });
+  const addProject = Effect.fn("T3ApplicationLive.addProject")(function* (projectInput: {
+    readonly path: string;
+    readonly title?: string;
+  }) {
+    const command = yield* makeProjectCreateCommand(projectInput).pipe(
+      Effect.provideService(Path.Path, path),
+      Effect.provideService(Crypto.Crypto, crypto),
+      Effect.provideService(Environment, environment),
+    );
+    const dispatch = yield* orchestration.dispatch(command);
+    const snapshot = yield* waitForShellSequence({
+      orchestration,
+      sequence: dispatch.sequence,
+    });
+    const project = findProjectById(snapshot, command.projectId);
+    if (project === null) {
+      return yield* Effect.fail(
+        new ProjectCreateVisibilityError({
+          message: `project created but not visible in shell snapshot: ${command.projectId}`,
+          projectId: command.projectId,
+        }),
+      );
+    }
+    return { dispatch, project };
+  });
+
+  return {
+    loadShell,
+    addProject,
+  };
+});

package/src/application/service.ts

@@ -0,0 +1,93 @@
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import type * as Stream from "effect/Stream";
+
+import type { ApplicationError } from "./error.ts";
+import type { DispatchResult } from "../domain/command-schema.ts";
+import type {
+  ProjectShell,
+  ServerProvider,
+  ShellSnapshot,
+  ThreadDetail,
+  ThreadMessage,
+  ThreadShell,
+  ModelSelection,
+} from "../domain/schema.ts";
+
+export type StartThreadInput = {
+  readonly projectRef: string;
+  readonly message: string;
+  readonly title?: string;
+  readonly provider?: string;
+  readonly model?: string;
+  readonly options?: NonNullable<ModelSelection["options"]>;
+  readonly worktreePath?: string;
+};
+
+export type SendThreadInput = {
+  readonly threadId: string;
+  readonly message: string;
+  readonly options?: NonNullable<ModelSelection["options"]>;
+};
+
+export type StartThreadPolicy = {
+  readonly until: "dispatch" | "visible" | "complete";
+};
+
+export type WaitEvent =
+  | { readonly type: "thread"; readonly thread: ThreadDetail }
+  | { readonly type: "message"; readonly message: ThreadMessage }
+  | { readonly type: "status"; readonly status: string; readonly threadId: string }
+  | { readonly type: "done"; readonly thread: ThreadDetail };
+
+export class T3Application extends Context.Service<
+  T3Application,
+  {
+    readonly loadShell: () => Effect.Effect<ShellSnapshot, ApplicationError>;
+    readonly listModels: (input: {
+      readonly all?: boolean;
+      readonly provider?: string;
+    }) => Effect.Effect<ReadonlyArray<ServerProvider>, ApplicationError>;
+    readonly addProject: (input: {
+      readonly path: string;
+      readonly title?: string;
+    }) => Effect.Effect<
+      { readonly dispatch: DispatchResult; readonly project: ProjectShell },
+      ApplicationError
+    >;
+    readonly listThreads: (projectRef: string) => Effect.Effect<
+      {
+        readonly project: ProjectShell;
+        readonly threads: ReadonlyArray<ThreadShell>;
+      },
+      ApplicationError
+    >;
+    readonly getThreadMessages: (threadId: string) => Effect.Effect<ThreadDetail, ApplicationError>;
+    readonly archiveThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
+    readonly startThread: (
+      input: StartThreadInput,
+      policy?: StartThreadPolicy,
+    ) => Effect.Effect<
+      {
+        readonly dispatch: DispatchResult;
+        readonly project: ProjectShell;
+        readonly threadId: string;
+        readonly thread?: ThreadDetail;
+      },
+      ApplicationError
+    >;
+    readonly sendThread: (
+      input: SendThreadInput,
+      policy?: StartThreadPolicy,
+    ) => Effect.Effect<
+      {
+        readonly dispatch: DispatchResult;
+        readonly threadId: string;
+        readonly thread?: ThreadDetail;
+      },
+      ApplicationError
+    >;
+    readonly watchThread: (threadId: string) => Stream.Stream<WaitEvent, ApplicationError>;
+    readonly waitForThread: (threadId: string) => Effect.Effect<ThreadDetail, ApplicationError>;
+  }
+>()("t3cli/T3Application") {}

package/src/application/shell-sequence.ts

@@ -0,0 +1,29 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+
+import type { Orchestration } from "../orchestration/service.ts";
+import { RpcError } from "../rpc/error.ts";
+import { ORCHESTRATION_WS_METHODS } from "../protocol/schema.ts";
+
+export function waitForShellSequence(input: {
+  readonly orchestration: Orchestration;
+  readonly sequence: number;
+}) {
+  return Effect.gen(function* () {
+    const sequence = yield* input.orchestration.watchShellSequence().pipe(
+      Stream.filter((snapshotSequence) => snapshotSequence >= input.sequence),
+      Stream.runHead,
+      Effect.scoped,
+    );
+    if (Option.isNone(sequence)) {
+      return yield* Effect.fail(
+        new RpcError({
+          message: `shell stream ended before sequence ${input.sequence}`,
+          method: ORCHESTRATION_WS_METHODS.subscribeShell,
+        }),
+      );
+    }
+    return yield* input.orchestration.getShellSnapshot();
+  });
+}

package/src/application/thread-commands.ts

@@ -0,0 +1,89 @@
+import * as Crypto from "effect/Crypto";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+
+import type {
+  ThreadArchiveCommand,
+  ThreadCreateCommand,
+  ThreadTurnStartCommand,
+} from "../domain/command-schema.ts";
+import type { ModelSelection, ProjectShell, ServerConfig } from "../domain/schema.ts";
+import { resolveModelSelection } from "./model-selection.ts";
+import type { SendThreadInput, StartThreadInput } from "./service.ts";
+
+export const makeThreadStartCommands = Effect.fn("makeThreadStartCommands")(function* (input: {
+  readonly start: StartThreadInput;
+  readonly project: ProjectShell;
+  readonly serverConfig: ServerConfig;
+}) {
+  const crypto = yield* Crypto.Crypto;
+  const threadId = yield* crypto.randomUUIDv4.pipe(Effect.orDie);
+  const createdAt = DateTime.formatIso(yield* DateTime.now);
+  const modelSelection = yield* resolveModelSelection(input);
+  const inputTitle = input.start.title?.trim();
+  const messageTitle = input.start.message.trim().split(/\s+/).slice(0, 8).join(" ");
+  const title = inputTitle !== undefined && inputTitle.length > 0 ? inputTitle : messageTitle;
+  const createCommand = {
+    type: "thread.create",
+    commandId: `t3cli:thread-create:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    threadId,
+    projectId: input.project.id,
+    title: title.length > 0 ? title : "New thread",
+    modelSelection,
+    runtimeMode: "full-access",
+    interactionMode: "default",
+    branch: null,
+    worktreePath: input.start.worktreePath ?? null,
+    createdAt,
+  } satisfies ThreadCreateCommand;
+  const turnCommand = {
+    type: "thread.turn.start",
+    commandId: `t3cli:thread-start:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    threadId,
+    message: {
+      messageId: yield* crypto.randomUUIDv4.pipe(Effect.orDie),
+      role: "user",
+      text: input.start.message,
+      attachments: [],
+    },
+    modelSelection,
+    titleSeed: title,
+    runtimeMode: "full-access",
+    interactionMode: "default",
+    createdAt,
+  } satisfies ThreadTurnStartCommand;
+  return { createCommand, turnCommand, threadId };
+});
+
+export const makeThreadTurnContinueCommand = Effect.fn("makeThreadTurnContinueCommand")(function* (
+  input: SendThreadInput & { readonly modelSelection?: ModelSelection },
+) {
+  const crypto = yield* Crypto.Crypto;
+  const createdAt = DateTime.formatIso(yield* DateTime.now);
+  return {
+    type: "thread.turn.start",
+    commandId: `t3cli:thread-start:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    threadId: input.threadId,
+    message: {
+      messageId: yield* crypto.randomUUIDv4.pipe(Effect.orDie),
+      role: "user",
+      text: input.message,
+      attachments: [],
+    },
+    runtimeMode: "full-access",
+    interactionMode: "default",
+    ...(input.modelSelection !== undefined ? { modelSelection: input.modelSelection } : {}),
+    createdAt,
+  } satisfies ThreadTurnStartCommand;
+});
+
+export const makeThreadArchiveCommand = Effect.fn("makeThreadArchiveCommand")(function* (
+  threadId: string,
+) {
+  const crypto = yield* Crypto.Crypto;
+  return {
+    type: "thread.archive",
+    commandId: `t3cli:thread-archive:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    threadId,
+  } satisfies ThreadArchiveCommand;
+});

package/src/application/thread-wait.ts

@@ -0,0 +1,86 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+
+import { ThreadSessionError } from "../domain/error.ts";
+import type { Orchestration } from "../orchestration/service.ts";
+import type { ThreadDetail, ThreadMessage } from "../domain/schema.ts";
+import type { WaitEvent } from "./service.ts";
+import {
+  applyThreadEvent,
+  isThreadActive,
+  isThreadCompleteEnough,
+  messageFromEvent,
+  messageKey,
+  threadStatus,
+} from "../domain/thread-lifecycle.ts";
+
+export function watchThread(input: {
+  readonly orchestration: Orchestration;
+  readonly threadId: string;
+}) {
+  let current: ThreadDetail | undefined;
+  let currentMessages: Map<string, ThreadMessage> | undefined;
+  return Stream.scoped(
+    input.orchestration.watchThreadItems(input.threadId).pipe(
+      Stream.flatMap((item) => {
+        if (item.kind === "snapshot") {
+          const messages = new Map<string, ThreadMessage>();
+          for (const message of item.snapshot.thread.messages) {
+            messages.set(messageKey(message), message);
+          }
+          current = item.snapshot.thread;
+          currentMessages = messages;
+
+          const events: Array<WaitEvent> = [
+            { type: "thread", thread: current },
+            { type: "status", status: threadStatus(current), threadId: current.id },
+          ];
+          if (!isThreadActive(current) && isThreadCompleteEnough(current)) {
+            events.push({ type: "done", thread: current });
+          }
+          return Stream.fromIterable(events);
+        }
+
+        if (current === undefined || currentMessages === undefined) {
+          return Stream.fail(
+            new ThreadSessionError({
+              message: `thread stream event received before snapshot: ${input.threadId}`,
+              threadId: input.threadId,
+            }),
+          );
+        }
+
+        current = applyThreadEvent(current, item.event, currentMessages);
+        const message = messageFromEvent(item.event, currentMessages);
+        const events: Array<WaitEvent> = message !== null ? [{ type: "message", message }] : [];
+        events.push({ type: "status", status: threadStatus(current), threadId: current.id });
+        if (!isThreadActive(current) && isThreadCompleteEnough(current)) {
+          events.push({ type: "done", thread: current });
+        }
+        return Stream.fromIterable(events);
+      }),
+      Stream.takeUntil((event) => event.type === "done"),
+    ),
+  );
+}
+
+export function waitForThread(input: {
+  readonly orchestration: Orchestration;
+  readonly threadId: string;
+}) {
+  return watchThread(input).pipe(
+    Stream.runLast,
+    Effect.flatMap((event) => {
+      if (Option.isSome(event) && event.value.type === "done") {
+        return Effect.succeed(event.value.thread);
+      }
+      return Effect.fail(
+        new ThreadSessionError({
+          message: `thread wait ended without done event: ${input.threadId}`,
+          threadId: input.threadId,
+        }),
+      );
+    }),
+  );
+}