t3code-cli 0.5.1 → 0.6.0

package/src/cli/index.ts

@@ -0,0 +1,10 @@
+export {
+  formatFlag,
+  modelFlags,
+  projectFlag,
+  projectPathFlag,
+  threadFlag,
+  threadFormatFlag,
+  waitFormatFlag,
+  worktreeFlag,
+} from "./flags.ts";

package/src/cli/{models.ts → model.ts}

@@ -2,14 +2,15 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Command, Flag } from "effect/unstable/cli";
 
+import { formatFlag } from "./flags.ts";
 import { T3Application } from "../application/service.ts";
 import { Environment } from "../environment/service.ts";
 import { formatModelsHuman } from "./model-format.ts";
-import { humanJsonFormatChoices, resolveOutputFormat } from "./output-format.ts";
+import { resolveOutputFormat } from "./output-format.ts";
 import { T3Output } from "./output/service.ts";
 
-export function createModelsCommand() {
-  return Command.make("models").pipe(
+export function createModelCommand() {
+  return Command.make("model").pipe(
     Command.withDescription("model commands"),
     Command.withSubcommands([listCommand]),
   );
@@ -20,7 +21,7 @@ const listCommand = Command.make(
   {
     all: Flag.boolean("all"),
     provider: Flag.string("provider").pipe(Flag.optional),
-    format: Flag.choice("format", humanJsonFormatChoices).pipe(Flag.withDefault("auto")),
+    format: formatFlag,
   },
   ({ all, provider, format }) =>
     Effect.gen(function* () {

package/src/cli/{projects.ts → project.ts}

@@ -1,15 +1,16 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import { Argument, Command, Flag } from "effect/unstable/cli";
+import { Command, Flag } from "effect/unstable/cli";
 
+import { formatFlag, projectPathFlag } from "./flags.ts";
 import { formatProjectAddedHuman, formatProjectsHuman } from "./project-format.ts";
 import { T3Application } from "../application/service.ts";
 import { Environment } from "../environment/service.ts";
-import { humanJsonFormatChoices, resolveOutputFormat } from "./output-format.ts";
+import { resolveOutputFormat } from "./output-format.ts";
 import { T3Output } from "./output/service.ts";
 
-export function createProjectsCommand() {
-  return Command.make("projects").pipe(
+export function createProjectCommand() {
+  return Command.make("project").pipe(
     Command.withDescription("project commands"),
     Command.withSubcommands([listCommand, addCommand]),
   );
@@ -18,7 +19,7 @@ export function createProjectsCommand() {
 const listCommand = Command.make(
   "list",
   {
-    format: Flag.choice("format", humanJsonFormatChoices).pipe(Flag.withDefault("auto")),
+    format: formatFlag,
   },
   ({ format }) =>
     Effect.gen(function* () {
@@ -38,9 +39,9 @@ const listCommand = Command.make(
 const addCommand = Command.make(
   "add",
   {
-    path: Argument.string("path"),
+    path: projectPathFlag,
     title: Flag.string("title").pipe(Flag.optional),
-    format: Flag.choice("format", humanJsonFormatChoices).pipe(Flag.withDefault("auto")),
+    format: formatFlag,
   },
   ({ path, title, format }) =>
     Effect.gen(function* () {

package/src/cli/require.ts

@@ -0,0 +1,31 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+
+import { T3Config } from "../config/service.ts";
+import { ProjectLookupError } from "../domain/error.ts";
+import { resolveCommandProjectRef } from "../scope/index.ts";
+
+export const requireCommandProjectRef = Effect.fn("requireCommandProjectRef")(function* (input: {
+  readonly project: Option.Option<string>;
+  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly cwd: string;
+}) {
+  const config = yield* T3Config;
+  const resolved = yield* config.resolve();
+  const ref = resolveCommandProjectRef({
+    value: Option.getOrUndefined(input.project),
+    env: input.env,
+    cwd: input.cwd,
+    isLocal: resolved.local,
+  });
+  if (ref === undefined) {
+    return yield* Effect.fail(
+      new ProjectLookupError({
+        message:
+          "project is required: pass --project, set T3CODE_PROJECT_ROOT / T3CODE_PROJECT_ID, or use local auth",
+        ref: input.cwd,
+      }),
+    );
+  }
+  return ref;
+});

package/src/cli/{threads.ts → thread.ts}

@@ -7,8 +7,8 @@ import { sendThreadCommand } from "./threads/send.ts";
 import { startThreadCommand } from "./threads/start.ts";
 import { waitForThreadCommand } from "./threads/wait.ts";
 
-export function createThreadsCommand() {
-  return Command.make("threads").pipe(
+export function createThreadCommand() {
+  return Command.make("thread").pipe(
     Command.withDescription("thread commands"),
     Command.withSubcommands([
       listThreadsCommand,

package/src/cli/threads/archive.ts

@@ -1,28 +1,44 @@
 import * as Effect from "effect/Effect";
-import { Argument, Command, Flag } from "effect/unstable/cli";
+import * as Option from "effect/Option";
+import { Command } from "effect/unstable/cli";
 
+import { formatFlag, threadFlag } from "../flags.ts";
+import { MissingThreadError } from "../error.ts";
+import { resolveThreadId } from "../../scope/index.ts";
 import { T3Application } from "../../application/service.ts";
 import { Environment } from "../../environment/service.ts";
-import { humanJsonFormatChoices, resolveOutputFormat } from "../output-format.ts";
+import { resolveOutputFormat } from "../output-format.ts";
 import { T3Output } from "../output/service.ts";
 
 export const archiveThreadCommand = Command.make(
   "archive",
   {
-    thread: Argument.string("thread"),
-    format: Flag.choice("format", humanJsonFormatChoices).pipe(Flag.withDefault("auto")),
+    thread: threadFlag,
+    format: formatFlag,
   },
   ({ thread, format }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
       const environment = yield* Environment;
       const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
       const resolvedFormat = resolveOutputFormat(format, environment, "json");
-      const dispatch = yield* application.archiveThread(thread);
+      const dispatch = yield* application.archiveThread(threadId);
       if (resolvedFormat === "json") {
-        yield* output.printJson(dispatch);
-      } else {
-        yield* output.printInfo(`thread archived: ${thread}\nsequence: ${dispatch.sequence}`);
+        return yield* output.printJson(dispatch);
       }
+      return yield* output.printInfo(
+        `thread archived: ${threadId}\nsequence: ${dispatch.sequence}`,
+      );
     }),
 ).pipe(Command.withDescription("archive thread"));

package/src/cli/threads/list.ts

@@ -1,17 +1,19 @@
 import * as Effect from "effect/Effect";
-import { Argument, Command, Flag } from "effect/unstable/cli";
+import { Command } from "effect/unstable/cli";
 
+import { formatFlag, projectFlag } from "../flags.ts";
+import { requireCommandProjectRef } from "../require.ts";
 import { formatThreadsHuman } from "../thread-format.ts";
 import { T3Application } from "../../application/service.ts";
 import { Environment } from "../../environment/service.ts";
-import { humanJsonFormatChoices, resolveOutputFormat } from "../output-format.ts";
+import { resolveOutputFormat } from "../output-format.ts";
 import { T3Output } from "../output/service.ts";
 
 export const listThreadsCommand = Command.make(
   "list",
   {
-    project: Argument.string("project"),
-    format: Flag.choice("format", humanJsonFormatChoices).pipe(Flag.withDefault("auto")),
+    project: projectFlag,
+    format: formatFlag,
   },
   ({ project, format }) =>
     Effect.gen(function* () {
@@ -19,7 +21,12 @@ export const listThreadsCommand = Command.make(
       const environment = yield* Environment;
       const output = yield* T3Output;
       const resolvedFormat = resolveOutputFormat(format, environment, "json");
-      const result = yield* application.listThreads(project);
+      const projectRef = yield* requireCommandProjectRef({
+        project,
+        env: environment.env,
+        cwd: environment.cwd,
+      });
+      const result = yield* application.listThreads(projectRef);
       if (resolvedFormat === "json") {
         yield* output.printJson(result.threads);
       } else {

package/src/cli/threads/messages.ts

@@ -1,20 +1,24 @@
 import * as Effect from "effect/Effect";
-import { Argument, Command, Flag } from "effect/unstable/cli";
+import * as Option from "effect/Option";
+import { Command, Flag } from "effect/unstable/cli";
 
+import { formatFlag, threadFlag } from "../flags.ts";
 import { InvalidLimitError } from "../error.ts";
+import { MissingThreadError } from "../error.ts";
+import { resolveThreadId } from "../../scope/index.ts";
 import { formatThreadMessagesHuman, formatThreadMessagesJson } from "../thread-format.ts";
 import { T3Application } from "../../application/service.ts";
 import { Environment } from "../../environment/service.ts";
-import { humanJsonFormatChoices, resolveOutputFormat } from "../output-format.ts";
+import { resolveOutputFormat } from "../output-format.ts";
 import { T3Output } from "../output/service.ts";
 
 export const getThreadMessagesCommand = Command.make(
   "messages",
   {
-    thread: Argument.string("thread"),
+    thread: threadFlag,
     limit: Flag.integer("limit").pipe(Flag.withDefault(20)),
     full: Flag.boolean("full"),
-    format: Flag.choice("format", humanJsonFormatChoices).pipe(Flag.withDefault("auto")),
+    format: formatFlag,
   },
   ({ thread, limit, full, format }) =>
     Effect.gen(function* () {
@@ -26,8 +30,19 @@ export const getThreadMessagesCommand = Command.make(
       const application = yield* T3Application;
       const environment = yield* Environment;
       const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
       const resolvedFormat = resolveOutputFormat(format, environment, "json");
-      const detail = yield* application.getThreadMessages(thread);
+      const detail = yield* application.getThreadMessages(threadId);
       if (resolvedFormat === "json") {
         return yield* output.printJson(formatThreadMessagesJson(detail, full));
       }

package/src/cli/threads/send.ts

@@ -2,32 +2,27 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 
+import { modelFlags, threadFlag, threadFormatFlag } from "../flags.ts";
 import { readInitialMessage } from "../message-input.ts";
 import { buildModelOptions } from "../model-options.ts";
+import { MissingThreadError } from "../error.ts";
+import { resolveThreadId } from "../../scope/index.ts";
 import { T3Application } from "../../application/service.ts";
 import { Environment } from "../../environment/service.ts";
 import { T3Input } from "../input/service.ts";
-import {
-  canRenderLiveTerminal,
-  humanJsonNdjsonFormatChoices,
-  resolveOutputFormat,
-} from "../output-format.ts";
+import { canRenderLiveTerminal, resolveOutputFormat } from "../output-format.ts";
 import { T3Output } from "../output/service.ts";
 import { printWaitEventsHuman, printWaitEventsNdjson } from "../wait-events.ts";
 
 export const sendThreadCommand = Command.make(
   "send",
   {
-    thread: Argument.string("thread"),
+    thread: threadFlag,
     message: Argument.string("message").pipe(Argument.optional),
     stdin: Flag.boolean("stdin"),
-    option: Flag.keyValuePair("option").pipe(Flag.optional),
-    reasoningEffort: Flag.string("reasoning-effort").pipe(Flag.optional),
-    effort: Flag.string("effort").pipe(Flag.optional),
-    fastMode: Flag.boolean("fast-mode").pipe(Flag.optional),
-    thinking: Flag.boolean("thinking").pipe(Flag.optional),
+    ...modelFlags,
     wait: Flag.boolean("wait"),
-    format: Flag.choice("format", humanJsonNdjsonFormatChoices).pipe(Flag.withDefault("auto")),
+    format: threadFormatFlag,
   },
   ({ thread, message, stdin, option, reasoningEffort, effort, fastMode, thinking, wait, format }) =>
     Effect.gen(function* () {
@@ -44,14 +39,25 @@ export const sendThreadCommand = Command.make(
         fastMode,
         thinking,
       });
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
       const input = {
         message: text,
-        threadId: thread,
+        threadId,
         ...(options.length > 0 ? { options } : {}),
       };
-      const application = yield* T3Application;
-      const environment = yield* Environment;
-      const output = yield* T3Output;
       const resolvedFormat = resolveOutputFormat(format, environment, wait ? "ndjson" : "json");
 
       if (resolvedFormat === "ndjson") {
@@ -60,32 +66,30 @@ export const sendThreadCommand = Command.make(
         if (wait) {
           yield* printWaitEventsNdjson(output, application.watchThread(sent.threadId));
         }
-        return;
+        return yield* Effect.void;
       }
 
       if (wait) {
         const sent = yield* application.sendThread(input, { until: "dispatch" });
         if (resolvedFormat === "json") {
           const finalThread = yield* application.waitForThread(sent.threadId);
-          yield* output.printJson({
+          return yield* output.printJson({
             dispatch: sent.dispatch,
             threadId: sent.threadId,
             thread: finalThread,
           });
-          return;
         }
         yield* printWaitEventsHuman(output, application.watchThread(sent.threadId), {
           threadId: sent.threadId,
           live: canRenderLiveTerminal(environment),
         });
-        return;
+        return yield* Effect.void;
       }
 
       const result = yield* application.sendThread(input, { until: "visible" });
       if (resolvedFormat === "json") {
-        yield* output.printJson(result);
-      } else {
-        yield* output.printInfo(`message sent: ${result.threadId}`);
+        return yield* output.printJson(result);
       }
+      return yield* output.printInfo(`message sent: ${result.threadId}`);
     }),
 ).pipe(Command.withDescription("send message to existing thread"));

package/src/cli/threads/start.ts

@@ -3,37 +3,32 @@ import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 
+import { modelFlags, projectFlag, threadFormatFlag, worktreeFlag } from "../flags.ts";
 import { readInitialMessage } from "../message-input.ts";
 import { buildModelOptions } from "../model-options.ts";
+import { requireCommandProjectRef } from "../require.ts";
+import { resolveWorktreePath } from "../../scope/index.ts";
 import { formatThreadStartedHuman } from "../thread-format.ts";
 import { T3Application } from "../../application/service.ts";
 import { Environment } from "../../environment/service.ts";
 import { T3Input } from "../input/service.ts";
-import {
-  canRenderLiveTerminal,
-  humanJsonNdjsonFormatChoices,
-  resolveOutputFormat,
-} from "../output-format.ts";
+import { canRenderLiveTerminal, resolveOutputFormat } from "../output-format.ts";
 import { T3Output } from "../output/service.ts";
 import { printWaitEventsHuman, printWaitEventsNdjson } from "../wait-events.ts";
 
 export const startThreadCommand = Command.make(
   "start",
   {
-    project: Argument.string("project"),
+    project: projectFlag,
     message: Argument.string("message").pipe(Argument.optional),
     stdin: Flag.boolean("stdin"),
     title: Flag.string("title").pipe(Flag.optional),
-    worktree: Flag.string("worktree").pipe(Flag.optional),
+    worktree: worktreeFlag,
     provider: Flag.string("provider").pipe(Flag.optional),
     model: Flag.string("model").pipe(Flag.optional),
-    option: Flag.keyValuePair("option").pipe(Flag.optional),
-    reasoningEffort: Flag.string("reasoning-effort").pipe(Flag.optional),
-    effort: Flag.string("effort").pipe(Flag.optional),
-    fastMode: Flag.boolean("fast-mode").pipe(Flag.optional),
-    thinking: Flag.boolean("thinking").pipe(Flag.optional),
+    ...modelFlags,
     wait: Flag.boolean("wait"),
-    format: Flag.choice("format", humanJsonNdjsonFormatChoices).pipe(Flag.withDefault("auto")),
+    format: threadFormatFlag,
   },
   ({
     project,
@@ -59,7 +54,6 @@ export const startThreadCommand = Command.make(
         readStdin: inputService.readStdin,
       });
       const titleValue = Option.getOrUndefined(title);
-      const worktreeValue = Option.getOrUndefined(worktree);
       const providerValue = Option.getOrUndefined(provider);
       const modelValue = Option.getOrUndefined(model);
       const options = buildModelOptions({
@@ -69,22 +63,29 @@ export const startThreadCommand = Command.make(
         fastMode,
         thinking,
       });
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const projectRef = yield* requireCommandProjectRef({
+        project,
+        env: environment.env,
+        cwd: environment.cwd,
+      });
+      const worktreePath = resolveWorktreePath({
+        value: Option.getOrUndefined(worktree),
+        env: environment.env,
+      });
       const input = {
-        projectRef: project,
         message: text,
+        projectRef,
         ...(titleValue !== undefined && titleValue.length > 0 ? { title: titleValue } : {}),
-        ...(worktreeValue !== undefined && worktreeValue.length > 0
-          ? { worktreePath: worktreeValue }
-          : {}),
+        ...(worktreePath !== undefined ? { worktreePath } : {}),
         ...(providerValue !== undefined && providerValue.length > 0
           ? { provider: providerValue }
           : {}),
         ...(modelValue !== undefined && modelValue.length > 0 ? { model: modelValue } : {}),
         ...(options.length > 0 ? { options } : {}),
       };
-      const application = yield* T3Application;
-      const environment = yield* Environment;
-      const output = yield* T3Output;
       const resolvedFormat = resolveOutputFormat(format, environment, wait ? "ndjson" : "json");
 
       if (resolvedFormat === "ndjson") {

package/src/cli/threads/wait.ts

@@ -1,34 +1,44 @@
 import * as Effect from "effect/Effect";
-import { Argument, Command, Flag } from "effect/unstable/cli";
+import * as Option from "effect/Option";
+import { Command } from "effect/unstable/cli";
 
+import { threadFlag, waitFormatFlag } from "../flags.ts";
+import { MissingThreadError } from "../error.ts";
+import { resolveThreadId } from "../../scope/index.ts";
 import { Environment } from "../../environment/service.ts";
 import { T3Application } from "../../application/service.ts";
-import {
-  canRenderLiveTerminal,
-  humanNdjsonFormatChoices,
-  resolveOutputFormat,
-} from "../output-format.ts";
+import { canRenderLiveTerminal, resolveOutputFormat } from "../output-format.ts";
 import { T3Output } from "../output/service.ts";
 import { printWaitEventsHuman, printWaitEventsNdjson } from "../wait-events.ts";
 
 export const waitForThreadCommand = Command.make(
   "wait",
   {
-    thread: Argument.string("thread"),
-    format: Flag.choice("format", humanNdjsonFormatChoices).pipe(Flag.withDefault("auto")),
+    thread: threadFlag,
+    format: waitFormatFlag,
   },
   ({ thread, format }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
       const environment = yield* Environment;
       const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
       const resolvedFormat = resolveOutputFormat(format, environment, "ndjson");
       if (resolvedFormat === "ndjson") {
-        yield* printWaitEventsNdjson(output, application.watchThread(thread));
-        return;
+        return yield* printWaitEventsNdjson(output, application.watchThread(threadId));
       }
-      yield* printWaitEventsHuman(output, application.watchThread(thread), {
-        threadId: thread,
+      return yield* printWaitEventsHuman(output, application.watchThread(threadId), {
+        threadId,
         live: canRenderLiveTerminal(environment),
       });
     }),

package/src/config/index.ts

@@ -0,0 +1,5 @@
+export { T3Config } from "./service.ts";
+export type { ResolvedConfig, StoredConfig } from "./service.ts";
+export { T3ConfigLive, makeT3Config } from "./layer.ts";
+export { ConfigError, UrlError } from "./error.ts";
+export type { ConfigServiceError } from "./error.ts";

package/src/config/layer.ts

@@ -69,6 +69,7 @@ export const makeT3Config = Effect.fn("makeT3Config")(function* () {
       url: normalizedUrl,
       token,
       source,
+      local: stored.local ?? false,
     };
   });
 
@@ -84,6 +85,7 @@ 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) {

package/src/config/service.ts

@@ -6,12 +6,14 @@ 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<

package/src/connection/index.ts

@@ -0,0 +1,9 @@
+export { T3CodeConnectionError } from "./error.ts";
+export { T3CodeRpcLayer, makeT3CodeRpcLayer } from "./layer.ts";
+export { T3CodeNodeRpcLayer } from "./node.ts";
+export {
+  T3CodeConnectionProvider,
+  T3CodeConnectionProviderLive,
+  makeT3CodeConnectionProvider,
+} from "./service.ts";
+export type { T3CodeAuth, T3CodeConnection, T3CodeOrigin } from "./type.ts";

package/src/contracts/index.ts

@@ -0,0 +1,8 @@
+export type {
+  OrchestrationMessage,
+  OrchestrationProjectShell,
+  OrchestrationShellSnapshot,
+  OrchestrationThread,
+  OrchestrationThreadShell,
+  ServerProvider,
+} from "#t3tools/contracts";