t3code-cli 0.11.0 → 0.12.0

package/src/cli/terminal/commands.test.ts

@@ -1,101 +0,0 @@
-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 { T3Input } from "../input/service.ts";
-import { T3Output } from "../output/service.ts";
-import { readTerminalCommand } from "./read.ts";
-import { writeTerminalCommand } from "./write.ts";
-
-const testLayer = Layer.mergeAll(
-  Layer.succeed(
-    T3Application,
-    fromPartial({
-      getTerminal: () => Effect.die("getTerminal should not be called"),
-      attachTerminal: () => Effect.die("attachTerminal should not be called"),
-      writeTerminal: () => Effect.die("writeTerminal 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,
-  }),
-  Layer.succeed(T3Input, {
-    readStdin: () => Effect.die("readStdin should not be called"),
-    readStdinBinary: () => Effect.die("readStdinBinary should not be called"),
-  }),
-  NodeServices.layer,
-  NodeEnvironmentLive,
-);
-
-describe("readTerminalCommand", () => {
-  it.layer(testLayer)("readTerminalCommand", (t) => {
-    t.effect("rejects --from-sequence without --follow", () =>
-      Effect.gen(function* () {
-        const run = Command.runWith(readTerminalCommand, { version: "0.0.0-test" });
-        const exit = yield* run(["--thread", "thread-1", "term-1", "--from-sequence", "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, "--from-sequence requires --follow");
-        }
-      }),
-    );
-  });
-});
-
-describe("writeTerminalCommand", () => {
-  it.layer(testLayer)("writeTerminalCommand", (t) => {
-    t.effect("rejects multiple payload sources", () =>
-      Effect.gen(function* () {
-        const run = Command.runWith(writeTerminalCommand, { version: "0.0.0-test" });
-        const exit = yield* run(["--thread", "thread-1", "term-1", "hello", "--stdin"]).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);
-        }
-      }),
-    );
-  });
-});

package/src/cli/terminal-format.ts

@@ -1,167 +0,0 @@
-import type { TerminalSessionSnapshot, TerminalSummary } from "#t3tools/contracts";
-
-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>) {
-  const headers = {
-    id: "id",
-    status: "status",
-    label: "label",
-    cwd: "cwd",
-    updated: "updated",
-    process: "process",
-  };
-
-  const widths = {
-    id: columnWidth(
-      headers.id,
-      rows.map((row) => row.id),
-      44,
-    ),
-    status: columnWidth(
-      headers.status,
-      rows.map((row) => row.status),
-      8,
-    ),
-    label: columnWidth(
-      headers.label,
-      rows.map((row) => row.label),
-      24,
-    ),
-    cwd: columnWidth(
-      headers.cwd,
-      rows.map((row) => row.cwd),
-      40,
-    ),
-    updated: columnWidth(
-      headers.updated,
-      rows.map((row) => row.updated),
-      24,
-    ),
-    process: columnWidth(
-      headers.process,
-      rows.map((row) => row.process),
-      20,
-    ),
-  };
-
-  const header = [
-    pad(headers.id, widths.id),
-    pad(headers.status, widths.status),
-    pad(headers.label, widths.label),
-    pad(headers.cwd, widths.cwd),
-    pad(headers.updated, widths.updated),
-    pad(headers.process, widths.process),
-  ].join("  ");
-
-  const divider = [
-    "-".repeat(widths.id),
-    "-".repeat(widths.status),
-    "-".repeat(widths.label),
-    "-".repeat(widths.cwd),
-    "-".repeat(widths.updated),
-    "-".repeat(widths.process),
-  ].join("  ");
-
-  const body = rows
-    .map((row) =>
-      [
-        pad(row.id, widths.id),
-        pad(row.status, widths.status),
-        pad(row.label, widths.label),
-        pad(row.cwd, widths.cwd),
-        pad(row.updated, widths.updated),
-        pad(row.process, widths.process),
-      ].join("  "),
-    )
-    .join("\n");
-
-  return `${header}\n${divider}\n${body}`;
-}
-
-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(", ") : "-";
-}
-
-function columnWidth(header: string, values: ReadonlyArray<string>, maxWidth: number) {
-  const widest = values.reduce((width, value) => Math.max(width, value.length), header.length);
-  return Math.min(widest, maxWidth);
-}
-
-function pad(value: string, width: number) {
-  return truncate(value, width).padEnd(width, " ");
-}
-
-function truncate(value: string, width: number) {
-  if (value.length <= width) {
-    return value;
-  }
-  if (width <= 3) {
-    return value.slice(0, width);
-  }
-  return `${value.slice(0, width - 3)}...`;
-}

package/src/cli/thread-format.ts

@@ -1,128 +0,0 @@
-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";
-
-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 lines = [
-    `title: ${thread.title}`,
-    `id: ${thread.id}`,
-    `status: ${thread.status}`,
-    `model: ${thread.modelSelection.instanceId}/${thread.modelSelection.model}`,
-    ...(thread.branch !== null ? [`branch: ${thread.branch}`] : []),
-    ...(thread.worktreePath !== null ? [`worktree: ${thread.worktreePath}`] : []),
-    `messages: ${thread.messageCount}`,
-  ];
-  if (thread.pendingApprovals.length > 0) {
-    const requestIds = thread.pendingApprovals.map((approval) => approval.requestId).join(", ");
-    lines.push(`pending approvals: ${thread.pendingApprovals.length} (${requestIds})`);
-  }
-  if (thread.pendingUserInputs.length > 0) {
-    const requestIds = thread.pendingUserInputs.map((input) => input.requestId).join(", ");
-    lines.push(`pending user inputs: ${thread.pendingUserInputs.length} (${requestIds})`);
-  }
-  return `${lines.join("\n")}\n`;
-}
-
-export function formatThreadsHuman(threads: ReadonlyArray<OrchestrationThreadShell>) {
-  return threads
-    .map(
-      (thread) =>
-        `- ${thread.title}${thread.archivedAt !== null ? " (archived)" : ""}\n  id: ${thread.id}\n  status: ${threadStatus(thread)}\n  updated: ${thread.updatedAt}\n`,
-    )
-    .join("");
-}
-
-export function formatThreadDeletedHuman(input: {
-  readonly threadId: string;
-  readonly dispatch: { readonly sequence: number };
-}) {
-  return `thread deleted: ${input.threadId}\nsequence: ${input.dispatch.sequence}`;
-}
-
-export function formatThreadStartedHuman(input: {
-  readonly thread: OrchestrationThread;
-  readonly sequence: number;
-}) {
-  return `thread started: ${input.thread.title}\nid: ${input.thread.id}\nstatus: ${threadStatus(input.thread)}\nsequence: ${input.sequence}`;
-}
-
-export function formatThreadMessagesHuman(thread: OrchestrationThread, limit: number) {
-  const messages = limit === 0 ? thread.messages : thread.messages.slice(-limit);
-  return messages.map((message) => `\n### ${message.role}\n\n${message.text}\n`).join("");
-}
-
-export function formatWaitDoneHuman(thread: OrchestrationThread) {
-  const latest = latestAssistantMessage(thread);
-  return `status: ${threadStatus(thread)}\n${latest !== undefined ? `\n### ${latest.role}\n\n${latest.text}\n` : ""}`;
-}
-
-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 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/config/layer.ts

@@ -1,105 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Filter from "effect/Filter";
-import * as Layer from "effect/Layer";
-import * as Path from "effect/Path";
-import * as Schema from "effect/Schema";
-
-import { Environment, type EnvironmentShape } from "../environment/service.ts";
-import { ConfigError } from "./error.ts";
-import { T3Config, type StoredConfig } from "./service.ts";
-import { normalizeHttpBaseUrl } from "./url.ts";
-
-export const makeT3Config = Effect.fn("makeT3Config")(function* () {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const environment = yield* Environment;
-  const configFilePath = resolveConfigPath(path, environment);
-  const readStored = Effect.fn("T3ConfigLive.readStored")(function* () {
-    const raw = yield* fs.readFileString(configFilePath).pipe(
-      Effect.catchFilter(Filter.reason("PlatformError", "NotFound"), () =>
-        Effect.succeed(undefined),
-      ),
-      Effect.mapError(
-        (error) => new ConfigError({ message: "failed to read config", cause: error }),
-      ),
-    );
-    if (raw === undefined) {
-      return {};
-    }
-    return yield* parseStoredConfig(raw);
-  });
-  const writeStored = Effect.fn("T3ConfigLive.writeStored")(function* (config: StoredConfig) {
-    yield* fs
-      .makeDirectory(path.dirname(configFilePath), { recursive: true, mode: 0o700 })
-      .pipe(
-        Effect.mapError(
-          (error) => new ConfigError({ message: "failed to write config", cause: error }),
-        ),
-      );
-    yield* fs
-      .writeFileString(configFilePath, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 })
-      .pipe(
-        Effect.mapError(
-          (error) => new ConfigError({ message: "failed to write config", cause: error }),
-        ),
-      );
-  });
-  const resolve = Effect.fn("T3ConfigLive.resolve")(function* () {
-    const stored = yield* readStored();
-    const envUrl = environment.env["T3CODE_URL"];
-    const envToken = environment.env["T3CODE_TOKEN"];
-    const envUrlValue = envUrl?.trim();
-    const envTokenValue = envToken?.trim();
-    const url = envUrlValue !== undefined && envUrlValue.length > 0 ? envUrlValue : stored.url;
-    const token =
-      envTokenValue !== undefined && envTokenValue.length > 0 ? envTokenValue : stored.token;
-    if (url === undefined || url.length === 0 || token === undefined || token.length === 0) {
-      return yield* Effect.fail(
-        new ConfigError({ message: "not authenticated. run: t3cli auth pair <pairing-url>" }),
-      );
-    }
-    const source: "env" | "config" =
-      (envUrlValue !== undefined && envUrlValue.length > 0) ||
-      (envTokenValue !== undefined && envTokenValue.length > 0)
-        ? "env"
-        : "config";
-    const normalizedUrl = yield* normalizeHttpBaseUrl(url);
-    return {
-      url: normalizedUrl,
-      token,
-      source,
-      local: stored.local ?? false,
-    };
-  });
-
-  return {
-    readStored,
-    writeStored,
-    resolve,
-  };
-});
-
-export const T3ConfigLive = Layer.effect(T3Config, makeT3Config());
-
-const StoredConfigSchema = Schema.Struct({
-  url: Schema.optionalKey(Schema.String),
-  token: Schema.optionalKey(Schema.String),
-  local: Schema.optionalKey(Schema.Boolean),
-});
-
-function parseStoredConfig(raw: string) {
-  return Schema.decodeUnknownEffect(Schema.fromJsonString(StoredConfigSchema))(raw).pipe(
-    Effect.mapError((error) => new ConfigError({ message: "failed to read config", cause: error })),
-  );
-}
-
-function resolveConfigPath(path: Path.Path, environment: EnvironmentShape) {
-  const xdgConfigHome = environment.env["XDG_CONFIG_HOME"];
-  const xdgConfigHomeValue = xdgConfigHome?.trim();
-  const root =
-    xdgConfigHomeValue !== undefined && xdgConfigHomeValue.length > 0
-      ? xdgConfigHomeValue
-      : path.join(environment.homeDir, ".config");
-  return path.join(root, "t3cli", "config.json");
-}

package/src/config/service.ts

@@ -1,26 +0,0 @@
-import * as Context from "effect/Context";
-import type * as Effect from "effect/Effect";
-
-import type { ConfigError, ConfigServiceError } from "./error.ts";
-
-export type StoredConfig = {
-  readonly url?: string;
-  readonly token?: string;
-  readonly local?: boolean;
-};
-
-export type ResolvedConfig = {
-  readonly url: string;
-  readonly token: string;
-  readonly source: "env" | "config";
-  readonly local: boolean;
-};
-
-export class T3Config extends Context.Service<
-  T3Config,
-  {
-    readonly readStored: () => Effect.Effect<StoredConfig, ConfigError>;
-    readonly writeStored: (config: StoredConfig) => Effect.Effect<void, ConfigError>;
-    readonly resolve: () => Effect.Effect<ResolvedConfig, ConfigServiceError>;
-  }
->()("t3cli/T3Config") {}

package/src/environment/layer.ts

@@ -1,12 +0,0 @@
-import { homedir } from "node:os";
-import * as Layer from "effect/Layer";
-
-import { Environment } from "./service.ts";
-
-export const NodeEnvironmentLive = Layer.succeed(Environment)({
-  cwd: process.cwd(),
-  homeDir: homedir(),
-  env: process.env,
-  stdoutIsTTY: process.stdout.isTTY ?? false,
-  stderrIsTTY: process.stderr.isTTY ?? false,
-});

package/src/environment/service.ts

@@ -1,13 +0,0 @@
-import * as Context from "effect/Context";
-
-export type EnvironmentShape = {
-  readonly cwd: string;
-  readonly homeDir: string;
-  readonly env: Readonly<Record<string, string | undefined>>;
-  readonly stdoutIsTTY: boolean;
-  readonly stderrIsTTY: boolean;
-};
-
-export class Environment extends Context.Service<Environment, EnvironmentShape>()(
-  "t3cli/Environment",
-) {}

package/src/layout/index.ts

@@ -1 +0,0 @@
-export { readT3LayoutFromNodeProcess, resolveT3BaseDir, type T3Layout } from "./base-dir.ts";