t3code-cli 0.14.2 → 0.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "t3code-cli",
-  "version": "0.14.2",
+  "version": "0.15.0",
   "description": "CLI for t3code",
   "keywords": [
     "claude",
@@ -124,7 +124,7 @@
     "typescript": "^7.0.2",
     "vite-plus": "^0.2.6",
     "yaml": "^2.9.0",
-    "@t3tools/contracts": "0.0.32"
+    "@t3tools/contracts": "0.0.33"
   },
   "engines": {
     "node": ">=24.0.0"

package/src/application/error.ts

@@ -1,4 +1,4 @@
 import type { DomainError } from "../domain/error.ts";
-import type { RpcError } from "../rpc/error.ts";
+import type { OrchestrationError } from "../orchestration/service.ts";
 
-export type ApplicationError = DomainError | RpcError;
+export type ApplicationError = DomainError | OrchestrationError;

package/src/application/index.ts

@@ -23,6 +23,7 @@ export type {
   ProjectActionRunResult,
   ProjectActionSelector,
   SendThreadInput,
+  SnoozeThreadInput,
   StartThreadInput,
   StartThreadPolicy,
   T3ActionApplicationService,

package/src/application/service.ts

@@ -9,6 +9,8 @@ import type {
   OrchestrationSearchThreadsInput,
   OrchestrationShellSnapshot,
   OrchestrationThread,
+  OrchestrationThreadDetailSnapshot,
+  OrchestrationThreadDetailWindow,
   OrchestrationThreadShell,
   ProjectScript,
   ProjectScriptIcon,
@@ -62,8 +64,18 @@ export type CallbackThreadInput = {
   readonly prompt: string;
 };
 
+export interface SnoozeThreadInput {
+  readonly threadId: string;
+  readonly snoozedUntil: string;
+}
+
 export type ListThreadsInclude = "active" | "archived" | "all";
 
+export interface GetThreadMessagesInput {
+  readonly threadId: string;
+  readonly window?: OrchestrationThreadDetailWindow;
+}
+
 export type UpdateThreadInput = {
   readonly threadId: string;
   readonly title?: string;
@@ -74,9 +86,13 @@ export type UpdateThreadInput = {
   readonly worktreePath?: string | null;
 };
 
-export type StartThreadPolicy = {
+export interface ThreadDispatchPolicy {
   readonly until: "dispatch" | "visible" | "complete";
-};
+}
+
+export interface StartThreadPolicy extends ThreadDispatchPolicy {
+  readonly onThreadCreated?: (threadId: string) => Effect.Effect<void>;
+}
 
 export type WaitEvent =
   | { readonly type: "thread"; readonly thread: OrchestrationThread }
@@ -197,6 +213,7 @@ export class T3ProjectApplication extends Context.Service<
 >()("t3cli/T3ProjectApplication") {}
 
 export type T3ThreadApplicationService = {
+  readonly awaitShellSequence: (sequence: number) => Effect.Effect<void, ApplicationError>;
   readonly searchThreads: (
     input: OrchestrationSearchThreadsInput,
   ) => Effect.Effect<ReadonlyArray<ThreadSearchResult>, ApplicationError>;
@@ -213,8 +230,11 @@ export type T3ThreadApplicationService = {
     ApplicationError
   >;
   readonly getThreadMessages: (
+    input: GetThreadMessagesInput,
+  ) => Effect.Effect<OrchestrationThreadDetailSnapshot, ApplicationError>;
+  readonly getThreadSummary: (
     threadId: string,
-  ) => Effect.Effect<OrchestrationThread, ApplicationError>;
+  ) => Effect.Effect<OrchestrationThreadShell, ApplicationError>;
   readonly showThread: (threadId: string) => Effect.Effect<ThreadShow, ApplicationError>;
   readonly approveThread: (input: {
     readonly threadId: string;
@@ -234,7 +254,19 @@ export type T3ThreadApplicationService = {
   >;
   readonly archiveThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
   readonly interruptThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
+  readonly interruptThreadTurn: (
+    threadId: string,
+    turnId: string,
+  ) => Effect.Effect<DispatchResult | undefined, ApplicationError>;
+  readonly pinThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
+  readonly settleThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
+  readonly snoozeThread: (
+    input: SnoozeThreadInput,
+  ) => Effect.Effect<DispatchResult, ApplicationError>;
   readonly unarchiveThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
+  readonly unpinThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
+  readonly unsnoozeThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
+  readonly unsettleThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
   readonly deleteThread: (
     threadId: string,
   ) => Effect.Effect<
@@ -250,6 +282,7 @@ export type T3ThreadApplicationService = {
   ) => Effect.Effect<
     {
       readonly dispatch: DispatchResult;
+      readonly messageId: string;
       readonly project: OrchestrationProjectShell;
       readonly threadId: string;
       readonly thread?: OrchestrationThread;
@@ -258,10 +291,11 @@ export type T3ThreadApplicationService = {
   >;
   readonly sendThread: (
     input: SendThreadInput,
-    policy?: StartThreadPolicy,
+    policy?: ThreadDispatchPolicy,
   ) => Effect.Effect<
     {
       readonly dispatch: DispatchResult;
+      readonly messageId: string;
       readonly threadId: string;
       readonly thread?: OrchestrationThread;
     },

package/src/application/thread-commands.ts

@@ -115,6 +115,84 @@ export const makeThreadUnarchiveCommand = Effect.fn("makeThreadUnarchiveCommand"
   } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.unarchive" }>;
 });
 
+export const makeThreadSettleCommand = Effect.fn("makeThreadSettleCommand")(function* (
+  threadId: string,
+) {
+  const crypto = yield* Crypto.Crypto;
+  return {
+    type: "thread.settle",
+    commandId: CommandId.make(
+      `t3cli:thread-settle:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    ),
+    threadId: ThreadId.make(threadId),
+  } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.settle" }>;
+});
+
+export const makeThreadUnsettleCommand = Effect.fn("makeThreadUnsettleCommand")(function* (
+  threadId: string,
+) {
+  const crypto = yield* Crypto.Crypto;
+  return {
+    type: "thread.unsettle",
+    commandId: CommandId.make(
+      `t3cli:thread-unsettle:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    ),
+    threadId: ThreadId.make(threadId),
+    reason: "user",
+  } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.unsettle" }>;
+});
+
+export const makeThreadSnoozeCommand = Effect.fn("makeThreadSnoozeCommand")(function* (input: {
+  readonly threadId: string;
+  readonly snoozedUntil: string;
+}) {
+  const crypto = yield* Crypto.Crypto;
+  return {
+    type: "thread.snooze",
+    commandId: CommandId.make(
+      `t3cli:thread-snooze:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    ),
+    threadId: ThreadId.make(input.threadId),
+    snoozedUntil: input.snoozedUntil,
+  } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.snooze" }>;
+});
+
+export const makeThreadUnsnoozeCommand = Effect.fn("makeThreadUnsnoozeCommand")(function* (
+  threadId: string,
+) {
+  const crypto = yield* Crypto.Crypto;
+  return {
+    type: "thread.unsnooze",
+    commandId: CommandId.make(
+      `t3cli:thread-unsnooze:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    ),
+    threadId: ThreadId.make(threadId),
+    reason: "user",
+  } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.unsnooze" }>;
+});
+
+export const makeThreadPinCommand = Effect.fn("makeThreadPinCommand")(function* (threadId: string) {
+  const crypto = yield* Crypto.Crypto;
+  return {
+    type: "thread.pin",
+    commandId: CommandId.make(`t3cli:thread-pin:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`),
+    threadId: ThreadId.make(threadId),
+  } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.pin" }>;
+});
+
+export const makeThreadUnpinCommand = Effect.fn("makeThreadUnpinCommand")(function* (
+  threadId: string,
+) {
+  const crypto = yield* Crypto.Crypto;
+  return {
+    type: "thread.unpin",
+    commandId: CommandId.make(
+      `t3cli:thread-unpin:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    ),
+    threadId: ThreadId.make(threadId),
+  } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.unpin" }>;
+});
+
 export const makeThreadSessionStopCommand = Effect.fn("makeThreadSessionStopCommand")(function* (
   threadId: string,
 ) {

package/src/application/threads.ts

@@ -6,7 +6,14 @@ import { CliRuntime } from "../cli/runtime/service.ts";
 import { T3Orchestration } from "../orchestration/service.ts";
 import { ProjectLookupError, ThreadLookupError, ThreadSessionError } from "../domain/error.ts";
 import { resolveProjectScope } from "../domain/helpers.ts";
-import { type ListThreadsInclude, type StartThreadInput } from "./service.ts";
+import {
+  type GetThreadMessagesInput,
+  type ListThreadsInclude,
+  type SnoozeThreadInput,
+  type StartThreadInput,
+  type StartThreadPolicy,
+  type ThreadDispatchPolicy,
+} from "./service.ts";
 import type { CallbackThreadInput, SendThreadInput } from "./service.ts";
 import type { T3ThreadApplicationService } from "./service.ts";
 import type {
@@ -28,10 +35,16 @@ import {
   makeThreadArchiveCommand,
   makeThreadDeleteCommand,
   makeThreadInterruptCommand,
+  makeThreadPinCommand,
   makeThreadSessionStopCommand,
+  makeThreadSettleCommand,
+  makeThreadSnoozeCommand,
   makeThreadStartCommands,
   makeThreadTurnContinueCommand,
   makeThreadUnarchiveCommand,
+  makeThreadUnpinCommand,
+  makeThreadUnsnoozeCommand,
+  makeThreadUnsettleCommand,
   makeThreadUserInputRespondCommand,
 } from "./thread-commands.ts";
 import { makeUpdateThread } from "./thread-update.ts";
@@ -102,9 +115,26 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
     });
   });
   const getThreadMessages = Effect.fn("T3ApplicationLive.getThreadMessages")(function* (
+    input: GetThreadMessagesInput,
+  ) {
+    return yield* orchestration.getThreadDetailSnapshot(input);
+  });
+  const getThreadSummary = Effect.fn("T3ApplicationLive.getThreadSummary")(function* (
     threadId: string,
   ) {
-    return yield* orchestration.getThreadSnapshot(threadId);
+    const snapshot = yield* loadThreadsSnapshot("all").pipe(
+      Effect.provideService(T3Orchestration, orchestration),
+    );
+    const thread = snapshot.threads.find((item) => item.id === threadId);
+    if (thread === undefined) {
+      return yield* Effect.fail(
+        new ThreadLookupError({
+          message: `thread not found: ${threadId}`,
+          threadId,
+        }),
+      );
+    }
+    return thread;
   });
   const showThread = Effect.fn("T3ApplicationLive.showThread")(function* (threadId: string) {
     const thread = yield* orchestration.getThreadSnapshot(threadId);
@@ -114,7 +144,9 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
     const command = yield* makeThreadArchiveCommand(threadId).pipe(
       Effect.provideService(Crypto.Crypto, crypto),
     );
-    return yield* orchestration.dispatch(command);
+    const dispatch = yield* orchestration.dispatch(command);
+    yield* awaitShellSequence(dispatch.sequence);
+    return dispatch;
   });
   const unarchiveThread = Effect.fn("T3ApplicationLive.unarchiveThread")(function* (
     threadId: string,
@@ -124,6 +156,48 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
     );
     return yield* orchestration.dispatch(command);
   });
+  const settleThread = Effect.fn("T3ApplicationLive.settleThread")(function* (threadId: string) {
+    const command = yield* makeThreadSettleCommand(threadId).pipe(
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
+    return yield* orchestration.dispatch(command);
+  });
+  const unsettleThread = Effect.fn("T3ApplicationLive.unsettleThread")(function* (
+    threadId: string,
+  ) {
+    const command = yield* makeThreadUnsettleCommand(threadId).pipe(
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
+    return yield* orchestration.dispatch(command);
+  });
+  const snoozeThread = Effect.fn("T3ApplicationLive.snoozeThread")(function* (
+    input: SnoozeThreadInput,
+  ) {
+    const command = yield* makeThreadSnoozeCommand(input).pipe(
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
+    return yield* orchestration.dispatch(command);
+  });
+  const unsnoozeThread = Effect.fn("T3ApplicationLive.unsnoozeThread")(function* (
+    threadId: string,
+  ) {
+    const command = yield* makeThreadUnsnoozeCommand(threadId).pipe(
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
+    return yield* orchestration.dispatch(command);
+  });
+  const pinThread = Effect.fn("T3ApplicationLive.pinThread")(function* (threadId: string) {
+    const command = yield* makeThreadPinCommand(threadId).pipe(
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
+    return yield* orchestration.dispatch(command);
+  });
+  const unpinThread = Effect.fn("T3ApplicationLive.unpinThread")(function* (threadId: string) {
+    const command = yield* makeThreadUnpinCommand(threadId).pipe(
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
+    return yield* orchestration.dispatch(command);
+  });
   const interruptThread = Effect.fn("T3ApplicationLive.interruptThread")(function* (
     threadId: string,
   ) {
@@ -135,6 +209,19 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
     }).pipe(Effect.provideService(Crypto.Crypto, crypto));
     return yield* orchestration.dispatch(command);
   });
+  const interruptThreadTurn = Effect.fn("T3ApplicationLive.interruptThreadTurn")(function* (
+    threadId: string,
+    turnId: string,
+  ) {
+    const snapshot = yield* orchestration.getThreadSnapshot(threadId);
+    if (snapshot.session?.activeTurnId !== turnId) {
+      return undefined;
+    }
+    const command = yield* makeThreadInterruptCommand({ threadId, turnId }).pipe(
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
+    return yield* orchestration.dispatch(command);
+  });
   const deleteThread = Effect.fn("T3ApplicationLive.deleteThread")(function* (threadId: string) {
     const snapshot = yield* loadThreadsSnapshot("all").pipe(
       Effect.provideService(T3Orchestration, orchestration),
@@ -167,9 +254,7 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
     );
   const startThread = Effect.fn("T3ApplicationLive.startThread")(function* (
     startInput: StartThreadInput,
-    policy?: {
-      readonly until: "dispatch" | "visible" | "complete";
-    },
+    policy?: StartThreadPolicy,
   ) {
     const snapshot = yield* orchestration.getShellSnapshot();
     const projectRef = startInput.projectRef;
@@ -199,13 +284,17 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
       project: scope.project,
       serverConfig,
     }).pipe(Effect.provideService(Crypto.Crypto, crypto));
+    const threadId = commands.threadId;
     const createDispatch = yield* orchestration.dispatch(commands.createCommand);
+    if (policy?.onThreadCreated !== undefined) {
+      yield* policy.onThreadCreated(threadId);
+    }
     yield* awaitShellSequence(createDispatch.sequence);
     const dispatch = yield* orchestration.dispatch(commands.turnCommand);
-    const threadId = commands.threadId;
+    const messageId = commands.turnCommand.message.messageId;
     const until = policy?.until ?? "dispatch";
     if (until === "dispatch") {
-      return { dispatch, project: scope.project, threadId };
+      return { dispatch, messageId, project: scope.project, threadId };
     }
     yield* awaitShellSequence(dispatch.sequence);
     if (until === "visible") {
@@ -215,17 +304,15 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
           return opened.snapshot;
         }),
       );
-      return { dispatch, project: scope.project, threadId, thread };
+      return { dispatch, messageId, project: scope.project, threadId, thread };
     }
     const thread = yield* awaitThreadCompletion(threadId);
     yield* failIfThreadError(thread);
-    return { dispatch, project: scope.project, threadId, thread };
+    return { dispatch, messageId, project: scope.project, threadId, thread };
   });
   const sendThread = Effect.fn("T3ApplicationLive.sendThread")(function* (
     input: SendThreadInput,
-    policy?: {
-      readonly until: "dispatch" | "visible" | "complete";
-    },
+    policy?: ThreadDispatchPolicy,
   ) {
     const modelSelection =
       input.options !== undefined && input.options.length > 0
@@ -239,9 +326,10 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
       ...(modelSelection !== undefined ? { modelSelection } : {}),
     }).pipe(Effect.provideService(Crypto.Crypto, crypto));
     const dispatch = yield* orchestration.dispatch(command);
+    const messageId = command.message.messageId;
     const until = policy?.until ?? "dispatch";
     if (until === "dispatch") {
-      return { dispatch, threadId: input.threadId };
+      return { dispatch, messageId, threadId: input.threadId };
     }
     yield* awaitShellSequence(dispatch.sequence);
     if (until === "visible") {
@@ -251,11 +339,11 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
           return opened.snapshot;
         }),
       );
-      return { dispatch, threadId: input.threadId, thread };
+      return { dispatch, messageId, threadId: input.threadId, thread };
     }
     const thread = yield* awaitThreadCompletion(input.threadId);
     yield* failIfThreadError(thread);
-    return { dispatch, threadId: input.threadId, thread };
+    return { dispatch, messageId, threadId: input.threadId, thread };
   });
   const watchThread = (threadId: string) => streamThreadEvents(threadId);
   const waitForThread = Effect.fn("T3ApplicationLive.waitForThread")(function* (threadId: string) {
@@ -299,13 +387,22 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
   return {
     approveThread,
     archiveThread,
+    awaitShellSequence,
     deleteThread,
     interruptThread,
+    interruptThreadTurn,
+    pinThread,
+    settleThread,
+    snoozeThread,
     updateThread,
     unarchiveThread,
+    unpinThread,
+    unsnoozeThread,
+    unsettleThread,
     listThreads,
     searchThreads,
     getThreadMessages,
+    getThreadSummary,
     respondToThread,
     sendThread,
     showThread,

package/src/cli/app.ts

@@ -1,6 +1,7 @@
 import { Command } from "effect/unstable/cli";
 
 import { createActionCommand } from "./action.ts";
+import { askCommand } from "./ask.ts";
 import { createAuthCommand } from "./auth.ts";
 import { createEnvCommand } from "./env.ts";
 import { cliEnvironmentSetting } from "./env/flag.ts";
@@ -22,6 +23,7 @@ export function createCliCommand() {
     Command.withGlobalFlags([cliEnvironmentSetting]),
     Command.withSubcommands([
       createActionCommand(),
+      askCommand,
       createAuthCommand(),
       createEnvCommand(),
       listThreadsCommand,