@maiaos/cli 0.1.0-canary.44938d4.manual.1

package/dist/command-line/arguments.d.ts

@@ -0,0 +1,21 @@
+export type ParsedArguments = {
+    readonly json: boolean;
+    readonly jsonFlagCount: number;
+    readonly tokens: readonly string[];
+};
+export type ParsedOptions = {
+    readonly flags: ReadonlySet<string>;
+    readonly options: ReadonlyMap<string, string>;
+    readonly positionals: readonly string[];
+};
+export declare class CliArgumentError extends Error {
+}
+export declare const argumentsAreBounded: (arguments_: readonly string[]) => boolean;
+export declare const parseArguments: (arguments_: readonly string[]) => ParsedArguments;
+export declare const parseOptions: (tokens: readonly string[], allowed: ReadonlySet<string>, allowedFlags?: ReadonlySet<string>) => ParsedOptions;
+export declare const requirePositionals: (positionals: readonly string[], count: number, usage: string) => void;
+export declare const requireNoArguments: (tokens: readonly string[], command: string) => void;
+export declare const readPageSize: (value: string | undefined) => number;
+export declare const readCursor: (value?: string) => string;
+export declare const readExpectedRevision: (value: string | undefined) => string;
+//# sourceMappingURL=arguments.d.ts.map

package/dist/command-line/arguments.js

@@ -0,0 +1,99 @@
+import { Buffer } from "node:buffer";
+const MAX_ARGUMENT_BYTES = 16 * 1024;
+const MAX_ARGUMENT_COUNT = 32;
+const MAX_TOKEN_BYTES = 4096;
+const MAX_SIGNED_INT_64 = 9223372036854775807n;
+const DEFAULT_PAGE_SIZE = 2;
+export class CliArgumentError extends Error {
+}
+export const argumentsAreBounded = (arguments_) => arguments_.length <= MAX_ARGUMENT_COUNT &&
+    arguments_.every((argument) => Buffer.byteLength(argument, "utf8") <= MAX_TOKEN_BYTES) &&
+    arguments_.reduce((total, argument) => total + Buffer.byteLength(argument, "utf8"), 0) <= MAX_ARGUMENT_BYTES;
+export const parseArguments = (arguments_) => {
+    const jsonFlagCount = arguments_.filter((argument) => argument === "--json").length;
+    return {
+        json: jsonFlagCount > 0,
+        jsonFlagCount,
+        tokens: arguments_.filter((argument) => argument !== "--json"),
+    };
+};
+const parseOptionToken = (state, token) => {
+    if (state.pendingOption !== undefined) {
+        if (token.startsWith("--")) {
+            throw new CliArgumentError(`Option '${state.pendingOption}' requires a value.`);
+        }
+        state.options.set(state.pendingOption, token);
+        delete state.pendingOption;
+        return;
+    }
+    if (!token.startsWith("--")) {
+        state.positionals.push(token);
+        return;
+    }
+    if (state.allowedFlags.has(token)) {
+        if (state.flags.has(token)) {
+            throw new CliArgumentError(`Option '${token}' may be used only once.`);
+        }
+        state.flags.add(token);
+        return;
+    }
+    if (!state.allowed.has(token)) {
+        throw new CliArgumentError("The command contains an unknown option.");
+    }
+    if (state.options.has(token)) {
+        throw new CliArgumentError(`Option '${token}' may be used only once.`);
+    }
+    state.pendingOption = token;
+};
+export const parseOptions = (tokens, allowed, allowedFlags = new Set()) => {
+    const state = {
+        allowed,
+        allowedFlags,
+        flags: new Set(),
+        options: new Map(),
+        positionals: [],
+    };
+    tokens.forEach((token) => {
+        parseOptionToken(state, token);
+    });
+    if (state.pendingOption !== undefined) {
+        throw new CliArgumentError(`Option '${state.pendingOption}' requires a value.`);
+    }
+    return {
+        flags: state.flags,
+        options: state.options,
+        positionals: state.positionals,
+    };
+};
+export const requirePositionals = (positionals, count, usage) => {
+    if (positionals.length !== count) {
+        throw new CliArgumentError(`Usage: ${usage}`);
+    }
+};
+export const requireNoArguments = (tokens, command) => {
+    if (tokens.length > 0) {
+        throw new CliArgumentError(`${command} does not accept additional arguments.`);
+    }
+};
+export const readPageSize = (value) => {
+    if (value === undefined)
+        return DEFAULT_PAGE_SIZE;
+    if (!/^(?:[1-9]|[1-9]\d|100)$/u.test(value)) {
+        throw new CliArgumentError("Option '--limit' must be an integer from 1 to 100.");
+    }
+    return Number(value);
+};
+const readInt64 = (value, errorMessage) => {
+    if (!/^(?:0|[1-9]\d*)$/u.test(value) || BigInt(value) > MAX_SIGNED_INT_64) {
+        throw new CliArgumentError(errorMessage);
+    }
+    return value;
+};
+export const readCursor = (value = "0") => readInt64(value, "Option '--after' must be a non-negative signed 64-bit integer cursor.");
+export const readExpectedRevision = (value) => {
+    if (value === undefined) {
+        throw new CliArgumentError("Option '--expected-revision' is required.");
+    }
+    return readInt64(value, "Option '--expected-revision' must be a non-negative signed 64-bit integer.");
+};
+//# sourceMappingURL=arguments.js.map

package/dist/command-line/context.d.ts

@@ -0,0 +1,112 @@
+import type { ExecutionCatalogGetResult, InstalledHarnessListResult, IntegrationApplyCodexResult, IntegrationApplyPiRpcResult, IntegrationPlanCodexResult, IntegrationPlanPiRpcResult, IntegrationRemoveCodexResult, IntegrationRemovePiRpcResult, IntegrationStatusCodexResult, IntegrationStatusPiRpcResult, InvocationContextShowResult, LiveTerminalCloseResult, LiveTerminalControllerAcquireResult, LiveTerminalControllerReleaseResult, LiveTerminalControllerRequestResult, LiveTerminalControllerRequestShowResult, LiveTerminalResizeResult, LiveTerminalSignalResult, LiveTerminalWriteResult, LocalNodeStatusResult, MonitorBootstrapCreateResult, OrchestrationDispatchSettleTerminalResult, OrchestrationDispatchShowResult, OrchestrationInboxAckResult, OrchestrationInboxCheckResult, OrchestrationQuestionCancelResult, OrchestrationQuestionOpenResult, OrchestrationQuestionReplyResult, OrchestrationRunCreateResult, OrchestrationRunListResult, OrchestrationRunShowResult, OrchestrationTaskListResult, OrchestrationTaskShowResult, ProjectListResult, ProjectRegisterResult, ProjectShowResult, ReceiptGetResult, ReceiptListParameters, ReceiptListResult, RuntimeProbeResult, SessionCreateResult, SessionEventsListResult, SessionListResult, SessionShowResult, SessionStartResult, TerminalCreateResult, TerminalEventsListResult, TerminalListResult, TerminalReadResult, TerminalShowResult, TurnInterruptResult, TurnSendResult, TurnShowResult, WorkspaceExecutionConfigureResult, WorkspaceExecutionShowResult, WorkspaceListResult, WorkspaceRepositoryAttachResult, WorkspaceShowResult } from "@maiaos/sdk";
+import type { acknowledgeRunDelivery, cancelRunQuestion, checkRunInbox, createRun, openRunQuestion, replyRunQuestion, settleRunDispatchTerminal } from "../orchestration/client.js";
+import type { AttachRepositoryInput, CliNodeResult, ConfigureWorkspaceExecutionInput, RegisterProjectInput } from "../project-workspace/client.js";
+import type { CreateSessionInput, StartSessionInput } from "../session/client.js";
+import type { acquireTerminalController, closeTerminal, CreateTerminalInput, releaseTerminalController, requestTerminalController, resizeTerminal, showTerminalControllerRequest, signalTerminal, writeTerminalInput } from "../terminal/client.js";
+import type { InterruptTurnInput, SendTurnInput } from "../turn/client.js";
+import type { CliIo } from "./output.js";
+export type CliDependencies = {
+    readonly acknowledgeRunDelivery: (input: Parameters<typeof acknowledgeRunDelivery>[0]) => Promise<CliNodeResult<OrchestrationInboxAckResult>>;
+    readonly acquireTerminalController: (input: Parameters<typeof acquireTerminalController>[0]) => Promise<CliNodeResult<LiveTerminalControllerAcquireResult>>;
+    readonly applyIntegration?: (integration: "codex" | "pi-rpc", input: {
+        readonly commandId?: string;
+        readonly planId: string;
+    }) => Promise<CliNodeResult<IntegrationApplyCodexResult | IntegrationApplyPiRpcResult>>;
+    readonly attachWorkspaceRepository: (input: AttachRepositoryInput) => Promise<CliNodeResult<WorkspaceRepositoryAttachResult>>;
+    readonly cancelRunQuestion: (input: Parameters<typeof cancelRunQuestion>[0]) => Promise<CliNodeResult<OrchestrationQuestionCancelResult>>;
+    readonly checkRunInbox: (input: Parameters<typeof checkRunInbox>[0]) => Promise<CliNodeResult<OrchestrationInboxCheckResult>>;
+    readonly closeTerminal: (input: Parameters<typeof closeTerminal>[0]) => Promise<CliNodeResult<LiveTerminalCloseResult>>;
+    readonly configureWorkspaceExecution?: (input: ConfigureWorkspaceExecutionInput) => Promise<CliNodeResult<WorkspaceExecutionConfigureResult>>;
+    readonly createMonitorBootstrap?: () => Promise<CliNodeResult<MonitorBootstrapCreateResult>>;
+    readonly createRun: (input: Parameters<typeof createRun>[0]) => Promise<CliNodeResult<OrchestrationRunCreateResult>>;
+    readonly createSession: (input: CreateSessionInput) => Promise<CliNodeResult<SessionCreateResult>>;
+    readonly createTerminal: (input: CreateTerminalInput) => Promise<CliNodeResult<TerminalCreateResult>>;
+    readonly getReceipt: (commandId: string) => Promise<CliNodeResult<ReceiptGetResult>>;
+    readonly interruptTurn: (input: InterruptTurnInput) => Promise<CliNodeResult<TurnInterruptResult>>;
+    readonly listInstalledHarnesses: () => Promise<CliNodeResult<InstalledHarnessListResult>>;
+    readonly listProjects: (input: {
+        readonly afterCursor: string;
+        readonly limit: number;
+    }) => Promise<CliNodeResult<ProjectListResult>>;
+    readonly listReceipts: (parameters: ReceiptListParameters) => Promise<CliNodeResult<ReceiptListResult>>;
+    readonly listRuns: (input: {
+        readonly afterCursor: string;
+        readonly limit: number;
+        readonly workspaceId: string;
+    }) => Promise<CliNodeResult<OrchestrationRunListResult>>;
+    readonly listSessionEvents: (input: {
+        readonly afterSessionCursor: string;
+        readonly limit: number;
+        readonly sessionId: string;
+    }) => Promise<CliNodeResult<SessionEventsListResult>>;
+    readonly listSessions: (input: {
+        readonly afterCursor: string;
+        readonly limit: number;
+        readonly projectId: string;
+    }) => Promise<CliNodeResult<SessionListResult>>;
+    readonly listTasks: (input: {
+        readonly afterCursor: string;
+        readonly limit: number;
+        readonly runId: string;
+    }) => Promise<CliNodeResult<OrchestrationTaskListResult>>;
+    readonly listTerminalEvents: (input: {
+        readonly afterTerminalCursor: string;
+        readonly limit: number;
+        readonly terminalId: string;
+    }) => Promise<CliNodeResult<TerminalEventsListResult>>;
+    readonly listTerminals: (input: {
+        readonly afterCursor: string;
+        readonly limit: number;
+        readonly workspaceId: string;
+    }) => Promise<CliNodeResult<TerminalListResult>>;
+    readonly listWorkspaces: (input: {
+        readonly afterCursor: string;
+        readonly limit: number;
+        readonly projectId: string;
+    }) => Promise<CliNodeResult<WorkspaceListResult>>;
+    readonly openRunQuestion: (input: Parameters<typeof openRunQuestion>[0]) => Promise<CliNodeResult<OrchestrationQuestionOpenResult>>;
+    readonly planIntegration?: (integration: "codex" | "pi-rpc") => Promise<CliNodeResult<IntegrationPlanCodexResult | IntegrationPlanPiRpcResult>>;
+    readonly probeRuntime: (runtime?: "codex" | "pi-rpc") => Promise<CliNodeResult<RuntimeProbeResult>>;
+    readonly readExecutionCatalog?: () => Promise<CliNodeResult<ExecutionCatalogGetResult>>;
+    readonly readStatus: () => Promise<LocalNodeStatusResult>;
+    readonly readTerminal: (input: {
+        readonly afterChunkCursor: string;
+        readonly limit: number;
+        readonly terminalId: string;
+    }) => Promise<CliNodeResult<TerminalReadResult>>;
+    readonly registerProject: (input: RegisterProjectInput) => Promise<CliNodeResult<ProjectRegisterResult>>;
+    readonly releaseTerminalController: (input: Parameters<typeof releaseTerminalController>[0]) => Promise<CliNodeResult<LiveTerminalControllerReleaseResult>>;
+    readonly removeIntegration?: (integration: "codex" | "pi-rpc", input: {
+        readonly commandId?: string;
+    }) => Promise<CliNodeResult<IntegrationRemoveCodexResult | IntegrationRemovePiRpcResult>>;
+    readonly replyRunQuestion: (input: Parameters<typeof replyRunQuestion>[0]) => Promise<CliNodeResult<OrchestrationQuestionReplyResult>>;
+    readonly requestTerminalController: (input: Parameters<typeof requestTerminalController>[0]) => Promise<CliNodeResult<LiveTerminalControllerRequestResult>>;
+    readonly resizeTerminal: (input: Parameters<typeof resizeTerminal>[0]) => Promise<CliNodeResult<LiveTerminalResizeResult>>;
+    readonly sendTurn: (input: SendTurnInput) => Promise<CliNodeResult<TurnSendResult>>;
+    readonly settleRunDispatchTerminal: (input: Parameters<typeof settleRunDispatchTerminal>[0]) => Promise<CliNodeResult<OrchestrationDispatchSettleTerminalResult>>;
+    readonly showCurrentContext: () => Promise<CliNodeResult<InvocationContextShowResult>>;
+    readonly showDispatch: (runId: string) => Promise<CliNodeResult<OrchestrationDispatchShowResult>>;
+    readonly showProject: (projectId: string) => Promise<CliNodeResult<ProjectShowResult>>;
+    readonly showRun: (runId: string) => Promise<CliNodeResult<OrchestrationRunShowResult>>;
+    readonly showSession: (sessionId: string) => Promise<CliNodeResult<SessionShowResult>>;
+    readonly showTask: (input: {
+        readonly runId: string;
+        readonly taskId: string;
+    }) => Promise<CliNodeResult<OrchestrationTaskShowResult>>;
+    readonly showTerminal: (terminalId: string) => Promise<CliNodeResult<TerminalShowResult>>;
+    readonly showTerminalControllerRequest: (input: Parameters<typeof showTerminalControllerRequest>[0]) => Promise<CliNodeResult<LiveTerminalControllerRequestShowResult>>;
+    readonly showTurn: (turnId: string) => Promise<CliNodeResult<TurnShowResult>>;
+    readonly showWorkspace: (workspaceId: string) => Promise<CliNodeResult<WorkspaceShowResult>>;
+    readonly showWorkspaceExecution?: (workspaceId: string) => Promise<CliNodeResult<WorkspaceExecutionShowResult>>;
+    readonly signalTerminal: (input: Parameters<typeof signalTerminal>[0]) => Promise<CliNodeResult<LiveTerminalSignalResult>>;
+    readonly startSession: (input: StartSessionInput) => Promise<CliNodeResult<SessionStartResult>>;
+    readonly statusIntegration?: (integration: "codex" | "pi-rpc") => Promise<CliNodeResult<IntegrationStatusCodexResult | IntegrationStatusPiRpcResult>>;
+    readonly writeTerminalInput: (input: Parameters<typeof writeTerminalInput>[0]) => Promise<CliNodeResult<LiveTerminalWriteResult>>;
+};
+export type CommandContext = {
+    readonly dependencies: CliDependencies;
+    readonly io: CliIo;
+    readonly json: boolean;
+    readonly version: string;
+};
+//# sourceMappingURL=context.d.ts.map

package/dist/command-line/context.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=context.js.map

package/dist/command-line/help.d.ts

@@ -0,0 +1,36 @@
+export declare const HELP_FAMILY_NAMES: readonly ["context", "execution", "help", "integration", "project", "receipt", "runtime", "run", "session", "status", "terminal", "version", "workspace", "monitor", "turn"];
+export type CliHelpFamilyName = (typeof HELP_FAMILY_NAMES)[number];
+export type CliHelpAvailability = "implemented" | "source_implemented_candidate";
+export type CliHelpIndexCommand = {
+    readonly candidateUsageCount: number;
+    readonly implementedUsageCount: number;
+    readonly name: CliHelpFamilyName;
+    readonly summary: string;
+};
+export type CliHelpIndexResult = {
+    readonly command: "help";
+    readonly commands: readonly CliHelpIndexCommand[];
+    readonly name: "maia";
+    readonly registryDigest: string;
+    readonly version: string;
+};
+export type CliHelpFamilyUsage = {
+    readonly availability: CliHelpAvailability;
+    readonly usage: string;
+};
+export type CliHelpFamilyResult = {
+    readonly command: "help";
+    readonly family: CliHelpFamilyName;
+    readonly name: "maia";
+    readonly usage: readonly CliHelpFamilyUsage[];
+    readonly version: string;
+};
+export type CliHelpResult = CliHelpFamilyResult | CliHelpIndexResult;
+export declare const HELP_USAGE: string[];
+export declare const createHelpRegistryDigest: (usages?: readonly string[]) => string;
+export declare const createHelpIndex: (version: string) => CliHelpIndexResult;
+export declare const createHelpFamily: (version: string, family: CliHelpFamilyName) => CliHelpFamilyResult;
+export declare const parseHelpFamily: (tokens: readonly string[]) => CliHelpFamilyName | undefined;
+export declare const createHelpResult: (version: string, tokens: readonly string[]) => CliHelpResult;
+export declare const helpUsageAvailability: (usage: string) => CliHelpAvailability | undefined;
+//# sourceMappingURL=help.d.ts.map

package/dist/command-line/help.js

@@ -0,0 +1,267 @@
+import { createHash } from "node:crypto";
+import { CliArgumentError } from "./arguments.js";
+export const HELP_FAMILY_NAMES = [
+    "context",
+    "execution",
+    "help",
+    "integration",
+    "project",
+    "receipt",
+    "runtime",
+    "run",
+    "session",
+    "status",
+    "terminal",
+    "version",
+    "workspace",
+    "monitor",
+    "turn",
+];
+const implemented = "implemented";
+const candidate = "source_implemented_candidate";
+const usagePrefix = "maia [--json] ";
+const commandIdOption = " [--command-id <id>]";
+const expectedRevisionOption = " --expected-revision <revision>";
+const pageOptions = " [--limit <1..100>] [--after <cursor>]";
+const coordinatorOption = " --coordinator-epoch 1";
+const orchestrationRevisionOptions = " --expected-run-revision <revision> --expected-dispatch-revision <revision>";
+const terminalGenerationOption = " --terminal-generation <1..65535>";
+const terminalFencedUsage = (prefix) => `${prefix} --controller-id <id> --controller-epoch <epoch> --controller-revision <revision> --controller-expires-at <timestamp>${terminalGenerationOption}${expectedRevisionOption}${commandIdOption}`;
+const HELP_USAGE_ROWS = [
+    [implemented, 9, "status"],
+    [implemented, 13, "monitor"],
+    [candidate, 0, "context show"],
+    [candidate, 1, "execution catalog"],
+    [
+        implemented,
+        4,
+        `project add <repository> [--name <name>]${commandIdOption}`,
+    ],
+    [implemented, 4, `project list${pageOptions}`],
+    [implemented, 4, "project show <project-id>"],
+    [
+        implemented,
+        5,
+        "receipt list [--limit <1..32>] [--after <cursor>] [--actor <actor-id>] [--method <method>] [--since <recorded-at>] [--until <recorded-at>]",
+    ],
+    [implemented, 5, "receipt show <command-id>"],
+    [
+        candidate,
+        7,
+        `run create <workspace-id> <terminal-id> --graph-stdin${commandIdOption}`,
+    ],
+    [
+        candidate,
+        7,
+        "run list --workspace <workspace-id> [--limit <1..100>] [--after <cursor>]",
+    ],
+    [candidate, 7, "run show <run-id>"],
+    [candidate, 7, "run task list <run-id> [--limit <1..32>] [--after <cursor>]"],
+    [candidate, 7, "run task show <run-id> <task-id>"],
+    [
+        candidate,
+        7,
+        "run inbox check <run-id> --owner <run|dispatch> --owner-id <id> --coordinator-epoch 1 [--limit <1..16>]",
+    ],
+    [
+        candidate,
+        7,
+        `run inbox ack <run-id> --owner <run|dispatch> --owner-id <id> --delivery-id <id> --expected-mailbox-revision <revision> --coordinator-epoch 1${commandIdOption}`,
+    ],
+    [
+        candidate,
+        7,
+        `run question open <run-id> <dispatch-id> --subject <text> --body-stdin${orchestrationRevisionOptions}${coordinatorOption}${commandIdOption}`,
+    ],
+    [
+        candidate,
+        7,
+        `run question reply <run-id> <dispatch-id> <question-id> --answer-stdin${orchestrationRevisionOptions} --expected-question-revision <revision>${coordinatorOption}${commandIdOption}`,
+    ],
+    [
+        candidate,
+        7,
+        `run question cancel <run-id> <dispatch-id> <question-id>${orchestrationRevisionOptions} --expected-question-revision <revision>${coordinatorOption}${commandIdOption}`,
+    ],
+    [candidate, 7, "run dispatch show <run-id>"],
+    [
+        candidate,
+        7,
+        `run dispatch settle-terminal <run-id> <dispatch-id>${orchestrationRevisionOptions}${coordinatorOption}${commandIdOption}`,
+    ],
+    [candidate, 3, "integration plan codex"],
+    [candidate, 3, `integration apply <plan-id>${commandIdOption}`],
+    [candidate, 3, "integration status codex"],
+    [candidate, 3, `integration remove codex${commandIdOption}`],
+    [candidate, 3, "integration plan pi-rpc"],
+    [
+        candidate,
+        3,
+        `integration apply <plan-id> --integration pi-rpc${commandIdOption}`,
+    ],
+    [candidate, 3, "integration status pi-rpc"],
+    [candidate, 3, `integration remove pi-rpc${commandIdOption}`],
+    [candidate, 6, "runtime list"],
+    [implemented, 6, "runtime probe codex"],
+    [candidate, 6, "runtime probe pi-rpc"],
+    [
+        implemented,
+        8,
+        `session create <workspace-id> --runtime <codex|pi> [--profile <codex|pi-rpc>]${commandIdOption}`,
+    ],
+    [
+        implemented,
+        8,
+        "session events <session-id> [--limit <1..32>] [--after <session-cursor>]",
+    ],
+    [implemented, 8, `session list --project <project-id>${pageOptions}`],
+    [implemented, 8, "session show <session-id>"],
+    [
+        candidate,
+        8,
+        `session start <session-id>${expectedRevisionOption}${commandIdOption}`,
+    ],
+    [
+        candidate,
+        10,
+        `terminal create <workspace-id> [--interactive --columns <2..500> --rows <2..300>]${commandIdOption}`,
+    ],
+    [
+        candidate,
+        10,
+        `terminal controller request <terminal-id>${terminalGenerationOption} --lease-ms <1000..30000>${commandIdOption}`,
+    ],
+    [
+        candidate,
+        10,
+        `terminal controller request show <terminal-id> <controller-request-id>${terminalGenerationOption}`,
+    ],
+    [
+        candidate,
+        10,
+        `terminal controller acquire <terminal-id> <controller-request-id>${terminalGenerationOption}${expectedRevisionOption}${commandIdOption}`,
+    ],
+    [
+        candidate,
+        10,
+        terminalFencedUsage("terminal controller release <terminal-id>"),
+    ],
+    [
+        candidate,
+        10,
+        "terminal events <terminal-id> [--limit <1..32>] [--after <terminal-cursor>]",
+    ],
+    [
+        candidate,
+        10,
+        terminalFencedUsage("terminal input write <terminal-id> --input-stdin --input-id <id> --input-sequence <1..2147483647>"),
+    ],
+    [candidate, 10, `terminal list --workspace <workspace-id>${pageOptions}`],
+    [
+        candidate,
+        10,
+        "terminal read <terminal-id> [--limit <1..8>] [--after <chunk-cursor>]",
+    ],
+    [
+        candidate,
+        10,
+        terminalFencedUsage("terminal resize <terminal-id> --columns <2..500> --rows <2..300>"),
+    ],
+    [candidate, 10, "terminal show <terminal-id>"],
+    [
+        candidate,
+        10,
+        terminalFencedUsage("terminal signal <terminal-id> --signal <hangup|interrupt|terminate>"),
+    ],
+    [candidate, 10, terminalFencedUsage("terminal close <terminal-id>")],
+    [
+        candidate,
+        14,
+        `turn interrupt <turn-id>${expectedRevisionOption}${commandIdOption}`,
+    ],
+    [
+        candidate,
+        14,
+        `turn send <session-id> --prompt-stdin${expectedRevisionOption}${commandIdOption}`,
+    ],
+    [candidate, 14, "turn show <turn-id> [--include-content]"],
+    [implemented, 12, `workspace list --project <project-id>${pageOptions}`],
+    [candidate, 12, "workspace execution show <workspace-id>"],
+    [
+        candidate,
+        12,
+        `workspace execution set <workspace-id> (--profile <profile-id> | --policy <policy-id>)${expectedRevisionOption}${commandIdOption}`,
+    ],
+    [
+        candidate,
+        12,
+        `workspace execution clear <workspace-id>${expectedRevisionOption}${commandIdOption}`,
+    ],
+    [implemented, 12, "workspace show <workspace-id>"],
+    [
+        implemented,
+        12,
+        `workspace repo add <workspace-id> <repository>${expectedRevisionOption} [--name <name>]${commandIdOption}`,
+    ],
+    [implemented, 11, "version"],
+];
+const fullUsage = (tail) => `${usagePrefix}${tail}`;
+export const HELP_USAGE = HELP_USAGE_ROWS.map((row) => fullUsage(row[2]));
+const HELP_SUMMARIES = [
+    "Show context.",
+    "Inspect execution.",
+    "Show command index.",
+    "Manage integrations.",
+    "Inspect projects.",
+    "Inspect results.",
+    "Inspect runtime.",
+    "Coordinate Runs.",
+    "Inspect sessions.",
+    "Inspect Maia node.",
+    "Use Terminal.",
+    "Show CLI version.",
+    "Inspect workspaces.",
+    "Open monitor.",
+    "Use turns.",
+];
+export const createHelpRegistryDigest = (usages = HELP_USAGE) => `sha256:${createHash("sha256").update(usages.join("\n")).digest("hex")}`;
+const countAvailability = (family, availability) => HELP_USAGE_ROWS.filter((row) => row[1] === family && row[0] === availability)
+    .length;
+export const createHelpIndex = (version) => ({
+    command: "help",
+    commands: HELP_FAMILY_NAMES.map((name, index) => ({
+        candidateUsageCount: countAvailability(index, candidate),
+        implementedUsageCount: countAvailability(index, implemented),
+        name,
+        summary: HELP_SUMMARIES[index],
+    })),
+    name: "maia",
+    registryDigest: createHelpRegistryDigest(),
+    version,
+});
+export const createHelpFamily = (version, family) => ({
+    command: "help",
+    family,
+    name: "maia",
+    usage: HELP_USAGE_ROWS.filter((row) => HELP_FAMILY_NAMES[row[1]] === family).map((row) => ({ availability: row[0], usage: fullUsage(row[2]) })),
+    version,
+});
+export const parseHelpFamily = (tokens) => {
+    if (tokens.length > 1) {
+        throw new CliArgumentError("Help accepts at most one command family.");
+    }
+    const family = tokens[0];
+    if (tokens.length === 1 &&
+        (family === undefined || !HELP_FAMILY_NAMES.includes(family))) {
+        throw new CliArgumentError("Help does not include that command family.");
+    }
+    return family;
+};
+export const createHelpResult = (version, tokens) => {
+    const family = parseHelpFamily(tokens);
+    return family === undefined
+        ? createHelpIndex(version)
+        : createHelpFamily(version, family);
+};
+export const helpUsageAvailability = (usage) => HELP_USAGE_ROWS[HELP_USAGE.indexOf(usage)]?.[0];
+//# sourceMappingURL=help.js.map