t3code-cli 0.10.0 → 0.12.0

package/src/cli/threads/archive.ts

@@ -1,30 +1,35 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import { Command, Flag } from "effect/unstable/cli";
+import { Command } from "effect/unstable/cli";
 
-import { formatFlag, threadFlag } from "../flags.ts";
-import { MissingThreadError, SelfArchiveError } from "../error.ts";
-import { resolveThreadId } from "../../scope/index.ts";
+import { extraArgsConfig } from "../extra-args.ts";
+import { formatFlag, selfActionForceFlag, threadFlag } from "../flags.ts";
+import { MissingThreadError } from "../error.ts";
+import { requireSelfActionConfirmation } from "../interaction/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 { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 
 export const archiveThreadCommand = Command.make(
   "archive",
   {
     thread: threadFlag,
-    force: Flag.boolean("force").pipe(Flag.withAlias("f")),
+    force: selfActionForceFlag,
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, force, format }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       const threadId = resolveThreadId({
         value: Option.getOrUndefined(thread),
-        env: environment.env,
+        scope: t3CliEnv.scope,
       });
       if (threadId === undefined) {
         return yield* Effect.fail(
@@ -33,27 +38,20 @@ export const archiveThreadCommand = Command.make(
           }),
         );
       }
-      const envThreadId = environment.env.T3CODE_THREAD_ID;
-      if (
-        envThreadId !== undefined &&
-        envThreadId.length > 0 &&
-        threadId === envThreadId &&
-        !force
-      ) {
-        return yield* Effect.fail(
-          new SelfArchiveError({
-            threadId,
-            message: `cannot archive thread ${threadId}: matches T3CODE_THREAD_ID (are you trying to archive yourself?). Use --force to override.`,
-          }),
-        );
-      }
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      yield* requireSelfActionConfirmation({
+        threadId,
+        force,
+        cliRuntime,
+        t3CliEnv,
+        action: "archive",
+      });
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const dispatch = yield* application.archiveThread(threadId);
       if (resolvedFormat === "json") {
         return yield* output.printJson(dispatch);
       }
       return yield* output.printInfo(
-        `thread archived: ${threadId}\nsequence: ${dispatch.sequence}`,
+        `thread archived: ${threadId} (sequence ${dispatch.sequence})`,
       );
     }),
 ).pipe(Command.withDescription("archive thread"));

package/src/cli/threads/callback.ts

@@ -4,10 +4,11 @@ import * as ChildProcess from "effect/unstable/process/ChildProcess";
 import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
 import { Command, Flag } from "effect/unstable/cli";
 
+import { extraArgsConfig } from "../extra-args.ts";
 import { threadFlag } from "../flags.ts";
 import { MissingThreadError } from "../error.ts";
-import { resolveThreadId } from "../../scope/index.ts";
-import { Environment } from "../../environment/service.ts";
+import { resolveThreadId } from "../scope/index.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
 import { T3Application } from "../../application/service.ts";
 import { T3Output } from "../output/service.ts";
 import { CliPath } from "../../cli-path/service.ts";
@@ -22,11 +23,12 @@ export const callbackThreadCommand = Command.make(
       Flag.withDescription("Fork and detach as background process"),
       Flag.optional,
     ),
+    ...extraArgsConfig,
   },
   ({ from, thread, prompt, background }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       const cliPath = yield* CliPath;
       const spawner = yield* ChildProcessSpawner;
@@ -35,7 +37,7 @@ export const callbackThreadCommand = Command.make(
 
       const targetThreadId = resolveThreadId({
         value: Option.getOrUndefined(thread),
-        env: environment.env,
+        scope: t3CliEnv.scope,
       });
       if (targetThreadId === undefined) {
         return yield* Effect.fail(

package/src/cli/threads/delete.ts

@@ -0,0 +1,67 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command } from "effect/unstable/cli";
+
+import { extraArgsConfig } from "../extra-args.ts";
+import { requireDestructiveConfirmation } from "../interaction/confirm.ts";
+import { formatFlag, selfActionForceFlag, threadFlag, yesFlag } from "../flags.ts";
+import { formatThreadDeletedHuman } from "../format/thread.ts";
+import { MissingThreadError } from "../error.ts";
+import { requireSelfActionConfirmation } from "../interaction/self-action.ts";
+import { resolveThreadId } from "../scope/index.ts";
+import { T3Application } from "../../application/service.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { resolveOutputFormat } from "../format/output.ts";
+import { T3Output } from "../output/service.ts";
+
+export const deleteThreadCommand = Command.make(
+  "delete",
+  {
+    thread: threadFlag,
+    force: selfActionForceFlag,
+    yes: yesFlag,
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ thread, force, yes, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        scope: t3CliEnv.scope,
+      });
+      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,
+        cliRuntime,
+        t3CliEnv,
+        action: "delete",
+      });
+      yield* requireDestructiveConfirmation({
+        message: `Delete thread ${threadId}?`,
+        yes,
+        cliRuntime,
+        t3CliEnv,
+      });
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "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,57 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command } from "effect/unstable/cli";
+
+import { extraArgsConfig } from "../extra-args.ts";
+import { formatFlag, selfActionForceFlag, threadFlag } from "../flags.ts";
+import { MissingThreadError } from "../error.ts";
+import { requireSelfActionConfirmation } from "../interaction/self-action.ts";
+import { resolveThreadId } from "../scope/index.ts";
+import { T3Application } from "../../application/service.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { resolveOutputFormat } from "../format/output.ts";
+import { T3Output } from "../output/service.ts";
+
+export const interruptThreadCommand = Command.make(
+  "interrupt",
+  {
+    thread: threadFlag,
+    force: selfActionForceFlag,
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ thread, force, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        scope: t3CliEnv.scope,
+      });
+      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,
+        cliRuntime,
+        t3CliEnv,
+        action: "interrupt",
+      });
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      const dispatch = yield* application.interruptThread(threadId);
+      if (resolvedFormat === "json") {
+        return yield* output.printJson({ threadId, dispatch });
+      }
+      return yield* output.printInfo(
+        `thread interrupted: ${threadId} (sequence ${dispatch.sequence})`,
+      );
+    }),
+).pipe(Command.withDescription("interrupt running thread turn"));

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

@@ -0,0 +1,71 @@
+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/config.ts";
+import * as CliRuntime from "../../cli/runtime/service.ts";
+import { t3CliEnvConfigLayer } from "../../config/env/env.test-utils.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,
+  CliRuntime.layer,
+  t3CliEnvConfigLayer("/tmp/t3cli-test"),
+);
+
+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,32 +1,44 @@
 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 { extraArgsConfig } from "../extra-args.ts";
 import { formatFlag, projectFlag } from "../flags.ts";
+import { InvalidFlagCombinationError } from "../error.ts";
 import { requireCommandProjectRef } from "../require.ts";
-import { formatThreadsHuman } from "../thread-format.ts";
+import { formatThreadsHuman } from "../format/thread.ts";
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
-import { resolveOutputFormat } from "../output-format.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 
 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,
+    ...extraArgsConfig,
   },
-  ({ project, format }) =>
+  ({ project, archived, all, format }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
-      const projectRef = yield* requireCommandProjectRef({
-        project,
-        env: environment.env,
-        cwd: environment.cwd,
-      });
-      const result = yield* application.listThreads(projectRef);
+      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, cliRuntime, t3CliEnv, "json");
+      const projectRef = yield* requireCommandProjectRef({ project });
+      const result = yield* application.listThreads(projectRef, { include });
       if (resolvedFormat === "json") {
         yield* output.printJson(result.threads);
       } else {

package/src/cli/threads/messages.ts

@@ -2,14 +2,16 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Command, Flag } from "effect/unstable/cli";
 
+import { extraArgsConfig } from "../extra-args.ts";
 import { formatFlag, threadFlag } from "../flags.ts";
 import { InvalidLimitError } from "../error.ts";
 import { MissingThreadError } from "../error.ts";
-import { resolveThreadId } from "../../scope/index.ts";
-import { formatThreadMessagesHuman, formatThreadMessagesJson } from "../thread-format.ts";
+import { resolveThreadId } from "../scope/index.ts";
+import { formatThreadMessagesHuman, formatThreadMessagesJson } from "../format/thread.ts";
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
-import { resolveOutputFormat } from "../output-format.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 
 export const getThreadTranscriptCommand = Command.make(
@@ -19,6 +21,7 @@ export const getThreadTranscriptCommand = Command.make(
     limit: Flag.integer("limit").pipe(Flag.withDefault(20)),
     full: Flag.boolean("full"),
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, limit, full, format }) =>
     Effect.gen(function* () {
@@ -28,11 +31,12 @@ export const getThreadTranscriptCommand = Command.make(
         );
       }
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       const threadId = resolveThreadId({
         value: Option.getOrUndefined(thread),
-        env: environment.env,
+        scope: t3CliEnv.scope,
       });
       if (threadId === undefined) {
         return yield* Effect.fail(
@@ -41,7 +45,7 @@ export const getThreadTranscriptCommand = Command.make(
           }),
         );
       }
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const detail = yield* application.getThreadMessages(threadId);
       if (resolvedFormat === "json") {
         return yield* output.printJson(formatThreadMessagesJson(detail, full));

package/src/cli/threads/respond.ts

@@ -2,14 +2,16 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Command, Flag } from "effect/unstable/cli";
 
+import { extraArgsConfig } from "../extra-args.ts";
 import { formatFlag, threadFlag } from "../flags.ts";
 import { MissingRequestError, MissingThreadError } from "../error.ts";
 import { readJsonAnswers } from "../message-input.ts";
-import { resolveThreadId } from "../../scope/index.ts";
+import { resolveThreadId } from "../scope/index.ts";
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
 import { T3Input } from "../input/service.ts";
-import { resolveOutputFormat } from "../output-format.ts";
+import { resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 
 const requestFlag = Flag.string("request").pipe(
@@ -25,6 +27,7 @@ export const respondThreadCommand = Command.make(
     answers: Flag.string("answers").pipe(Flag.optional),
     stdin: Flag.boolean("stdin"),
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, request, answers, stdin, format }) =>
     Effect.gen(function* () {
@@ -35,11 +38,12 @@ export const respondThreadCommand = Command.make(
         readStdin: inputService.readStdin,
       });
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       const threadId = resolveThreadId({
         value: Option.getOrUndefined(thread),
-        env: environment.env,
+        scope: t3CliEnv.scope,
       });
       if (threadId === undefined) {
         return yield* Effect.fail(
@@ -54,7 +58,7 @@ export const respondThreadCommand = Command.make(
           new MissingRequestError({ message: "request id is required: pass --request" }),
         );
       }
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const result = yield* application.respondToThread({
         threadId,
         requestId,
@@ -64,7 +68,7 @@ export const respondThreadCommand = Command.make(
         return yield* output.printJson(result);
       }
       return yield* output.printInfo(
-        `user input submitted: ${result.requestId}\nsequence: ${result.dispatch.sequence}`,
+        `user input submitted: ${result.requestId} (sequence ${result.dispatch.sequence})`,
       );
     }),
 ).pipe(Command.withDescription("respond to a pending user-input request"));

package/src/cli/threads/send.ts

@@ -2,15 +2,18 @@ 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 { extraArgsConfig } from "../extra-args.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 { resolveThreadId } from "../../scope/index.ts";
+import { requireSelfActionConfirmation } from "../interaction/self-action.ts";
+import { resolveThreadId } from "../scope/index.ts";
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
 import { T3Input } from "../input/service.ts";
-import { canRenderLiveTerminal, resolveOutputFormat } from "../output-format.ts";
+import { canRenderLiveTerminal, resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 import { printWaitEventsHuman, printWaitEventsNdjson } from "../wait-events.ts";
 
@@ -18,13 +21,27 @@ 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,
+    ...extraArgsConfig,
   },
-  ({ 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({
@@ -40,11 +57,12 @@ export const sendThreadCommand = Command.make(
         thinking,
       });
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       const threadId = resolveThreadId({
         value: Option.getOrUndefined(thread),
-        env: environment.env,
+        scope: t3CliEnv.scope,
       });
       if (threadId === undefined) {
         return yield* Effect.fail(
@@ -53,12 +71,24 @@ export const sendThreadCommand = Command.make(
           }),
         );
       }
+      yield* requireSelfActionConfirmation({
+        threadId,
+        force,
+        cliRuntime,
+        t3CliEnv,
+        action: "send a message to",
+      });
       const input = {
         message: text,
         threadId,
         ...(options.length > 0 ? { options } : {}),
       };
-      const resolvedFormat = resolveOutputFormat(format, environment, wait ? "ndjson" : "json");
+      const resolvedFormat = resolveOutputFormat(
+        format,
+        cliRuntime,
+        t3CliEnv,
+        wait ? "ndjson" : "json",
+      );
 
       if (resolvedFormat === "ndjson") {
         const sent = yield* application.sendThread(input, { until: wait ? "dispatch" : "visible" });
@@ -81,7 +111,7 @@ export const sendThreadCommand = Command.make(
         }
         yield* printWaitEventsHuman(output, application.watchThread(sent.threadId), {
           threadId: sent.threadId,
-          live: canRenderLiveTerminal(environment),
+          live: canRenderLiveTerminal(cliRuntime, t3CliEnv),
         });
         return yield* Effect.void;
       }

package/src/cli/threads/show.ts

@@ -2,13 +2,15 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Command } from "effect/unstable/cli";
 
+import { extraArgsConfig } from "../extra-args.ts";
 import { formatFlag, threadFlag } from "../flags.ts";
 import { MissingThreadError } from "../error.ts";
-import { resolveThreadId } from "../../scope/index.ts";
-import { formatThreadShowHuman, formatThreadShowJson } from "../thread-format.ts";
+import { resolveThreadId } from "../scope/index.ts";
+import { formatThreadShowHuman, formatThreadShowJson } from "../format/thread.ts";
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
-import { resolveOutputFormat } from "../output-format.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 
 export const showThreadCommand = Command.make(
@@ -16,15 +18,17 @@ export const showThreadCommand = Command.make(
   {
     thread: threadFlag,
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, format }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       const threadId = resolveThreadId({
         value: Option.getOrUndefined(thread),
-        env: environment.env,
+        scope: t3CliEnv.scope,
       });
       if (threadId === undefined) {
         return yield* Effect.fail(
@@ -33,7 +37,7 @@ export const showThreadCommand = Command.make(
           }),
         );
       }
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const detail = yield* application.showThread(threadId);
       if (resolvedFormat === "json") {
         return yield* output.printJson(formatThreadShowJson(detail));