@maiaos/cli 0.1.0-canary.2

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

@@ -0,0 +1,86 @@
+import type { ExecutionCatalogGetResult, ExecutionCommandRunParameters, ExecutionCommandRunResult, ExecutionFileReadParameters, ExecutionFileReadResult, ExecutionPlacementCreateParameters, ExecutionPlacementCreateResult, ExecutionPlacementShowParameters, ExecutionPlacementShowResult, ExecutionWorktreeCheckpointCreateParameters, ExecutionWorktreeCheckpointCreateResult, ExecutionWorktreeCheckpointShowResult, ExecutionWorktreeCreateParameters, ExecutionWorktreeCreateResult, ExecutionWorktreeImportParameters, ExecutionWorktreeImportResult, ExecutionWorktreeReconcileParameters, ExecutionWorktreeReconcileResult, ExecutionWorktreeRemoveApplyParameters, ExecutionWorktreeRemoveApplyResult, ExecutionWorktreeRemovePlanResult, ExecutionWorktreeStatusResult, ProjectContextListResult, ProjectContextRecordResult, ProjectContextShowResult, ProjectListResult, ProjectRegisterResult, ProjectShowResult, ReceiptGetResult, ReceiptListParameters, ReceiptListResult, WorkspaceContextShowResult, WorkspaceExecutionConfigureParameters, WorkspaceExecutionConfigureResult, WorkspaceExecutionShowResult, WorkspaceListResult, WorkspaceMembershipAttachParameters, WorkspaceMembershipAttachResult, WorkspaceRepositoryAttachResult, WorkspaceSelectParameters, WorkspaceSelectResult, WorkspaceShowResult } from "@maiaos/sdk";
+import { type CliNodeEffect, type CliNodeOperations } from "../local-node/index.js";
+export type { CliNodeResult } from "../local-node/index.js";
+type OptionalCommand<TValue> = TValue extends unknown ? Omit<TValue, "commandId"> & {
+    readonly commandId?: string;
+} : never;
+export type CreateExecutionPlacementInput = OptionalCommand<ExecutionPlacementCreateParameters>;
+export type CreateExecutionCheckpointInput = OptionalCommand<ExecutionWorktreeCheckpointCreateParameters>;
+export type CreateExecutionWorktreeInput = OptionalCommand<ExecutionWorktreeCreateParameters>;
+export type ImportExecutionWorktreeInput = OptionalCommand<ExecutionWorktreeImportParameters>;
+export type ReconcileExecutionWorktreeInput = OptionalCommand<ExecutionWorktreeReconcileParameters>;
+export type AttachWorkspaceMembershipInput = OptionalCommand<WorkspaceMembershipAttachParameters>;
+export type SelectWorkspaceInput = OptionalCommand<WorkspaceSelectParameters>;
+export type RemoveExecutionWorktreeInput = OptionalCommand<ExecutionWorktreeRemoveApplyParameters>;
+export type RegisterProjectInput = {
+    readonly commandId?: string;
+    readonly name?: string;
+    readonly path: string;
+};
+export type RecordProjectContextInput = {
+    readonly body: string;
+    readonly commandId?: string;
+    readonly projectId: string;
+};
+export type AttachRepositoryInput = RegisterProjectInput & {
+    readonly expectedRevision: string;
+    readonly workspaceId: string;
+};
+export type RunExecutionCommandInput = Omit<ExecutionCommandRunParameters, "commandId"> & {
+    readonly commandId?: string;
+};
+export type ReadExecutionFileInput = Omit<ExecutionFileReadParameters, "commandId"> & {
+    readonly commandId?: string;
+};
+export type ConfigureWorkspaceExecutionInput = (Omit<Extract<WorkspaceExecutionConfigureParameters, {
+    operation: "clear";
+}>, "commandId"> & {
+    readonly commandId?: string;
+}) | (Omit<Extract<WorkspaceExecutionConfigureParameters, {
+    operation: "set";
+}>, "commandId"> & {
+    readonly commandId?: string;
+});
+export declare const makeProjectWorkspaceClient: (node: CliNodeOperations) => {
+    attachWorkspaceMembership: (input: AttachWorkspaceMembershipInput) => CliNodeEffect<WorkspaceMembershipAttachResult>;
+    attachWorkspaceRepository: (input: AttachRepositoryInput) => CliNodeEffect<WorkspaceRepositoryAttachResult>;
+    configureWorkspaceExecution: (input: ConfigureWorkspaceExecutionInput) => CliNodeEffect<WorkspaceExecutionConfigureResult>;
+    createExecutionCheckpoint: (input: CreateExecutionCheckpointInput) => CliNodeEffect<ExecutionWorktreeCheckpointCreateResult>;
+    createExecutionPlacement: (input: CreateExecutionPlacementInput) => CliNodeEffect<ExecutionPlacementCreateResult>;
+    createExecutionWorktree: (input: CreateExecutionWorktreeInput) => CliNodeEffect<ExecutionWorktreeCreateResult>;
+    getReceipt: (commandId: string) => CliNodeEffect<ReceiptGetResult>;
+    importExecutionWorktree: (input: ImportExecutionWorktreeInput) => CliNodeEffect<ExecutionWorktreeImportResult>;
+    listProjectContext: (input: {
+        readonly afterCursor: string;
+        readonly limit: number;
+        readonly projectId: string;
+    }) => CliNodeEffect<ProjectContextListResult>;
+    listProjects: (input: {
+        readonly afterCursor: string;
+        readonly limit: number;
+    }) => CliNodeEffect<ProjectListResult>;
+    listReceipts: (input: ReceiptListParameters) => CliNodeEffect<ReceiptListResult>;
+    listWorkspaces: (input: {
+        readonly afterCursor: string;
+        readonly limit: number;
+        readonly projectId: string;
+    }) => CliNodeEffect<WorkspaceListResult>;
+    planExecutionWorktreeRemove: (workspaceId: string) => CliNodeEffect<ExecutionWorktreeRemovePlanResult>;
+    readExecutionCatalog: () => CliNodeEffect<ExecutionCatalogGetResult>;
+    readExecutionFile: (input: ReadExecutionFileInput) => CliNodeEffect<ExecutionFileReadResult>;
+    reconcileExecutionWorktree: (input: ReconcileExecutionWorktreeInput) => CliNodeEffect<ExecutionWorktreeReconcileResult>;
+    recordProjectContext: (input: RecordProjectContextInput) => CliNodeEffect<ProjectContextRecordResult>;
+    registerProject: (input: RegisterProjectInput) => CliNodeEffect<ProjectRegisterResult>;
+    removeExecutionWorktree: (input: RemoveExecutionWorktreeInput) => CliNodeEffect<ExecutionWorktreeRemoveApplyResult>;
+    runExecutionCommand: (input: RunExecutionCommandInput) => CliNodeEffect<ExecutionCommandRunResult>;
+    selectWorkspace: (input: SelectWorkspaceInput) => CliNodeEffect<WorkspaceSelectResult>;
+    showExecutionCheckpoint: (checkpointId: string) => CliNodeEffect<ExecutionWorktreeCheckpointShowResult>;
+    showExecutionPlacement: (input: ExecutionPlacementShowParameters) => CliNodeEffect<ExecutionPlacementShowResult>;
+    showExecutionWorktreeStatus: (workspaceId: string) => CliNodeEffect<ExecutionWorktreeStatusResult>;
+    showProject: (projectId: string) => CliNodeEffect<ProjectShowResult>;
+    showProjectContext: (noteId: string) => CliNodeEffect<ProjectContextShowResult>;
+    showWorkspace: (workspaceId: string) => CliNodeEffect<WorkspaceShowResult>;
+    showWorkspaceContext: () => CliNodeEffect<WorkspaceContextShowResult>;
+    showWorkspaceExecution: (workspaceId: string) => CliNodeEffect<WorkspaceExecutionShowResult>;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/project-workspace/client.js

@@ -0,0 +1,159 @@
+import { basename, resolve } from "node:path";
+import { executionCommandRunParametersSchema, executionFileReadParametersSchema, executionPlacementCreateParametersSchema, executionPlacementShowParametersSchema, executionWorktreeCheckpointCreateParametersSchema, executionWorktreeCheckpointShowParametersSchema, executionWorktreeCreateParametersSchema, executionWorktreeImportParametersSchema, executionWorktreeReconcileParametersSchema, executionWorktreeRemoveApplyParametersSchema, executionWorktreeRemovePlanParametersSchema, executionWorktreeStatusParametersSchema, projectContextListParametersSchema, projectContextRecordParametersSchema, projectContextShowParametersSchema, projectListParametersSchema, projectRegisterParametersSchema, projectShowParametersSchema, receiptGetParametersSchema, receiptListParametersSchema, workspaceContextShowParametersSchema, workspaceExecutionConfigureParametersSchema, workspaceExecutionShowParametersSchema, workspaceListParametersSchema, workspaceMembershipAttachParametersSchema, workspaceRepositoryAttachParametersSchema, workspaceSelectParametersSchema, workspaceShowParametersSchema, } from "@maiaos/sdk";
+import * as Effect from "effect/Effect";
+import { commandIdentifier, } from "../local-node/index.js";
+export const makeProjectWorkspaceClient = (node) => {
+    const registerProject = (input) => {
+        const rootPath = resolve(input.path);
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({
+                commandId,
+                expectedRevision: "0",
+                name: input.name ?? basename(rootPath),
+                rootPath,
+            }, projectRegisterParametersSchema, (client, parameters, options) => client.registerProject(parameters, options), { commandId });
+        });
+    };
+    const listProjectContext = (input) => {
+        return node.runValidatedNodeOperation(input, projectContextListParametersSchema, (client, parameters, options) => client.listProjectContext(parameters, options));
+    };
+    const listProjects = (input) => {
+        return node.runValidatedNodeOperation(input, projectListParametersSchema, (client, parameters, options) => client.listProjects(parameters, options));
+    };
+    const recordProjectContext = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({
+                attribution: "user",
+                body: input.body,
+                commandId,
+                projectId: input.projectId,
+            }, projectContextRecordParametersSchema, (client, parameters, options) => client.recordProjectContext(parameters, options), { commandId });
+        });
+    };
+    const showProject = (projectId) => {
+        return node.runValidatedNodeOperation({ projectId }, projectShowParametersSchema, (client, parameters, options) => client.showProject(parameters, options));
+    };
+    const showProjectContext = (noteId) => {
+        return node.runValidatedNodeOperation({ noteId }, projectContextShowParametersSchema, (client, parameters, options) => client.showProjectContext(parameters, options));
+    };
+    const listWorkspaces = (input) => {
+        return node.runValidatedNodeOperation(input, workspaceListParametersSchema, (client, parameters, options) => client.listWorkspaces(parameters, options));
+    };
+    const attachWorkspaceMembership = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId }, workspaceMembershipAttachParametersSchema, (client, parameters, options) => client.attachWorkspaceMembership(parameters, options), { commandId });
+        });
+    };
+    const selectWorkspace = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId }, workspaceSelectParametersSchema, (client, parameters, options) => client.selectWorkspace(parameters, options), { commandId });
+        });
+    };
+    const showWorkspaceContext = () => node.runValidatedNodeOperation({}, workspaceContextShowParametersSchema, (client, parameters, options) => client.showWorkspaceContext(parameters, options));
+    const showWorkspace = (workspaceId) => {
+        return node.runValidatedNodeOperation({ workspaceId }, workspaceShowParametersSchema, (client, parameters, options) => client.showWorkspace(parameters, options));
+    };
+    const createExecutionPlacement = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId }, executionPlacementCreateParametersSchema, (client, parameters, options) => client.createExecutionPlacement(parameters, options), { commandId });
+        });
+    };
+    const showExecutionPlacement = (input) => node.runValidatedNodeOperation(input, executionPlacementShowParametersSchema, (client, parameters, options) => client.showExecutionPlacement(parameters, options));
+    const createExecutionWorktree = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId }, executionWorktreeCreateParametersSchema, (client, parameters, options) => client.createExecutionWorktree(parameters, options), { commandId });
+        });
+    };
+    const importExecutionWorktree = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId, rootPath: resolve(input.rootPath) }, executionWorktreeImportParametersSchema, (client, parameters, options) => client.importExecutionWorktree(parameters, options), { commandId });
+        });
+    };
+    const showExecutionWorktreeStatus = (workspaceId) => node.runValidatedNodeOperation({ workspaceId }, executionWorktreeStatusParametersSchema, (client, parameters, options) => client.showExecutionWorktreeStatus(parameters, options));
+    const reconcileExecutionWorktree = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId }, executionWorktreeReconcileParametersSchema, (client, parameters, options) => client.reconcileExecutionWorktree(parameters, options), { commandId });
+        });
+    };
+    const planExecutionWorktreeRemove = (workspaceId) => node.runValidatedNodeOperation({ workspaceId }, executionWorktreeRemovePlanParametersSchema, (client, parameters, options) => client.planExecutionWorktreeRemove(parameters, options));
+    const removeExecutionWorktree = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId }, executionWorktreeRemoveApplyParametersSchema, (client, parameters, options) => client.removeExecutionWorktree(parameters, options), { commandId });
+        });
+    };
+    const createExecutionCheckpoint = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId }, executionWorktreeCheckpointCreateParametersSchema, (client, parameters, options) => client.createExecutionCheckpoint(parameters, options), { commandId });
+        });
+    };
+    const showExecutionCheckpoint = (checkpointId) => node.runValidatedNodeOperation({ checkpointId }, executionWorktreeCheckpointShowParametersSchema, (client, parameters, options) => client.showExecutionCheckpoint(parameters, options));
+    const readExecutionCatalog = () => node.runNodeClientOperation((client, options) => client.readExecutionCatalog({}, options));
+    const readExecutionFile = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId }, executionFileReadParametersSchema, (client, parameters, options) => client.readExecutionFile(parameters, options), { commandId });
+        });
+    };
+    const runExecutionCommand = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId }, executionCommandRunParametersSchema, (client, parameters, options) => client.runExecutionCommand(parameters, options), { commandId });
+        });
+    };
+    const showWorkspaceExecution = (workspaceId) => {
+        return node.runValidatedNodeOperation({ workspaceId }, workspaceExecutionShowParametersSchema, (client, parameters, options) => client.showWorkspaceExecution(parameters, options));
+    };
+    const configureWorkspaceExecution = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId }, workspaceExecutionConfigureParametersSchema, (client, parameters, options) => client.configureWorkspaceExecution(parameters, options), { commandId });
+        });
+    };
+    const attachWorkspaceRepository = (input) => {
+        const rootPath = resolve(input.path);
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({
+                commandId,
+                expectedRevision: input.expectedRevision,
+                name: input.name ?? basename(rootPath),
+                rootPath,
+                workspaceId: input.workspaceId,
+            }, workspaceRepositoryAttachParametersSchema, (client, parameters, options) => client.attachWorkspaceRepository(parameters, options), { commandId });
+        });
+    };
+    const getReceipt = (commandId) => {
+        return node.runValidatedNodeOperation({ commandId }, receiptGetParametersSchema, (client, parameters, options) => client.getReceipt(parameters, options));
+    };
+    const listReceipts = (input) => {
+        return node.runValidatedNodeOperation(input, receiptListParametersSchema, (client, parameters, options) => client.listReceipts(parameters, options));
+    };
+    return {
+        attachWorkspaceMembership,
+        attachWorkspaceRepository,
+        configureWorkspaceExecution,
+        createExecutionCheckpoint,
+        createExecutionPlacement,
+        createExecutionWorktree,
+        getReceipt,
+        importExecutionWorktree,
+        listProjectContext,
+        listProjects,
+        listReceipts,
+        listWorkspaces,
+        planExecutionWorktreeRemove,
+        readExecutionCatalog,
+        readExecutionFile,
+        reconcileExecutionWorktree,
+        recordProjectContext,
+        registerProject,
+        removeExecutionWorktree,
+        runExecutionCommand,
+        selectWorkspace,
+        showExecutionCheckpoint,
+        showExecutionPlacement,
+        showExecutionWorktreeStatus,
+        showProject,
+        showProjectContext,
+        showWorkspace,
+        showWorkspaceContext,
+        showWorkspaceExecution,
+    };
+};
+//# sourceMappingURL=client.js.map

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

@@ -0,0 +1,30 @@
+import { type CommandContext, type CommandEffect } from "../command-line/index.js";
+export declare const runProjectRegister: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runProjectList: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runProjectShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runProjectContextRecord: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runProjectContextList: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runProjectContextShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runExecutionCatalogShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runExecutionFileRead: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runExecutionCommandRun: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runExecutionPlacementCreate: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runExecutionPlacementShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runExecutionWorktreeCreate: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runExecutionWorktreeImport: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runExecutionWorktreeStatus: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runExecutionWorktreeReconcile: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runExecutionWorktreeRemovePlan: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runExecutionWorktreeRemoveApply: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runExecutionCheckpointShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runExecutionCheckpointCreate: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runWorkspaceList: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runWorkspaceMembershipAttach: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runWorkspaceSelect: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runWorkspaceContextShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runWorkspaceShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runWorkspaceRepositoryAttach: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runWorkspaceExecutionShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runWorkspaceExecutionSet: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runWorkspaceExecutionClear: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+//# sourceMappingURL=commands.d.ts.map