@stigmer/cli 3.0.8

package/src/output/command-result.ts

@@ -0,0 +1,185 @@
+// Structured command output. Instead of ad-hoc console writes, mutating
+// commands build a CommandResult (status + message + sections + hints), then a
+// renderer formats it for human, JSON, or quiet output. Mirrors the Go CLI's
+// pkg/clioutput.
+//
+// Stream discipline: JSON data goes to stdout (so pipes capture only the
+// payload); human and quiet status lines go to stderr.
+
+import type { OutputFormat } from "./format.js";
+import { shouldColorize, styler } from "./style.js";
+
+export type ResultStatus = "success" | "warning" | "error";
+
+export interface KeyValue {
+  readonly key: string;
+  readonly value: string;
+}
+
+/** A group of related fields/items under an optional title. */
+export class Section {
+  readonly title: string;
+  readonly fields: KeyValue[] = [];
+  readonly items: string[] = [];
+
+  constructor(title: string) {
+    this.title = title;
+  }
+
+  field(key: string, value: string): this {
+    this.fields.push({ key, value });
+    return this;
+  }
+
+  item(text: string): this {
+    this.items.push(text);
+    return this;
+  }
+}
+
+/** The structured outcome of a command. Build via the static factories. */
+export class CommandResult {
+  readonly status: ResultStatus;
+  readonly message: string;
+  readonly sections: Section[] = [];
+  readonly hints: string[] = [];
+
+  private constructor(status: ResultStatus, message: string) {
+    this.status = status;
+    this.message = message;
+  }
+
+  static success(message: string): CommandResult {
+    return new CommandResult("success", message);
+  }
+
+  static warning(message: string): CommandResult {
+    return new CommandResult("warning", message);
+  }
+
+  static error(message: string): CommandResult {
+    return new CommandResult("error", message);
+  }
+
+  addSection(title = ""): Section {
+    const section = new Section(title);
+    this.sections.push(section);
+    return section;
+  }
+
+  hint(text: string): this {
+    this.hints.push(text);
+    return this;
+  }
+}
+
+const ICONS: Record<ResultStatus, string> = {
+  success: "✓",
+  warning: "⚠",
+  error: "✗",
+};
+
+interface JsonResult {
+  status: string;
+  message: string;
+  sections?: JsonSection[];
+  hints?: string[];
+}
+
+interface JsonSection {
+  title?: string;
+  fields?: KeyValue[];
+  items?: string[];
+}
+
+/** JSON form of a CommandResult (omits empty sections/hints), newline-terminated. */
+export function resultToJson(result: CommandResult): string {
+  const out: JsonResult = { status: result.status, message: result.message };
+
+  if (result.sections.length > 0) {
+    out.sections = result.sections.map((section) => {
+      const jsonSection: JsonSection = {};
+      if (section.title !== "") jsonSection.title = section.title;
+      if (section.fields.length > 0) {
+        jsonSection.fields = section.fields.map((field) => ({ key: field.key, value: field.value }));
+      }
+      if (section.items.length > 0) jsonSection.items = [...section.items];
+      return jsonSection;
+    });
+  }
+
+  if (result.hints.length > 0) out.hints = [...result.hints];
+
+  return JSON.stringify(out, null, 2) + "\n";
+}
+
+/** Colored, structured human form, newline-terminated. */
+export function resultToHuman(result: CommandResult, colorize: boolean): string {
+  const style = styler(colorize);
+  const lines: string[] = [statusLine(result, colorize)];
+
+  for (const section of result.sections) {
+    lines.push("");
+    if (section.title !== "") lines.push(style.bold(`${section.title}:`));
+
+    if (section.fields.length > 0) {
+      const widestKey = Math.max(...section.fields.map((field) => field.key.length));
+      for (const field of section.fields) {
+        const padding = " ".repeat(widestKey - field.key.length + 4);
+        lines.push(`  ${style.dim(field.key)}${padding}${field.value}`);
+      }
+    }
+
+    for (const item of section.items) lines.push(`  - ${item}`);
+  }
+
+  if (result.hints.length > 0) {
+    lines.push("");
+    for (const hint of result.hints) lines.push(`  ${style.dim(hint)}`);
+  }
+
+  return lines.join("\n") + "\n";
+}
+
+/** Status line only — for scripting where pass/fail is all that matters. */
+export function resultToQuiet(result: CommandResult, colorize: boolean): string {
+  return statusLine(result, colorize) + "\n";
+}
+
+function statusLine(result: CommandResult, colorize: boolean): string {
+  const style = styler(colorize);
+  const text = `${ICONS[result.status]} ${result.message}`;
+  switch (result.status) {
+    case "success":
+      return style.green(text);
+    case "warning":
+      return style.yellow(text);
+    case "error":
+      return style.red(text);
+  }
+}
+
+/** A pair of writable streams; defaults to the process std streams. */
+export interface ResultStreams {
+  readonly stdout: { write(chunk: string): unknown };
+  readonly stderr: { write(chunk: string): unknown; isTTY?: boolean };
+}
+
+const DEFAULT_STREAMS: ResultStreams = { stdout: process.stdout, stderr: process.stderr };
+
+/** Render a CommandResult to the appropriate stream for the resolved format. */
+export function renderResult(
+  result: CommandResult,
+  format: OutputFormat,
+  streams: ResultStreams = DEFAULT_STREAMS,
+): void {
+  if (format === "json") {
+    streams.stdout.write(resultToJson(result));
+    return;
+  }
+  if (format === "quiet") {
+    streams.stderr.write(resultToQuiet(result, shouldColorize(streams.stderr)));
+    return;
+  }
+  streams.stderr.write(resultToHuman(result, shouldColorize(streams.stderr)));
+}

package/src/output/confirm.test.ts

@@ -0,0 +1,43 @@
+import { PassThrough } from "node:stream";
+import { describe, expect, it } from "vitest";
+import { confirm } from "./confirm.js";
+
+// A PassThrough masquerading as an interactive TTY input, with a writable sink
+// for the prompt text we don't need to inspect.
+function ttyPair(isTTY: boolean): { input: NodeJS.ReadStream; output: NodeJS.WritableStream } {
+  const input = new PassThrough();
+  (input as unknown as { isTTY: boolean }).isTTY = isTTY;
+  return { input: input as unknown as NodeJS.ReadStream, output: new PassThrough() };
+}
+
+async function answer(reply: string): Promise<boolean> {
+  const { input, output } = ttyPair(true);
+  const pending = confirm("Proceed? [y/N]", { input, output });
+  (input as unknown as PassThrough).write(`${reply}\n`);
+  return pending;
+}
+
+describe("confirm", () => {
+  it("auto-confirms when forced, without reading input", async () => {
+    expect(await confirm("Proceed? [y/N]", { force: true })).toBe(true);
+  });
+
+  it("refuses (no prompt) when input is not a TTY", async () => {
+    const { input, output } = ttyPair(false);
+    expect(await confirm("Proceed? [y/N]", { input, output })).toBe(false);
+  });
+
+  it.each([
+    ["y", true],
+    ["Y", true],
+    ["yes", true],
+    ["YES", true],
+    [" y ", true],
+    ["n", false],
+    ["no", false],
+    ["", false],
+    ["nope", false],
+  ])("interprets %j as %s", async (reply, expected) => {
+    expect(await answer(reply)).toBe(expected);
+  });
+});

package/src/output/confirm.ts

@@ -0,0 +1,53 @@
+// Interactive yes/no confirmation for destructive commands. Mirrors the Go
+// CLI's clioutput.Confirmer: a `--force` flag (or a non-interactive stderr)
+// auto-confirms, so scripts, pipes, and CI never hang waiting on a TTY prompt.
+//
+// Lives in `output/` to match Go's pkg/clioutput placement — the prompt is part
+// of the human output contract (it writes to stderr, alongside warning panels),
+// not part of any resource's transport logic.
+
+import { createInterface } from "node:readline";
+
+export interface ConfirmOptions {
+  /** When true, skip the prompt and return true immediately (`--force`). */
+  readonly force?: boolean;
+  /** Input stream to read the answer from. Defaults to process.stdin. */
+  readonly input?: NodeJS.ReadStream;
+  /** Output stream the prompt is written to. Defaults to process.stderr. */
+  readonly output?: NodeJS.WritableStream;
+}
+
+/**
+ * Ask the user to confirm a destructive action. Returns true to proceed.
+ *
+ * Resolution order:
+ *   - `--force`            → true (no prompt)
+ *   - non-interactive TTY  → false (refuse rather than block a pipe/CI run)
+ *   - interactive          → true only for an explicit yes ("y"/"yes")
+ *
+ * The default-no posture matches the "[y/N]" prompt: anything that is not an
+ * affirmative answer aborts, which is the safe outcome for an irreversible
+ * operation.
+ */
+export async function confirm(prompt: string, options: ConfirmOptions = {}): Promise<boolean> {
+  if (options.force === true) return true;
+
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stderr;
+
+  // Without a TTY there is no one to answer; refuse rather than hang. Callers
+  // that need unattended deletes pass `--force`.
+  if (input.isTTY !== true) return false;
+
+  const rl = createInterface({ input, output });
+  try {
+    const answer = await new Promise<string>((resolve) => rl.question(`${prompt} `, resolve));
+    return isAffirmative(answer);
+  } finally {
+    rl.close();
+  }
+}
+
+function isAffirmative(answer: string): boolean {
+  return /^y(es)?$/i.test(answer.trim());
+}

package/src/output/format.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import { UsageError } from "../errors/usage-error.js";
+import { resolveFormat, supportedFormats } from "./format.js";
+
+describe("resolveFormat — defaults per command class", () => {
+  it("defaults reads to table", () => {
+    expect(resolveFormat({}, "read")).toBe("table");
+  });
+  it("defaults mutations to human", () => {
+    expect(resolveFormat({}, "mutating")).toBe("human");
+  });
+  it("defaults streaming to inline", () => {
+    expect(resolveFormat({}, "streaming")).toBe("inline");
+  });
+});
+
+describe("resolveFormat — --json alias resolves per class", () => {
+  it("maps --json to json for reads", () => {
+    expect(resolveFormat({ json: true }, "read")).toBe("json");
+  });
+  it("maps --json to json for mutations", () => {
+    expect(resolveFormat({ json: true }, "mutating")).toBe("json");
+  });
+  it("maps --json to ndjson for streaming", () => {
+    expect(resolveFormat({ json: true }, "streaming")).toBe("ndjson");
+  });
+});
+
+describe("resolveFormat — --quiet alias", () => {
+  it("maps --quiet to quiet for mutations", () => {
+    expect(resolveFormat({ quiet: true }, "mutating")).toBe("quiet");
+  });
+  it("rejects --json together with --quiet", () => {
+    expect(() => resolveFormat({ json: true, quiet: true }, "mutating")).toThrow(UsageError);
+  });
+});
+
+describe("resolveFormat — explicit -o/--output", () => {
+  it("maps universal table -> human for mutations", () => {
+    expect(resolveFormat({ output: "table" }, "mutating")).toBe("human");
+  });
+  it("maps universal table -> inline for streaming", () => {
+    expect(resolveFormat({ output: "table" }, "streaming")).toBe("inline");
+  });
+  it("accepts yaml for reads", () => {
+    expect(resolveFormat({ output: "yaml" }, "read")).toBe("yaml");
+  });
+  it("is case-insensitive", () => {
+    expect(resolveFormat({ output: "JSON" }, "read")).toBe("json");
+  });
+  it("rejects an unknown universal value", () => {
+    expect(() => resolveFormat({ output: "xml" }, "read")).toThrow(/invalid --output value/);
+  });
+  it("rejects yaml for mutations (unsupported by the class)", () => {
+    expect(() => resolveFormat({ output: "yaml" }, "mutating")).toThrow(/not supported/);
+  });
+});
+
+describe("supportedFormats", () => {
+  it("lists the universal values each class supports", () => {
+    expect(supportedFormats("read")).toEqual(["table", "json", "yaml"]);
+    expect(supportedFormats("mutating")).toEqual(["table", "json"]);
+    expect(supportedFormats("streaming")).toEqual(["table", "json", "ndjson"]);
+  });
+});

package/src/output/format.ts

@@ -0,0 +1,101 @@
+// Unified output-format resolution.
+//
+// The Go CLI grew three inconsistent output conventions (D-CLI-2): reads used
+// `-o table|json|yaml`, mutations used `--json`/`--quiet`, and streaming used
+// `--json` for NDJSON. The TS CLI unifies the *surface* on a single
+// `-o/--output` flag with one universal vocabulary — table | json | yaml |
+// ndjson — and keeps `--json`/`--quiet` as back-compat aliases.
+//
+// The *meaning* of each universal value adapts to the command's class so a
+// single mental model ("json = machine-readable") works everywhere:
+//
+//   universal | read   | mutating | streaming
+//   ----------|--------|----------|----------
+//   table     | table  | human    | inline
+//   json      | json   | json     | ndjson
+//   yaml      | yaml   | —        | —
+//   ndjson    | —      | —        | ndjson
+//   --json    | json   | json     | ndjson
+//   --quiet   | —      | quiet    | —
+
+import { UsageError } from "../errors/usage-error.js";
+
+/** Internal format the renderers consume, after class-aware resolution. */
+export type OutputFormat = "table" | "json" | "yaml" | "human" | "quiet" | "ndjson" | "inline";
+
+/** Output behavior class a command belongs to. */
+export type CommandClass = "read" | "mutating" | "streaming";
+
+/** Raw output-selection flags as parsed from the command line. */
+export interface OutputFlags {
+  readonly output?: string;
+  readonly json?: boolean;
+  readonly quiet?: boolean;
+}
+
+const UNIVERSAL_FORMATS = ["table", "json", "yaml", "ndjson"] as const;
+type UniversalFormat = (typeof UNIVERSAL_FORMATS)[number];
+
+// Maps the universal vocabulary onto each class's internal renderer format.
+// A missing entry means that universal value is not supported by the class.
+const CLASS_FORMAT_MAP: Record<CommandClass, Partial<Record<UniversalFormat, OutputFormat>>> = {
+  read: { table: "table", json: "json", yaml: "yaml" },
+  mutating: { table: "human", json: "json" },
+  streaming: { table: "inline", json: "ndjson", ndjson: "ndjson" },
+};
+
+const DEFAULT_FORMAT: Record<CommandClass, OutputFormat> = {
+  read: "table",
+  mutating: "human",
+  streaming: "inline",
+};
+
+/**
+ * Resolve the explicit/alias output flags into a single renderer format,
+ * honoring the command class's defaults and supported values. Throws a
+ * UsageError (exit code 2) on conflicting or unsupported selections.
+ */
+export function resolveFormat(flags: OutputFlags, commandClass: CommandClass): OutputFormat {
+  if (flags.json === true && flags.quiet === true) {
+    throw new UsageError("--json and --quiet cannot be used together");
+  }
+
+  if (flags.output !== undefined && flags.output !== "") {
+    return resolveExplicit(flags.output, commandClass);
+  }
+
+  if (flags.quiet === true) {
+    return "quiet";
+  }
+
+  if (flags.json === true) {
+    return CLASS_FORMAT_MAP[commandClass].json ?? "json";
+  }
+
+  return DEFAULT_FORMAT[commandClass];
+}
+
+function resolveExplicit(raw: string, commandClass: CommandClass): OutputFormat {
+  const value = raw.toLowerCase();
+  if (!isUniversalFormat(value)) {
+    throw new UsageError(
+      `invalid --output value "${raw}" (expected one of: ${UNIVERSAL_FORMATS.join(", ")})`,
+    );
+  }
+  const mapped = CLASS_FORMAT_MAP[commandClass][value];
+  if (mapped === undefined) {
+    throw new UsageError(
+      `--output ${value} is not supported by this command (supported: ${supportedFormats(commandClass).join(", ")})`,
+    );
+  }
+  return mapped;
+}
+
+/** The universal output values a given command class supports, for help/errors. */
+export function supportedFormats(commandClass: CommandClass): UniversalFormat[] {
+  return UNIVERSAL_FORMATS.filter((value) => CLASS_FORMAT_MAP[commandClass][value] !== undefined);
+}
+
+function isUniversalFormat(value: string): value is UniversalFormat {
+  return (UNIVERSAL_FORMATS as readonly string[]).includes(value);
+}

package/src/output/index.ts

@@ -0,0 +1,30 @@
+// Public surface of the CLI output module.
+
+export {
+  type CommandClass,
+  type OutputFlags,
+  type OutputFormat,
+  resolveFormat,
+  supportedFormats,
+} from "./format.js";
+export {
+  protoToJsonValue,
+  renderProtoJson,
+  renderProtoListJson,
+  renderProtoListYaml,
+  renderProtoYaml,
+} from "./proto.js";
+export { renderEmpty, renderTable } from "./table.js";
+export {
+  CommandResult,
+  type KeyValue,
+  renderResult,
+  type ResultStatus,
+  type ResultStreams,
+  resultToHuman,
+  resultToJson,
+  resultToQuiet,
+  Section,
+} from "./command-result.js";
+export { type NdjsonEvent, ndjsonLine, writeNdjson } from "./ndjson.js";
+export { shouldColorize, type Styler, styler } from "./style.js";

package/src/output/ndjson.ts

@@ -0,0 +1,55 @@
+// NDJSON envelope + writer for streaming commands (run/resume/draft).
+//
+// The wire shape mirrors the Go CLI's run --json output (run_stream_json.go):
+// every line is a `{type, ts, payload}` object, and the payload is cleaned of
+// nil/empty-string fields before encoding. This module owns the *formatting*;
+// the Event→{type, payload} mapping lives in resources/stream/render-ndjson.ts.
+
+export interface NdjsonEvent {
+  readonly type: string;
+  readonly [key: string]: unknown;
+}
+
+/** The Go-parity envelope: a typed event with a timestamp and cleaned payload. */
+export interface NdjsonEnvelope extends NdjsonEvent {
+  readonly ts: string;
+  readonly payload: Record<string, unknown>;
+}
+
+/** Serialize a single NDJSON event (one compact JSON object + newline). */
+export function ndjsonLine(event: NdjsonEvent): string {
+  return JSON.stringify(event) + "\n";
+}
+
+/** Write a single NDJSON event to the given stream. */
+export function writeNdjson(out: { write(chunk: string): unknown }, event: NdjsonEvent): void {
+  out.write(ndjsonLine(event));
+}
+
+/**
+ * Build a `{type, ts, payload}` envelope, cleaning the payload exactly like Go's
+ * writeJSONEvent: drop `undefined`/`null` and empty-string fields, but keep
+ * `false` and `0`. `now` is injectable for deterministic tests.
+ */
+export function ndjsonEnvelope(
+  type: string,
+  payload: Record<string, unknown>,
+  now: () => string = defaultTimestamp,
+): NdjsonEnvelope {
+  return { type, ts: now(), payload: cleanNdjsonPayload(payload) };
+}
+
+/** Drop nil and empty-string entries from a payload (booleans/numbers survive). */
+export function cleanNdjsonPayload(payload: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(payload)) {
+    if (value === undefined || value === null) continue;
+    if (typeof value === "string" && value === "") continue;
+    out[key] = value;
+  }
+  return out;
+}
+
+function defaultTimestamp(): string {
+  return new Date().toISOString();
+}

package/src/output/proto.test.ts

@@ -0,0 +1,72 @@
+import { create } from "@bufbuild/protobuf";
+import { ApiResourceKindMetaSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+import { parse as parseYaml } from "yaml";
+import { describe, expect, it } from "vitest";
+import {
+  protoToJsonValue,
+  renderProtoJson,
+  renderProtoListJson,
+  renderProtoListYaml,
+  renderProtoYaml,
+} from "./proto.js";
+
+// A small, stable generated message exercising snake_case fields (display_name,
+// id_prefix, is_versioned) and default-omission (group/version/tier enums = 0).
+function sampleMeta() {
+  return create(ApiResourceKindMetaSchema, {
+    name: "Agent",
+    displayName: "Agent",
+    idPrefix: "agt",
+    isVersioned: true,
+  });
+}
+
+describe("renderProtoJson — protojson parity", () => {
+  it("uses proto (snake_case) field names", () => {
+    const parsed = JSON.parse(renderProtoJson(ApiResourceKindMetaSchema, sampleMeta()));
+    expect(parsed).toEqual({
+      name: "Agent",
+      display_name: "Agent",
+      id_prefix: "agt",
+      is_versioned: true,
+    });
+  });
+
+  it("omits unpopulated (default-valued) fields", () => {
+    const parsed = JSON.parse(renderProtoJson(ApiResourceKindMetaSchema, sampleMeta()));
+    expect(parsed).not.toHaveProperty("group");
+    expect(parsed).not.toHaveProperty("tier");
+    expect(parsed).not.toHaveProperty("authorization");
+  });
+
+  it("pretty-prints with a trailing newline", () => {
+    const rendered = renderProtoJson(ApiResourceKindMetaSchema, sampleMeta());
+    expect(rendered.endsWith("\n")).toBe(true);
+    expect(rendered).toContain('  "name": "Agent"');
+  });
+});
+
+describe("renderProtoYaml — round-trips through the same JSON value", () => {
+  it("yields the same field names and values as the JSON renderer", () => {
+    const meta = sampleMeta();
+    const fromYaml = parseYaml(renderProtoYaml(ApiResourceKindMetaSchema, meta));
+    expect(fromYaml).toEqual(protoToJsonValue(ApiResourceKindMetaSchema, meta));
+  });
+});
+
+describe("list renderers", () => {
+  it("renders a JSON array of messages", () => {
+    const parsed = JSON.parse(
+      renderProtoListJson(ApiResourceKindMetaSchema, [sampleMeta(), sampleMeta()]),
+    );
+    expect(Array.isArray(parsed)).toBe(true);
+    expect(parsed).toHaveLength(2);
+    expect(parsed[0].id_prefix).toBe("agt");
+  });
+
+  it("renders a YAML array equal to the JSON-value array", () => {
+    const items = [sampleMeta()];
+    const fromYaml = parseYaml(renderProtoListYaml(ApiResourceKindMetaSchema, items));
+    expect(fromYaml).toEqual(items.map((m) => protoToJsonValue(ApiResourceKindMetaSchema, m)));
+  });
+});

package/src/output/proto.ts

@@ -0,0 +1,55 @@
+// Canonical protobuf -> JSON/YAML rendering for read verbs.
+//
+// Parity contract (mirrors Go pkg/display/proto.go and mcp-server marshal.ts):
+// the Go CLI emits protojson with UseProtoNames=true and EmitUnpopulated=false,
+// 2-space indented. protobuf-es `toJson` with { useProtoFieldName: true }
+// reproduces that exactly — snake_case fields, omitted defaults, base64 bytes,
+// string enums, RFC-3339 timestamps — and the YAML path round-trips through the
+// same JSON value so field naming stays identical.
+
+import { type DescMessage, type JsonValue, type MessageShape, toJson } from "@bufbuild/protobuf";
+import { stringify as toYaml } from "yaml";
+
+const JSON_WRITE_OPTIONS = { useProtoFieldName: true } as const;
+
+/** Proto -> protojson JsonValue (snake_case fields, omitted defaults). */
+export function protoToJsonValue<Desc extends DescMessage>(
+  schema: Desc,
+  message: MessageShape<Desc>,
+): JsonValue {
+  return toJson(schema, message, JSON_WRITE_OPTIONS);
+}
+
+/** Render a single proto message as pretty JSON, newline-terminated. */
+export function renderProtoJson<Desc extends DescMessage>(
+  schema: Desc,
+  message: MessageShape<Desc>,
+): string {
+  return JSON.stringify(protoToJsonValue(schema, message), null, 2) + "\n";
+}
+
+/** Render a single proto message as YAML. */
+export function renderProtoYaml<Desc extends DescMessage>(
+  schema: Desc,
+  message: MessageShape<Desc>,
+): string {
+  return toYaml(protoToJsonValue(schema, message));
+}
+
+/** Render a list of proto messages as a pretty JSON array, newline-terminated. */
+export function renderProtoListJson<Desc extends DescMessage>(
+  schema: Desc,
+  messages: readonly MessageShape<Desc>[],
+): string {
+  const array = messages.map((message) => protoToJsonValue(schema, message));
+  return JSON.stringify(array, null, 2) + "\n";
+}
+
+/** Render a list of proto messages as a YAML array. */
+export function renderProtoListYaml<Desc extends DescMessage>(
+  schema: Desc,
+  messages: readonly MessageShape<Desc>[],
+): string {
+  const array = messages.map((message) => protoToJsonValue(schema, message));
+  return toYaml(array);
+}