@ttctl/cli 0.0.0 → 0.1.0-rc.1

package/dist/lib/envelopes.d.ts

@@ -0,0 +1,540 @@
+import type { DryRunPreview, WireShapeDiffEntry } from "@ttctl/core";
+import type { OutputFormat } from "./output.js";
+export type { WireShapeDiffEntry };
+/**
+ * Cross-CLI envelope ABI (#128) — discriminated-union wire shape for
+ * write-success and error responses, plus the top-level list envelope.
+ *
+ * The envelope locks the public-API contract for the JSON output:
+ * pre-`v1.0` (`0.x`) signals "expect breaking changes"; `v1.0` onward,
+ * any JSON shape change is a breaking-change release (semver-major).
+ *
+ * Discriminators:
+ *
+ * - `ok: true | false` separates success from error.
+ * - `operation: string` (e.g., `"profile.skills.add"`) identifies the
+ *   verb so consumers can branch without parsing the command path.
+ * - For success: `created` / `updated` / `removed` field name selects
+ *   the verb (add / update / remove respectively). Mutually exclusive.
+ * - For errors: `errors[]` is ALWAYS plural — even single-error cases
+ *   ship a 1-element array so consumers don't branch on 1-vs-N shape.
+ *
+ * Routing (per `emitErrorAndExit`):
+ *
+ * - `--output=json` errors → STDOUT (machine consumers read structured
+ *   payload regardless of exit code).
+ * - `--output=yaml` errors → STDOUT (same reasoning).
+ * - `--output=pretty` errors → STDERR human-formatted block; STDOUT
+ *   stays clean.
+ * - Exit code is nonzero on error in all formats; `0` on success.
+ *
+ * The version string is hard-coded `"1.0"` here. Bumping to `"1.1"`
+ * signals an additive (non-breaking) change; bumping to `"2.0"`
+ * signals a breaking change — both are forward-evolution levers
+ * consumers may discriminate on.
+ */
+export declare const ENVELOPE_VERSION: "1.0";
+/**
+ * One field-level diff entry for the `update` envelope's optional
+ * `changes` array. v0.4 ships the type but does NOT thread `changes`
+ * through the helpers — populating the `from` value requires a
+ * pre-mutation read or a server-returned old-state shape that the core
+ * layer does not surface today. The shape is reserved so adding it in
+ * a future release is non-breaking (additive).
+ *
+ * `from` and `to` are kept as `unknown` because the diff is shallow
+ * across heterogeneous field types (numbers, strings, booleans, null);
+ * narrowing belongs to the consumer.
+ */
+export interface EnvelopeChange {
+    field: string;
+    from: unknown;
+    to: unknown;
+}
+/**
+ * One entry in the error envelope's plural `errors[]` array. `code` is
+ * a stable machine-readable token (`VALIDATION_ERROR`, `NO_VIEWER`,
+ * `CF_403_PERSISTENT`, …). `message` is human-readable. `field`,
+ * `hint`, `documentationUrl` are optional — `documentationUrl` is
+ * reserved for v1.0+ when the error doc URLs exist; v0.4 omits.
+ *
+ * `diff?` is the additive slot reserved for `WIRE_SHAPE_ERROR` (Z-3 /
+ * #286): each entry is a `WireShapeDiffEntry` per
+ * `docs/wire-validation-error-format.md`. Populated only when `code`
+ * is `"WIRE_SHAPE_ERROR"`; absent for every other code. Adding this
+ * optional field is non-breaking under `ENVELOPE_VERSION = "1.0"`
+ * (additive — sibling slot to `documentationUrl?`). The single-valued
+ * `field?` slot keeps its meaning for non-wire-shape errors; the two
+ * are mutually-exclusive in practice but the wire shape doesn't
+ * enforce it.
+ */
+export interface EnvelopeError {
+    code: string;
+    field?: string;
+    message: string;
+    hint?: string;
+    documentationUrl?: string;
+    diff?: WireShapeDiffEntry[];
+}
+/**
+ * Offset-style pagination metadata block for the top-level list
+ * envelope. Activated by #138 (the wiring issue for the reservation
+ * #128 introduced).
+ *
+ * Shape decision (#138 user decision 2026-05-12): the CLI's
+ * `--page` / `--per-page` flags are 1-indexed offset-style; the wire
+ * across Toptal surfaces is heterogeneous (page-based
+ * `eligibleJobs(page, pageSize)`, offset wrapped
+ * `gigs(pagination: {limit, offset})`, cursor
+ * `payments(pagination: {limit, after})`), but the user-facing
+ * envelope normalises to offset-style metadata for predictable
+ * scripting.
+ *
+ * All fields are optional so commands whose wire ops report only a
+ * subset (e.g., a cursor-style backend that doesn't expose
+ * `totalCount`) can populate the fields they have without padding the
+ * rest. A list response with `pageInfo` omitted entirely signals "no
+ * pagination metadata available" (e.g., a wire op that returns all
+ * entities in one go).
+ *
+ * Pre-#138 the reservation was cursor-style (`{hasNextPage?,
+ * endCursor?}`) — never populated in v0.4. The reshape is
+ * forward-evolution under `ENVELOPE_VERSION = "1.0"` (pre-1.0 the
+ * envelope explicitly signals "expect breaking changes").
+ */
+export interface EnvelopePageInfo {
+    /** 1-indexed page number the server returned. */
+    currentPage?: number;
+    /** Items per page the server actually applied. May differ from the
+     * client request when the server enforces a cap. */
+    perPage?: number;
+    /** Total pages, derived from `totalCount / perPage` (rounded up).
+     * Omitted when the server doesn't expose `totalCount`. */
+    totalPages?: number;
+    /** True when at least one more page is available after the current
+     * page; false when the current page is the last (or the only) one. */
+    hasNextPage?: boolean;
+}
+/**
+ * Discriminated success envelope for `add`. The `created` field carries
+ * the full payload of the new entity (or the post-mutation list, for
+ * sub-domains where the core API returns the full list — visas /
+ * portfolio in v0.4 — until per-domain narrowing lands in a follow-up).
+ */
+export interface SuccessEnvelopeAdd<T> {
+    ok: true;
+    version: typeof ENVELOPE_VERSION;
+    operation: string;
+    created: T;
+    notice?: string;
+}
+/**
+ * Discriminated success envelope for `update`. `changes?` is reserved
+ * (v0.4 omits — see `EnvelopeChange` doc).
+ */
+export interface SuccessEnvelopeUpdate<T> {
+    ok: true;
+    version: typeof ENVELOPE_VERSION;
+    operation: string;
+    updated: T;
+    changes?: EnvelopeChange[];
+    notice?: string;
+}
+/**
+ * Discriminated success envelope for `remove`. `removed.id` is the
+ * server-issued identifier of the now-deleted entity; the helper
+ * derives it from the caller's input so the envelope shape is stable
+ * regardless of whether the core API returns void, an id, or a
+ * post-mutation list.
+ */
+export interface SuccessEnvelopeRemove {
+    ok: true;
+    version: typeof ENVELOPE_VERSION;
+    operation: string;
+    removed: {
+        id: string;
+    };
+    notice?: string;
+}
+/**
+ * Error envelope. Always `ok: false`; `errors[]` is ALWAYS plural even
+ * for single-error cases.
+ */
+export interface ErrorEnvelope {
+    ok: false;
+    version: typeof ENVELOPE_VERSION;
+    operation: string;
+    errors: EnvelopeError[];
+}
+/**
+ * Top-level list envelope for `list` verbs. The `items` field carries
+ * the array; `pageInfo?` carries offset-style pagination metadata when
+ * the underlying wire op supplied any (activated in #138). Commands
+ * whose wire op has no pagination args still emit `{version, items}`
+ * with no `pageInfo` field.
+ */
+export interface ListEnvelope<T> {
+    version: typeof ENVELOPE_VERSION;
+    items: T[];
+    pageInfo?: EnvelopePageInfo;
+}
+/**
+ * Wrap an array as the v0.4+ list envelope (`{version, items,
+ * pageInfo?}`). The `version` field is required (locked at `"1.0"`)
+ * so wire consumers can branch on the envelope shape uniformly across
+ * success / error / list payloads.
+ *
+ * When `pageInfo` is supplied (by a paginated command's action
+ * handler after threading `--page` / `--per-page` through to the
+ * service layer), it's included verbatim. When omitted (by a list
+ * command whose wire op has no pagination args, OR when the user
+ * passes no flags and the server returns no metadata), the envelope
+ * surfaces `{version, items}` only.
+ *
+ * The empty-state wrapper from #122 (`isEmptyCollection` in
+ * `lib/empty-state-cta.ts`) detects both raw `[]` AND `{items: []}` —
+ * wrapping list output through this helper keeps the empty-state
+ * behavior unchanged on json/yaml.
+ *
+ * Pure — no I/O.
+ */
+export declare function wrapListEnvelope<T>(items: T[], pageInfo?: EnvelopePageInfo): ListEnvelope<T>;
+/**
+ * Pretty success-line marker. The visible glyph is a heavy check
+ * (`✓`); kept in a constant so tests can assert on it without
+ * duplicating Unicode escapes across snapshots.
+ */
+export declare const PRETTY_SUCCESS_PREFIX = "\u2713";
+/**
+ * Stringify the JSON success-add envelope (single-line, no extra
+ * whitespace — matches `formatResult` json branch). Exposed for tests.
+ */
+export declare function formatAddJson<T>(envelope: SuccessEnvelopeAdd<T>): string;
+/**
+ * Stringify the YAML success-add envelope as block-style YAML via
+ * `formatYaml`. Exposed for tests.
+ */
+export declare function formatAddYaml<T>(envelope: SuccessEnvelopeAdd<T>): string;
+/**
+ * Stringify the JSON success-update envelope. Exposed for tests.
+ */
+export declare function formatUpdateJson<T>(envelope: SuccessEnvelopeUpdate<T>): string;
+/**
+ * Stringify the YAML success-update envelope. Exposed for tests.
+ */
+export declare function formatUpdateYaml<T>(envelope: SuccessEnvelopeUpdate<T>): string;
+/**
+ * Stringify the JSON success-remove envelope. Exposed for tests.
+ */
+export declare function formatRemoveJson(envelope: SuccessEnvelopeRemove): string;
+/**
+ * Stringify the YAML success-remove envelope. Exposed for tests.
+ */
+export declare function formatRemoveYaml(envelope: SuccessEnvelopeRemove): string;
+/**
+ * Stringify the JSON error envelope. Exposed for tests.
+ */
+export declare function formatErrorJson(envelope: ErrorEnvelope): string;
+/**
+ * Stringify the YAML error envelope. Exposed for tests.
+ */
+export declare function formatErrorYaml(envelope: ErrorEnvelope): string;
+/**
+ * Build the pretty-format rendering of a success-add envelope:
+ *
+ *     ✓ Added: <prettySummary>
+ *       <prettyEntity-line-1>
+ *       <prettyEntity-line-2>
+ *       …
+ *
+ * `prettyEntity` is OPTIONAL — when omitted the output is just the
+ * single-line summary. `notice` (when present) appears on its own
+ * trailing line, also indented.
+ *
+ * Pure — directly unit-testable.
+ */
+export declare function formatAddPretty<T>(args: {
+    prettySummary: string;
+    prettyEntity?: ((entity: T) => string) | undefined;
+    entity: T;
+    notice?: string | undefined;
+}): string;
+/**
+ * Build the pretty-format rendering of a success-update envelope.
+ * Mirror of `formatAddPretty` with an "Updated:" header. v0.4 does NOT
+ * render the `changes` diff (the deep comparison is out of scope per
+ * #128 caller context); the field is reserved on the JSON/YAML wire
+ * shape only.
+ */
+export declare function formatUpdatePretty<T>(args: {
+    prettySummary: string;
+    prettyEntity?: ((entity: T) => string) | undefined;
+    entity: T;
+    notice?: string | undefined;
+}): string;
+/**
+ * Build the pretty-format rendering of a success-remove envelope:
+ *
+ *     ✓ Removed: <prettySummary or id>
+ *
+ * The summary defaults to the bare id when no `prettySummary` is
+ * supplied; callers that have the entity name handy (post-fetch) can
+ * pass a richer line like `"sk_abc123 (TypeScript)"`.
+ */
+export declare function formatRemovePretty(args: {
+    id: string;
+    prettySummary?: string | undefined;
+    notice?: string | undefined;
+}): string;
+/**
+ * Maximum number of diff entries rendered in the pretty form of a
+ * `WIRE_SHAPE_ERROR` (per `docs/wire-validation-error-format.md`
+ * § `-o pretty`). The JSON / YAML wire shapes carry the full list;
+ * only the human-readable rendering caps to keep terminal output
+ * scannable. When the diff exceeds the cap, a `… and <K> more` line
+ * tells the operator where to look for the full data.
+ */
+export declare const WIRE_SHAPE_DIFF_PRETTY_CAP = 10;
+/**
+ * Build the pretty-format rendering of an error envelope. Each error
+ * surfaces as its own block; `field` and `hint` annotate the message
+ * when present.
+ *
+ *     Error: <message-1>
+ *       (Code: <code-1>)
+ *       (Field: <field-1>)
+ *       Diff (schema vs wire):
+ *         <op> <path>: expected <expected>, got <actual> [("<value>")]
+ *         …
+ *       Hint: <hint-1>
+ *
+ *     Error: <message-2>
+ *       …
+ *
+ * The format is symmetric with `formatTtctlErrorMessage` from
+ * `errors.ts` (used for the typed-hierarchy `TtctlError` block) — same
+ * `Error: …` prefix, same parenthesised metadata. The recovery line
+ * from `TtctlError` does not have a generic equivalent here; callers
+ * convert to `hint` if a recovery sentence is available.
+ *
+ * `WIRE_SHAPE_ERROR` (Z-3 / #286) carries a `diff` field — when
+ * present, the pretty form renders a `Diff (schema vs wire):` block
+ * before the `Hint:` footer per
+ * `docs/wire-validation-error-format.md` § `-o pretty`. Capped at
+ * {@link WIRE_SHAPE_DIFF_PRETTY_CAP} entries; overflow renders a
+ * `… and <K> more …` line pointing at `-o json` for the full diff.
+ */
+export declare function formatErrorPretty(envelope: ErrorEnvelope): string;
+/**
+ * One-line stderr summary for the pretty error path. The AC requires
+ * a "one-line stderr summary" alongside the multi-line block — when
+ * stdout is structured (json/yaml) the summary is omitted because the
+ * structured payload IS the summary.
+ *
+ * Defaults to `Error: <first-error.message>` when the caller does not
+ * pass an explicit summary. Useful when piping the multi-line block
+ * elsewhere but still wanting a glance-readable single line on the
+ * terminal.
+ */
+export declare function defaultPrettyErrorSummary(envelope: ErrorEnvelope): string;
+/**
+ * Build the success-add envelope object (pure — no I/O). Shape:
+ * `{ok: true, version: "1.0", operation, created, notice?}`. Exposed
+ * separately from `emitAddSuccess` so callers (and tests) can inspect
+ * the structured shape without going through stdout.
+ */
+export declare function buildAddEnvelope<T>(args: {
+    operation: string;
+    created: T;
+    notice?: string | undefined;
+}): SuccessEnvelopeAdd<T>;
+/**
+ * Build the success-update envelope object (pure — no I/O). Shape:
+ * `{ok: true, version: "1.0", operation, updated, changes?, notice?}`.
+ *
+ * `changes` is reserved (see `EnvelopeChange` doc). Callers do not
+ * thread it through in v0.4; the parameter is preserved for future
+ * extension without an API churn.
+ */
+export declare function buildUpdateEnvelope<T>(args: {
+    operation: string;
+    updated: T;
+    changes?: EnvelopeChange[] | undefined;
+    notice?: string | undefined;
+}): SuccessEnvelopeUpdate<T>;
+/**
+ * Build the success-remove envelope object (pure — no I/O). Shape:
+ * `{ok: true, version: "1.0", operation, removed: {id}, notice?}`.
+ */
+export declare function buildRemoveEnvelope(args: {
+    operation: string;
+    id: string;
+    notice?: string | undefined;
+}): SuccessEnvelopeRemove;
+/**
+ * Build the error envelope object (pure — no I/O). Shape:
+ * `{ok: false, version: "1.0", operation, errors[]}`. `errors` is
+ * normalised to a plural array even for single-error inputs so the
+ * wire shape is stable.
+ */
+export declare function buildErrorEnvelope(args: {
+    operation: string;
+    errors: EnvelopeError[];
+}): ErrorEnvelope;
+/**
+ * Side-effecting emitter for the `add` success envelope. Writes the
+ * per-format payload to stdout with a trailing newline; never throws.
+ *
+ * - `json` → single-line JSON envelope on stdout
+ * - `yaml` → block-style YAML envelope on stdout
+ * - `pretty` → `✓ Added: <summary>` + indented `prettyEntity?` on stdout
+ *
+ * The success path always exits 0 (the helper does not call
+ * `process.exit` — leaves it to the caller / Node's natural exit).
+ */
+export declare function emitAddSuccess<T>(args: {
+    operation: string;
+    format: OutputFormat;
+    created: T;
+    prettySummary: string;
+    prettyEntity?: ((entity: T) => string) | undefined;
+    notice?: string | undefined;
+}): void;
+/**
+ * Side-effecting emitter for the `update` success envelope. Mirror of
+ * `emitAddSuccess` for the update verb.
+ */
+export declare function emitUpdateSuccess<T>(args: {
+    operation: string;
+    format: OutputFormat;
+    updated: T;
+    prettySummary: string;
+    prettyEntity?: ((entity: T) => string) | undefined;
+    changes?: EnvelopeChange[] | undefined;
+    notice?: string | undefined;
+}): void;
+/**
+ * Side-effecting emitter for the `remove` success envelope. The id is
+ * the server-issued identifier of the now-deleted entity (the caller
+ * already knows it from the input or from the API response).
+ */
+export declare function emitRemoveSuccess(args: {
+    operation: string;
+    format: OutputFormat;
+    id: string;
+    prettySummary?: string | undefined;
+    notice?: string | undefined;
+}): void;
+/**
+ * Discriminated success envelope for `--dry-run` (issue #52). Mirrors
+ * the wire shape of {@link SuccessEnvelopeUpdate} (`ok: true, version,
+ * operation, …`) plus a `dryRun: true` discriminator and a `preview`
+ * field carrying the structured "would-have-sent" payload from the
+ * core layer's {@link DryRunPreview}.
+ *
+ * Why a separate envelope variant rather than reusing
+ * `SuccessEnvelopeUpdate`: dry-run is fundamentally a "no-op confirmed"
+ * outcome — there is NO updated entity, only a preview of the request
+ * that WOULD have updated one. Reusing the update envelope would force
+ * `updated: ...` to carry a fake/empty value that downstream consumers
+ * could mistake for a real result. The `dryRun: true` discriminator
+ * makes the no-effect semantics legible at the JSON layer.
+ *
+ * Wire shape: `{ ok, version, operation, dryRun: true, preview: { … } }`
+ * where the `preview` body matches the AC (#52 § Output format under
+ * --dry-run): `{ operation, variables, transport, surface, headers }`
+ * with secrets redacted.
+ */
+export interface SuccessEnvelopeDryRun {
+    ok: true;
+    version: typeof ENVELOPE_VERSION;
+    operation: string;
+    dryRun: true;
+    preview: DryRunPreview;
+    notice?: string;
+}
+/**
+ * Build the dry-run success envelope object (pure — no I/O). Shape:
+ * `{ok: true, version: "1.0", operation, dryRun: true, preview, notice?}`.
+ *
+ * Exposed separately from {@link emitDryRunSuccess} so callers (and
+ * tests) can inspect the structured shape without going through stdout.
+ */
+export declare function buildDryRunEnvelope(args: {
+    operation: string;
+    preview: DryRunPreview;
+    notice?: string | undefined;
+}): SuccessEnvelopeDryRun;
+/**
+ * Stringify the JSON dry-run envelope (single-line, no extra whitespace
+ * — matches `formatResult` json branch). Exposed for tests.
+ */
+export declare function formatDryRunJson(envelope: SuccessEnvelopeDryRun): string;
+/**
+ * Stringify the YAML dry-run envelope as block-style YAML via
+ * `formatYaml`. Exposed for tests.
+ */
+export declare function formatDryRunYaml(envelope: SuccessEnvelopeDryRun): string;
+/**
+ * Build the pretty-format rendering of a dry-run envelope:
+ *
+ *     ✓ Dry run: would call `<operationName>` (no changes sent)
+ *       surface:    <surface> (<transport>)
+ *       endpoint:   <endpoint>
+ *       variables:
+ *         <pretty-printed-JSON, 2-space indented>
+ *       headers:
+ *         authorization: Token token=<redacted>
+ *         <other-header>: <value>
+ *         …
+ *
+ * Pure — directly unit-testable. The output is human-friendly: the
+ * variables block uses `JSON.stringify(_, null, 2)` to give a readable
+ * multi-line shape, while headers list one-per-line so the redacted
+ * `authorization` is obvious at a glance.
+ */
+export declare function formatDryRunPretty(envelope: SuccessEnvelopeDryRun): string;
+/**
+ * Side-effecting emitter for the dry-run success envelope. Mirrors
+ * {@link emitUpdateSuccess} for the dry-run variant — writes the
+ * per-format payload to stdout with a trailing newline; never throws.
+ *
+ * - `json` → single-line JSON envelope on stdout
+ * - `yaml` → block-style YAML envelope on stdout
+ * - `pretty` → multi-line `✓ Dry run: …` block on stdout
+ *
+ * The success path always exits 0 (helper does not call `process.exit`
+ * — leaves it to the caller / Node's natural exit). This matches the
+ * AC: a well-formed dry-run preview exits 0 regardless of whether the
+ * apply-path WOULD have errored at the server level.
+ */
+export declare function emitDryRunSuccess(args: {
+    operation: string;
+    format: OutputFormat;
+    preview: DryRunPreview;
+    notice?: string | undefined;
+}): void;
+/**
+ * Side-effecting error emitter. Routes per format and exits the
+ * process — never returns.
+ *
+ * Routing:
+ *
+ * - `json` / `yaml`: the structured envelope is written to STDOUT (so
+ *   `jq`/`yq` consumers see structured payload regardless of exit
+ *   code). The exit code is nonzero (default `1`).
+ * - `pretty`: a one-line stderr summary is written FIRST, then the
+ *   multi-line human block (also on stderr). STDOUT stays clean.
+ *
+ * Exit code defaults to `1`; callers can pass a different value (e.g.
+ * `2` for transport-level Cloudflare blocks, mirroring
+ * `exitCodeForTtctlError`).
+ */
+export declare function emitErrorAndExit(args: {
+    operation: string;
+    format: OutputFormat;
+    errors: EnvelopeError[];
+    prettySummary?: string | undefined;
+    exitCode?: number;
+}): never;
+//# sourceMappingURL=envelopes.d.ts.map

package/dist/lib/envelopes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelopes.d.ts","sourceRoot":"","sources":["../../src/lib/envelopes.ts"],"names":[],"mappings":"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"}