t3code-cli 0.10.0 → 0.12.0

package/src/application/models.ts

@@ -2,25 +2,25 @@ import * as Effect from "effect/Effect";
 
 import { filterProvidersForModelListing } from "../domain/model-config.ts";
 import { T3Orchestration } from "../orchestration/service.ts";
+import type { T3ModelApplicationService } from "./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 }
-        : {}),
-    });
-  });
+  const listModels: T3ModelApplicationService["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,
-  };
+  } satisfies T3ModelApplicationService;
 });

package/src/application/project-commands.ts

@@ -2,18 +2,16 @@ 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 { CommandId, ProjectId, type ClientOrchestrationCommand } from "#t3tools/contracts";
-
-import { Environment } from "../environment/service.ts";
+import { CommandId, ProjectId, type ClientOrchestrationCommand } from "@t3tools/contracts";
 
 export const makeProjectCreateCommand = Effect.fn("makeProjectCreateCommand")(function* (input: {
   readonly path: string;
   readonly title?: string;
+  readonly cwd: string;
 }) {
   const path = yield* Path.Path;
   const crypto = yield* Crypto.Crypto;
-  const environment = yield* Environment;
-  const workspaceRoot = path.resolve(environment.cwd, input.path);
+  const workspaceRoot = path.resolve(input.cwd, input.path);
   const projectId = ProjectId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
   const title = input.title?.trim();
   const createdAt = DateTime.formatIso(yield* DateTime.now);
@@ -28,3 +26,38 @@ export const makeProjectCreateCommand = Effect.fn("makeProjectCreateCommand")(fu
     createdAt,
   } satisfies Extract<ClientOrchestrationCommand, { readonly type: "project.create" }>;
 });
+
+export const makeProjectDeleteCommand = Effect.fn("makeProjectDeleteCommand")(function* (input: {
+  readonly projectId: string;
+  readonly force?: boolean;
+}) {
+  const crypto = yield* Crypto.Crypto;
+  return {
+    type: "project.delete",
+    commandId: CommandId.make(
+      `t3cli:project-delete:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    ),
+    projectId: ProjectId.make(input.projectId),
+    ...(input.force === true ? { force: true } : {}),
+  } satisfies Extract<ClientOrchestrationCommand, { readonly type: "project.delete" }>;
+});
+
+export const makeProjectMetaUpdateCommand = Effect.fn("makeProjectMetaUpdateCommand")(
+  function* (input: {
+    readonly projectId: string;
+    readonly scripts: Extract<
+      ClientOrchestrationCommand,
+      { readonly type: "project.meta.update" }
+    >["scripts"];
+  }) {
+    const crypto = yield* Crypto.Crypto;
+    return {
+      type: "project.meta.update",
+      commandId: CommandId.make(
+        `t3cli:project-meta-update:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+      ),
+      projectId: ProjectId.make(input.projectId),
+      scripts: input.scripts,
+    } satisfies Extract<ClientOrchestrationCommand, { readonly type: "project.meta.update" }>;
+  },
+);

package/src/application/projects.ts

@@ -2,35 +2,52 @@ 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 { CliRuntime } from "../cli/runtime/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 { ProjectCreateVisibilityError, ProjectLookupError } from "../domain/error.ts";
+import { findProjectById, resolveProjectScope } from "../domain/helpers.ts";
+import { makeProjectCreateCommand, makeProjectDeleteCommand } from "./project-commands.ts";
 import { waitForShellSequence } from "./shell-sequence.ts";
+import type { T3ProjectApplicationService } from "./service.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* () {
+  const cliRuntime = yield* CliRuntime;
+  const loadShell: T3ProjectApplicationService["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 resolveProject: T3ProjectApplicationService["resolveProject"] = Effect.fn(
+    "T3ApplicationLive.resolveProject",
+  )(function* (projectRef: string) {
+    const snapshot = yield* orchestration.getShellSnapshot();
+    const scope = yield* resolveProjectScope(snapshot, {
+      ref: projectRef,
+    }).pipe(Effect.provideService(Path.Path, path));
+    if (scope === undefined) {
+      return yield* Effect.fail(
+        new ProjectLookupError({
+          message: `project not found: ${projectRef}`,
+          ref: projectRef,
+        }),
+      );
+    }
+    return scope.project;
+  });
+  const addProject: T3ProjectApplicationService["addProject"] = Effect.fn(
+    "T3ApplicationLive.addProject",
+  )(function* (projectInput: { readonly path: string; readonly title?: string }) {
+    const command = yield* makeProjectCreateCommand({
+      ...projectInput,
+      cwd: cliRuntime.cwd,
+    }).pipe(Effect.provideService(Path.Path, path), Effect.provideService(Crypto.Crypto, crypto));
     const dispatch = yield* orchestration.dispatch(command);
-    const snapshot = yield* waitForShellSequence({
-      orchestration,
-      sequence: dispatch.sequence,
-    });
+    const snapshot = yield* waitForShellSequence({ sequence: dispatch.sequence }).pipe(
+      Effect.provideService(T3Orchestration, orchestration),
+    );
     const project = findProjectById(snapshot, command.projectId);
     if (project === null) {
       return yield* Effect.fail(
@@ -42,9 +59,21 @@ export const makeProjectApplication = Effect.fn("makeProjectApplication")(functi
     }
     return { dispatch, project };
   });
+  const deleteProject: T3ProjectApplicationService["deleteProject"] = Effect.fn(
+    "T3ApplicationLive.deleteProject",
+  )(function* (input: { readonly projectId: string; readonly force?: boolean }) {
+    const command = yield* makeProjectDeleteCommand({
+      projectId: input.projectId,
+      ...(input.force === true ? { force: true } : {}),
+    }).pipe(Effect.provideService(Crypto.Crypto, crypto));
+    const dispatch = yield* orchestration.dispatch(command);
+    return { projectId: input.projectId, dispatch };
+  });
 
   return {
     loadShell,
     addProject,
-  };
+    resolveProject,
+    deleteProject,
+  } satisfies T3ProjectApplicationService;
 });

package/src/application/service.ts

@@ -9,9 +9,15 @@ import type {
   OrchestrationShellSnapshot,
   OrchestrationThread,
   OrchestrationThreadShell,
+  ProjectScript,
+  ProjectScriptIcon,
   ProviderUserInputAnswers,
   ServerProvider,
-} from "#t3tools/contracts";
+  TerminalAttachStreamEvent,
+  TerminalMetadataStreamEvent,
+  TerminalSessionSnapshot,
+  TerminalSummary,
+} from "@t3tools/contracts";
 
 import type { ApplicationError } from "./error.ts";
 import type { ThreadShow } from "./threads.ts";
@@ -26,6 +32,23 @@ export type StartThreadInput = {
   readonly worktreePath?: string;
 };
 
+export type CreateTerminalInput = {
+  readonly threadId: string;
+  readonly terminalId?: string;
+  readonly command?: string;
+  readonly env?: Readonly<Record<string, string>>;
+};
+
+export type TerminalRef = {
+  readonly threadId: string;
+  readonly terminalId: string;
+};
+
+export type TerminalAttachTarget = TerminalRef & {
+  readonly cwd: string;
+  readonly worktreePath: string | null;
+};
+
 export type SendThreadInput = {
   readonly threadId: string;
   readonly message: string;
@@ -38,6 +61,18 @@ export type CallbackThreadInput = {
   readonly prompt: string;
 };
 
+export type ListThreadsInclude = "active" | "archived" | "all";
+
+export type UpdateThreadInput = {
+  readonly threadId: string;
+  readonly title?: string;
+  readonly provider?: string;
+  readonly model?: string;
+  readonly options?: NonNullable<ModelSelection["options"]>;
+  readonly branch?: string | null;
+  readonly worktreePath?: string | null;
+};
+
 export type StartThreadPolicy = {
   readonly until: "dispatch" | "visible" | "complete";
 };
@@ -48,82 +83,244 @@ export type WaitEvent =
   | { readonly type: "status"; readonly status: string; readonly threadId: string }
   | { readonly type: "done"; readonly thread: OrchestrationThread };
 
-export class T3Application extends Context.Service<
-  T3Application,
-  {
-    readonly loadShell: () => Effect.Effect<OrchestrationShellSnapshot, 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: OrchestrationProjectShell },
-      ApplicationError
-    >;
-    readonly listThreads: (projectRef: string) => Effect.Effect<
-      {
-        readonly project: OrchestrationProjectShell;
-        readonly threads: ReadonlyArray<OrchestrationThreadShell>;
-      },
-      ApplicationError
-    >;
-    readonly getThreadMessages: (
-      threadId: string,
-    ) => Effect.Effect<OrchestrationThread, ApplicationError>;
-    readonly showThread: (threadId: string) => Effect.Effect<ThreadShow, ApplicationError>;
-    readonly approveThread: (input: {
+export type ProjectActionSelector =
+  | { readonly id: string; readonly name?: never }
+  | { readonly id?: never; readonly name: string };
+
+export type AddProjectActionInput = {
+  readonly projectRef: string;
+  readonly id?: string;
+  readonly name: string;
+  readonly command: string;
+  readonly icon?: ProjectScriptIcon;
+  readonly setup?: boolean;
+  readonly previewUrl?: string;
+  readonly autoOpenPreview?: boolean;
+};
+
+export type UpdateProjectActionInput = {
+  readonly projectRef: string;
+  readonly selector: ProjectActionSelector;
+  readonly name?: string;
+  readonly command?: string;
+  readonly icon?: ProjectScriptIcon;
+  readonly setup?: boolean;
+  readonly previewUrl?: string | null;
+  readonly autoOpenPreview?: boolean | null;
+};
+
+export type ProjectActionMutationResult = {
+  readonly dispatch: DispatchResult;
+  readonly project: OrchestrationProjectShell;
+  readonly action: ProjectScript;
+};
+
+export type ProjectActionDeleteResult = {
+  readonly dispatch: DispatchResult;
+  readonly project: OrchestrationProjectShell;
+  readonly action: ProjectScript;
+};
+
+export type ProjectActionRunResult = {
+  readonly project: OrchestrationProjectShell;
+  readonly action: ProjectScript;
+  readonly terminal: TerminalSessionSnapshot;
+};
+
+export type T3ActionApplicationService = {
+  readonly listActions: (projectRef: string) => Effect.Effect<
+    {
+      readonly project: OrchestrationProjectShell;
+      readonly actions: ReadonlyArray<ProjectScript>;
+    },
+    ApplicationError
+  >;
+  readonly addAction: (
+    input: AddProjectActionInput,
+  ) => Effect.Effect<ProjectActionMutationResult, ApplicationError>;
+  readonly updateAction: (
+    input: UpdateProjectActionInput,
+  ) => Effect.Effect<ProjectActionMutationResult, ApplicationError>;
+  readonly deleteAction: (input: {
+    readonly projectRef: string;
+    readonly selector: ProjectActionSelector;
+  }) => Effect.Effect<ProjectActionDeleteResult, ApplicationError>;
+  readonly runAction: (input: {
+    readonly threadId: string;
+    readonly selector: ProjectActionSelector;
+    readonly terminalId?: string;
+  }) => Effect.Effect<ProjectActionRunResult, ApplicationError>;
+};
+
+export class T3ActionApplication extends Context.Service<
+  T3ActionApplication,
+  T3ActionApplicationService
+>()("t3cli/T3ActionApplication") {}
+
+export type T3ModelApplicationService = {
+  readonly listModels: (input: {
+    readonly all?: boolean;
+    readonly provider?: string;
+  }) => Effect.Effect<ReadonlyArray<ServerProvider>, ApplicationError>;
+};
+
+export class T3ModelApplication extends Context.Service<
+  T3ModelApplication,
+  T3ModelApplicationService
+>()("t3cli/T3ModelApplication") {}
+
+export type T3ProjectApplicationService = {
+  readonly loadShell: () => Effect.Effect<OrchestrationShellSnapshot, ApplicationError>;
+  readonly addProject: (input: {
+    readonly path: string;
+    readonly title?: string;
+  }) => Effect.Effect<
+    { readonly dispatch: DispatchResult; readonly project: OrchestrationProjectShell },
+    ApplicationError
+  >;
+  readonly resolveProject: (
+    projectRef: string,
+  ) => Effect.Effect<OrchestrationProjectShell, ApplicationError>;
+  readonly deleteProject: (input: {
+    readonly projectId: string;
+    readonly force?: boolean;
+  }) => Effect.Effect<
+    { readonly projectId: string; readonly dispatch: DispatchResult },
+    ApplicationError
+  >;
+};
+
+export class T3ProjectApplication extends Context.Service<
+  T3ProjectApplication,
+  T3ProjectApplicationService
+>()("t3cli/T3ProjectApplication") {}
+
+export type T3ThreadApplicationService = {
+  readonly listThreads: (
+    projectRef: string,
+    options?: {
+      readonly include?: ListThreadsInclude;
+    },
+  ) => Effect.Effect<
+    {
+      readonly project: OrchestrationProjectShell;
+      readonly threads: ReadonlyArray<OrchestrationThreadShell>;
+    },
+    ApplicationError
+  >;
+  readonly getThreadMessages: (
+    threadId: string,
+  ) => Effect.Effect<OrchestrationThread, ApplicationError>;
+  readonly showThread: (threadId: string) => Effect.Effect<ThreadShow, ApplicationError>;
+  readonly approveThread: (input: {
+    readonly threadId: string;
+    readonly requestId: string;
+    readonly decision: "accept" | "decline" | "cancel";
+  }) => Effect.Effect<
+    { readonly threadId: string; readonly requestId: string; readonly dispatch: DispatchResult },
+    ApplicationError
+  >;
+  readonly respondToThread: (input: {
+    readonly threadId: string;
+    readonly requestId: string;
+    readonly answers: ProviderUserInputAnswers;
+  }) => Effect.Effect<
+    { readonly threadId: string; readonly requestId: string; readonly dispatch: DispatchResult },
+    ApplicationError
+  >;
+  readonly archiveThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
+  readonly interruptThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
+  readonly unarchiveThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
+  readonly deleteThread: (
+    threadId: string,
+  ) => Effect.Effect<
+    { readonly threadId: string; readonly dispatch: DispatchResult },
+    ApplicationError
+  >;
+  readonly updateThread: (
+    input: UpdateThreadInput,
+  ) => Effect.Effect<DispatchResult, ApplicationError>;
+  readonly startThread: (
+    input: StartThreadInput,
+    policy?: StartThreadPolicy,
+  ) => Effect.Effect<
+    {
+      readonly dispatch: DispatchResult;
+      readonly project: OrchestrationProjectShell;
       readonly threadId: string;
-      readonly requestId: string;
-      readonly decision: "accept" | "decline" | "cancel";
-    }) => Effect.Effect<
-      { readonly threadId: string; readonly requestId: string; readonly dispatch: DispatchResult },
-      ApplicationError
-    >;
-    readonly respondToThread: (input: {
+      readonly thread?: OrchestrationThread;
+    },
+    ApplicationError
+  >;
+  readonly sendThread: (
+    input: SendThreadInput,
+    policy?: StartThreadPolicy,
+  ) => Effect.Effect<
+    {
+      readonly dispatch: DispatchResult;
       readonly threadId: string;
-      readonly requestId: string;
-      readonly answers: ProviderUserInputAnswers;
-    }) => Effect.Effect<
-      { readonly threadId: string; readonly requestId: string; readonly dispatch: DispatchResult },
-      ApplicationError
-    >;
-    readonly archiveThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
-    readonly startThread: (
-      input: StartThreadInput,
-      policy?: StartThreadPolicy,
-    ) => Effect.Effect<
-      {
-        readonly dispatch: DispatchResult;
-        readonly project: OrchestrationProjectShell;
-        readonly threadId: string;
-        readonly thread?: OrchestrationThread;
-      },
-      ApplicationError
-    >;
-    readonly sendThread: (
-      input: SendThreadInput,
-      policy?: StartThreadPolicy,
-    ) => Effect.Effect<
-      {
-        readonly dispatch: DispatchResult;
-        readonly threadId: string;
-        readonly thread?: OrchestrationThread;
-      },
-      ApplicationError
-    >;
-    readonly watchThread: (threadId: string) => Stream.Stream<WaitEvent, ApplicationError>;
-    readonly waitForThread: (
-      threadId: string,
-    ) => Effect.Effect<OrchestrationThread, ApplicationError>;
-    readonly callbackThread: (input: CallbackThreadInput) => Effect.Effect<
-      {
-        readonly dispatch: DispatchResult;
-        readonly targetThreadId: string;
-      },
-      ApplicationError
-    >;
-  }
->()("t3cli/T3Application") {}
+      readonly thread?: OrchestrationThread;
+    },
+    ApplicationError
+  >;
+  readonly watchThread: (threadId: string) => Stream.Stream<WaitEvent, ApplicationError>;
+  readonly waitForThread: (
+    threadId: string,
+  ) => Effect.Effect<OrchestrationThread, ApplicationError>;
+  readonly callbackThread: (input: CallbackThreadInput) => Effect.Effect<
+    {
+      readonly dispatch: DispatchResult;
+      readonly targetThreadId: string;
+    },
+    ApplicationError
+  >;
+};
+
+export class T3ThreadApplication extends Context.Service<
+  T3ThreadApplication,
+  T3ThreadApplicationService
+>()("t3cli/T3ThreadApplication") {}
+
+export type T3TerminalApplicationService = {
+  readonly listTerminals: (
+    threadId: string,
+  ) => Effect.Effect<ReadonlyArray<TerminalSummary>, ApplicationError>;
+  readonly getTerminal: (terminal: TerminalRef) => Effect.Effect<TerminalSummary, ApplicationError>;
+  readonly createTerminal: (
+    input: CreateTerminalInput,
+  ) => Effect.Effect<TerminalSessionSnapshot, ApplicationError>;
+  readonly attachTerminal: (input: {
+    readonly terminal: TerminalAttachTarget;
+    readonly cols?: number;
+    readonly rows?: number;
+  }) => Stream.Stream<TerminalAttachStreamEvent, ApplicationError>;
+  readonly watchTerminalMetadata: () => Stream.Stream<
+    TerminalMetadataStreamEvent,
+    ApplicationError
+  >;
+  readonly writeTerminal: (input: {
+    readonly terminal: TerminalRef;
+    readonly data: string;
+  }) => Effect.Effect<void, ApplicationError>;
+  readonly resizeTerminal: (input: {
+    readonly terminal: TerminalRef;
+    readonly cols: number;
+    readonly rows: number;
+  }) => Effect.Effect<void, ApplicationError>;
+  readonly destroyTerminal: (terminal: TerminalRef) => Effect.Effect<void, ApplicationError>;
+};
+
+export class T3TerminalApplication extends Context.Service<
+  T3TerminalApplication,
+  T3TerminalApplicationService
+>()("t3cli/T3TerminalApplication") {}
+
+export type T3ApplicationService = T3ModelApplicationService &
+  T3ActionApplicationService &
+  T3ProjectApplicationService &
+  T3ThreadApplicationService &
+  T3TerminalApplicationService;
+
+export class T3Application extends Context.Service<T3Application, T3ApplicationService>()(
+  "t3cli/T3Application",
+) {}

package/src/application/shell-sequence.ts

@@ -1,17 +1,15 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
-import { ORCHESTRATION_WS_METHODS } from "#t3tools/contracts";
+import { ORCHESTRATION_WS_METHODS } from "@t3tools/contracts";
 
-import type { Orchestration } from "../orchestration/service.ts";
+import { T3Orchestration } from "../orchestration/service.ts";
 import { RpcError } from "../rpc/error.ts";
 
-export function waitForShellSequence(input: {
-  readonly orchestration: Orchestration;
-  readonly sequence: number;
-}) {
+export function waitForShellSequence(input: { readonly sequence: number }) {
   return Effect.gen(function* () {
-    const sequence = yield* input.orchestration.watchShellSequence().pipe(
+    const orchestration = yield* T3Orchestration;
+    const sequence = yield* orchestration.watchShellSequence().pipe(
       Stream.filter((snapshotSequence) => snapshotSequence >= input.sequence),
       Stream.runHead,
       Effect.scoped,
@@ -24,6 +22,6 @@ export function waitForShellSequence(input: {
         }),
       );
     }
-    return yield* input.orchestration.getShellSnapshot();
+    return yield* orchestration.getShellSnapshot();
   });
 }