t3code-cli 0.11.0 → 0.13.0

package/src/cli/format/model.ts

@@ -0,0 +1,29 @@
+import type { ServerProvider } from "@t3tools/contracts";
+
+import { formatTable } from "./human.ts";
+
+export function formatModelsHuman(providers: ReadonlyArray<ServerProvider>) {
+  if (providers.length === 0) {
+    return "no models found\n";
+  }
+  return providers
+    .map((provider) => {
+      const models = provider.models;
+      const displayName = provider.displayName ?? provider.instanceId;
+      const header = `${displayName} (${provider.instanceId}) - ${provider.status}`;
+      if (models.length === 0) {
+        return `${header}\n  no models`;
+      }
+      return `${header}\n${formatTable(
+        [
+          { header: "slug", value: (model) => model.slug, maxWidth: 40 },
+          { header: "name", value: (model) => model.name, maxWidth: 48 },
+          { header: "custom", value: (model) => (model.isCustom ? "yes" : "no"), maxWidth: 6 },
+          { header: "sub-provider", value: (model) => model.subProvider ?? "-", maxWidth: 24 },
+        ],
+        models,
+      )}`;
+    })
+    .join("\n\n")
+    .concat("\n");
+}

package/src/cli/format/output.ts

@@ -0,0 +1,51 @@
+import * as Option from "effect/Option";
+
+import type { T3CliEnvShape } from "../../config/env/env.ts";
+import type { CliRuntime } from "../runtime/service.ts";
+
+export const humanJsonFormatChoices = ["auto", "human", "json"] as const;
+export const humanNdjsonFormatChoices = ["auto", "human", "ndjson"] as const;
+export const humanJsonNdjsonFormatChoices = ["auto", "human", "json", "ndjson"] as const;
+
+export type HumanJsonFormat = (typeof humanJsonFormatChoices)[number];
+export type HumanNdjsonFormat = (typeof humanNdjsonFormatChoices)[number];
+export type HumanJsonNdjsonFormat = (typeof humanJsonNdjsonFormatChoices)[number];
+
+export function resolveOutputFormat<T extends "json" | "ndjson">(
+  format: "auto" | "human" | T,
+  cliRuntime: CliRuntime["Service"],
+  t3CliEnv: T3CliEnvShape,
+  nonHumanFormat: T,
+): "human" | T {
+  if (format !== "auto") {
+    return format;
+  }
+  return isHumanTerminal(cliRuntime, t3CliEnv) ? "human" : nonHumanFormat;
+}
+
+export function canRenderLiveTerminal(cliRuntime: CliRuntime["Service"], t3CliEnv: T3CliEnvShape) {
+  return (
+    cliRuntime.stderrIsTTY &&
+    Option.getOrElse(t3CliEnv.term, () => "") !== "dumb" &&
+    !isAgentEnvironment(t3CliEnv)
+  );
+}
+
+export function isInteractiveHumanTerminal(
+  cliRuntime: CliRuntime["Service"],
+  t3CliEnv: T3CliEnvShape,
+) {
+  return (
+    cliRuntime.stdoutIsTTY &&
+    !isAgentEnvironment(t3CliEnv) &&
+    Option.getOrElse(t3CliEnv.term, () => "") !== "dumb"
+  );
+}
+
+function isHumanTerminal(cliRuntime: CliRuntime["Service"], t3CliEnv: T3CliEnvShape) {
+  return isInteractiveHumanTerminal(cliRuntime, t3CliEnv);
+}
+
+export function isAgentEnvironment(t3CliEnv: T3CliEnvShape) {
+  return t3CliEnv.ci || t3CliEnv.codexCi || t3CliEnv.codexThreadId || t3CliEnv.t3cliAgent;
+}

package/src/cli/format/project.ts

@@ -0,0 +1,32 @@
+import type { OrchestrationProjectShell } from "@t3tools/contracts";
+
+import { formatRecord, formatTable } from "./human.ts";
+
+export function formatProjectsHuman(projects: ReadonlyArray<OrchestrationProjectShell>) {
+  if (projects.length === 0) {
+    return "no projects\n";
+  }
+  return `${formatTable(
+    [
+      { header: "title", value: (project) => project.title, maxWidth: 32 },
+      { header: "id", value: (project) => project.id, maxWidth: 40 },
+      { header: "path", value: (project) => project.workspaceRoot, maxWidth: 72 },
+    ],
+    projects,
+  )}\n`;
+}
+
+export function formatProjectAddedHuman(project: OrchestrationProjectShell) {
+  return `project added\n${formatRecord([
+    { field: "title", value: project.title },
+    { field: "id", value: project.id },
+    { field: "path", value: project.workspaceRoot },
+  ])}`;
+}
+
+export function formatProjectDeletedHuman(input: {
+  readonly projectId: string;
+  readonly dispatch: { readonly sequence: number };
+}) {
+  return `project deleted: ${input.projectId} (sequence ${input.dispatch.sequence})`;
+}

package/src/cli/format/terminal.ts

@@ -0,0 +1,87 @@
+import type { TerminalSessionSnapshot, TerminalSummary } from "@t3tools/contracts";
+
+import { formatTable } from "./human.ts";
+
+type TerminalRow = {
+  readonly id: string;
+  readonly status: string;
+  readonly label: string;
+  readonly cwd: string;
+  readonly updated: string;
+  readonly process: string;
+};
+
+export function formatTerminalListHuman(terminals: ReadonlyArray<TerminalSummary>) {
+  if (terminals.length === 0) {
+    return "no terminals\n";
+  }
+  return `${formatTerminalTable(terminals.map(toSummaryRow))}\n`;
+}
+
+export function formatTerminalCreatedHuman(snapshot: TerminalSessionSnapshot) {
+  return `terminal created\n${formatTerminalTable([toSnapshotRow(snapshot)])}`;
+}
+
+export function formatTerminalWrittenHuman(input: {
+  readonly terminalId: string;
+  readonly threadId: string;
+  readonly bytes: number;
+}) {
+  return `wrote ${input.bytes} bytes to ${input.terminalId} (${input.threadId})`;
+}
+
+export function formatTerminalDestroyedHuman(input: {
+  readonly terminalId: string;
+  readonly threadId: string;
+}) {
+  return `destroyed ${input.terminalId} (${input.threadId})`;
+}
+
+function formatTerminalTable(rows: ReadonlyArray<TerminalRow>) {
+  return formatTable(
+    [
+      { header: "id", value: (row) => row.id, maxWidth: 44 },
+      { header: "status", value: (row) => row.status, maxWidth: 8 },
+      { header: "label", value: (row) => row.label, maxWidth: 24 },
+      { header: "cwd", value: (row) => row.cwd, maxWidth: 40 },
+      { header: "updated", value: (row) => row.updated, maxWidth: 24 },
+      { header: "process", value: (row) => row.process, maxWidth: 20 },
+    ],
+    rows,
+  );
+}
+
+function toSummaryRow(terminal: TerminalSummary): TerminalRow {
+  return {
+    id: terminal.terminalId,
+    status: terminal.status,
+    label: terminal.label,
+    cwd: terminal.cwd,
+    updated: terminal.updatedAt,
+    process: formatProcessInfo(terminal),
+  };
+}
+
+function toSnapshotRow(snapshot: TerminalSessionSnapshot): TerminalRow {
+  return {
+    id: snapshot.terminalId,
+    status: snapshot.status,
+    label: snapshot.label,
+    cwd: snapshot.cwd,
+    updated: snapshot.updatedAt,
+    process: formatProcessInfo(snapshot),
+  };
+}
+
+function formatProcessInfo(input: {
+  readonly pid: number | null;
+  readonly exitCode: number | null;
+  readonly exitSignal: number | null;
+}) {
+  const parts = [
+    typeof input.pid === "number" ? `pid ${input.pid}` : null,
+    typeof input.exitCode === "number" ? `exit ${input.exitCode}` : null,
+    typeof input.exitSignal === "number" ? `sig ${input.exitSignal}` : null,
+  ].filter((part): part is string => part !== null);
+  return parts.length > 0 ? parts.join(", ") : "-";
+}

package/src/cli/{thread-format.test.ts → format/thread.test.ts}

@@ -2,9 +2,9 @@ import "vite-plus/test/config";
 
 import { assert, describe, it } from "@effect/vitest";
 import { fromPartial } from "@total-typescript/shoehorn";
-import type { OrchestrationThreadShell } from "#t3tools/contracts";
+import type { OrchestrationThreadShell } from "@t3tools/contracts";
 
-import { formatThreadsHuman } from "./thread-format.ts";
+import { formatThreadsHuman } from "./thread.ts";
 
 describe("formatThreadsHuman", () => {
   it("appends (archived) for archived threads", () => {
@@ -26,7 +26,9 @@ describe("formatThreadsHuman", () => {
     ];
 
     const output = formatThreadsHuman(threads);
-    assert.include(output, "- Active thread\n");
-    assert.include(output, "- Archived thread (archived)\n");
+    assert.include(output, "title            id          status   updated                   flags");
+    assert.include(output, "Active thread    active-1");
+    assert.include(output, "Archived thread  archived-1");
+    assert.include(output, "archived");
   });
 });

package/src/cli/format/thread.ts

@@ -0,0 +1,185 @@
+import type { ThreadShow } from "../../application/threads.ts";
+import type { WaitEvent } from "../../application/service.ts";
+import type { OrchestrationThread, OrchestrationThreadShell } from "@t3tools/contracts";
+import { latestAssistantMessage, threadStatus } from "../../domain/thread-lifecycle.ts";
+import { formatChatTranscript, formatRecord, formatTable } from "./human.ts";
+
+export function formatThreadShowJson(thread: ThreadShow) {
+  return {
+    id: thread.id,
+    projectId: thread.projectId,
+    title: thread.title,
+    status: thread.status,
+    session: thread.session,
+    latestTurn: thread.latestTurn,
+    modelSelection: thread.modelSelection,
+    runtimeMode: thread.runtimeMode,
+    interactionMode: thread.interactionMode,
+    branch: thread.branch,
+    worktreePath: thread.worktreePath,
+    archivedAt: thread.archivedAt,
+    createdAt: thread.createdAt,
+    updatedAt: thread.updatedAt,
+    messageCount: thread.messageCount,
+    hasPendingApprovals: thread.hasPendingApprovals,
+    hasPendingUserInput: thread.hasPendingUserInput,
+    hasActionableProposedPlan: thread.hasActionableProposedPlan,
+    pendingApprovals: thread.pendingApprovals,
+    pendingUserInputs: thread.pendingUserInputs,
+  };
+}
+
+export function formatThreadShowHuman(thread: ThreadShow) {
+  const sections = [
+    formatRecord([
+      { field: "title", value: thread.title },
+      { field: "id", value: thread.id },
+      { field: "project", value: thread.projectId },
+      { field: "status", value: thread.status },
+      {
+        field: "model",
+        value: `${thread.modelSelection.instanceId}/${thread.modelSelection.model}`,
+      },
+      { field: "runtime", value: thread.runtimeMode },
+      { field: "interaction", value: thread.interactionMode },
+      ...(thread.branch !== null ? [{ field: "branch", value: thread.branch }] : []),
+      ...(thread.worktreePath !== null ? [{ field: "worktree", value: thread.worktreePath }] : []),
+      ...(thread.archivedAt !== null ? [{ field: "archived", value: thread.archivedAt }] : []),
+      { field: "messages", value: String(thread.messageCount) },
+      { field: "updated", value: thread.updatedAt },
+    ]),
+  ];
+  if (thread.pendingApprovals.length > 0) {
+    sections.push(
+      `\npending approvals\n${formatTable(
+        [
+          { header: "request", value: (approval) => approval.requestId, maxWidth: 40 },
+          { header: "kind", value: (approval) => approval.requestKind, maxWidth: 16 },
+          { header: "created", value: (approval) => approval.createdAt, maxWidth: 28 },
+          { header: "detail", value: (approval) => approval.detail ?? "-", maxWidth: 72 },
+        ],
+        thread.pendingApprovals,
+      )}`,
+    );
+  }
+  if (thread.pendingUserInputs.length > 0) {
+    sections.push(
+      `\npending user inputs\n${formatTable(
+        [
+          { header: "request", value: (input) => input.requestId, maxWidth: 40 },
+          { header: "questions", value: (input) => String(input.questions.length), maxWidth: 9 },
+          { header: "created", value: (input) => input.createdAt, maxWidth: 28 },
+          {
+            header: "prompt",
+            value: (input) => input.questions.map((question) => question.question).join("\n"),
+            maxWidth: 72,
+          },
+        ],
+        thread.pendingUserInputs,
+      )}`,
+    );
+  }
+  return `${sections.join("\n")}\n`;
+}
+
+export function formatThreadsHuman(threads: ReadonlyArray<OrchestrationThreadShell>) {
+  if (threads.length === 0) {
+    return "no threads\n";
+  }
+  return `${formatTable(
+    [
+      { header: "title", value: (thread) => thread.title, maxWidth: 36 },
+      { header: "id", value: (thread) => thread.id, maxWidth: 40 },
+      { header: "status", value: (thread) => threadStatus(thread), maxWidth: 18 },
+      { header: "updated", value: (thread) => thread.updatedAt, maxWidth: 28 },
+      { header: "flags", value: formatThreadFlags, maxWidth: 34 },
+    ],
+    threads,
+  )}\n`;
+}
+
+export function formatThreadDeletedHuman(input: {
+  readonly threadId: string;
+  readonly dispatch: { readonly sequence: number };
+}) {
+  return `thread deleted: ${input.threadId} (sequence ${input.dispatch.sequence})`;
+}
+
+export function formatThreadStartedHuman(input: {
+  readonly thread: OrchestrationThread;
+  readonly sequence: number;
+}) {
+  return `thread started\n${formatRecord([
+    { field: "title", value: input.thread.title },
+    { field: "id", value: input.thread.id },
+    { field: "status", value: threadStatus(input.thread) },
+    { field: "sequence", value: String(input.sequence) },
+  ])}`;
+}
+
+export function formatThreadMessagesHuman(thread: OrchestrationThread, limit: number) {
+  const messages = limit === 0 ? thread.messages : thread.messages.slice(-limit);
+  return formatChatTranscript(messages);
+}
+
+export function formatWaitDoneHuman(thread: OrchestrationThread) {
+  const latest = latestAssistantMessage(thread);
+  return `status: ${threadStatus(thread)}\n${
+    latest !== undefined ? `\n${formatChatTranscript([latest])}` : ""
+  }`;
+}
+
+export function formatThreadMessagesJson(thread: OrchestrationThread, full: boolean) {
+  return full ? thread : { thread: stripThreadMessages(thread), messages: thread.messages };
+}
+
+export function formatWaitEventNdjson(event: WaitEvent) {
+  if (event.type !== "thread" && event.type !== "done") {
+    return event;
+  }
+  const compactThread = stripThreadHeavy(event.thread);
+  return event.type === "done"
+    ? {
+        type: "done",
+        thread: compactThread,
+        latestAssistantMessage: latestAssistantMessage(event.thread) ?? null,
+      }
+    : {
+        type: "thread",
+        thread: compactThread,
+        messageCount: event.thread.messages.length,
+      };
+}
+
+function stripThreadMessages<T extends { readonly messages: unknown }>(thread: T) {
+  const { messages: _messages, ...rest } = thread;
+  return rest;
+}
+
+function formatThreadFlags(thread: OrchestrationThreadShell) {
+  const flags = [
+    thread.archivedAt !== null ? "archived" : null,
+    thread.hasPendingApprovals ? "approval" : null,
+    thread.hasPendingUserInput ? "input" : null,
+    thread.hasActionableProposedPlan ? "plan" : null,
+  ].filter((flag): flag is string => flag !== null);
+  return flags.length > 0 ? flags.join(", ") : "-";
+}
+
+function stripThreadHeavy<
+  T extends {
+    readonly messages: unknown;
+    readonly activities?: unknown;
+    readonly proposedPlans?: unknown;
+    readonly checkpoints?: unknown;
+  },
+>(thread: T) {
+  const {
+    messages: _messages,
+    activities: _activities,
+    proposedPlans: _proposedPlans,
+    checkpoints: _checkpoints,
+    ...rest
+  } = thread;
+  return rest;
+}

package/src/cli/index.ts

@@ -8,3 +8,23 @@ export {
   waitFormatFlag,
   worktreeFlag,
 } from "./flags.ts";
+export * as Env from "./env/index.ts";
+export * as Runtime from "./runtime/index.ts";
+export {
+  resolveCommandProjectRef,
+  resolveProjectRef,
+  resolveThreadId,
+  resolveWorktreePath,
+} from "./scope/index.ts";
+export {
+  resolveOutputFormat,
+  canRenderLiveTerminal,
+  isInteractiveHumanTerminal,
+  isAgentEnvironment,
+  humanJsonFormatChoices,
+  humanNdjsonFormatChoices,
+  humanJsonNdjsonFormatChoices,
+  type HumanJsonFormat,
+  type HumanNdjsonFormat,
+  type HumanJsonNdjsonFormat,
+} from "./format/index.ts";

package/src/cli/interaction/confirm.ts

@@ -0,0 +1,64 @@
+import * as Effect from "effect/Effect";
+import * as Prompt from "effect/unstable/cli/Prompt";
+
+import { DestructiveConfirmationRequiredError } from "../error.ts";
+import { isInteractiveHumanTerminal } from "../format/output.ts";
+import type { T3CliEnvShape } from "../../config/env/env.ts";
+import type { CliRuntime } from "../runtime/service.ts";
+
+export const requireDestructiveConfirmation = Effect.fn("requireDestructiveConfirmation")(
+  function* (input: {
+    readonly message: string;
+    readonly yes: boolean;
+    readonly cliRuntime: CliRuntime["Service"];
+    readonly t3CliEnv: T3CliEnvShape;
+  }) {
+    if (input.yes) {
+      return;
+    }
+    if (!isInteractiveHumanTerminal(input.cliRuntime, input.t3CliEnv)) {
+      yield* Effect.fail(
+        new DestructiveConfirmationRequiredError({
+          message: "destructive action requires --yes in non-interactive mode",
+        }),
+      );
+      return;
+    }
+    const confirmed = yield* Prompt.run(Prompt.confirm({ message: input.message, initial: false }));
+    if (confirmed) {
+      return;
+    }
+    yield* Effect.fail(new DestructiveConfirmationRequiredError({ message: "aborted" }));
+  },
+);
+
+export const requireEnvironmentReplaceConfirmation = Effect.fn(
+  "requireEnvironmentReplaceConfirmation",
+)(function* (input: {
+  readonly name: string;
+  readonly replace: boolean;
+  readonly cliRuntime: CliRuntime["Service"];
+  readonly t3CliEnv: T3CliEnvShape;
+}) {
+  if (input.replace) {
+    return;
+  }
+  if (!isInteractiveHumanTerminal(input.cliRuntime, input.t3CliEnv)) {
+    yield* Effect.fail(
+      new DestructiveConfirmationRequiredError({
+        message: `environment '${input.name}' already exists: pass --replace`,
+      }),
+    );
+    return;
+  }
+  const confirmed = yield* Prompt.run(
+    Prompt.confirm({
+      message: `Environment '${input.name}' already exists. Replace?`,
+      initial: false,
+    }),
+  );
+  if (confirmed) {
+    return;
+  }
+  yield* Effect.fail(new DestructiveConfirmationRequiredError({ message: "aborted" }));
+});

package/src/cli/{self-action.ts → interaction/self-action.ts}

@@ -1,23 +1,25 @@
 import * as Effect from "effect/Effect";
 
-import { SelfActionError } from "./error.ts";
-import { isAgentEnvironment } from "./output-format.ts";
-import type { EnvironmentShape } from "../environment/service.ts";
+import { SelfActionError } from "../error.ts";
+import { isAgentEnvironment } from "../format/output.ts";
+import type { T3CliEnvShape } from "../../config/env/env.ts";
+import type { CliRuntime } from "../runtime/service.ts";
 
 export const requireSelfActionConfirmation = Effect.fn("requireSelfActionConfirmation")(
   function* (input: {
     readonly threadId: string;
     readonly force: boolean;
-    readonly environment: EnvironmentShape;
+    readonly cliRuntime: CliRuntime["Service"];
+    readonly t3CliEnv: T3CliEnvShape;
     readonly action: string;
   }) {
     if (input.force) {
       return;
     }
-    if (!isAgentEnvironment(input.environment)) {
+    if (!isAgentEnvironment(input.t3CliEnv)) {
       return;
     }
-    const callerThreadId = input.environment.env.T3CODE_THREAD_ID;
+    const callerThreadId = input.t3CliEnv.scope.t3codeThreadId;
     if (callerThreadId === undefined || callerThreadId.length === 0) {
       return;
     }

package/src/cli/message-input.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
-import { ProviderUserInputAnswers } from "#t3tools/contracts";
+import { ProviderUserInputAnswers } from "@t3tools/contracts";
 
 import { MessageInputError } from "./error.ts";
 import type { InputError } from "./input/error.ts";

package/src/cli/model.ts

@@ -2,11 +2,13 @@ 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 } from "./flags.ts";
 import { T3Application } from "../application/service.ts";
-import { Environment } from "../environment/service.ts";
-import { formatModelsHuman } from "./model-format.ts";
-import { resolveOutputFormat } from "./output-format.ts";
+import { CliRuntime } from "../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../config/env/env.ts";
+import { formatModelsHuman } from "./format/model.ts";
+import { resolveOutputFormat } from "./format/output.ts";
 import { T3Output } from "./output/service.ts";
 
 export function createModelCommand() {
@@ -22,14 +24,16 @@ const listCommand = Command.make(
     all: Flag.boolean("all"),
     provider: Flag.string("provider").pipe(Flag.optional),
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ all, provider, 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 providerValue = Option.getOrUndefined(provider);
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const providers = yield* application.listModels({
         all,
         ...(providerValue !== undefined && providerValue.length > 0

package/src/cli/project.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, projectPathFlag } from "./flags.ts";
-import { formatProjectAddedHuman, formatProjectsHuman } from "./project-format.ts";
+import { formatProjectAddedHuman, formatProjectsHuman } from "./format/project.ts";
 import { deleteProjectCommand } from "./projects/delete.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 function createProjectCommand() {
@@ -21,13 +23,15 @@ const listCommand = Command.make(
   "list",
   {
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ 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 resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const snapshot = yield* application.loadShell();
       if (resolvedFormat === "json") {
         yield* output.printJson(snapshot.projects);
@@ -43,13 +47,15 @@ const addCommand = Command.make(
     path: projectPathFlag,
     title: Flag.string("title").pipe(Flag.optional),
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ path, title, 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 resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const titleValue = Option.getOrUndefined(title);
       const result = yield* application.addProject({
         path,