@maiaos/cli 0.1.0-canary.2

package/dist/project-workspace/index.d.ts

@@ -0,0 +1,5 @@
+export { type AttachRepositoryInput, type AttachWorkspaceMembershipInput, type CliNodeResult, type ConfigureWorkspaceExecutionInput, type CreateExecutionCheckpointInput, type CreateExecutionPlacementInput, type CreateExecutionWorktreeInput, type ImportExecutionWorktreeInput, makeProjectWorkspaceClient, type ReadExecutionFileInput, type ReconcileExecutionWorktreeInput, type RecordProjectContextInput, type RegisterProjectInput, type RemoveExecutionWorktreeInput, type RunExecutionCommandInput, type SelectWorkspaceInput, } from "./client.js";
+export { runExecutionCatalogShow, runExecutionCheckpointCreate, runExecutionCheckpointShow, runExecutionCommandRun, runExecutionFileRead, runExecutionPlacementCreate, runExecutionPlacementShow, runExecutionWorktreeCreate, runExecutionWorktreeImport, runExecutionWorktreeReconcile, runExecutionWorktreeRemoveApply, runExecutionWorktreeRemovePlan, runExecutionWorktreeStatus, runProjectContextList, runProjectContextRecord, runProjectContextShow, runProjectList, runProjectRegister, runProjectShow, runWorkspaceContextShow, runWorkspaceExecutionClear, runWorkspaceExecutionSet, runWorkspaceExecutionShow, runWorkspaceList, runWorkspaceMembershipAttach, runWorkspaceRepositoryAttach, runWorkspaceSelect, runWorkspaceShow, } from "./commands.js";
+export { makeProjectMetadataClient, type ProjectMetadataCliDependencies, } from "./metadata-client.js";
+export { runProjectCreate, runProjectRename } from "./metadata-commands.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/project-workspace/index.js

@@ -0,0 +1,5 @@
+export { makeProjectWorkspaceClient, } from "./client.js";
+export { runExecutionCatalogShow, runExecutionCheckpointCreate, runExecutionCheckpointShow, runExecutionCommandRun, runExecutionFileRead, runExecutionPlacementCreate, runExecutionPlacementShow, runExecutionWorktreeCreate, runExecutionWorktreeImport, runExecutionWorktreeReconcile, runExecutionWorktreeRemoveApply, runExecutionWorktreeRemovePlan, runExecutionWorktreeStatus, runProjectContextList, runProjectContextRecord, runProjectContextShow, runProjectList, runProjectRegister, runProjectShow, runWorkspaceContextShow, runWorkspaceExecutionClear, runWorkspaceExecutionSet, runWorkspaceExecutionShow, runWorkspaceList, runWorkspaceMembershipAttach, runWorkspaceRepositoryAttach, runWorkspaceSelect, runWorkspaceShow, } from "./commands.js";
+export { makeProjectMetadataClient, } from "./metadata-client.js";
+export { runProjectCreate, runProjectRename } from "./metadata-commands.js";
+//# sourceMappingURL=index.js.map

package/dist/project-workspace/metadata-client.d.ts

@@ -0,0 +1,99 @@
+import { type ProjectCreateConfirmParameters, type ProjectCreatePreviewParameters, type ProjectRenameConfirmParameters, type ProjectRenamePreviewParameters } from "@maiaos/sdk";
+import type { CliNodeOperations } from "../local-node/index.js";
+export declare const makeProjectMetadataClient: (node: CliNodeOperations) => {
+    confirmProjectCreate: (input: ProjectCreateConfirmParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly actorId: string;
+        readonly commandId: string;
+        readonly containerId: string;
+        readonly delivery: "duplicate" | "new";
+        readonly inputDigest: string;
+        readonly project: {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly name: string;
+            readonly revision: string;
+            readonly schemaVersion: 1;
+            readonly updatedAt: string;
+        };
+        readonly receipt: {
+            readonly actorId: string;
+            readonly aggregateRevision: string;
+            readonly commandId: string;
+            readonly createdAt: string;
+            readonly eventCursor: string;
+            readonly method: string;
+            readonly receiptId: string;
+            readonly schemaVersion: 1;
+            readonly state: "succeeded";
+            readonly target: {
+                readonly id: string;
+                readonly type: string;
+            };
+            readonly updatedAt: string;
+        };
+        readonly containerRevision: string;
+        readonly expectedContainerRevision: string;
+        readonly method: "project.create.confirm";
+    }>;
+    confirmProjectRename: (input: ProjectRenameConfirmParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly actorId: string;
+        readonly commandId: string;
+        readonly containerId: string;
+        readonly delivery: "duplicate" | "new";
+        readonly inputDigest: string;
+        readonly project: {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly name: string;
+            readonly revision: string;
+            readonly schemaVersion: 1;
+            readonly updatedAt: string;
+        };
+        readonly receipt: {
+            readonly actorId: string;
+            readonly aggregateRevision: string;
+            readonly commandId: string;
+            readonly createdAt: string;
+            readonly eventCursor: string;
+            readonly method: string;
+            readonly receiptId: string;
+            readonly schemaVersion: 1;
+            readonly state: "succeeded";
+            readonly target: {
+                readonly id: string;
+                readonly type: string;
+            };
+            readonly updatedAt: string;
+        };
+        readonly expectedRevision: string;
+        readonly method: "project.rename.confirm";
+    }>;
+    previewProjectCreate: (input: ProjectCreatePreviewParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly commandId: string;
+        readonly containerId: string;
+        readonly expectedContainerRevision: string;
+        readonly name: string;
+        readonly inputDigest: string;
+        readonly proof: string;
+        readonly actorId: string;
+        readonly expiresAt: string;
+        readonly issuedAt: string;
+        readonly method: "project.create.preview";
+        readonly projectId: string;
+    }>;
+    previewProjectRename: (input: ProjectRenamePreviewParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly commandId: string;
+        readonly containerId: string;
+        readonly expectedRevision: string;
+        readonly name: string;
+        readonly projectId: string;
+        readonly inputDigest: string;
+        readonly proof: string;
+        readonly actorId: string;
+        readonly expiresAt: string;
+        readonly issuedAt: string;
+        readonly method: "project.rename.preview";
+    }>;
+};
+export type ProjectMetadataCliDependencies = ReturnType<typeof makeProjectMetadataClient>;
+//# sourceMappingURL=metadata-client.d.ts.map

package/dist/project-workspace/metadata-client.js

@@ -0,0 +1,8 @@
+import { projectCreateConfirmParametersSchema, projectCreatePreviewParametersSchema, projectRenameConfirmParametersSchema, projectRenamePreviewParametersSchema, } from "@maiaos/sdk";
+export const makeProjectMetadataClient = (node) => ({
+    confirmProjectCreate: (input) => node.runValidatedNodeOperation(input, projectCreateConfirmParametersSchema, (client, parameters, options) => client.confirmProjectCreate(parameters, options), { commandId: input.commandId }),
+    confirmProjectRename: (input) => node.runValidatedNodeOperation(input, projectRenameConfirmParametersSchema, (client, parameters, options) => client.confirmProjectRename(parameters, options), { commandId: input.commandId }),
+    previewProjectCreate: (input) => node.runValidatedNodeOperation(input, projectCreatePreviewParametersSchema, (client, parameters, options) => client.previewProjectCreate(parameters, options)),
+    previewProjectRename: (input) => node.runValidatedNodeOperation(input, projectRenamePreviewParametersSchema, (client, parameters, options) => client.previewProjectRename(parameters, options)),
+});
+//# sourceMappingURL=metadata-client.js.map

package/dist/project-workspace/metadata-commands.d.ts

@@ -0,0 +1,4 @@
+import { type CommandContext, type CommandEffect } from "../command-line/index.js";
+export declare const runProjectCreate: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runProjectRename: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+//# sourceMappingURL=metadata-commands.d.ts.map

package/dist/project-workspace/metadata-commands.js

@@ -0,0 +1,56 @@
+import { projectCreateConfirmParametersSchema, projectCreatePreviewParametersSchema, projectRenameConfirmParametersSchema, projectRenamePreviewParametersSchema, protocolErrorSchema, } from "@maiaos/sdk";
+import { Effect } from "effect";
+import { CliArgumentError, reportError, runInputTwoPhase, writeSuccess, } from "../command-line/index.js";
+import { formatProjectMetadataResult, } from "./output/index.js";
+const recoveryFor = (code, parameters) => code === "outcome_unknown" &&
+    typeof parameters === "object" &&
+    parameters !== null &&
+    "commandId" in parameters &&
+    "proof" in parameters &&
+    typeof parameters.commandId === "string"
+    ? { recovery: { commandId: parameters.commandId } }
+    : {};
+const writeResponse = (response, parameters, context) => {
+    if (!response.ok) {
+        const error = protocolErrorSchema.parse(response.error);
+        return reportError({ ...error, message: "Project operation failed." }, {
+            ...context,
+            ...(response.recovery === undefined
+                ? recoveryFor(error.code, parameters)
+                : { recovery: response.recovery }),
+        });
+    }
+    writeSuccess({ command: response.value.method, result: response.value }, context, formatProjectMetadataResult);
+    return 0;
+};
+const reportFailure = (context) => (error) => Effect.sync(() => reportError({
+    code: error instanceof CliArgumentError
+        ? "invalid_argument"
+        : "internal_error",
+    message: error instanceof CliArgumentError
+        ? error.message
+        : "Project command failed.",
+    retryable: false,
+}, context));
+export const runProjectCreate = (tokens, context) => runInputTwoPhase({
+    confirm: context.dependencies.confirmProjectCreate,
+    confirmSchema: projectCreateConfirmParametersSchema,
+    context,
+    label: "Project input",
+    preview: context.dependencies.previewProjectCreate,
+    previewOnly: ["projectId"],
+    previewSchema: projectCreatePreviewParametersSchema,
+    tokens,
+    write: (result) => writeResponse(result, undefined, context),
+}).pipe(Effect.catch(reportFailure(context)));
+export const runProjectRename = (tokens, context) => runInputTwoPhase({
+    confirm: context.dependencies.confirmProjectRename,
+    confirmSchema: projectRenameConfirmParametersSchema,
+    context,
+    label: "Project input",
+    preview: context.dependencies.previewProjectRename,
+    previewSchema: projectRenamePreviewParametersSchema,
+    tokens,
+    write: (result) => writeResponse(result, undefined, context),
+}).pipe(Effect.catch(reportFailure(context)));
+//# sourceMappingURL=metadata-commands.js.map

package/dist/project-workspace/output/human.d.ts

@@ -0,0 +1,126 @@
+import type { ExecutionCatalogGetResult, ExecutionCommandRunResult, ExecutionFileReadResult, ExecutionPlacementCreateResult, ExecutionPlacementShowResult, ExecutionWorktreeCheckpointCreateResult, ExecutionWorktreeCheckpointShowResult, ExecutionWorktreeCreateResult, ExecutionWorktreeImportResult, ExecutionWorktreeReconcileResult, ExecutionWorktreeRemoveApplyResult, ExecutionWorktreeRemovePlanResult, ExecutionWorktreeStatusResult, ProjectContextListResult, ProjectContextRecordResult, ProjectContextShowResult, ProjectListResult, ProjectRegisterResult, ProjectShowResult, WorkspaceContextShowResult, WorkspaceExecutionConfigureResult, WorkspaceExecutionShowResult, WorkspaceListResult, WorkspaceMembershipAttachResult, WorkspaceRepositoryAttachResult, WorkspaceSelectResult, WorkspaceShowResult } from "@maiaos/sdk";
+import { type CliIo } from "../../command-line/index.js";
+import type { CliNodeResult } from "../../local-node/index.js";
+export type CliExecutionResult = {
+    readonly command: "execution.catalog";
+    readonly result: ExecutionCatalogGetResult;
+} | {
+    readonly command: "execution.checkpoint.create";
+    readonly result: ExecutionWorktreeCheckpointCreateResult;
+} | {
+    readonly command: "execution.checkpoint.show";
+    readonly result: ExecutionWorktreeCheckpointShowResult;
+} | {
+    readonly command: "execution.command.run";
+    readonly result: ExecutionCommandRunResult;
+} | {
+    readonly command: "execution.file.read";
+    readonly result: ExecutionFileReadResult;
+} | {
+    readonly command: "execution.placement.create";
+    readonly result: ExecutionPlacementCreateResult;
+} | {
+    readonly command: "execution.placement.show";
+    readonly result: ExecutionPlacementShowResult;
+} | {
+    readonly command: "execution.worktree.create";
+    readonly result: ExecutionWorktreeCreateResult;
+} | {
+    readonly command: "execution.worktree.import";
+    readonly result: ExecutionWorktreeImportResult;
+} | {
+    readonly command: "execution.worktree.reconcile";
+    readonly result: ExecutionWorktreeReconcileResult;
+} | {
+    readonly command: "execution.worktree.remove.apply";
+    readonly result: ExecutionWorktreeRemoveApplyResult;
+} | {
+    readonly command: "execution.worktree.remove.plan";
+    readonly result: ExecutionWorktreeRemovePlanResult;
+} | {
+    readonly command: "execution.worktree.status";
+    readonly result: ExecutionWorktreeStatusResult;
+};
+export type CliProjectResult = {
+    readonly command: "project.context.list";
+    readonly result: ProjectContextListResult;
+} | {
+    readonly command: "project.context.record";
+    readonly result: {
+        readonly delivery: ProjectContextRecordResult["delivery"];
+        readonly noteId: string;
+        readonly projectId: string;
+        readonly receipt: ProjectContextRecordResult["receipt"];
+        readonly sequence: string;
+    };
+} | {
+    readonly command: "project.context.show";
+    readonly result: ProjectContextShowResult;
+} | {
+    readonly command: "project.list";
+    readonly result: ProjectListResult;
+} | {
+    readonly command: "project.register";
+    readonly result: {
+        readonly checkoutId: string;
+        readonly delivery: ProjectRegisterResult["delivery"];
+        readonly projectId: string;
+        readonly receipt: ProjectRegisterResult["receipt"];
+        readonly repositoryId: string;
+        readonly workspaceId: string;
+    };
+} | {
+    readonly command: "project.show";
+    readonly result: ProjectShowResult;
+};
+export type CliWorkspaceResult = {
+    readonly command: "workspace.context.show";
+    readonly result: WorkspaceContextShowResult;
+} | {
+    readonly command: "workspace.execution.configure";
+    readonly result: {
+        readonly binding?: WorkspaceExecutionConfigureResult["binding"];
+        readonly delivery: WorkspaceExecutionConfigureResult["delivery"];
+        readonly receipt: WorkspaceExecutionConfigureResult["receipt"];
+        readonly resolution: WorkspaceExecutionConfigureResult["resolution"];
+        readonly workspaceId: string;
+        readonly workspaceRevision: string;
+    };
+} | {
+    readonly command: "workspace.execution.show";
+    readonly result: WorkspaceExecutionShowResult;
+} | {
+    readonly command: "workspace.list";
+    readonly result: WorkspaceListResult;
+} | {
+    readonly command: "workspace.membership.attach";
+    readonly result: WorkspaceMembershipAttachResult;
+} | {
+    readonly command: "workspace.repository.attach";
+    readonly result: {
+        readonly checkoutId: string;
+        readonly delivery: WorkspaceRepositoryAttachResult["delivery"];
+        readonly receipt: WorkspaceRepositoryAttachResult["receipt"];
+        readonly repositoryId: string;
+        readonly workspaceId: string;
+        readonly workspaceRevision: string;
+    };
+} | {
+    readonly command: "workspace.select";
+    readonly result: WorkspaceSelectResult;
+} | {
+    readonly command: "workspace.show";
+    readonly result: WorkspaceShowResult;
+};
+export declare const formatWorkspaceResult: (result: CliWorkspaceResult) => string;
+export declare const formatProjectResult: (result: CliProjectResult) => string;
+export declare const formatExecutionResult: (result: CliExecutionResult) => string;
+type OutputContext = {
+    readonly io: CliIo;
+    readonly json: boolean;
+};
+export declare const writeProjectResult: <TValue>(result: CliNodeResult<TValue>, context: OutputContext, map: (value: TValue) => CliProjectResult) => number;
+export declare const writeWorkspaceResult: <TValue>(result: CliNodeResult<TValue>, context: OutputContext, map: (value: TValue) => CliWorkspaceResult) => number;
+export declare const writeExecutionResult: <TValue>(result: CliNodeResult<TValue>, context: OutputContext, map: (value: TValue) => CliExecutionResult) => number;
+export {};
+//# sourceMappingURL=human.d.ts.map

package/dist/project-workspace/output/human.js

@@ -0,0 +1,103 @@
+import { cell, formatRows, tab, writeNodeResult, } from "../../command-line/index.js";
+const formatProjectList = (result) => formatRows(result.items, (project) => `${project.id}\t${cell(project.name)}\t${project.revision}`, {
+    empty: "No Projects. Register one with: maia project register <path>",
+    headers: ["PROJECT", "NAME", "REVISION"],
+});
+const formatProjectContextList = (result) => formatRows(result.items, (note) => `${note.id}\t${note.sequence}\t${cell(note.body)}`, { empty: "No context notes.", headers: ["NOTE", "SEQUENCE", "BODY"] });
+const formatWorkspaceList = (result) => formatRows(result.items, (workspace) => `${workspace.id}\t${cell(workspace.name)}\t${workspace.kind}\t${workspace.revision}`, {
+    empty: "No Workspaces.",
+    headers: ["WORKSPACE", "NAME", "KIND", "REVISION"],
+});
+export const formatWorkspaceResult = (result) => {
+    switch (result.command) {
+        case "workspace.context.show":
+            return `${result.result.workspace.id}\t${result.result.workspace.revision}\t${result.result.context.contextRevision}\t${result.result.context.systemPromptInput.focus.projectId}\t${result.result.context.systemPromptInput.focus.repositoryId}\n`;
+        case "workspace.execution.configure":
+            return `${result.result.workspaceId}\t${result.result.workspaceRevision}\t${result.result.resolution.status}\t${result.result.resolution.reason}\n`;
+        case "workspace.execution.show":
+            return `${result.result.workspace.id}\t${result.result.workspace.revision}\t${result.result.resolution.status}\t${result.result.resolution.reason}\n`;
+        case "workspace.list":
+            return formatWorkspaceList(result.result);
+        case "workspace.membership.attach":
+            return `${result.result.membership.workspaceId}\t${result.result.workspace.revision}\t${result.result.context.contextRevision}\t${result.result.membership.projectId}\t${result.result.membership.repositoryId}\t${result.result.delivery}\t${result.result.receipt.receiptId}\n`;
+        case "workspace.repository.attach":
+            return `${result.result.repositoryId}\n`;
+        case "workspace.select":
+            return `${result.result.workspace.id}\t${result.result.workspace.revision}\t${result.result.context.contextRevision}\t${result.result.context.systemPromptInput.focus.projectId}\t${result.result.context.systemPromptInput.focus.repositoryId}\t${result.result.delivery}\t${result.result.receipt.receiptId}\n`;
+        case "workspace.show":
+            return `${result.result.workspace.id}\t${cell(result.result.workspace.name)}\t${result.result.workspace.revision}\n`;
+    }
+};
+export const formatProjectResult = (result) => {
+    switch (result.command) {
+        case "project.register":
+            return `${tab([result.result.projectId, result.result.workspaceId, result.result.repositoryId])}\nnext: maia session create --workspace ${result.result.workspaceId} --executor codex-cli --message '<task>'\n`;
+        case "project.list":
+            return formatProjectList(result.result);
+        case "project.show":
+            return `${result.result.project.id}\t${cell(result.result.project.name)}\t${result.result.project.revision}\n`;
+        case "project.context.record":
+            return `${result.result.noteId}\n`;
+        case "project.context.list":
+            return formatProjectContextList(result.result);
+        case "project.context.show":
+            return `${result.result.note.id}\t${result.result.note.sequence}\t${cell(result.result.note.body)}\n`;
+    }
+};
+const formatExecutionPlacement = (result) => {
+    const placement = result.result.placement;
+    return `${placement.id}\t${placement.kind}\t${placement.instanceId}\t${placement.revision}\t${placement.fencingEpoch}\n`;
+};
+const formatExecutionWorktree = (result) => {
+    switch (result.command) {
+        case "execution.worktree.create":
+        case "execution.worktree.import":
+            return `${result.result.workspace.id}\t${result.result.operation.id}\t${result.result.operation.state}\n`;
+        case "execution.worktree.status":
+            return `${result.result.workspace.id}\t${result.result.latestOperation.id}\t${result.result.latestOperation.state}\n`;
+        case "execution.worktree.reconcile":
+        case "execution.worktree.remove.apply":
+            return `${result.result.operation.id}\t${result.result.operation.state}\t${result.result.operation.cleanup}\n`;
+        case "execution.worktree.remove.plan":
+            return `${result.result.plan.id}\t${String(result.result.plan.eligible)}\t${String(result.result.plan.blockers.length)}\n`;
+        case "execution.checkpoint.create":
+            return `${result.result.operation.id}\t${result.result.operation.state}${result.result.checkpoint === undefined ? "" : `\t${result.result.checkpoint.id}`}\n`;
+        case "execution.checkpoint.show":
+            return `${result.result.checkpoint.id}\t${result.result.checkpoint.sourceRevision}\n`;
+    }
+};
+const formatExecutionCatalog = (result) => {
+    const [provider] = result.result.providers;
+    return `${provider.id}\t${provider.kind}\t${provider.binding}\t${provider.reason}\n`;
+};
+export const formatExecutionResult = (result) => {
+    if (result.command === "execution.catalog") {
+        return formatExecutionCatalog(result);
+    }
+    if (result.command === "execution.command.run") {
+        const operation = result.result.operation;
+        return `${operation.id}\t${operation.state}\t${operation.cleanup}\n`;
+    }
+    if (result.command === "execution.file.read") {
+        const operation = result.result.operation;
+        return `${operation.id}\t${operation.state}\n`;
+    }
+    if (result.command === "execution.placement.create" ||
+        result.command === "execution.placement.show") {
+        return formatExecutionPlacement(result);
+    }
+    return formatExecutionWorktree(result);
+};
+export const writeProjectResult = (result, context, map) => writeNodeResult(result, context, {
+    toResult: map,
+    toText: formatProjectResult,
+});
+export const writeWorkspaceResult = (result, context, map) => writeNodeResult(result, context, {
+    toResult: map,
+    toText: formatWorkspaceResult,
+});
+export const writeExecutionResult = (result, context, map) => writeNodeResult(result, context, {
+    toResult: map,
+    toText: formatExecutionResult,
+});
+//# sourceMappingURL=human.js.map

package/dist/project-workspace/output/index.d.ts

@@ -0,0 +1,3 @@
+export { type CliExecutionResult, type CliProjectResult, type CliWorkspaceResult, formatExecutionResult, formatProjectResult, formatWorkspaceResult, writeExecutionResult, writeProjectResult, writeWorkspaceResult, } from "./human.js";
+export { type CliProjectMetadataResult, formatProjectMetadataResult, isProjectMetadataResult, type ProjectMetadataResult, } from "./metadata.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/project-workspace/output/index.js

@@ -0,0 +1,3 @@
+export { formatExecutionResult, formatProjectResult, formatWorkspaceResult, writeExecutionResult, writeProjectResult, writeWorkspaceResult, } from "./human.js";
+export { formatProjectMetadataResult, isProjectMetadataResult, } from "./metadata.js";
+//# sourceMappingURL=index.js.map

package/dist/project-workspace/output/metadata.d.ts

@@ -0,0 +1,11 @@
+import type { ProjectCreateConfirmResult, ProjectCreatePreviewResult, ProjectRenameConfirmResult, ProjectRenamePreviewResult } from "@maiaos/sdk";
+export type ProjectMetadataResult = ProjectCreateConfirmResult | ProjectCreatePreviewResult | ProjectRenameConfirmResult | ProjectRenamePreviewResult;
+export type CliProjectMetadataResult = {
+    readonly command: ProjectMetadataResult["method"];
+    readonly result: ProjectMetadataResult;
+};
+export declare const isProjectMetadataResult: (result: {
+    readonly command: string;
+}) => result is CliProjectMetadataResult;
+export declare const formatProjectMetadataResult: ({ result, }: CliProjectMetadataResult) => string;
+//# sourceMappingURL=metadata.d.ts.map

package/dist/project-workspace/output/metadata.js

@@ -0,0 +1,17 @@
+export const isProjectMetadataResult = (result) => result.command === "project.create.preview" ||
+    result.command === "project.create.confirm" ||
+    result.command === "project.rename.preview" ||
+    result.command === "project.rename.confirm";
+const cell = (value) => value.replaceAll(/[\u0000-\u001F\u007F-\u009F]/gu, " ");
+export const formatProjectMetadataResult = ({ result, }) => {
+    switch (result.method) {
+        case "project.create.preview":
+            return `${result.containerId}\t${result.expectedContainerRevision}\t${result.projectId}\t${cell(result.name)}\t${result.expiresAt}\n`;
+        case "project.rename.preview":
+            return `${result.containerId}\t${result.projectId}\t${result.expectedRevision}\t${cell(result.name)}\t${result.expiresAt}\n`;
+        case "project.create.confirm":
+        case "project.rename.confirm":
+            return `${result.project.id}\t${cell(result.project.name)}\t${result.project.revision}\t${result.receipt.receiptId}\t${result.delivery}\n`;
+    }
+};
+//# sourceMappingURL=metadata.js.map

package/dist/project-workspace/tree/index.d.ts

@@ -0,0 +1,2 @@
+export { PROJECT_TREE } from "./tree.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/project-workspace/tree/index.js

@@ -0,0 +1,2 @@
+export { PROJECT_TREE } from "./tree.js";
+//# sourceMappingURL=index.js.map

package/dist/project-workspace/tree/tree.d.ts

@@ -0,0 +1,3 @@
+import type { TreeFragment } from "../../command-tree/index.js";
+export declare const PROJECT_TREE: TreeFragment;
+//# sourceMappingURL=tree.d.ts.map