output

type AutoFormatter ¶

type AutoFormatter struct{}

AutoFormatter writes the response body in the default human-friendly format. It does not write status or headers; callers that want interactive HTTP context should print those parts explicitly before rendering the body.

func (f *AutoFormatter) Format(w io.Writer, resp *Response, color bool) error

func (f *AutoFormatter) StartFramedValueStream(w io.Writer, base *Response, color bool, frame FramedValueTemplate) (ValueStream, error)

func (f *AutoFormatter) StartValueStream(w io.Writer, base *Response, color bool) (ValueStream, error)

type CBORFormatter ¶

type CBORFormatter struct{}

CBORFormatter encodes the response body as CBOR and writes the raw bytes to stdout. Useful for feeding binary-safe pipelines.

func (f *CBORFormatter) Format(w io.Writer, resp *Response, color bool) error

type Formatter ¶

type Formatter interface {
	Format(w io.Writer, resp *Response, color bool) error
}

Formatter renders a normalized Response to a writer. color indicates whether ANSI escape sequences are appropriate.

type FramedValueStreamFormatter ¶

type FramedValueStreamFormatter interface {
	StartFramedValueStream(w io.Writer, base *Response, color bool, frame FramedValueTemplate) (ValueStream, error)
}

FramedValueStreamFormatter can render a sequence of body/sub-values into a larger framed document shape such as a JSON array inside an object.

type FramedValueTemplate ¶

type FramedValueTemplate struct {
	Prefix      string
	Suffix      string
	ItemIndent  string
	CloseIndent string
}

FramedValueTemplate describes how a streamed sequence of values should be embedded into a larger JSON document shape.

type GronFormatter ¶

type GronFormatter struct{}

GronFormatter renders the body as "gron" format: each leaf value on its own line as `json.<path> = <value>;`. Useful for grep-friendly output.

func (f *GronFormatter) Format(w io.Writer, resp *Response, color bool) error

type ImageFormatter ¶

type ImageFormatter struct{}

ImageFormatter renders image/* responses inline on a TTY using the best available terminal graphics protocol.

Protocol is selected in order:

1. $RSH_IMAGE_PROTOCOL env var (kitty | iterm2 | halfblock)
2. Terminal env vars ($KITTY_WINDOW_ID / $TERM=xterm-kitty → Kitty; $TERM_PROGRAM ∈ {iTerm.app, WezTerm, Hyper} → iTerm2)
3. Unicode half-block fallback

When color is false (non-TTY), raw bytes are written unchanged.

func (f *ImageFormatter) Format(w io.Writer, resp *Response, color bool) error

type JSONFormatter ¶

type JSONFormatter struct{}

JSONFormatter writes only the response body as indented JSON. This is the default format in non-interactive (pipe/file) mode.

func (f *JSONFormatter) Format(w io.Writer, resp *Response, color bool) error

type LinesFormatter ¶

type LinesFormatter struct{}

LinesFormatter renders scalar values as shell-friendly text, one value per line. Structured values are rejected so callers do not accidentally lose object or array shape.

func (f *LinesFormatter) Format(w io.Writer, resp *Response, color bool) error

func (f *LinesFormatter) FormatValue(w io.Writer, value any, color bool) error

func (f *LinesFormatter) StartValueStream(w io.Writer, base *Response, color bool) (ValueStream, error)

type NDJSONFormatter ¶

type NDJSONFormatter struct{}

NDJSONFormatter renders one JSON value per line. This is the explicit record-oriented formatter for paginated item streams and event streams.

func (f *NDJSONFormatter) Format(w io.Writer, resp *Response, color bool) error

func (f *NDJSONFormatter) FormatValue(w io.Writer, value any, color bool) error

func (f *NDJSONFormatter) StartValueStream(w io.Writer, base *Response, color bool) (ValueStream, error)

type PluginFormatter ¶

type PluginFormatter struct {
	PluginPath string
	FormatName string
	Context    context.Context
}

PluginFormatter is an output.Formatter backed by a hook plugin. The plugin receives a short formatter session over CBOR on stdin and writes its formatted output directly to stdout (raw bytes, no CBOR reply framing).

func (f *PluginFormatter) Format(w io.Writer, resp *Response, color bool) error

func (f *PluginFormatter) FormatValue(w io.Writer, value any, color bool) error

func (f *PluginFormatter) StartValueStream(w io.Writer, base *Response, color bool) (ValueStream, error)

type Response ¶

type Response struct {
	Proto   string              `json:"proto"`
	Status  int                 `json:"status"`
	Headers map[string][]string `json:"headers"`
	// URL is the final response URL. It is used for presentation concerns such
	// as syntax highlighting file-like text responses by extension.
	URL string `json:"-"`
	// Links is populated by hypermedia parsers; empty until then.
	Links map[string]any `json:"links,omitempty"`
	Body  any            `json:"body"`
	// Raw holds the unformatted response body after Content-Encoding
	// decompression. Used by raw CLI output and binary/content-aware formatters
	// to write body bytes without formatter re-encoding.
	Raw []byte `json:"-"`
}

Response is the normalized form of every HTTP response before formatting. All formatters receive this struct; nothing downstream touches *http.Response.

func Normalize(resp *http.Response, reg *content.Registry, maxBytes int64) (*Response, error)

type TOONFormatter ¶ added in v2.2.0

type TOONFormatter struct{}

TOONFormatter renders the response body as Token-Oriented Object Notation (TOON), a compact, indentation-based encoding of the JSON data model designed to reduce token usage when structured data is fed to large language models.

This is an output-only encoder pinned to TOON spec v3.3 (https://github.com/toon-format/spec). It uses the default comma delimiter and two-space indentation. Map-backed object keys, including tabular field names derived from maps, are emitted in sorted order so normal Restish output is deterministic.

TOON's largest savings come from uniform arrays of flat, primitive-valued objects, which collapse into a tabular form that declares field names once and then streams rows. Non-uniform or nested arrays fall back to an expanded dash-marked list, and deeply nested or irregular data saves little versus JSON.

func (f *TOONFormatter) Format(w io.Writer, resp *Response, color bool) error

func (f *TOONFormatter) FormatValue(w io.Writer, value any, color bool) error

type TableFormatter ¶

type TableFormatter struct {
	// Columns is the ordered list of column names to display. When empty,
	// all keys found in the first row are used.
	Columns []string
	// SortBy is an optional column name to sort rows by ascending value.
	// Numeric cells sort numerically; other cells sort by display string.
	SortBy string
}

TableFormatter renders an array of objects as a Unicode box-drawing table. Non-array or non-object body values are formatted as plain JSON.

func (f *TableFormatter) Format(w io.Writer, resp *Response, color bool) error

type ThemeEntries ¶

type ThemeEntries map[string]string

ThemeEntries maps token names to Chroma style descriptors. Token names may be Chroma token type names (for example, "NameTag") or Restish aliases such as "key", "header_key", "keyword", "url", and "status_2xx".

func ParseThemeJSON(data []byte) (ThemeEntries, error)

type ValueFormatter ¶

type ValueFormatter interface {
	FormatValue(w io.Writer, value any, color bool) error
}

ValueFormatter renders a body/sub-value without implying that it is a full HTTP response. This is used for filtered values, paginated item streams, and event streams where status/header preambles would be misleading.

type ValueStream ¶

type ValueStream interface {
	WriteValue(value any) error
	Close() error
}

ValueStream receives a sequence of body/sub-values for a single logical output session.

type ValueStreamFormatter ¶

type ValueStreamFormatter interface {
	StartValueStream(w io.Writer, base *Response, color bool) (ValueStream, error)
}

ValueStreamFormatter can hold formatter-specific state across a stream of body/sub-values, such as writing one CSV header followed by many rows.

type YAMLFormatter ¶

type YAMLFormatter struct{}

YAMLFormatter serialises the response body as YAML.

func (f *YAMLFormatter) Format(w io.Writer, resp *Response, color bool) error

func (f *YAMLFormatter) FormatValue(w io.Writer, value any, color bool) error