t3code-cli 0.10.0 → 0.11.0

package/src/cli/threads/delete.ts

@@ -0,0 +1,61 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command } from "effect/unstable/cli";
+
+import { requireDestructiveConfirmation } from "../confirm.ts";
+import { formatFlag, selfActionForceFlag, threadFlag, yesFlag } from "../flags.ts";
+import { formatThreadDeletedHuman } from "../thread-format.ts";
+import { MissingThreadError } from "../error.ts";
+import { requireSelfActionConfirmation } from "../self-action.ts";
+import { resolveThreadId } from "../../scope/index.ts";
+import { T3Application } from "../../application/service.ts";
+import { Environment } from "../../environment/service.ts";
+import { resolveOutputFormat } from "../output-format.ts";
+import { T3Output } from "../output/service.ts";
+
+export const deleteThreadCommand = Command.make(
+  "delete",
+  {
+    thread: threadFlag,
+    force: selfActionForceFlag,
+    yes: yesFlag,
+    format: formatFlag,
+  },
+  ({ thread, force, yes, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+      yield* requireSelfActionConfirmation({
+        threadId,
+        force,
+        environment,
+        action: "delete",
+      });
+      yield* requireDestructiveConfirmation({
+        message: `Delete thread ${threadId}?`,
+        yes,
+        environment,
+      });
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const result = yield* application.deleteThread(threadId);
+      if (resolvedFormat === "json") {
+        return yield* output.printJson({
+          threadId: result.threadId,
+          dispatch: result.dispatch,
+        });
+      }
+      return yield* output.printInfo(formatThreadDeletedHuman(result));
+    }),
+).pipe(Command.withDescription("delete thread"));

package/src/cli/threads/interrupt.ts

@@ -0,0 +1,52 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command } from "effect/unstable/cli";
+
+import { formatFlag, selfActionForceFlag, threadFlag } from "../flags.ts";
+import { MissingThreadError } from "../error.ts";
+import { requireSelfActionConfirmation } from "../self-action.ts";
+import { resolveThreadId } from "../../scope/index.ts";
+import { T3Application } from "../../application/service.ts";
+import { Environment } from "../../environment/service.ts";
+import { resolveOutputFormat } from "../output-format.ts";
+import { T3Output } from "../output/service.ts";
+
+export const interruptThreadCommand = Command.make(
+  "interrupt",
+  {
+    thread: threadFlag,
+    force: selfActionForceFlag,
+    format: formatFlag,
+  },
+  ({ thread, force, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+      yield* requireSelfActionConfirmation({
+        threadId,
+        force,
+        environment,
+        action: "interrupt",
+      });
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const dispatch = yield* application.interruptThread(threadId);
+      if (resolvedFormat === "json") {
+        return yield* output.printJson({ threadId, dispatch });
+      }
+      return yield* output.printInfo(
+        `thread interrupted: ${threadId}\nsequence: ${dispatch.sequence}`,
+      );
+    }),
+).pipe(Command.withDescription("interrupt running thread turn"));

package/src/cli/threads/list.test.ts

@@ -0,0 +1,69 @@
+import "vite-plus/test/config";
+
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import * as Option from "effect/Option";
+import { assert, describe, it } from "@effect/vitest";
+import { Command } from "effect/unstable/cli";
+import { fromPartial } from "@total-typescript/shoehorn";
+
+import { T3Application } from "../../application/service.ts";
+import { T3Config } from "../../config/service.ts";
+import { NodeEnvironmentLive } from "../../environment/layer.ts";
+import { InvalidFlagCombinationError } from "../error.ts";
+import { T3Output } from "../output/service.ts";
+import { listThreadsCommand } from "./list.ts";
+
+const testLayer = Layer.mergeAll(
+  Layer.succeed(
+    T3Application,
+    fromPartial({
+      listThreads: () => Effect.die("listThreads should not be called"),
+    }),
+  ),
+  Layer.succeed(
+    T3Config,
+    fromPartial({
+      resolve: () =>
+        Effect.succeed({
+          url: "ws://localhost",
+          token: "token",
+          source: "config",
+          local: true,
+        }),
+    }),
+  ),
+  Layer.succeed(T3Output, {
+    writeStdout: () => Effect.void,
+    writeStderr: () => Effect.void,
+    printJson: () => Effect.void,
+    printNdjson: () => Effect.void,
+    printInfo: () => Effect.void,
+  }),
+  NodeServices.layer,
+  NodeEnvironmentLive,
+);
+
+describe("listThreadsCommand", () => {
+  it.layer(testLayer)("listThreadsCommand", (t) => {
+    t.effect("rejects --archived and --all together", () =>
+      Effect.gen(function* () {
+        const run = Command.runWith(listThreadsCommand, { version: "0.0.0-test" });
+        const exit = yield* run(["--archived", "--all", "--project", "proj-1"]).pipe(Effect.exit);
+        assert.isTrue(Exit.isFailure(exit));
+        if (!Exit.isFailure(exit)) {
+          return;
+        }
+        const error = Cause.findErrorOption(exit.cause);
+        assert.isTrue(Option.isSome(error));
+        if (Option.isSome(error)) {
+          assert.instanceOf(error.value, InvalidFlagCombinationError);
+          assert.equal(error.value.message, "--archived and --all are mutually exclusive");
+        }
+      }),
+    );
+  });
+});

package/src/cli/threads/list.ts

@@ -1,7 +1,9 @@
 import * as Effect from "effect/Effect";
-import { Command } from "effect/unstable/cli";
+import { Command, Flag } from "effect/unstable/cli";
 
+import type { ListThreadsInclude } from "../../application/service.ts";
 import { formatFlag, projectFlag } from "../flags.ts";
+import { InvalidFlagCombinationError } from "../error.ts";
 import { requireCommandProjectRef } from "../require.ts";
 import { formatThreadsHuman } from "../thread-format.ts";
 import { T3Application } from "../../application/service.ts";
@@ -13,20 +15,30 @@ export const listThreadsCommand = Command.make(
   "list",
   {
     project: projectFlag,
+    archived: Flag.boolean("archived").pipe(Flag.withDescription("List archived threads only")),
+    all: Flag.boolean("all").pipe(Flag.withDescription("List active and archived threads")),
     format: formatFlag,
   },
-  ({ project, format }) =>
+  ({ project, archived, all, format }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
       const environment = yield* Environment;
       const output = yield* T3Output;
+      if (archived && all) {
+        yield* Effect.fail(
+          new InvalidFlagCombinationError({
+            message: "--archived and --all are mutually exclusive",
+          }),
+        );
+      }
+      const include: ListThreadsInclude = archived ? "archived" : all ? "all" : "active";
       const resolvedFormat = resolveOutputFormat(format, environment, "json");
       const projectRef = yield* requireCommandProjectRef({
         project,
         env: environment.env,
         cwd: environment.cwd,
       });
-      const result = yield* application.listThreads(projectRef);
+      const result = yield* application.listThreads(projectRef, { include });
       if (resolvedFormat === "json") {
         yield* output.printJson(result.threads);
       } else {

package/src/cli/threads/send.ts

@@ -2,10 +2,11 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 
-import { modelFlags, threadFlag, threadFormatFlag } from "../flags.ts";
+import { modelFlags, selfActionForceFlag, threadFlag, threadFormatFlag } from "../flags.ts";
 import { readInitialMessage } from "../message-input.ts";
 import { buildModelOptions } from "../model-options.ts";
 import { MissingThreadError } from "../error.ts";
+import { requireSelfActionConfirmation } from "../self-action.ts";
 import { resolveThreadId } from "../../scope/index.ts";
 import { T3Application } from "../../application/service.ts";
 import { Environment } from "../../environment/service.ts";
@@ -18,13 +19,26 @@ export const sendThreadCommand = Command.make(
   "send",
   {
     thread: threadFlag,
+    force: selfActionForceFlag,
     message: Argument.string("message").pipe(Argument.optional),
     stdin: Flag.boolean("stdin"),
     ...modelFlags,
     wait: Flag.boolean("wait"),
     format: threadFormatFlag,
   },
-  ({ thread, message, stdin, option, reasoningEffort, effort, fastMode, thinking, wait, format }) =>
+  ({
+    thread,
+    force,
+    message,
+    stdin,
+    option,
+    reasoningEffort,
+    effort,
+    fastMode,
+    thinking,
+    wait,
+    format,
+  }) =>
     Effect.gen(function* () {
       const inputService = yield* T3Input;
       const text = yield* readInitialMessage({
@@ -53,6 +67,12 @@ export const sendThreadCommand = Command.make(
           }),
         );
       }
+      yield* requireSelfActionConfirmation({
+        threadId,
+        force,
+        environment,
+        action: "send a message to",
+      });
       const input = {
         message: text,
         threadId,

package/src/cli/threads/unarchive.ts

@@ -0,0 +1,44 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command } from "effect/unstable/cli";
+
+import { formatFlag, threadFlag } from "../flags.ts";
+import { MissingThreadError } from "../error.ts";
+import { resolveThreadId } from "../../scope/index.ts";
+import { T3Application } from "../../application/service.ts";
+import { Environment } from "../../environment/service.ts";
+import { resolveOutputFormat } from "../output-format.ts";
+import { T3Output } from "../output/service.ts";
+
+export const unarchiveThreadCommand = Command.make(
+  "unarchive",
+  {
+    thread: threadFlag,
+    format: formatFlag,
+  },
+  ({ thread, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const dispatch = yield* application.unarchiveThread(threadId);
+      if (resolvedFormat === "json") {
+        return yield* output.printJson(dispatch);
+      }
+      return yield* output.printInfo(
+        `thread unarchived: ${threadId}\nsequence: ${dispatch.sequence}`,
+      );
+    }),
+).pipe(Command.withDescription("unarchive thread"));

package/src/cli/threads/update.ts

@@ -0,0 +1,150 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command, Flag } from "effect/unstable/cli";
+
+import { formatFlag, modelFlags, selfActionForceFlag, threadFlag } from "../flags.ts";
+import {
+  ConflictingUpdateFlagsError,
+  MissingThreadError,
+  MissingUpdateFieldsError,
+} from "../error.ts";
+import { requireSelfActionConfirmation } from "../self-action.ts";
+import { buildModelOptions } from "../model-options.ts";
+import { resolveThreadId } from "../../scope/index.ts";
+import { T3Application } from "../../application/service.ts";
+import { Environment } from "../../environment/service.ts";
+import { resolveOutputFormat } from "../output-format.ts";
+import { T3Output } from "../output/service.ts";
+
+export const updateThreadCommand = Command.make(
+  "update",
+  {
+    thread: threadFlag,
+    force: selfActionForceFlag,
+    title: Flag.string("title").pipe(Flag.optional),
+    provider: Flag.string("provider").pipe(Flag.optional),
+    model: Flag.string("model").pipe(Flag.optional),
+    ...modelFlags,
+    branch: Flag.string("branch").pipe(Flag.optional),
+    clearBranch: Flag.boolean("clear-branch").pipe(Flag.optional),
+    worktree: Flag.string("worktree").pipe(Flag.optional),
+    clearWorktree: Flag.boolean("clear-worktree").pipe(Flag.optional),
+    format: formatFlag,
+  },
+  ({
+    thread,
+    force,
+    title,
+    provider,
+    model,
+    option,
+    reasoningEffort,
+    effort,
+    fastMode,
+    thinking,
+    branch,
+    clearBranch,
+    worktree,
+    clearWorktree,
+    format,
+  }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+
+      yield* requireSelfActionConfirmation({
+        threadId,
+        force,
+        environment,
+        action: "update",
+      });
+
+      const titleValue = Option.getOrUndefined(title);
+      const providerValue = Option.getOrUndefined(provider);
+      const modelValue = Option.getOrUndefined(model);
+      const branchValue = Option.getOrUndefined(branch);
+      const worktreeValue = Option.getOrUndefined(worktree);
+      const clearBranchValue = Option.getOrUndefined(clearBranch);
+      const clearWorktreeValue = Option.getOrUndefined(clearWorktree);
+      const options = buildModelOptions({
+        option,
+        reasoningEffort,
+        effort,
+        fastMode,
+        thinking,
+      });
+
+      if (clearBranchValue === true && branchValue !== undefined) {
+        return yield* Effect.fail(
+          new ConflictingUpdateFlagsError({
+            message: "--branch and --clear-branch are mutually exclusive",
+          }),
+        );
+      }
+      if (clearWorktreeValue === true && worktreeValue !== undefined) {
+        return yield* Effect.fail(
+          new ConflictingUpdateFlagsError({
+            message: "--worktree and --clear-worktree are mutually exclusive",
+          }),
+        );
+      }
+
+      const hasTitle = titleValue !== undefined && titleValue.length > 0;
+      const hasProvider = providerValue !== undefined && providerValue.length > 0;
+      const hasModel = modelValue !== undefined && modelValue.length > 0;
+      const hasBranch = branchValue !== undefined && branchValue.length > 0;
+      const hasWorktree = worktreeValue !== undefined && worktreeValue.length > 0;
+      if (
+        !hasTitle &&
+        !hasProvider &&
+        !hasModel &&
+        options.length === 0 &&
+        !hasBranch &&
+        clearBranchValue !== true &&
+        !hasWorktree &&
+        clearWorktreeValue !== true
+      ) {
+        return yield* Effect.fail(
+          new MissingUpdateFieldsError({
+            message:
+              "at least one update field is required: --title, model flags, --branch, --clear-branch, --worktree, or --clear-worktree",
+          }),
+        );
+      }
+
+      const dispatch = yield* application.updateThread({
+        threadId,
+        ...(hasTitle ? { title: titleValue } : {}),
+        ...(hasProvider ? { provider: providerValue } : {}),
+        ...(hasModel ? { model: modelValue } : {}),
+        ...(options.length > 0 ? { options } : {}),
+        ...(clearBranchValue === true
+          ? { branch: null }
+          : hasBranch
+            ? { branch: branchValue }
+            : {}),
+        ...(clearWorktreeValue === true
+          ? { worktreePath: null }
+          : hasWorktree
+            ? { worktreePath: worktreeValue }
+            : {}),
+      });
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      if (resolvedFormat === "json") {
+        return yield* output.printJson(dispatch);
+      }
+      return yield* output.printInfo(`thread updated: ${threadId}\nsequence: ${dispatch.sequence}`);
+    }),
+).pipe(Command.withDescription("update thread metadata"));

package/src/domain/error.ts

@@ -30,6 +30,14 @@ export class ThreadSessionError extends Schema.TaggedErrorClass<ThreadSessionErr
   },
 ) {}
 
+export class ThreadLookupError extends Schema.TaggedErrorClass<ThreadLookupError>()(
+  "ThreadLookupError",
+  {
+    message: Schema.String,
+    threadId: Schema.String,
+  },
+) {}
+
 export class ProjectCreateVisibilityError extends Schema.TaggedErrorClass<ProjectCreateVisibilityError>()(
   "ProjectCreateVisibilityError",
   {
@@ -38,9 +46,20 @@ export class ProjectCreateVisibilityError extends Schema.TaggedErrorClass<Projec
   },
 ) {}
 
+export class TerminalLookupError extends Schema.TaggedErrorClass<TerminalLookupError>()(
+  "TerminalLookupError",
+  {
+    message: Schema.String,
+    threadId: Schema.String,
+    terminalId: Schema.String,
+  },
+) {}
+
 export type DomainError =
   | ProjectLookupError
   | ModelSelectionError
   | ThreadEventError
   | ThreadSessionError
-  | ProjectCreateVisibilityError;
+  | ThreadLookupError
+  | ProjectCreateVisibilityError
+  | TerminalLookupError;

package/src/domain/model-config.ts

@@ -12,6 +12,10 @@ export function firstSelectableModel(provider: ServerProvider) {
   return provider.models[0];
 }
 
+export function findSelectableModel(provider: ServerProvider, slug: string) {
+  return provider.models.find((model) => model.slug === slug);
+}
+
 export function findSelectableProvider(
   providers: ReadonlyArray<ServerProvider>,
   instanceId: string,

package/src/domain/thread-lifecycle.ts

@@ -2,11 +2,25 @@ import {
   OrchestrationMessage,
   type OrchestrationEvent,
   type OrchestrationMessage as OrchestrationMessageType,
+  type OrchestrationSession,
   type OrchestrationThread,
   type OrchestrationThreadShell,
 } from "#t3tools/contracts";
 import * as Schema from "effect/Schema";
 
+type SessionStatusForDelete = OrchestrationSession["status"] | "closed";
+
+function isClosedSessionStatus(status: SessionStatusForDelete): status is "closed" {
+  return status === "closed";
+}
+
+export function sessionNeedsStopBeforeDelete(session: OrchestrationSession | null) {
+  if (session === null) {
+    return false;
+  }
+  return !isClosedSessionStatus(session.status);
+}
+
 export function isThreadActive(thread: OrchestrationThreadShell | OrchestrationThread) {
   if (thread.session?.status === "starting" || thread.session?.status === "running") {
     return true;

package/src/node/index.ts

@@ -0,0 +1,2 @@
+export { T3CodeNodeRpcLayer } from "../connection/node.ts";
+export { NodeEnvironmentLive } from "../environment/layer.ts";

package/src/orchestration/index.ts

@@ -4,4 +4,5 @@ export {
   type Orchestration,
   type OrchestrationError,
 } from "./service.ts";
+export { makeT3Orchestration, T3OrchestrationLive } from "./layer.ts";
 export { T3OrchestrationLayer } from "../runtime/layer.ts";