@maiaos/cli 0.1.0-canary.2

package/dist/project-workspace/commands.js

@@ -0,0 +1,700 @@
+import { MAX_PROJECT_CONTEXT_NOTE_BODY_BYTES, } from "@maiaos/sdk";
+import * as Effect from "effect/Effect";
+import { CliArgumentError, missingArgument, parseOptions, readCursor, readExpectedRevision, readPageSize, readRevisionOption, requirePositionals, } from "../command-line/index.js";
+import { writeExecutionResult, writeProjectResult, writeWorkspaceResult, } from "./output/index.js";
+const summarizeProjectRegistration = (result) => ({
+    checkoutId: result.checkout.id,
+    delivery: result.delivery,
+    projectId: result.project.id,
+    receipt: result.receipt,
+    repositoryId: result.repository.id,
+    workspaceId: result.workspace.id,
+});
+const summarizeRepositoryAttachment = (result) => ({
+    checkoutId: result.checkout.id,
+    delivery: result.delivery,
+    receipt: result.receipt,
+    repositoryId: result.repository.id,
+    workspaceId: result.workspace.id,
+    workspaceRevision: result.workspace.revision,
+});
+export const runProjectRegister = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--name"]));
+    requirePositionals(parsed.positionals, 1);
+    const path = parsed.positionals[0];
+    if (path === undefined) {
+        throw new CliArgumentError("The repository path is missing.");
+    }
+    const commandId = parsed.options.get("--command-id");
+    const name = parsed.options.get("--name");
+    const result = yield* context.dependencies.registerProject({
+        path,
+        ...(commandId === undefined ? {} : { commandId }),
+        ...(name === undefined ? {} : { name }),
+    });
+    return writeProjectResult(result, context, (value) => ({
+        command: "project.register",
+        result: summarizeProjectRegistration(value),
+    }));
+});
+export const runProjectList = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit"]));
+    requirePositionals(parsed.positionals, 0);
+    const result = yield* context.dependencies.listProjects({
+        afterCursor: readCursor(parsed.options.get("--after")),
+        limit: readPageSize(parsed.options.get("--limit")),
+    });
+    return writeProjectResult(result, context, (value) => ({
+        command: "project.list",
+        result: value,
+    }));
+});
+export const runProjectShow = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1);
+    const projectId = parsed.positionals[0];
+    if (projectId === undefined) {
+        throw new CliArgumentError("The project identifier is missing.");
+    }
+    const result = yield* context.dependencies.showProject(projectId);
+    return writeProjectResult(result, context, (value) => ({
+        command: "project.show",
+        result: value,
+    }));
+});
+const summarizeProjectContextRecord = (result) => ({
+    delivery: result.delivery,
+    noteId: result.note.id,
+    projectId: result.note.projectId,
+    receipt: result.receipt,
+    sequence: result.note.sequence,
+});
+const readProjectContextBody = (context) => {
+    if (context.io.stdin === undefined)
+        throw new CliArgumentError("Project context notes require standard input.");
+    return context.io.stdin({
+        label: "project context note",
+        maxBytes: MAX_PROJECT_CONTEXT_NOTE_BODY_BYTES,
+        maxChunks: 256,
+    });
+};
+const parseProjectContextRecord = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--project"]), new Set(["--body-stdin"]));
+    requirePositionals(parsed.positionals, 0);
+    if (!parsed.flags.has("--body-stdin"))
+        throw new CliArgumentError("Option '--body-stdin' is required.");
+    const projectId = parsed.options.get("--project");
+    if (projectId === undefined) {
+        throw new CliArgumentError("Option '--project' is required.");
+    }
+    const commandId = parsed.options.get("--command-id");
+    return {
+        projectId,
+        ...(commandId === undefined ? {} : { commandId }),
+    };
+};
+export const runProjectContextRecord = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseProjectContextRecord(tokens);
+    const result = yield* context.dependencies.recordProjectContext({
+        ...parsed,
+        body: yield* readProjectContextBody(context),
+    });
+    return writeProjectResult(result, context, (value) => ({
+        command: "project.context.record",
+        result: summarizeProjectContextRecord(value),
+    }));
+});
+export const runProjectContextList = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit", "--project"]));
+    requirePositionals(parsed.positionals, 0);
+    const projectId = parsed.options.get("--project");
+    if (projectId === undefined) {
+        throw new CliArgumentError("Option '--project' is required.");
+    }
+    const result = yield* context.dependencies.listProjectContext({
+        afterCursor: readCursor(parsed.options.get("--after")),
+        limit: readPageSize(parsed.options.get("--limit")),
+        projectId,
+    });
+    return writeProjectResult(result, context, (value) => ({
+        command: "project.context.list",
+        result: value,
+    }));
+});
+export const runProjectContextShow = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1);
+    const noteId = parsed.positionals[0];
+    if (noteId === undefined) {
+        throw new CliArgumentError("The project context note identifier is missing.");
+    }
+    const result = yield* context.dependencies.showProjectContext(noteId);
+    return writeProjectResult(result, context, (value) => ({
+        command: "project.context.show",
+        result: value,
+    }));
+});
+export const runExecutionCatalogShow = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 0);
+    const operation = context.dependencies.readExecutionCatalog;
+    if (operation === undefined)
+        throw new Error("Missing execution client.");
+    const result = yield* operation();
+    return writeExecutionResult(result, context, (value) => ({
+        command: "execution.catalog",
+        result: value,
+    }));
+});
+const parseExecutionFileRead = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--expected-revision"]));
+    requirePositionals(parsed.positionals, 2);
+    const [instanceId, relativePath] = parsed.positionals;
+    if (instanceId === undefined || relativePath === undefined) {
+        throw missingArgument();
+    }
+    return {
+        commandId: parsed.options.get("--command-id"),
+        expectedRevision: parsed.options.get("--expected-revision"),
+        instanceId,
+        relativePath,
+    };
+};
+export const runExecutionFileRead = (tokens, context) => Effect.gen(function* () {
+    const { commandId, expectedRevision, instanceId, relativePath } = parseExecutionFileRead(tokens);
+    const operation = context.dependencies.readExecutionFile;
+    if (operation === undefined)
+        throw new Error("Missing execution file client.");
+    const result = yield* operation({
+        expectedRevision: readExpectedRevision(expectedRevision),
+        instanceId,
+        relativePath,
+        ...(commandId === undefined ? {} : { commandId }),
+    });
+    return writeExecutionResult(result, context, (value) => ({
+        command: "execution.file.read",
+        result: value,
+    }));
+});
+const readExecutionCommandRun = (tokens) => {
+    const separator = tokens.indexOf("--");
+    if (separator < 0)
+        throw missingArgument();
+    const parsed = parseOptions(tokens.slice(0, separator), new Set(["--command-id", "--expected-revision"]));
+    requirePositionals(parsed.positionals, 1);
+    const [instanceId] = parsed.positionals;
+    const [executable, ...argv] = tokens.slice(separator + 1);
+    if (instanceId === undefined || executable === undefined) {
+        throw missingArgument();
+    }
+    const commandId = parsed.options.get("--command-id");
+    return {
+        argv,
+        executable,
+        expectedRevision: readExpectedRevision(parsed.options.get("--expected-revision")),
+        instanceId,
+        ...(commandId === undefined ? {} : { commandId }),
+    };
+};
+export const runExecutionCommandRun = (tokens, context) => Effect.gen(function* () {
+    const operation = context.dependencies.runExecutionCommand;
+    if (operation === undefined)
+        throw new Error("Missing execution client.");
+    const result = yield* operation(readExecutionCommandRun(tokens));
+    return writeExecutionResult(result, context, (value) => ({
+        command: "execution.command.run",
+        result: value,
+    }));
+});
+const requiredPlacementIdentity = (value, message) => {
+    if (value !== undefined)
+        return value;
+    throw new CliArgumentError(message);
+};
+const PLACEMENT_CREATE_OPTIONS = new Set([
+    "--attempt",
+    "--command-id",
+    "--expected-attempt-revision",
+    "--expected-instance-revision",
+    "--expected-session-revision",
+    "--expected-workspace-revision",
+    "--instance",
+    "--run",
+    "--session",
+    "--task",
+]);
+const readSessionPlacementCreate = (parsed) => {
+    const sessionId = parsed.options.get("--session");
+    const instanceId = parsed.options.get("--instance");
+    if (sessionId === undefined || instanceId === undefined)
+        throw new CliArgumentError("The Session placement identity is incomplete.");
+    const commandId = parsed.options.get("--command-id");
+    return {
+        ...(commandId === undefined ? {} : { commandId }),
+        expectedFencingEpoch: "0",
+        expectedInstanceRevision: readExpectedRevision(parsed.options.get("--expected-instance-revision")),
+        expectedPlacementRevision: "0",
+        expectedSessionRevision: readExpectedRevision(parsed.options.get("--expected-session-revision")),
+        expectedWorkspaceRevision: readExpectedRevision(parsed.options.get("--expected-workspace-revision")),
+        instanceId,
+        sessionId,
+    };
+};
+const readAttemptPlacementIdentity = (options) => {
+    const runId = options.get("--run");
+    const taskId = options.get("--task");
+    const attemptId = options.get("--attempt");
+    const instanceId = options.get("--instance");
+    return {
+        attemptId: requiredPlacementIdentity(attemptId, "The Attempt identifier is missing."),
+        instanceId: requiredPlacementIdentity(instanceId, "The instance identifier is missing."),
+        runId: requiredPlacementIdentity(runId, "The Run identifier is missing."),
+        taskId: requiredPlacementIdentity(taskId, "The Task identifier is missing."),
+    };
+};
+const readAttemptPlacementCreate = (parsed) => {
+    const identity = readAttemptPlacementIdentity(parsed.options);
+    const commandId = parsed.options.get("--command-id");
+    return {
+        attemptId: identity.attemptId,
+        ...(commandId === undefined ? {} : { commandId }),
+        expectedAttemptRevision: readExpectedRevision(parsed.options.get("--expected-attempt-revision")),
+        expectedFencingEpoch: "0",
+        expectedInstanceRevision: readExpectedRevision(parsed.options.get("--expected-instance-revision")),
+        expectedPlacementRevision: "0",
+        expectedWorkspaceRevision: readExpectedRevision(parsed.options.get("--expected-workspace-revision")),
+        instanceId: identity.instanceId,
+        runId: identity.runId,
+        taskId: identity.taskId,
+    };
+};
+const readExecutionPlacementCreate = (tokens) => {
+    const parsed = parseOptions(tokens, PLACEMENT_CREATE_OPTIONS);
+    requirePositionals(parsed.positionals, 0);
+    const session = parsed.options.has("--session");
+    if (session === parsed.options.has("--attempt"))
+        throw new CliArgumentError("Use one of '--session' or '--attempt'.");
+    return session
+        ? readSessionPlacementCreate(parsed)
+        : readAttemptPlacementCreate(parsed);
+};
+export const runExecutionPlacementCreate = (tokens, context) => Effect.gen(function* () {
+    const operation = context.dependencies.createExecutionPlacement;
+    if (operation === undefined)
+        throw new Error("Missing placement client.");
+    const result = yield* operation(readExecutionPlacementCreate(tokens));
+    return writeExecutionResult(result, context, (value) => ({
+        command: "execution.placement.create",
+        result: value,
+    }));
+});
+export const runExecutionPlacementShow = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--attempt", "--session"]));
+    requirePositionals(parsed.positionals, 0);
+    const session = parsed.options.get("--session");
+    const attempt = parsed.options.get("--attempt");
+    if ((session === undefined) === (attempt === undefined))
+        throw new CliArgumentError("Use one of '--session' or '--attempt'.");
+    const kind = session === undefined ? "attempt" : "session";
+    const ownerId = session ?? attempt ?? "";
+    const operation = context.dependencies.showExecutionPlacement;
+    if (operation === undefined)
+        throw new Error("Missing placement client.");
+    const result = yield* operation({ kind, ownerId });
+    return writeExecutionResult(result, context, (value) => ({
+        command: "execution.placement.show",
+        result: value,
+    }));
+});
+const requiredOption = (parsed, name) => {
+    const value = parsed.options.get(name);
+    if (value === undefined)
+        throw missingArgument();
+    return value;
+};
+const worktreeCommandId = (parsed) => {
+    const commandId = parsed.options.get("--command-id");
+    return commandId === undefined ? {} : { commandId };
+};
+const readExecutionWorktreeCreate = (tokens) => {
+    const parsed = parseOptions(tokens, new Set([
+        "--base",
+        "--command-id",
+        "--expected-project-revision",
+        "--project",
+        "--repository",
+    ]));
+    requirePositionals(parsed.positionals, 0);
+    return {
+        baseRevision: requiredOption(parsed, "--base"),
+        expectedProjectRevision: readRevisionOption(parsed.options.get("--expected-project-revision"), "--expected-project-revision"),
+        kind: "git-worktree",
+        projectId: requiredOption(parsed, "--project"),
+        repositoryId: requiredOption(parsed, "--repository"),
+        ...worktreeCommandId(parsed),
+    };
+};
+export const runExecutionWorktreeCreate = (tokens, context) => Effect.gen(function* () {
+    const operation = context.dependencies.createExecutionWorktree;
+    if (operation === undefined)
+        throw new Error("Missing worktree client.");
+    const result = yield* operation(readExecutionWorktreeCreate(tokens));
+    return writeExecutionResult(result, context, (value) => ({
+        command: "execution.worktree.create",
+        result: value,
+    }));
+});
+const readExecutionWorktreeImport = (tokens) => {
+    const parsed = parseOptions(tokens, new Set([
+        "--command-id",
+        "--expected-project-revision",
+        "--project",
+        "--repository",
+    ]));
+    requirePositionals(parsed.positionals, 1);
+    const [rootPath] = parsed.positionals;
+    if (rootPath === undefined)
+        throw missingArgument();
+    return {
+        expectedProjectRevision: readRevisionOption(parsed.options.get("--expected-project-revision"), "--expected-project-revision"),
+        kind: "git-worktree",
+        projectId: requiredOption(parsed, "--project"),
+        repositoryId: requiredOption(parsed, "--repository"),
+        rootPath,
+        ...worktreeCommandId(parsed),
+    };
+};
+export const runExecutionWorktreeImport = (tokens, context) => Effect.gen(function* () {
+    const operation = context.dependencies.importExecutionWorktree;
+    if (operation === undefined)
+        throw new Error("Missing worktree client.");
+    const result = yield* operation(readExecutionWorktreeImport(tokens));
+    return writeExecutionResult(result, context, (value) => ({
+        command: "execution.worktree.import",
+        result: value,
+    }));
+});
+export const runExecutionWorktreeStatus = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1);
+    const workspaceId = parsed.positionals[0];
+    if (workspaceId === undefined)
+        throw new CliArgumentError("Workspace missing.");
+    const operation = context.dependencies.showExecutionWorktreeStatus;
+    if (operation === undefined)
+        throw new Error("Missing worktree client.");
+    const result = yield* operation(workspaceId);
+    return writeExecutionResult(result, context, (value) => ({
+        command: "execution.worktree.status",
+        result: value,
+    }));
+});
+const readExecutionWorktreeReconcile = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--expected-operation-revision"]));
+    requirePositionals(parsed.positionals, 1);
+    const operationId = parsed.positionals[0];
+    if (operationId === undefined)
+        throw missingArgument();
+    return {
+        expectedOperationRevision: readRevisionOption(parsed.options.get("--expected-operation-revision"), "--expected-operation-revision"),
+        operationId,
+        ...worktreeCommandId(parsed),
+    };
+};
+export const runExecutionWorktreeReconcile = (tokens, context) => Effect.gen(function* () {
+    const operation = context.dependencies.reconcileExecutionWorktree;
+    if (operation === undefined)
+        throw new Error("Missing worktree client.");
+    const result = yield* operation(readExecutionWorktreeReconcile(tokens));
+    return writeExecutionResult(result, context, (value) => ({
+        command: "execution.worktree.reconcile",
+        result: value,
+    }));
+});
+export const runExecutionWorktreeRemovePlan = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1);
+    const workspaceId = parsed.positionals[0];
+    if (workspaceId === undefined)
+        throw new CliArgumentError("Workspace missing.");
+    const operation = context.dependencies.planExecutionWorktreeRemove;
+    if (operation === undefined)
+        throw new Error("Missing worktree client.");
+    const result = yield* operation(workspaceId);
+    return writeExecutionResult(result, context, (value) => ({
+        command: "execution.worktree.remove.plan",
+        result: value,
+    }));
+});
+const readExecutionWorktreeRemove = (tokens) => {
+    const parsed = parseOptions(tokens, new Set([
+        "--command-id",
+        "--expected-workspace-revision",
+        "--plan",
+        "--plan-digest",
+    ]));
+    requirePositionals(parsed.positionals, 1);
+    const [workspaceId] = parsed.positionals;
+    if (workspaceId === undefined)
+        throw missingArgument();
+    return {
+        expectedWorkspaceRevision: readRevisionOption(parsed.options.get("--expected-workspace-revision"), "--expected-workspace-revision"),
+        planDigest: requiredOption(parsed, "--plan-digest"),
+        planId: requiredOption(parsed, "--plan"),
+        workspaceId,
+        ...worktreeCommandId(parsed),
+    };
+};
+export const runExecutionWorktreeRemoveApply = (tokens, context) => Effect.gen(function* () {
+    const operation = context.dependencies.removeExecutionWorktree;
+    if (operation === undefined)
+        throw new Error("Missing worktree client.");
+    const result = yield* operation(readExecutionWorktreeRemove(tokens));
+    return writeExecutionResult(result, context, (value) => ({
+        command: "execution.worktree.remove.apply",
+        result: value,
+    }));
+});
+export const runExecutionCheckpointShow = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1);
+    const checkpointId = parsed.positionals[0];
+    if (checkpointId === undefined)
+        throw new CliArgumentError("Checkpoint missing.");
+    const operation = context.dependencies.showExecutionCheckpoint;
+    if (operation === undefined)
+        throw new Error("Missing checkpoint client.");
+    const result = yield* operation(checkpointId);
+    return writeExecutionResult(result, context, (value) => ({
+        command: "execution.checkpoint.show",
+        result: value,
+    }));
+});
+export const runExecutionCheckpointCreate = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--expected-instance-revision", "--instance"]));
+    requirePositionals(parsed.positionals, 0);
+    const instanceId = parsed.options.get("--instance");
+    if (instanceId === undefined)
+        throw new CliArgumentError("Option '--instance' is required.");
+    const operation = context.dependencies.createExecutionCheckpoint;
+    if (operation === undefined)
+        throw new Error("Missing checkpoint client.");
+    const result = yield* operation({
+        expectedInstanceRevision: readRevisionOption(parsed.options.get("--expected-instance-revision"), "--expected-instance-revision"),
+        instanceId,
+        ...worktreeCommandId(parsed),
+    });
+    return writeExecutionResult(result, context, (value) => ({
+        command: "execution.checkpoint.create",
+        result: value,
+    }));
+});
+export const runWorkspaceList = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit", "--project"]));
+    requirePositionals(parsed.positionals, 0);
+    const projectId = parsed.options.get("--project");
+    if (projectId === undefined) {
+        throw new CliArgumentError("Option '--project' is required.");
+    }
+    const result = yield* context.dependencies.listWorkspaces({
+        afterCursor: readCursor(parsed.options.get("--after")),
+        limit: readPageSize(parsed.options.get("--limit")),
+        projectId,
+    });
+    return writeWorkspaceResult(result, context, (value) => ({
+        command: "workspace.list",
+        result: value,
+    }));
+});
+const WORKSPACE_CONTEXT_REVISION_OPTIONS = new Set([
+    "--command-id",
+    "--project",
+    "--repository",
+    "--expected-active-context-revision",
+    "--expected-active-workspace-id",
+    "--expected-context-revision",
+    "--expected-workspace-revision",
+]);
+const readRequiredStringOption = (options, name) => {
+    const value = options.get(name);
+    if (value === undefined)
+        throw new CliArgumentError(`Option '${name}' is required.`);
+    return value;
+};
+const readWorkspaceContextIdentity = (parsed) => {
+    requirePositionals(parsed.positionals, 1);
+    const [workspaceId] = parsed.positionals;
+    const projectId = parsed.options.get("--project");
+    const repositoryId = parsed.options.get("--repository");
+    if (workspaceId === undefined ||
+        projectId === undefined ||
+        repositoryId === undefined)
+        throw missingArgument();
+    return { projectId, repositoryId, workspaceId };
+};
+const parseWorkspaceContextMutation = (tokens) => {
+    const parsed = parseOptions(tokens, WORKSPACE_CONTEXT_REVISION_OPTIONS);
+    const identity = readWorkspaceContextIdentity(parsed);
+    const commandId = parsed.options.get("--command-id");
+    return {
+        input: {
+            ...identity,
+            expectedContextRevision: readRevisionOption(parsed.options.get("--expected-context-revision"), "--expected-context-revision"),
+            expectedWorkspaceRevision: readRevisionOption(parsed.options.get("--expected-workspace-revision"), "--expected-workspace-revision"),
+            ...(commandId === undefined ? {} : { commandId }),
+        },
+        options: parsed.options,
+    };
+};
+const readWorkspaceSelection = (tokens) => {
+    const parsed = parseWorkspaceContextMutation(tokens);
+    return {
+        ...parsed.input,
+        expectedActiveContextRevision: readRevisionOption(parsed.options.get("--expected-active-context-revision"), "--expected-active-context-revision"),
+        expectedActiveWorkspaceId: readRequiredStringOption(parsed.options, "--expected-active-workspace-id"),
+    };
+};
+export const runWorkspaceMembershipAttach = (tokens, context) => Effect.gen(function* () {
+    const operation = context.dependencies.attachWorkspaceMembership;
+    if (operation === undefined)
+        throw new Error("Missing Workspace client.");
+    const result = yield* operation(parseWorkspaceContextMutation(tokens).input);
+    return writeWorkspaceResult(result, context, (value) => ({
+        command: "workspace.membership.attach",
+        result: value,
+    }));
+});
+export const runWorkspaceSelect = (tokens, context) => Effect.gen(function* () {
+    const operation = context.dependencies.selectWorkspace;
+    if (operation === undefined)
+        throw new Error("Missing Workspace client.");
+    const result = yield* operation(readWorkspaceSelection(tokens));
+    return writeWorkspaceResult(result, context, (value) => ({
+        command: "workspace.select",
+        result: value,
+    }));
+});
+export const runWorkspaceContextShow = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 0);
+    const operation = context.dependencies.showWorkspaceContext;
+    if (operation === undefined)
+        throw new Error("Missing Workspace client.");
+    const result = yield* operation();
+    return writeWorkspaceResult(result, context, (value) => ({
+        command: "workspace.context.show",
+        result: value,
+    }));
+});
+export const runWorkspaceShow = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1);
+    const workspaceId = parsed.positionals[0];
+    if (workspaceId === undefined) {
+        throw new CliArgumentError("The workspace identifier is missing.");
+    }
+    const result = yield* context.dependencies.showWorkspace(workspaceId);
+    return writeWorkspaceResult(result, context, (value) => ({
+        command: "workspace.show",
+        result: value,
+    }));
+});
+const parseWorkspaceRepositoryAttach = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--expected-revision", "--name", "--workspace"]));
+    requirePositionals(parsed.positionals, 1);
+    const [path] = parsed.positionals;
+    const workspaceId = parsed.options.get("--workspace");
+    const expectedRevision = readExpectedRevision(parsed.options.get("--expected-revision"));
+    if (workspaceId === undefined || path === undefined) {
+        throw new CliArgumentError("A repository path and '--workspace' are required.");
+    }
+    const commandId = parsed.options.get("--command-id");
+    const name = parsed.options.get("--name");
+    return {
+        expectedRevision,
+        path,
+        workspaceId,
+        ...(commandId === undefined ? {} : { commandId }),
+        ...(name === undefined ? {} : { name }),
+    };
+};
+export const runWorkspaceRepositoryAttach = (tokens, context) => Effect.gen(function* () {
+    const input = parseWorkspaceRepositoryAttach(tokens);
+    const result = yield* context.dependencies.attachWorkspaceRepository(input);
+    return writeWorkspaceResult(result, context, (value) => ({
+        command: "workspace.repository.attach",
+        result: summarizeRepositoryAttachment(value),
+    }));
+});
+const summarizeExecutionConfiguration = (result) => ({
+    ...(result.binding === undefined ? {} : { binding: result.binding }),
+    delivery: result.delivery,
+    receipt: result.receipt,
+    resolution: result.resolution,
+    workspaceId: result.workspace.id,
+    workspaceRevision: result.workspace.revision,
+});
+const readExecutionSelection = (profileId, policyId) => {
+    if ((profileId === undefined) === (policyId === undefined)) {
+        throw new CliArgumentError("Exactly one of '--execution-profile' or '--policy' is required.");
+    }
+    return profileId === undefined
+        ? { id: policyId ?? "", kind: "policy" }
+        : { id: profileId, kind: "profile" };
+};
+const readExecutionMutation = (parsed) => {
+    requirePositionals(parsed.positionals, 1);
+    const workspaceId = parsed.positionals[0];
+    if (workspaceId === undefined) {
+        throw new CliArgumentError("The workspace identifier is missing.");
+    }
+    const commandId = parsed.options.get("--command-id");
+    return {
+        expectedRevision: readExpectedRevision(parsed.options.get("--expected-revision")),
+        workspaceId,
+        ...(commandId === undefined ? {} : { commandId }),
+    };
+};
+const readExecutionInput = (operation, tokens) => {
+    const parsed = parseOptions(tokens, new Set([
+        "--command-id",
+        "--expected-revision",
+        ...(operation === "set" ? ["--execution-profile", "--policy"] : []),
+    ]));
+    const common = readExecutionMutation(parsed);
+    return operation === "clear"
+        ? { ...common, operation }
+        : {
+            ...common,
+            operation,
+            selection: readExecutionSelection(parsed.options.get("--execution-profile"), parsed.options.get("--policy")),
+        };
+};
+export const runWorkspaceExecutionShow = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1);
+    const workspaceId = parsed.positionals[0];
+    if (workspaceId === undefined) {
+        throw new CliArgumentError("The workspace identifier is missing.");
+    }
+    const operation = context.dependencies.showWorkspaceExecution;
+    if (operation === undefined)
+        throw new Error("Missing execution client.");
+    const result = yield* operation(workspaceId);
+    return writeWorkspaceResult(result, context, (value) => ({
+        command: "workspace.execution.show",
+        result: value,
+    }));
+});
+const configureExecution = (operation) => (tokens, context) => {
+    const configure = context.dependencies.configureWorkspaceExecution;
+    if (configure === undefined)
+        throw new Error("Missing execution client.");
+    return Effect.map(configure(readExecutionInput(operation, tokens)), (result) => writeWorkspaceResult(result, context, (value) => ({
+        command: "workspace.execution.configure",
+        result: summarizeExecutionConfiguration(value),
+    })));
+};
+export const runWorkspaceExecutionSet = configureExecution("set");
+export const runWorkspaceExecutionClear = configureExecution("clear");
+//# sourceMappingURL=commands.js.map