t3code-cli 0.11.0 → 0.13.0

package/src/cli/terminal/write.ts

@@ -2,13 +2,15 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 
-import { formatTerminalWrittenHuman } from "../terminal-format.ts";
+import { extraArgsConfig } from "../extra-args.ts";
+import { formatTerminalWrittenHuman } from "../format/terminal.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 { InvalidFlagCombinationError } from "../error.ts";
 import { T3Input } from "../input/service.ts";
 import { formatFlag, threadFlag } from "../flags.ts";
-import { resolveOutputFormat } from "../output-format.ts";
+import { resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 import { decodeBase64Payload, decodeHexPayload } from "./encoding.ts";
 import { TerminalCliError } from "./error.ts";
@@ -25,17 +27,16 @@ export const writeTerminalCommand = Command.make(
     base64: Flag.string("base64").pipe(Flag.optional),
     quiet: Flag.boolean("quiet"),
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, terminalId, data, stdin, hex, base64, quiet, format }) =>
     Effect.gen(function* () {
       const output = yield* T3Output;
       const inputService = yield* T3Input;
       const application = yield* T3Application;
-      const environment = yield* Environment;
-      const threadId = yield* requireCommandThreadId({
-        thread,
-        env: environment.env,
-      });
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const threadId = yield* requireCommandThreadId({ thread });
       const argumentData = Option.getOrUndefined(data);
       const hexData = Option.getOrUndefined(hex);
       const base64Data = Option.getOrUndefined(base64);
@@ -83,7 +84,7 @@ export const writeTerminalCommand = Command.make(
         return;
       }
       const bytes = Buffer.byteLength(payload, "latin1");
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       if (resolvedFormat === "json") {
         yield* output.printJson({
           threadId,

package/src/cli/threads/approve.ts

@@ -2,12 +2,14 @@ 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 { resolveThreadId } from "../../scope/index.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";
 
 const approvalDecisionFlag = Flag.choice("decision", ["accept", "decline", "cancel"] as const).pipe(
@@ -26,15 +28,17 @@ export const approveThreadCommand = Command.make(
     request: requestFlag,
     decision: approvalDecisionFlag,
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, request, decision, 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(
@@ -49,13 +53,13 @@ export const approveThreadCommand = 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.approveThread({ threadId, requestId, decision });
       if (resolvedFormat === "json") {
         return yield* output.printJson(result);
       }
       return yield* output.printInfo(
-        `approval submitted: ${result.requestId}\nsequence: ${result.dispatch.sequence}`,
+        `approval submitted: ${result.requestId} (sequence ${result.dispatch.sequence})`,
       );
     }),
 ).pipe(Command.withDescription("respond to a pending approval request"));

package/src/cli/threads/archive.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, selfActionForceFlag, threadFlag } from "../flags.ts";
 import { MissingThreadError } from "../error.ts";
-import { requireSelfActionConfirmation } from "../self-action.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 { 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(
@@ -17,15 +19,17 @@ export const archiveThreadCommand = Command.make(
     thread: threadFlag,
     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(
@@ -37,16 +41,17 @@ export const archiveThreadCommand = Command.make(
       yield* requireSelfActionConfirmation({
         threadId,
         force,
-        environment,
+        cliRuntime,
+        t3CliEnv,
         action: "archive",
       });
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      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

@@ -2,15 +2,17 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Command } from "effect/unstable/cli";
 
-import { requireDestructiveConfirmation } from "../confirm.ts";
+import { extraArgsConfig } from "../extra-args.ts";
+import { requireDestructiveConfirmation } from "../interaction/confirm.ts";
 import { formatFlag, selfActionForceFlag, threadFlag, yesFlag } from "../flags.ts";
-import { formatThreadDeletedHuman } from "../thread-format.ts";
+import { formatThreadDeletedHuman } from "../format/thread.ts";
 import { MissingThreadError } from "../error.ts";
-import { requireSelfActionConfirmation } from "../self-action.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 { 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 deleteThreadCommand = Command.make(
@@ -20,15 +22,17 @@ export const deleteThreadCommand = Command.make(
     force: selfActionForceFlag,
     yes: yesFlag,
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, force, yes, 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(
@@ -40,15 +44,17 @@ export const deleteThreadCommand = Command.make(
       yield* requireSelfActionConfirmation({
         threadId,
         force,
-        environment,
+        cliRuntime,
+        t3CliEnv,
         action: "delete",
       });
       yield* requireDestructiveConfirmation({
         message: `Delete thread ${threadId}?`,
         yes,
-        environment,
+        cliRuntime,
+        t3CliEnv,
       });
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const result = yield* application.deleteThread(threadId);
       if (resolvedFormat === "json") {
         return yield* output.printJson({

package/src/cli/threads/interrupt.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, selfActionForceFlag, threadFlag } from "../flags.ts";
 import { MissingThreadError } from "../error.ts";
-import { requireSelfActionConfirmation } from "../self-action.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 { 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 interruptThreadCommand = Command.make(
@@ -17,15 +19,17 @@ export const interruptThreadCommand = Command.make(
     thread: threadFlag,
     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(
@@ -37,16 +41,17 @@ export const interruptThreadCommand = Command.make(
       yield* requireSelfActionConfirmation({
         threadId,
         force,
-        environment,
+        cliRuntime,
+        t3CliEnv,
         action: "interrupt",
       });
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      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}\nsequence: ${dispatch.sequence}`,
+        `thread interrupted: ${threadId} (sequence ${dispatch.sequence})`,
       );
     }),
 ).pipe(Command.withDescription("interrupt running thread turn"));

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

@@ -11,8 +11,9 @@ 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 { 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";
@@ -44,7 +45,8 @@ const testLayer = Layer.mergeAll(
     printInfo: () => Effect.void,
   }),
   NodeServices.layer,
-  NodeEnvironmentLive,
+  CliRuntime.layer,
+  t3CliEnvConfigLayer("/tmp/t3cli-test"),
 );
 
 describe("listThreadsCommand", () => {

package/src/cli/threads/list.ts

@@ -2,13 +2,15 @@ import * as Effect from "effect/Effect";
 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(
@@ -18,11 +20,13 @@ export const listThreadsCommand = Command.make(
     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, 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;
       if (archived && all) {
         yield* Effect.fail(
@@ -32,12 +36,8 @@ export const listThreadsCommand = Command.make(
         );
       }
       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 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);

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,16 +2,18 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 
+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 { requireSelfActionConfirmation } from "../self-action.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";
 
@@ -25,6 +27,7 @@ export const sendThreadCommand = Command.make(
     ...modelFlags,
     wait: Flag.boolean("wait"),
     format: threadFormatFlag,
+    ...extraArgsConfig,
   },
   ({
     thread,
@@ -54,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(
@@ -70,7 +74,8 @@ export const sendThreadCommand = Command.make(
       yield* requireSelfActionConfirmation({
         threadId,
         force,
-        environment,
+        cliRuntime,
+        t3CliEnv,
         action: "send a message to",
       });
       const input = {
@@ -78,7 +83,12 @@ export const sendThreadCommand = Command.make(
         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" });
@@ -101,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));