t3code-cli 0.10.0 → 0.12.0

package/src/cli/thread-format.ts

@@ -1,121 +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}\n  id: ${thread.id}\n  status: ${threadStatus(thread)}\n  updated: ${thread.updatedAt}\n`,
-    )
-    .join("");
-}
-
-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";