t3code-cli 0.14.1 → 0.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "t3code-cli",
-  "version": "0.14.1",
+  "version": "0.15.0",
   "description": "CLI for t3code",
   "keywords": [
     "claude",
@@ -106,9 +106,9 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@effect/platform-node": "4.0.0-beta.102",
+    "@effect/platform-node": "4.0.0-beta.103",
     "@napi-rs/keyring": "^1.3.0",
-    "effect": "4.0.0-beta.102",
+    "effect": "4.0.0-beta.103",
     "marked": "^15.0.12",
     "marked-terminal": "^7.3.0",
     "string-width": "^8.2.2",
@@ -116,7 +116,7 @@
   },
   "devDependencies": {
     "@changesets/cli": "^2.31.1",
-    "@effect/vitest": "4.0.0-beta.102",
+    "@effect/vitest": "4.0.0-beta.103",
     "@t3tools/client-runtime": "link:upstream-t3code/packages/client-runtime",
     "@t3tools/shared": "link:upstream-t3code/packages/shared",
     "@total-typescript/shoehorn": "^0.1.2",
@@ -124,7 +124,7 @@
     "typescript": "^7.0.2",
     "vite-plus": "^0.2.6",
     "yaml": "^2.9.0",
-    "@t3tools/contracts": "0.0.30"
+    "@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,
@@ -31,3 +32,4 @@ export type {
   WaitEvent,
 } from "./service.ts";
 export type { ApplicationError } from "./error.ts";
+export type { ThreadSearchResult } from "./threads.ts";

package/src/application/service.ts

@@ -6,8 +6,11 @@ import type {
   ModelSelection,
   OrchestrationMessage,
   OrchestrationProjectShell,
+  OrchestrationSearchThreadsInput,
   OrchestrationShellSnapshot,
   OrchestrationThread,
+  OrchestrationThreadDetailSnapshot,
+  OrchestrationThreadDetailWindow,
   OrchestrationThreadShell,
   ProjectScript,
   ProjectScriptIcon,
@@ -20,7 +23,7 @@ import type {
 } from "@t3tools/contracts";
 
 import type { ApplicationError } from "./error.ts";
-import type { ThreadShow } from "./threads.ts";
+import type { ThreadSearchResult, ThreadShow } from "./threads.ts";
 
 export type StartThreadInput = {
   readonly projectRef?: string;
@@ -61,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;
@@ -73,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 }
@@ -196,6 +213,10 @@ 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>;
   readonly listThreads: (
     projectRef: string,
     options?: {
@@ -209,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;
@@ -230,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<
@@ -246,6 +282,7 @@ export type T3ThreadApplicationService = {
   ) => Effect.Effect<
     {
       readonly dispatch: DispatchResult;
+      readonly messageId: string;
       readonly project: OrchestrationProjectShell;
       readonly threadId: string;
       readonly thread?: OrchestrationThread;
@@ -254,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,10 +6,21 @@ 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 { OrchestrationThreadShell } from "@t3tools/contracts";
+import type {
+  OrchestrationSearchThreadsInput,
+  OrchestrationThreadSearchMatch,
+  OrchestrationThreadShell,
+} from "@t3tools/contracts";
 import { mergeModelOptions } from "./model-selection.ts";
 import { derivePendingApprovals, derivePendingUserInputs } from "../domain/thread-activities.ts";
 import {
@@ -24,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";
@@ -73,10 +90,51 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
       threads: snapshot.threads.filter((thread) => thread.projectId === scope.project.id),
     };
   });
+  const searchThreads = Effect.fn("T3ApplicationLive.searchThreads")(function* (
+    input: OrchestrationSearchThreadsInput,
+  ) {
+    const result = yield* orchestration.searchThreads(input);
+    const snapshot = yield* orchestration.getShellSnapshot();
+    const threadsById = new Map(snapshot.threads.map((thread) => [thread.id, thread]));
+    const projectsById = new Map(snapshot.projects.map((project) => [project.id, project]));
+    return result.matches.map((match) => {
+      const thread = threadsById.get(match.threadId);
+      const project = projectsById.get(match.projectId);
+      return {
+        threadId: match.threadId,
+        threadTitle: thread?.title ?? null,
+        projectId: match.projectId,
+        projectTitle: project?.title ?? null,
+        workspaceRoot: project?.workspaceRoot ?? null,
+        branch: thread?.branch ?? null,
+        worktreePath: thread?.worktreePath ?? null,
+        source: match.source,
+        snippet: match.snippet,
+        messageCreatedAt: match.messageCreatedAt,
+      } satisfies ThreadSearchResult;
+    });
+  });
   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);
@@ -86,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,
@@ -96,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,
   ) {
@@ -107,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),
@@ -139,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;
@@ -171,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") {
@@ -187,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
@@ -211,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") {
@@ -223,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) {
@@ -271,12 +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,
@@ -287,6 +413,19 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
   } satisfies T3ThreadApplicationService;
 });
 
+export type ThreadSearchResult = {
+  readonly threadId: OrchestrationThreadSearchMatch["threadId"];
+  readonly threadTitle: string | null;
+  readonly projectId: OrchestrationThreadSearchMatch["projectId"];
+  readonly projectTitle: string | null;
+  readonly workspaceRoot: string | null;
+  readonly branch: string | null;
+  readonly worktreePath: string | null;
+  readonly source: OrchestrationThreadSearchMatch["source"];
+  readonly snippet: OrchestrationThreadSearchMatch["snippet"];
+  readonly messageCreatedAt: OrchestrationThreadSearchMatch["messageCreatedAt"];
+};
+
 const loadThreadsSnapshot = Effect.fn("loadThreadsSnapshot")(function* (
   include: ListThreadsInclude,
 ) {

package/src/cli/app.ts

@@ -1,12 +1,14 @@
 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";
 import { createTerminalCommandGroup } from "./terminal.ts";
 import { createModelCommand } from "./model.ts";
 import { createProjectCommand } from "./project.ts";
+import { searchThreadsCommand } from "./search.ts";
 import { createThreadCommand } from "./thread.ts";
 import { listThreadsCommand } from "./threads/list.ts";
 import { sendThreadCommand } from "./threads/send.ts";
@@ -21,11 +23,13 @@ export function createCliCommand() {
     Command.withGlobalFlags([cliEnvironmentSetting]),
     Command.withSubcommands([
       createActionCommand(),
+      askCommand,
       createAuthCommand(),
       createEnvCommand(),
       listThreadsCommand,
       createModelCommand(),
       createProjectCommand(),
+      searchThreadsCommand,
       createTerminalCommandGroup(),
       startThreadCommand,
       sendThreadCommand,