@maiaos/cli 0.1.0-canary.2

package/dist/command-tree/grammar.js

@@ -0,0 +1,160 @@
+const PATH_WORD = /^[a-z][a-z0-9-]*$/u;
+const RANGE = /^<(\d+)\.\.(\d+)(?: [a-z]+)?>$/u;
+const CHOICES = /^<([a-z0-9-]+(?:\|[a-z0-9-]+)+)>$/u;
+const LIST = /^<([a-z-]+)>\[,<[a-z-]+>\.\.\.\]$/u;
+const splitTopLevel = (text, separator) => {
+    const cuts = (text.match(/./gsu) ?? []).reduce((state, character, index) => {
+        if ("[(<".includes(character))
+            return { ...state, depth: state.depth + 1 };
+        if ("])>".includes(character))
+            return { ...state, depth: state.depth - 1 };
+        return character === separator &&
+            state.depth === 0 &&
+            (separator === " " || text[index - 1] === " ")
+            ? { ...state, indexes: [...state.indexes, index] }
+            : state;
+    }, { depth: 0, indexes: [] }).indexes;
+    return [-1, ...cuts]
+        .map((cut, position) => text.slice(cut + 1, cuts[position] ?? text.length))
+        .map((part) => part.trim())
+        .filter((part) => part !== "");
+};
+const NAMED_TYPES = [
+    [/^(?:revision|epoch|n|port)$/u, "integer"],
+    [/cursor$/u, "cursor"],
+    [/(?:^|-)id$/u, "id"],
+    [/(?:path|repository|dir|executable|\.json)$/u, "path"],
+    [/^url$/u, "url"],
+    [/^duration$/u, "duration"],
+    [/^(?:digest|sha256)$/u, "digest"],
+    [/(?:timestamp|recorded-at)$/u, "timestamp"],
+];
+const describeValue = (value) => {
+    const range = RANGE.exec(value);
+    if (range !== null)
+        return { max: Number(range[2]), min: Number(range[1]), type: "integer" };
+    const choices = CHOICES.exec(value);
+    if (choices !== null)
+        return { choices: (choices[1] ?? "").split("|"), type: "choice" };
+    if (LIST.test(value))
+        return { type: "list" };
+    if (!value.startsWith("<")) {
+        return value.includes(",")
+            ? { choices: value.split(","), type: "list" }
+            : { choices: [value], type: "choice" };
+    }
+    const name = /^<([a-z0-9.-]+)>$/u.exec(value)?.[1];
+    const named = name === undefined
+        ? undefined
+        : NAMED_TYPES.find(([pattern]) => pattern.test(name));
+    return named === undefined ? {} : { type: named[1] };
+};
+const pushArgument = (state, argument, scope) => {
+    if (state.output.some((existing) => existing.name === argument.name))
+        return;
+    state.output.push({
+        ...argument,
+        ...(scope.oneOf === undefined ? {} : { oneOf: scope.oneOf }),
+        ...(scope.optional ? {} : { required: true }),
+    });
+};
+const isValueToken = (token) => token !== undefined && !/^[-[(|]/u.test(token);
+const parseGroup = (state, token, scope) => {
+    const alternatives = splitTopLevel(token.slice(1, -1), "|");
+    const oneOf = alternatives.length > 1 ? (state.groups += 1) : scope.oneOf;
+    alternatives.forEach((alternative) => {
+        parseSequence(state, splitTopLevel(alternative, " "), {
+            optional: scope.optional || token.startsWith("["),
+            ...(oneOf === undefined ? {} : { oneOf }),
+        });
+    });
+};
+const parseOption = (state, [token = "", next], scope) => {
+    const name = token.split("|").at(-1) ?? token;
+    if (!isValueToken(next)) {
+        pushArgument(state, { name }, scope);
+        return 1;
+    }
+    pushArgument(state, { name, value: next, ...describeValue(next) }, scope);
+    return 2;
+};
+const parseToken = (state, tokens, scope) => {
+    const [token = ""] = tokens;
+    if (token.startsWith("[") || token.startsWith("(")) {
+        parseGroup(state, token, scope);
+    }
+    else if (token === "--") {
+        pushArgument(state, { name: "--", type: "separator" }, scope);
+    }
+    else if (token.startsWith("-")) {
+        return parseOption(state, tokens, scope);
+    }
+    else {
+        const name = token.replace(/\.\.\.$/u, "");
+        pushArgument(state, {
+            name,
+            ...(name.startsWith("<") ? describeValue(name) : {}),
+            ...(token.endsWith("...") ? { repeated: true } : {}),
+        }, scope);
+    }
+    return 1;
+};
+const parseSequence = (state, tokens, scope) => {
+    if (tokens.length === 0)
+        return;
+    parseSequence(state, tokens.slice(parseToken(state, tokens, scope)), scope);
+};
+export const parseUsage = (usage) => {
+    const tokens = splitTopLevel(usage, " ");
+    const boundary = tokens.findIndex((token) => !PATH_WORD.test(token));
+    const pathLength = boundary === -1 ? tokens.length : boundary;
+    const state = { groups: 0, output: [] };
+    parseSequence(state, tokens.slice(pathLength), { optional: false });
+    return { args: state.output, path: tokens.slice(0, pathLength) };
+};
+const SAMPLE_VALUES = [
+    [/^<command-id>$/u, "cmd-1"],
+    [/^<(?:[a-z]+-)*([a-z]+)-id>$/u, "$1_1"],
+    [/^<relative-path>$/u, "README.md"],
+    [/^<absolute-executable>$/u, "/usr/bin/env"],
+    [/^<url>$/u, "https://example.com"],
+    [/^<id>$/u, "id-1"],
+    [/^<timestamp>$/u, "2026-01-01T00:00:00Z"],
+    [/^<duration>$/u, "30s"],
+    [/^<text>$|^<answer>$/u, "'text'"],
+];
+const sampleFor = (argument) => {
+    const raw = argument.value ?? argument.name;
+    if (argument.choices !== undefined)
+        return argument.choices[0] ?? raw;
+    if (argument.min !== undefined)
+        return String(argument.min);
+    const sample = SAMPLE_VALUES.find(([pattern]) => pattern.test(raw));
+    if (sample !== undefined)
+        return raw.replace(sample[0], sample[1]);
+    if (argument.type === "integer" || argument.type === "cursor")
+        return "1";
+    if (argument.type === "path")
+        return ".";
+    return raw.replaceAll(/[<>]/gu, "").replace(/\[.*$/u, "");
+};
+const isBareOption = (argument) => argument.type === "separator" ||
+    (argument.name.startsWith("-") && argument.value === undefined);
+export const exampleFor = (form) => {
+    const seen = new Set();
+    const words = form.args.flatMap((argument) => {
+        if (argument.required === undefined)
+            return [];
+        if (argument.oneOf !== undefined) {
+            if (seen.has(argument.oneOf))
+                return [];
+            seen.add(argument.oneOf);
+        }
+        if (isBareOption(argument))
+            return [argument.name];
+        const sample = sampleFor(argument);
+        return argument.name.startsWith("-") ? [argument.name, sample] : [sample];
+    });
+    return ["maia", ...form.path, ...words].join(" ");
+};
+//# sourceMappingURL=grammar.js.map

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

@@ -0,0 +1,62 @@
+import { type TreeArgument } from "./grammar.js";
+import type { TreeLeafKind } from "./row.js";
+import { type TreeAvailability, type TreeNode } from "./tree.js";
+export declare const CLI_CONTRACT: {
+    readonly envelope: {
+        readonly failure: '{"ok":false,"error":{"code","message","retryable"},"usage"?,"hint"?,"recovery"?} on stderr';
+        readonly success: '{"ok":true,"resolved"?,"result":{"command","result"}} on stdout';
+    };
+    readonly exitCodes: readonly [readonly [0, "done"], readonly [64, "invalid usage"], readonly [66, "unknown ID"], readonly [69, "Node unavailable"], readonly [70, "other failure: read the message"], readonly [74, "deadline reached"], readonly [75, "retry later: revision changed, full, limited or held"], readonly [76, "outcome unknown: run maia receipt show <command-id>"], readonly [77, "not permitted"]];
+    readonly grammar: "<x> is a value, [x] optional, (a | b) one of, <a|b> a choice, <1..100> an integer range, <duration> 30s, 10m or 1h, x... repeats; 'maia <command> --help --json' lists typed arguments.";
+    readonly idempotency: "A mutation that guards a revision takes the current --expected-revision (or a named --expected-*-revision); --command-id <id> names the mutation, and a retry with the same command ID replays the first result.";
+    readonly input: "Prompts appear only when stdin and stderr are terminals and --json and --no-input (MAIA_NO_INPUT=1) are absent; otherwise a command that confirms fails (exit 64) and names its flags. A two-phase command previews with --dry-run and confirms that preview from stdin with --confirm-stdin.";
+    readonly pagination: "Lists take --limit and --after <cursor>; pass the result's nextCursor as --after.";
+    readonly precedence: "A flag wins over its environment variable (MAIA_PROFILE, MAIA_NODE, MAIA_NO_INPUT), which wins over the default.";
+    readonly references: "A resource argument takes a full ID, a unique ID prefix of 4+ hex digits or a unique name or Session title; an ambiguous one fails (exit 64) listing candidates. A missing required --project or --workspace comes from the current folder, then the selected Workspace. 'resolved' lists each argument the CLI resolved and how.";
+    readonly version: 3;
+};
+declare const GLOBAL_OPTIONS: readonly ["--json", "--profile <name>", "--node <name>", "--no-input", "-h|--help"];
+type HelpChild = {
+    readonly availability?: TreeAvailability;
+    readonly kind: "group" | TreeLeafKind;
+    readonly name: string;
+    readonly summary: string;
+};
+type HelpForm = {
+    readonly args?: readonly TreeArgument[];
+    readonly availability: TreeAvailability;
+    readonly summary?: string;
+    readonly usage: string;
+};
+export type CliHelpNode = HelpChild & Partial<Omit<HelpForm, "summary">> & {
+    readonly children?: readonly (CliHelpNode | HelpChild)[];
+    readonly example?: string;
+    readonly forms?: readonly HelpForm[];
+    readonly operations?: readonly string[];
+};
+export type CliHelpTreeResult = {
+    readonly command: "help";
+    readonly commands: readonly CliHelpNode[];
+    readonly contract: typeof CLI_CONTRACT;
+    readonly globalOptions: typeof GLOBAL_OPTIONS;
+    readonly name: "maia";
+    readonly registryDigest: string;
+    readonly version: string;
+};
+export type CliHelpNodeResult = CliHelpNode & {
+    readonly command: "help";
+    readonly path: string;
+    readonly version: string;
+};
+export type CliHelpResult = CliHelpNodeResult | CliHelpTreeResult;
+export declare const leafExample: (node: TreeNode) => string | undefined;
+export declare const formatNodeHelp: (node: TreeNode) => string;
+export declare const formatRootHelp: (version: string) => string;
+export declare const createHelpTree: (version: string) => CliHelpTreeResult;
+export declare const createNodeHelp: (version: string, node: TreeNode) => CliHelpNodeResult;
+export declare const usageHint: (tokens: readonly string[]) => {
+    readonly hint: string;
+    readonly usage: readonly string[];
+};
+export {};
+//# sourceMappingURL=help.d.ts.map

package/dist/command-tree/help.js

@@ -0,0 +1,219 @@
+import { exampleFor, parseUsage } from "./grammar.js";
+import { commandTree, createTreeDigest, findNode, TREE_SECTIONS, } from "./tree.js";
+export const CLI_CONTRACT = {
+    envelope: {
+        failure: '{"ok":false,"error":{"code","message","retryable"},"usage"?,"hint"?,"recovery"?} on stderr',
+        success: '{"ok":true,"resolved"?,"result":{"command","result"}} on stdout',
+    },
+    exitCodes: [
+        [0, "done"],
+        [64, "invalid usage"],
+        [66, "unknown ID"],
+        [69, "Node unavailable"],
+        [70, "other failure: read the message"],
+        [74, "deadline reached"],
+        [75, "retry later: revision changed, full, limited or held"],
+        [76, "outcome unknown: run maia receipt show <command-id>"],
+        [77, "not permitted"],
+    ],
+    grammar: "<x> is a value, [x] optional, (a | b) one of, <a|b> a choice, <1..100> an integer range, <duration> 30s, 10m or 1h, x... repeats; 'maia <command> --help --json' lists typed arguments.",
+    idempotency: "A mutation that guards a revision takes the current --expected-revision (or a named --expected-*-revision); --command-id <id> names the mutation, and a retry with the same command ID replays the first result.",
+    input: "Prompts appear only when stdin and stderr are terminals and --json and --no-input (MAIA_NO_INPUT=1) are absent; otherwise a command that confirms fails (exit 64) and names its flags. A two-phase command previews with --dry-run and confirms that preview from stdin with --confirm-stdin.",
+    pagination: "Lists take --limit and --after <cursor>; pass the result's nextCursor as --after.",
+    precedence: "A flag wins over its environment variable (MAIA_PROFILE, MAIA_NODE, MAIA_NO_INPUT), which wins over the default.",
+    references: "A resource argument takes a full ID, a unique ID prefix of 4+ hex digits or a unique name or Session title; an ambiguous one fails (exit 64) listing candidates. A missing required --project or --workspace comes from the current folder, then the selected Workspace. 'resolved' lists each argument the CLI resolved and how.",
+    version: 3,
+};
+const GLOBAL_OPTIONS = [
+    "--json",
+    "--profile <name>",
+    "--node <name>",
+    "--no-input",
+    "-h|--help",
+];
+const GLOBAL_LINE = `Global options: ${GLOBAL_OPTIONS.join(", ")} (anywhere before --)`;
+const nodeAvailability = (node) => {
+    const values = new Set(node.forms.map((form) => form.availability));
+    return values.size === 1 ? [...values][0] : undefined;
+};
+const describeChild = (node) => {
+    const availability = nodeAvailability(node);
+    return {
+        ...(availability === undefined ? {} : { availability }),
+        kind: node.kind ?? "group",
+        name: node.name,
+        summary: node.summary,
+    };
+};
+export const leafExample = (node) => {
+    const form = node.forms[0];
+    if (node.example !== undefined)
+        return node.example;
+    return form === undefined ? undefined : exampleFor(parseUsage(form.usage));
+};
+const formFields = (form, typed) => ({
+    ...(typed ? { args: parseUsage(form.usage).args } : {}),
+    availability: form.availability,
+    usage: `maia ${form.usage}`,
+});
+const describeLeaf = (node, typed) => {
+    const [first] = node.forms;
+    if (first === undefined)
+        return {};
+    return {
+        ...(node.forms.length === 1
+            ? formFields(first, typed)
+            : {
+                forms: node.forms.map((form) => ({
+                    ...formFields(form, typed),
+                    summary: form.summary,
+                })),
+            }),
+        example: leafExample(node) ?? "",
+        operations: node.operations,
+    };
+};
+const describeNode = (node, deep) => ({
+    ...describeChild(node),
+    ...describeLeaf(node, !deep),
+    ...(node.children.length === 0
+        ? {}
+        : {
+            children: node.children.map((child) => deep ? describeNode(child, true) : describeChild(child)),
+        }),
+});
+const pad = (rows) => {
+    const width = Math.max(...rows.map(([left]) => left.length)) + 2;
+    return rows.map(([left, right]) => `  ${left.padEnd(width)}${right}`);
+};
+const candidateMark = (node) => nodeAvailability(node) === "source_implemented_candidate"
+    ? " (candidate)"
+    : "";
+const childLines = (node) => pad(node.children.map((child) => [
+    child.name,
+    `${child.summary}${candidateMark(child)}`,
+]));
+const describeArgument = (argument) => {
+    const bounds = argument.min === undefined
+        ? ""
+        : ` ${String(argument.min)}..${String(argument.max)}`;
+    return [
+        `${argument.type ?? (argument.value === undefined ? "flag" : "text")}${bounds}`,
+        ...(argument.required === undefined ? [] : ["required"]),
+        ...(argument.repeated === undefined ? [] : ["repeatable"]),
+        ...(argument.oneOf === undefined
+            ? []
+            : [`one of group ${String(argument.oneOf)}`]),
+    ].join(", ");
+};
+const operationLine = (node) => {
+    if (node.operations.length === 0)
+        return `Kind: ${node.kind ?? "local"}`;
+    const label = node.operations.length > 1 ? "Operations" : "Operation";
+    const kind = node.kind === "operation" ? "" : ` (${node.kind ?? ""})`;
+    return `${label}: ${node.operations.join(", ")}${kind}`;
+};
+const argumentLines = (node) => {
+    const entries = node.forms
+        .flatMap((form) => parseUsage(form.usage).args)
+        .filter((argument, index, all) => all.findIndex((other) => other.name === argument.name) === index);
+    return entries.length === 0
+        ? []
+        : [
+            "",
+            "Arguments:",
+            ...pad(entries.map((argument) => [
+                argument.value === undefined
+                    ? argument.name
+                    : `${argument.name} ${argument.value}`,
+                describeArgument(argument),
+            ])),
+        ];
+};
+const usageLines = (node) => {
+    const [form] = node.forms;
+    if (node.forms.length === 1 && form !== undefined)
+        return [
+            `Usage: maia ${form.usage}`,
+            `${form.summary}${candidateMark(node)}`,
+        ];
+    return [
+        `${node.summary}${candidateMark(node)}`,
+        "",
+        "Usage:",
+        ...node.forms.map((each) => `  maia ${each.usage}\n    ${each.summary}`),
+    ];
+};
+const formatLeaf = (node) => [
+    ...usageLines(node),
+    ...argumentLines(node),
+    "",
+    "Example:",
+    `  ${leafExample(node) ?? ""}`,
+    operationLine(node),
+];
+const formatGroup = (node) => [
+    ...(node.forms.length === 0
+        ? [`Usage: maia ${node.path.join(" ")} <command>`, node.summary]
+        : []),
+    "",
+    "Commands:",
+    ...childLines(node),
+    "",
+    `Run 'maia ${node.path.join(" ")} <command> --help' for details.`,
+];
+export const formatNodeHelp = (node) => `${[
+    ...(node.forms.length === 0 ? [] : formatLeaf(node)),
+    ...(node.children.length === 0 ? [] : formatGroup(node)),
+    GLOBAL_LINE,
+].join("\n")}\n`;
+export const formatRootHelp = (version) => {
+    const root = commandTree();
+    const sections = TREE_SECTIONS.flatMap(([title, names]) => [
+        "",
+        title,
+        ...pad(names.map((name) => {
+            const node = root.children.find((child) => child.name === name);
+            return [name, node === undefined ? "" : node.summary];
+        })),
+    ]);
+    return `${[
+        `Maia CLI ${version}`,
+        "",
+        `Usage: maia [--json] [--profile <name>] [--node <name>] [--no-input] <command> [-h|--help]`,
+        ...sections,
+        "",
+        "Run 'maia <command> --help' for one command; 'maia help --json' describes every command.",
+    ].join("\n")}\n`;
+};
+export const createHelpTree = (version) => ({
+    command: "help",
+    commands: commandTree().children.map((child) => describeNode(child, true)),
+    contract: CLI_CONTRACT,
+    globalOptions: GLOBAL_OPTIONS,
+    name: "maia",
+    registryDigest: createTreeDigest(),
+    version,
+});
+export const createNodeHelp = (version, node) => ({
+    command: "help",
+    ...describeNode(node, false),
+    path: node.path.join(" "),
+    version,
+});
+export const usageHint = (tokens) => {
+    const { node } = findNode(tokens);
+    const path = node.path.join(" ");
+    const usage = [
+        ...node.forms.map((form) => `maia ${form.usage}`),
+        ...(node.children.length > 0 || node.path.length === 0
+            ? [`maia ${path === "" ? "" : `${path} `}<command>`]
+            : []),
+    ];
+    const example = leafExample(node);
+    return {
+        hint: `${example === undefined ? "" : `Example: ${example}\n`}Run 'maia ${path === "" ? "" : `${path} `}--help' for details.`,
+        usage,
+    };
+};
+//# sourceMappingURL=help.js.map

package/dist/command-tree/index.d.ts

@@ -0,0 +1,8 @@
+export type { CliVersionResult } from "./commands.js";
+export { exampleFor, parseUsage, type TreeArgument, type TreeForm, } from "./grammar.js";
+export { CLI_CONTRACT, type CliHelpNode, type CliHelpNodeResult, type CliHelpResult, type CliHelpTreeResult, createHelpTree, createNodeHelp, formatNodeHelp, formatRootHelp, leafExample, usageHint, } from "./help.js";
+export { REFERENCE_PLACEHOLDER, REFERENCE_USAGE } from "./placeholder.js";
+export type { GroupRow, LeafRow, LeafRunner, RunnerReference, TreeFragment, TreeLeafKind, TreeOperation, } from "./row.js";
+export { suggestPaths, unknownPathMessage } from "./suggest.js";
+export { commandTree, createTreeDigest, findNode, isNodeBacked, TREE_FRAGMENTS, TREE_SECTIONS, type TreeAvailability, type TreeLeafForm, type TreeNode, treeNodes, treeUsages, usagePath, } from "./tree.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/command-tree/index.js

@@ -0,0 +1,6 @@
+export { exampleFor, parseUsage, } from "./grammar.js";
+export { CLI_CONTRACT, createHelpTree, createNodeHelp, formatNodeHelp, formatRootHelp, leafExample, usageHint, } from "./help.js";
+export { REFERENCE_PLACEHOLDER, REFERENCE_USAGE } from "./placeholder.js";
+export { suggestPaths, unknownPathMessage } from "./suggest.js";
+export { commandTree, createTreeDigest, findNode, isNodeBacked, TREE_FRAGMENTS, TREE_SECTIONS, treeNodes, treeUsages, usagePath, } from "./tree.js";
+//# sourceMappingURL=index.js.map

package/dist/command-tree/local.d.ts

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

package/dist/command-tree/local.js

@@ -0,0 +1,126 @@
+const local = () => import("./commands.js");
+const doctor = () => import("../status/index.js");
+const mcp = () => import("../mcp/index.js");
+const presentation = () => import("../presentation/index.js");
+const agent = [local, "runAgent"];
+export const LOCAL_TREE = {
+    groups: [
+        ["agent extension", "Agent extensions."],
+        ["presentation", "Read-only view specifications."],
+        ["presentation catalog", "The presentation view catalog."],
+        ["presentation workspace-directory", "The Workspace directory view."],
+        ["presentation project-list", "The Project list view."],
+        ["presentation session-list", "The Session list view."],
+    ],
+    leaves: [
+        [
+            "help [<command>...]",
+            0,
+            "",
+            "Show help for the CLI or one command.",
+            {
+                example: "maia --json help session create",
+                kind: "local",
+                run: [local, "runHelp"],
+            },
+        ],
+        [
+            "version",
+            0,
+            "",
+            "Show the CLI version, protocol and commit.",
+            {
+                example: "maia --json version",
+                kind: "local",
+                run: [local, "runVersion"],
+            },
+        ],
+        [
+            "completion <bash|zsh|fish>",
+            0,
+            "",
+            "Print a shell completion script.",
+            {
+                example: "maia completion zsh",
+                kind: "local",
+                run: [local, "runCompletion"],
+            },
+        ],
+        [
+            "doctor",
+            0,
+            "",
+            "Check this installation, the Node and accounts; name each fix.",
+            {
+                example: "maia doctor",
+                kind: "local",
+                node: true,
+                run: [doctor, "runDoctor"],
+            },
+        ],
+        [
+            "agent [--continue] [-e|--extension <path>] [-ne|--no-extensions] [--model <provider/model>] [--thinking <level>] [extension flags] [--] [prompt]",
+            0,
+            "",
+            "Run Maia's coding agent interactively.",
+            { kind: "local", run: agent },
+        ],
+        [
+            "agent --print [--no-session] [-e|--extension <path>] [-ne|--no-extensions] [--model <provider/model>] [--thinking <level>] [extension flags] [--] <prompt>",
+            0,
+            "",
+            "Print one answer from Maia's coding agent.",
+            { kind: "local", run: agent },
+        ],
+        [
+            "agent --json-events [--no-session] [-e|--extension <path>] [-ne|--no-extensions] [--model <provider/model>] [--thinking <level>] [extension flags] [--] <prompt>",
+            0,
+            "",
+            "Stream one answer as JSON events.",
+            { kind: "local", run: agent },
+        ],
+        [
+            "agent extension digest <path>",
+            0,
+            "",
+            "Print an agent extension's digest.",
+            { kind: "local", run: [local, "runAgentExtensionDigest"] },
+        ],
+        [
+            "presentation catalog show",
+            1,
+            "presentation.catalog.show",
+            "Show the presentation view catalog.",
+            { run: [presentation, "runCatalogShow"] },
+        ],
+        [
+            "presentation workspace-directory show --input-stdin",
+            1,
+            "presentation.workspace-directory.show",
+            "Show the Workspace directory view.",
+            { run: [presentation, "runWorkspaceDirectoryShow"] },
+        ],
+        [
+            "presentation project-list show --input-stdin",
+            1,
+            "presentation.project-list.show",
+            "Show the Project list view.",
+            { run: [presentation, "runProjectListShow"] },
+        ],
+        [
+            "presentation session-list show --input-stdin",
+            1,
+            "presentation.session-list.show",
+            "Show the Session list view.",
+            { run: [presentation, "runSessionListShow"] },
+        ],
+        [
+            "mcp [--worker]",
+            1,
+            "",
+            "Serve coordinator or worker tools over MCP stdio.",
+            { kind: "local", node: true, run: [mcp, "runMcpCommand"] },
+        ],
+    ],
+};
+//# sourceMappingURL=local.js.map

package/dist/command-tree/placeholder.d.ts

@@ -0,0 +1,3 @@
+export declare const REFERENCE_PLACEHOLDER: RegExp;
+export declare const REFERENCE_USAGE: RegExp;
+//# sourceMappingURL=placeholder.d.ts.map

package/dist/command-tree/placeholder.js

@@ -0,0 +1,4 @@
+const KINDS = "connection|container|project|session|workspace";
+export const REFERENCE_PLACEHOLDER = new RegExp(`^<(?:[a-z]+-)*?(${KINDS})(?:-id)?>$`, "u");
+export const REFERENCE_USAGE = new RegExp(`<(?:[a-z]+-)*?(?:${KINDS})(?:-id)?>`, "u");
+//# sourceMappingURL=placeholder.js.map

package/dist/command-tree/row.d.ts

@@ -0,0 +1,29 @@
+import type { localNodeRequestPayloadSchema, SessionAttachFrame } from "@maiaos/sdk";
+import type { CommandContext, CommandEffect } from "../command-line/index.js";
+export type TreeOperation = ReturnType<typeof localNodeRequestPayloadSchema.parse>["method"] | SessionAttachFrame["operationId"];
+export type TreeLeafKind = "composite" | "discriminant" | "local" | "operation" | "shortcut" | "two-phase";
+export type LeafRunner = (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export type RunnerReference = readonly [
+    load: () => Promise<object>,
+    name: string
+];
+export type LeafExtra = {
+    readonly example?: string;
+    readonly kind?: Exclude<TreeLeafKind, "operation">;
+    readonly node?: true;
+    readonly remote?: false;
+    readonly run: RunnerReference;
+};
+export type LeafRow = readonly [
+    usage: string,
+    availability: 0 | 1,
+    operations: "" | readonly TreeOperation[] | TreeOperation,
+    summary: string,
+    extra: LeafExtra
+];
+export type GroupRow = readonly [path: string, summary: string];
+export type TreeFragment = {
+    readonly groups: readonly GroupRow[];
+    readonly leaves: readonly LeafRow[];
+};
+//# sourceMappingURL=row.d.ts.map

package/dist/command-tree/row.js

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

package/dist/command-tree/suggest.d.ts

@@ -0,0 +1,3 @@
+export declare const suggestPaths: (tokens: readonly string[]) => readonly string[];
+export declare const unknownPathMessage: (tokens: readonly string[]) => string;
+//# sourceMappingURL=suggest.d.ts.map