t3code-cli 0.11.0 → 0.12.0

package/src/application/actions.ts

@@ -0,0 +1,475 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import {
+  MAX_SCRIPT_ID_LENGTH,
+  SCRIPT_RUN_COMMAND_PATTERN,
+  type OrchestrationProjectShell,
+  type OrchestrationShellSnapshot,
+  type ProjectScript,
+} from "@t3tools/contracts";
+
+import {
+  ProjectActionLookupError,
+  ProjectActionValidationError,
+  ProjectLookupError,
+  ThreadLookupError,
+} from "../domain/error.ts";
+import { findProjectById, resolveProjectScope } from "../domain/helpers.ts";
+import { T3Orchestration } from "../orchestration/service.ts";
+import { makeProjectMetaUpdateCommand } from "./project-commands.ts";
+import { waitForShellSequence } from "./shell-sequence.ts";
+import {
+  T3TerminalApplication,
+  type AddProjectActionInput,
+  type ProjectActionSelector,
+  type T3ActionApplicationService,
+  type UpdateProjectActionInput,
+} from "./service.ts";
+
+const DEFAULT_ACTION_ICON = "play";
+const isScriptRunCommand = Schema.is(SCRIPT_RUN_COMMAND_PATTERN);
+type Mutable<T> = { -readonly [K in keyof T]: T[K] };
+type MutablePartial<T> = { -readonly [K in keyof T]?: T[K] };
+
+export const makeActionApplication = Effect.fn("makeActionApplication")(function* () {
+  const orchestration = yield* T3Orchestration;
+  const terminalApplication = yield* T3TerminalApplication;
+  const crypto = yield* Crypto.Crypto;
+  const path = yield* Path.Path;
+
+  const resolveProject = Effect.fn("T3ActionApplication.resolveProject")(function* (
+    snapshot: OrchestrationShellSnapshot,
+    projectRef: string,
+  ) {
+    const scope = yield* resolveProjectScope(snapshot, { ref: projectRef }).pipe(
+      Effect.provideService(Path.Path, path),
+    );
+    if (scope === undefined) {
+      return yield* Effect.fail(
+        new ProjectLookupError({
+          message: `project not found: ${projectRef}`,
+          ref: projectRef,
+        }),
+      );
+    }
+    return scope.project;
+  });
+
+  const dispatchScriptsUpdate = Effect.fn("T3ActionApplication.dispatchScriptsUpdate")(function* (
+    projectId: string,
+    scripts: ReadonlyArray<ProjectScript>,
+  ) {
+    const command = yield* makeProjectMetaUpdateCommand({
+      projectId,
+      scripts: [...scripts],
+    }).pipe(Effect.provideService(Crypto.Crypto, crypto));
+    const dispatch = yield* orchestration.dispatch(command);
+    const snapshot = yield* waitForShellSequence({ sequence: dispatch.sequence }).pipe(
+      Effect.provideService(T3Orchestration, orchestration),
+    );
+    const project = findProjectById(snapshot, projectId);
+    if (project === null) {
+      return yield* Effect.fail(
+        new ProjectLookupError({
+          message: `project not found after action update: ${projectId}`,
+          ref: projectId,
+        }),
+      );
+    }
+    return { dispatch, project };
+  });
+
+  const listActions: T3ActionApplicationService["listActions"] = Effect.fn(
+    "T3ActionApplication.listActions",
+  )(function* (projectRef: string) {
+    const snapshot = yield* orchestration.getShellSnapshot();
+    const project = yield* resolveProject(snapshot, projectRef);
+    return { project, actions: project.scripts };
+  });
+
+  const addAction: T3ActionApplicationService["addAction"] = Effect.fn(
+    "T3ActionApplication.addAction",
+  )(function* (input: AddProjectActionInput) {
+    const snapshot = yield* orchestration.getShellSnapshot();
+    const project = yield* resolveProject(snapshot, input.projectRef);
+    const name = yield* requireTrimmedNonEmpty(input.name, "action name", project.id);
+    const command = yield* requireTrimmedNonEmpty(input.command, "action command", project.id);
+    const id =
+      input.id !== undefined
+        ? yield* requireProjectScriptId(input.id, project.id)
+        : nextProjectScriptId(
+            name,
+            project.scripts.map((script) => script.id),
+          );
+    yield* validateUnusedId(project, id);
+    const preview = yield* normalizePreviewInput({
+      projectId: project.id,
+      autoOpenPreview: input.autoOpenPreview ?? false,
+      ...(input.previewUrl !== undefined ? { previewUrl: input.previewUrl } : {}),
+    });
+    const action: ProjectScript = {
+      id,
+      name,
+      command,
+      icon: input.icon ?? DEFAULT_ACTION_ICON,
+      runOnWorktreeCreate: input.setup === true,
+      ...preview,
+    };
+    const nextScripts = enforceSingleSetup(
+      [...project.scripts, action],
+      action.runOnWorktreeCreate ? action.id : null,
+    );
+    const result = yield* dispatchScriptsUpdate(project.id, nextScripts);
+    const persisted = yield* resolveActionBySelectorEffect(
+      result.project.scripts,
+      { id: action.id },
+      project.id,
+    );
+    return { ...result, action: persisted };
+  });
+
+  const updateAction: T3ActionApplicationService["updateAction"] = Effect.fn(
+    "T3ActionApplication.updateAction",
+  )(function* (input: UpdateProjectActionInput) {
+    const snapshot = yield* orchestration.getShellSnapshot();
+    const project = yield* resolveProject(snapshot, input.projectRef);
+    const existing = yield* resolveActionBySelectorEffect(
+      project.scripts,
+      input.selector,
+      project.id,
+    );
+    const updated = yield* normalizeActionUpdate(project.id, existing, input);
+    const nextScripts = enforceSingleSetup(
+      project.scripts.map((script) => (script.id === existing.id ? updated : script)),
+      updated.runOnWorktreeCreate ? updated.id : null,
+    );
+    const result = yield* dispatchScriptsUpdate(project.id, nextScripts);
+    const persisted = yield* resolveActionBySelectorEffect(
+      result.project.scripts,
+      { id: existing.id },
+      project.id,
+    );
+    return { ...result, action: persisted };
+  });
+
+  const deleteAction: T3ActionApplicationService["deleteAction"] = Effect.fn(
+    "T3ActionApplication.deleteAction",
+  )(function* (input: { readonly projectRef: string; readonly selector: ProjectActionSelector }) {
+    const snapshot = yield* orchestration.getShellSnapshot();
+    const project = yield* resolveProject(snapshot, input.projectRef);
+    const action = yield* resolveActionBySelectorEffect(
+      project.scripts,
+      input.selector,
+      project.id,
+    );
+    const nextScripts = project.scripts.filter((script) => script.id !== action.id);
+    const result = yield* dispatchScriptsUpdate(project.id, nextScripts);
+    return { ...result, action };
+  });
+
+  const runAction: T3ActionApplicationService["runAction"] = Effect.fn(
+    "T3ActionApplication.runAction",
+  )(function* (input: {
+    readonly threadId: string;
+    readonly selector: ProjectActionSelector;
+    readonly terminalId?: string;
+  }) {
+    const snapshot = yield* orchestration.getShellSnapshot();
+    const thread = snapshot.threads.find((candidate) => candidate.id === input.threadId);
+    if (thread === undefined) {
+      return yield* Effect.fail(
+        new ThreadLookupError({
+          message: `thread not found: ${input.threadId}`,
+          threadId: input.threadId,
+        }),
+      );
+    }
+    const project = findProjectById(snapshot, thread.projectId);
+    if (project === null) {
+      return yield* Effect.fail(
+        new ProjectLookupError({
+          message: `project not found for thread: ${input.threadId}`,
+          ref: thread.projectId,
+        }),
+      );
+    }
+    const action = yield* resolveActionBySelectorEffect(
+      project.scripts,
+      input.selector,
+      project.id,
+    );
+    const env = {
+      T3CODE_PROJECT_ROOT: project.workspaceRoot,
+      ...(thread.worktreePath !== null ? { T3CODE_WORKTREE_PATH: thread.worktreePath } : {}),
+    };
+    const terminal = yield* terminalApplication.createTerminal({
+      threadId: thread.id,
+      command: action.command,
+      env,
+      ...(input.terminalId !== undefined ? { terminalId: input.terminalId } : {}),
+    });
+    return { project, action, terminal };
+  });
+
+  return {
+    addAction,
+    deleteAction,
+    listActions,
+    runAction,
+    updateAction,
+  } satisfies T3ActionApplicationService;
+});
+
+export function nextProjectScriptId(name: string, existingIds: Iterable<string>): string {
+  const taken = new Set(Array.from(existingIds));
+  const baseId = normalizeScriptId(name);
+  if (!taken.has(baseId)) {
+    return baseId;
+  }
+
+  let suffix = 2;
+  while (suffix < 10_000) {
+    const candidate = `${baseId}-${suffix}`;
+    const safeCandidate =
+      candidate.length <= MAX_SCRIPT_ID_LENGTH
+        ? candidate
+        : `${baseId.slice(0, Math.max(1, MAX_SCRIPT_ID_LENGTH - String(suffix).length - 1))}-${suffix}`;
+    if (!taken.has(safeCandidate)) {
+      return safeCandidate;
+    }
+    suffix += 1;
+  }
+
+  return `${baseId}-${Date.now()}`.slice(0, MAX_SCRIPT_ID_LENGTH);
+}
+
+export function resolveActionBySelector(
+  scripts: ReadonlyArray<ProjectScript>,
+  selector: ProjectActionSelector,
+  projectId: string,
+): ProjectScript {
+  const result = resolveActionSelector(scripts, selector, projectId);
+  if ("action" in result) {
+    return result.action;
+  }
+  throw result.error;
+}
+
+function resolveActionBySelectorEffect(
+  scripts: ReadonlyArray<ProjectScript>,
+  selector: ProjectActionSelector,
+  projectId: string,
+) {
+  const result = resolveActionSelector(scripts, selector, projectId);
+  if ("action" in result) {
+    return Effect.succeed(result.action);
+  }
+  return Effect.fail(result.error);
+}
+
+function resolveActionSelector(
+  scripts: ReadonlyArray<ProjectScript>,
+  selector: ProjectActionSelector,
+  projectId: string,
+): { readonly action: ProjectScript } | { readonly error: ProjectActionLookupError } {
+  if (selector.id !== undefined) {
+    const id = selector.id.trim();
+    const match = scripts.find((script) => script.id === id);
+    if (match !== undefined) {
+      return { action: match };
+    }
+    return {
+      error: new ProjectActionLookupError({
+        message: `action not found by id: ${id}`,
+        projectId,
+        selector: `id:${id}`,
+      }),
+    };
+  }
+
+  const normalized = selector.name.trim().toLowerCase();
+  const matches = scripts.filter((script) => script.name.trim().toLowerCase() === normalized);
+  if (matches.length === 1) {
+    return { action: matches[0]! };
+  }
+  if (matches.length === 0) {
+    return {
+      error: new ProjectActionLookupError({
+        message: `action not found by name: ${selector.name.trim()}`,
+        projectId,
+        selector: `name:${selector.name.trim()}`,
+      }),
+    };
+  }
+  return {
+    error: new ProjectActionLookupError({
+      message: `action name is ambiguous: ${selector.name.trim()} matched ${matches.length} actions`,
+      projectId,
+      selector: `name:${selector.name.trim()}`,
+    }),
+  };
+}
+
+function normalizeScriptId(value: string): string {
+  const cleaned = value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  if (cleaned.length === 0) {
+    return "script";
+  }
+  if (cleaned.length <= MAX_SCRIPT_ID_LENGTH) {
+    return cleaned;
+  }
+  const truncated = cleaned.slice(0, MAX_SCRIPT_ID_LENGTH).replace(/-+$/g, "");
+  return truncated.length > 0 ? truncated : "script";
+}
+
+function validateUnusedId(project: OrchestrationProjectShell, id: string) {
+  if (project.scripts.some((script) => script.id === id)) {
+    return Effect.fail(
+      new ProjectActionValidationError({
+        message: `action id already exists: ${id}`,
+        projectId: project.id,
+      }),
+    );
+  }
+  return Effect.void;
+}
+
+function requireProjectScriptId(value: string, projectId: string) {
+  return Effect.gen(function* () {
+    const id = yield* requireTrimmedNonEmpty(value, "action id", projectId);
+    if (!isScriptRunCommand(`script.${id}.run`)) {
+      return yield* Effect.fail(
+        new ProjectActionValidationError({
+          message: `action id must be lowercase alphanumeric or hyphenated and at most ${MAX_SCRIPT_ID_LENGTH} characters`,
+          projectId,
+        }),
+      );
+    }
+    return id;
+  });
+}
+
+function requireTrimmedNonEmpty(value: string, field: string, projectId: string) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return Effect.fail(
+      new ProjectActionValidationError({
+        message: `${field} must not be empty`,
+        projectId,
+      }),
+    );
+  }
+  return Effect.succeed(trimmed);
+}
+
+function enforceSingleSetup(
+  scripts: ReadonlyArray<ProjectScript>,
+  setupActionId: string | null,
+): ReadonlyArray<ProjectScript> {
+  if (setupActionId === null) {
+    return scripts;
+  }
+  return scripts.map((script) =>
+    script.id === setupActionId
+      ? { ...script, runOnWorktreeCreate: true }
+      : script.runOnWorktreeCreate
+        ? { ...script, runOnWorktreeCreate: false }
+        : script,
+  );
+}
+
+function normalizePreviewInput(input: {
+  readonly projectId: string;
+  readonly previewUrl?: string;
+  readonly autoOpenPreview: boolean;
+}) {
+  return Effect.gen(function* () {
+    const previewUrl = input.previewUrl?.trim();
+    if (previewUrl !== undefined && previewUrl.length > 0) {
+      return {
+        previewUrl,
+        ...(input.autoOpenPreview ? { autoOpenPreview: true } : {}),
+      } satisfies Partial<ProjectScript>;
+    }
+    if (input.autoOpenPreview) {
+      return yield* Effect.fail(
+        new ProjectActionValidationError({
+          message: "--auto-open-preview requires --preview-url",
+          projectId: input.projectId,
+        }),
+      );
+    }
+    return {};
+  });
+}
+
+function normalizeActionUpdate(
+  projectId: string,
+  existing: ProjectScript,
+  input: UpdateProjectActionInput,
+) {
+  return Effect.gen(function* () {
+    const patch: MutablePartial<ProjectScript> = {};
+    let clearPreviewUrl = false;
+    let clearAutoOpenPreview = false;
+    if (input.name !== undefined) {
+      patch.name = yield* requireTrimmedNonEmpty(input.name, "action name", projectId);
+    }
+    if (input.command !== undefined) {
+      patch.command = yield* requireTrimmedNonEmpty(input.command, "action command", projectId);
+    }
+    if (input.icon !== undefined) {
+      patch.icon = input.icon;
+    }
+    if (input.setup !== undefined) {
+      patch.runOnWorktreeCreate = input.setup;
+    }
+    if (input.previewUrl !== undefined) {
+      if (input.previewUrl === null) {
+        clearPreviewUrl = true;
+        clearAutoOpenPreview = true;
+      } else {
+        patch.previewUrl = yield* requireTrimmedNonEmpty(
+          input.previewUrl,
+          "preview URL",
+          projectId,
+        );
+      }
+    }
+    if (input.autoOpenPreview !== undefined) {
+      if (input.autoOpenPreview !== true) {
+        clearAutoOpenPreview = true;
+      } else {
+        const nextPreviewUrl = clearPreviewUrl
+          ? undefined
+          : (patch.previewUrl ?? existing.previewUrl);
+        if (nextPreviewUrl === undefined) {
+          return yield* Effect.fail(
+            new ProjectActionValidationError({
+              message: "--auto-open-preview requires an existing or updated --preview-url",
+              projectId,
+            }),
+          );
+        }
+        patch.autoOpenPreview = true;
+      }
+    }
+    const updated: Mutable<ProjectScript> = {
+      ...existing,
+      ...patch,
+    };
+    if (clearPreviewUrl) {
+      delete updated.previewUrl;
+    }
+    if (clearAutoOpenPreview) {
+      delete updated.autoOpenPreview;
+    }
+    return updated;
+  });
+}

package/src/application/index.ts

@@ -1,4 +1,5 @@
 export {
+  T3ActionApplication,
   T3Application,
   T3ModelApplication,
   T3ProjectApplication,
@@ -7,6 +8,7 @@ export {
 } from "./service.ts";
 export {
   makeT3Application,
+  T3ActionApplicationLive,
   T3ApplicationLive,
   T3ApplicationSlicesLive,
   T3ModelApplicationLive,
@@ -15,14 +17,16 @@ export {
   T3ThreadApplicationLive,
 } from "./layer.ts";
 export type {
+  AddProjectActionInput,
+  ProjectActionDeleteResult,
+  ProjectActionMutationResult,
+  ProjectActionRunResult,
+  ProjectActionSelector,
   SendThreadInput,
   StartThreadInput,
   StartThreadPolicy,
-  T3ApplicationService,
-  T3ModelApplicationService,
-  T3ProjectApplicationService,
-  T3TerminalApplicationService,
-  T3ThreadApplicationService,
+  T3ActionApplicationService,
+  UpdateProjectActionInput,
   UpdateThreadInput,
   WaitEvent,
 } from "./service.ts";

package/src/application/layer.ts

@@ -1,9 +1,11 @@
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 
+import { makeActionApplication } from "./actions.ts";
 import { makeModelsApplication } from "./models.ts";
 import { makeProjectApplication } from "./projects.ts";
 import {
+  T3ActionApplication,
   T3Application,
   T3ModelApplication,
   T3ProjectApplication,
@@ -15,10 +17,12 @@ import { makeThreadApplication } from "./threads.ts";
 
 export const makeT3Application = Effect.fn("makeT3Application")(function* () {
   const models = yield* T3ModelApplication;
+  const actions = yield* T3ActionApplication;
   const projects = yield* T3ProjectApplication;
   const terminals = yield* T3TerminalApplication;
   const threads = yield* T3ThreadApplication;
   return {
+    ...actions,
     ...models,
     ...projects,
     ...terminals,
@@ -35,9 +39,14 @@ export const T3TerminalApplicationLive = Layer.effect(
   T3TerminalApplication,
   makeTerminalApplication(),
 );
+export const T3ActionApplicationLive = Layer.effect(
+  T3ActionApplication,
+  makeActionApplication(),
+).pipe(Layer.provide(T3TerminalApplicationLive));
 export const T3ThreadApplicationLive = Layer.effect(T3ThreadApplication, makeThreadApplication());
 
 export const T3ApplicationSlicesLive = Layer.mergeAll(
+  T3ActionApplicationLive,
   T3ModelApplicationLive,
   T3ProjectApplicationLive,
   T3TerminalApplicationLive,

package/src/application/model-selection.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect";
-import { ModelSelection, ProviderInstanceId } from "#t3tools/contracts";
-import type { OrchestrationProjectShell } from "#t3tools/contracts";
+import { ModelSelection, ProviderInstanceId } from "@t3tools/contracts";
+import type { OrchestrationProjectShell } from "@t3tools/contracts";
 import * as Schema from "effect/Schema";
 
 import { ModelSelectionError } from "../domain/error.ts";

package/src/application/project-commands.ts

@@ -2,18 +2,16 @@ import * as Crypto from "effect/Crypto";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Path from "effect/Path";
-import { CommandId, ProjectId, type ClientOrchestrationCommand } from "#t3tools/contracts";
-
-import { Environment } from "../environment/service.ts";
+import { CommandId, ProjectId, type ClientOrchestrationCommand } from "@t3tools/contracts";
 
 export const makeProjectCreateCommand = Effect.fn("makeProjectCreateCommand")(function* (input: {
   readonly path: string;
   readonly title?: string;
+  readonly cwd: string;
 }) {
   const path = yield* Path.Path;
   const crypto = yield* Crypto.Crypto;
-  const environment = yield* Environment;
-  const workspaceRoot = path.resolve(environment.cwd, input.path);
+  const workspaceRoot = path.resolve(input.cwd, input.path);
   const projectId = ProjectId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
   const title = input.title?.trim();
   const createdAt = DateTime.formatIso(yield* DateTime.now);
@@ -43,3 +41,23 @@ export const makeProjectDeleteCommand = Effect.fn("makeProjectDeleteCommand")(fu
     ...(input.force === true ? { force: true } : {}),
   } satisfies Extract<ClientOrchestrationCommand, { readonly type: "project.delete" }>;
 });
+
+export const makeProjectMetaUpdateCommand = Effect.fn("makeProjectMetaUpdateCommand")(
+  function* (input: {
+    readonly projectId: string;
+    readonly scripts: Extract<
+      ClientOrchestrationCommand,
+      { readonly type: "project.meta.update" }
+    >["scripts"];
+  }) {
+    const crypto = yield* Crypto.Crypto;
+    return {
+      type: "project.meta.update",
+      commandId: CommandId.make(
+        `t3cli:project-meta-update:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+      ),
+      projectId: ProjectId.make(input.projectId),
+      scripts: input.scripts,
+    } satisfies Extract<ClientOrchestrationCommand, { readonly type: "project.meta.update" }>;
+  },
+);

package/src/application/projects.ts

@@ -2,7 +2,7 @@ import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
 import * as Path from "effect/Path";
 
-import { Environment } from "../environment/service.ts";
+import { CliRuntime } from "../cli/runtime/service.ts";
 import { T3Orchestration } from "../orchestration/service.ts";
 import { ProjectCreateVisibilityError, ProjectLookupError } from "../domain/error.ts";
 import { findProjectById, resolveProjectScope } from "../domain/helpers.ts";
@@ -14,7 +14,7 @@ export const makeProjectApplication = Effect.fn("makeProjectApplication")(functi
   const orchestration = yield* T3Orchestration;
   const crypto = yield* Crypto.Crypto;
   const path = yield* Path.Path;
-  const environment = yield* Environment;
+  const cliRuntime = yield* CliRuntime;
   const loadShell: T3ProjectApplicationService["loadShell"] = Effect.fn(
     "T3ApplicationLive.loadShell",
   )(function* () {
@@ -40,11 +40,10 @@ export const makeProjectApplication = Effect.fn("makeProjectApplication")(functi
   const addProject: T3ProjectApplicationService["addProject"] = Effect.fn(
     "T3ApplicationLive.addProject",
   )(function* (projectInput: { readonly path: string; readonly title?: string }) {
-    const command = yield* makeProjectCreateCommand(projectInput).pipe(
-      Effect.provideService(Path.Path, path),
-      Effect.provideService(Crypto.Crypto, crypto),
-      Effect.provideService(Environment, environment),
-    );
+    const command = yield* makeProjectCreateCommand({
+      ...projectInput,
+      cwd: cliRuntime.cwd,
+    }).pipe(Effect.provideService(Path.Path, path), Effect.provideService(Crypto.Crypto, crypto));
     const dispatch = yield* orchestration.dispatch(command);
     const snapshot = yield* waitForShellSequence({ sequence: dispatch.sequence }).pipe(
       Effect.provideService(T3Orchestration, orchestration),