@getorrery/cells 0.0.0-stage → 0.2.2

package/dist/el/content.d.ts

@@ -0,0 +1,299 @@
+/** List 1 · Content, Tier 2: what the host or an extension puts in a turn — port of `el/content.rs`. */
+import { type Col, type Item, type Line, type Seg, type TRow } from "../cells";
+import { type Block } from "./block";
+/** A line given as runs: `[[text, class], …]`. */
+export type Runs = [string, string][];
+export declare function runs(r: Runs): Line;
+/** One run of text in a style mode. */
+export interface TextItem {
+    value: string;
+    /** `normal`, `dim`, `success`, `warning`, `error`, `accent`; `normal` when absent. */
+    style?: string;
+}
+/** Text nodes, in order. */
+export interface TextView {
+    items: TextItem[];
+    caret?: boolean;
+}
+/** A text node: in mono, success/warning/error gain a `[word]` and accent turns bold. */
+export declare function textLines(it: TextItem, w: number, m: boolean): Line[];
+/** Text nodes, one after another. */
+export declare function text(p: TextView, w: number, m: boolean): Item[];
+/** Markdown, possibly still streaming. */
+export interface MarkdownView {
+    source: string;
+    streaming?: boolean;
+    link?: number | null;
+    dim?: boolean;
+}
+/** Markdown as rows. */
+export declare function markdown(p: MarkdownView, w: number, m: boolean): Item[];
+/** A column. */
+export interface Column {
+    label: string;
+    width: number;
+    align?: string | null;
+    priority?: number;
+    flex?: boolean;
+    trim_left?: boolean;
+}
+/** A cell: text, or `[text, class]`. */
+export type CellV = string | [string, string];
+/** A row. */
+export interface RowV {
+    cells: CellV[];
+    disabled?: boolean;
+}
+/** A table node. */
+export interface TableView {
+    columns: Column[];
+    rows?: RowV[];
+    sort?: [number, boolean] | null;
+    selected?: number | null;
+    column?: number | null;
+    /** `ready`, `loading`, `empty`, `error`; `ready` when absent. */
+    state?: string;
+    note?: string | null;
+    error?: string | null;
+}
+/** The table's columns and rows as the drawing primitive takes them. */
+export declare function tableParts(p: TableView, m: boolean): [Col[], TRow[]];
+/** A table: drops columns by priority; a spinner or a reason under it. */
+export declare function table(p: TableView, w: number, m: boolean): Item[];
+/** A tree node. */
+export interface TreeNodeV {
+    label: string;
+    meta?: string | null;
+    dir?: boolean;
+    expanded?: boolean;
+    children?: TreeNodeV[];
+    /** `ready`, `loading`, `empty`, `error`; `ready` when absent. */
+    state?: string;
+    error?: string | null;
+    disabled?: boolean;
+    selected?: boolean;
+}
+/** A tree node's view. */
+export interface TreeView {
+    nodes: TreeNodeV[];
+}
+/** A tree with `▸ ▾` and `│` guides. */
+export declare function tree(p: TreeView, w: number, m: boolean): Item[];
+/** A diff line. */
+export interface DiffLineV {
+    n: string;
+    sign: string;
+    text: string;
+}
+/** A hunk. */
+export interface HunkV {
+    header: string;
+    context?: string;
+    lines: DiffLineV[];
+}
+/** A file shown as a summary rather than lines. */
+export interface DiffSummary {
+    path: string;
+    note: string;
+}
+/** A diff node. */
+export interface DiffView {
+    path: string;
+    add?: number;
+    del?: number;
+    hunks?: HunkV[];
+    /** `ready`, `streaming`, `empty`, `summary`, `error`; `ready` when absent. */
+    state?: string;
+    selected?: number | null;
+    error?: string | null;
+    summaries?: DiffSummary[];
+}
+/** A class for a diff sign. */
+export declare function signClass(s: string): string;
+/** A diff line: number, sign, text on a tinted band; long lines wrap under a `↪` gutter. */
+export declare function diffLine(n: string, s: string, text: string, w: number, nw: number): Line[];
+/** A unified diff at every width. */
+export declare function diff(p: DiffView, w: number, m: boolean): Item[];
+/** A bar `w` wide: `━` in colour, `[####....]` in mono. */
+export declare function bar(n: number, total: number, w: number, m: boolean, c: string): Line;
+/** A progress node. */
+export interface ProgressView {
+    label: string;
+    done?: number;
+    total?: number | null;
+    /** `running`, `paused`, `error`, `empty`; `running` when absent. */
+    state?: string;
+    note?: string | null;
+    error?: string | null;
+}
+/** Label, bar, `done/total`. */
+export declare function progress(p: ProgressView, w: number, m: boolean): Item[];
+/** A named output channel. */
+export interface StreamView {
+    name: string;
+    /** `stdout` when absent. */
+    channel?: string;
+    /** `running`, `closed`, `error`, `detached`, `empty`; `running` when absent. */
+    state?: string;
+    status?: string;
+    lines?: string[];
+    note?: string | null;
+    selected?: boolean;
+}
+/** Header with state; the tail under a `│`. */
+export declare function stream(p: StreamView, w: number, m: boolean): Item[];
+/** A task item. */
+export interface TaskItemV {
+    text: string;
+    /** `pending`, `active`, `done`, `failed`, `skipped`; `pending` when absent. */
+    state?: string;
+    note?: string | null;
+}
+/** A checklist. */
+export interface TaskView {
+    items?: TaskItemV[];
+    selected?: number | null;
+    working?: string | null;
+}
+/** A task's mark. */
+export declare function tick(state: string, m: boolean): Seg;
+/** A task row: mark, text, note. */
+export declare function taskRow(it: TaskItemV, w: number, m: boolean): Line;
+/** `Tasks n/m` and the items, ticking in place. */
+export declare function task(p: TaskView, w: number, m: boolean): Item[];
+/** A choice. */
+export interface ChoiceV {
+    label: string;
+    hint?: string | null;
+}
+/** How a question was answered, once it was. */
+export interface Answered {
+    prompt: string;
+    answer: string;
+    note?: string | null;
+}
+/** A question. */
+export interface QuestionView {
+    prompt: string;
+    choices?: ChoiceV[];
+    selected?: number;
+    countdown?: string | null;
+    error?: string | null;
+    answered?: Answered | null;
+}
+/** `? prompt`, numbered choices, the default named. */
+export declare function question(p: QuestionView, w: number, m: boolean): Item[];
+/** An option of a select or multi-select field. */
+export interface Opt {
+    label: string;
+    on?: boolean;
+}
+/** A form field. */
+export interface FieldV {
+    label: string;
+    /** `text`, `secret`, `select`, `multi`, `confirm`; `text` when absent. */
+    kind?: string;
+    value?: string;
+    options?: Opt[];
+    placeholder?: string;
+    short?: string | null;
+    error?: string | null;
+}
+/** A form. */
+export interface FormView {
+    fields: FieldV[];
+    focused?: number | null;
+    /** `editing`, `saving`, `disabled`, `sequential`; `editing` when absent. */
+    state?: string;
+    /** `Save` when absent. */
+    submit?: string;
+    busy?: string | null;
+    reason?: string | null;
+}
+/** A secret, masked: a fixed run of dots and the last four. */
+export declare function mask(v: string, dots: number): string;
+/** Every field at once (a label column at ≥60 columns, stacked below), or one question per line in the sequential fallback. */
+export declare function form(p: FormView, w: number, m: boolean): Item[];
+/** {@link form} as lines; `submit` false leaves the submit row off. */
+export declare function formLines(p: FormView, w: number, m: boolean, submit: boolean): Line[];
+/** A titled group of calls. */
+export interface StackView {
+    title: string;
+    count?: string | null;
+    blocks?: Block[];
+}
+/** A rule with the title, then the calls under it. */
+export declare function stack(p: StackView, w: number, m: boolean): Item[];
+/** A list item. */
+export interface ListItemV {
+    label: string;
+    detail?: string;
+    disabled?: boolean;
+}
+/** A navigable list. */
+export interface ListView {
+    items?: ListItemV[];
+    selected?: number;
+    /** `ready`, `loading`, `empty`, `error`, `disabled`; `ready` when absent. */
+    state?: string;
+    note?: string | null;
+    error?: string | null;
+}
+/** `❯` and a band on the cursor; disabled rows dim with their reason. */
+export declare function list(p: ListView, w: number, m: boolean): Item[];
+/** A button. */
+export interface ButtonV {
+    label: string;
+    primary?: boolean;
+    busy?: string | null;
+    disabled?: boolean;
+}
+/** A row of buttons. */
+export interface ButtonView {
+    buttons: ButtonV[];
+    focused?: number | null;
+    pressed?: number | null;
+    error?: string | null;
+    note?: string | null;
+}
+/** `[ Label ]`s; focus fills one with the accent. */
+export declare function button(p: ButtonView, w: number, m: boolean): Item[];
+/** An output line: text, or `[text, class]`. */
+export type OutLine = string | [string, string];
+/** A shell line. */
+export interface CommandView {
+    cmd: string;
+    /** `running`, `ok`, `error`, `blocked`; `running` when absent. */
+    state?: string;
+    status?: string;
+    output?: OutLine[];
+    note?: string | null;
+    selected?: boolean;
+}
+/** `$ command`, the output tail, exit status and time. */
+export declare function command(p: CommandView, w: number, m: boolean): Item[];
+/** A titled group that opens and closes. */
+export interface CollapsibleView {
+    title: string;
+    count?: string;
+    open?: boolean;
+    /** `ready`, `loading`, `empty`, `error`, `disabled`; `ready` when absent. */
+    state?: string;
+    body?: OutLine[];
+    note?: string | null;
+    selected?: boolean;
+}
+/** `▸ Title  count`, one row closed. */
+export declare function collapsible(p: CollapsibleView, w: number, m: boolean): Item[];
+/** An extension's node, drawn by its fallback. */
+export interface CustomView {
+    ns: string;
+    fallback?: Runs[];
+    props?: [string, string][];
+    /** `fallback`, `loading`, `error`, `disabled`; `fallback` when absent. */
+    state?: string;
+    note?: string | null;
+    keys?: string | null;
+}
+/** A dashed box titled with the namespace. */
+export declare function custom(p: CustomView, w: number, m: boolean): Item[];

package/dist/el/context.d.ts

@@ -0,0 +1,99 @@
+/**
+ * List 2 · Context, cost & model: the context meter, `/context`, `/cost`, the
+ * model picker, the compaction marker — port of `el/context.rs`.
+ */
+import { type Item, type Line } from "../cells";
+import { type FooterView } from "./chrome";
+import type { CellV } from "./content";
+/** Rust's `format!("{:.1}", x)`: exact decimal value, ties to even. */
+export declare function fixed1(x: number): string;
+/** A row over the footer: a warning, work in progress, or a failure. */
+export interface Notice {
+    /** `warn`, `busy`, `error`. */
+    kind: string;
+    text: string;
+}
+/** Draw a notice row. */
+export declare function noticeLines(n: Notice, w: number, m: boolean): Line[];
+/** The footer's meter, and the notice above it near the limit. */
+export interface CtxMeterView {
+    footer: FooterView;
+    notice?: Notice | null;
+}
+/** 10 cells in the footer; a notice row at 90%, compaction at 95%. */
+export declare function ctxmeter(p: CtxMeterView, w: number, m: boolean): Item[];
+/** A share of the context window. */
+export interface Part {
+    label: string;
+    letter: string;
+    class: string;
+    /** Thousands of tokens. */
+    k: number;
+}
+/** `/context`. */
+export interface ContextView {
+    title: string;
+    parts: Part[];
+    total: string;
+    /** The window, thousands of tokens; 200 when absent. */
+    limit_k?: number;
+    /** `ready`, `loading`, `error`; `ready` when absent. */
+    state?: string;
+    error?: string | null;
+    filled?: number | null;
+}
+/** A grid of 100 cells, coloured (or lettered) by share, and its legend. */
+export declare function context(p: ContextView, w: number, m: boolean): Item[];
+/** `/cost`. */
+export interface CostView {
+    turns?: CellV[][];
+    models?: CellV[][];
+    session?: string;
+    total?: string;
+    selected?: number | null;
+    /** `ready`, `loading`, `empty`; `ready` when absent. */
+    state?: string;
+    warn?: string | null;
+}
+/** Per turn, per model, session total; unknown prices read `—`. */
+export declare function cost(p: CostView, w: number, m: boolean): Item[];
+/** A model. */
+export interface ModelRow {
+    id: string;
+    caps?: string;
+    ctx?: string;
+    price?: string;
+    blocked?: string | null;
+    /** A dim word after it: `in use`, `not on the server yet`. */
+    note?: string | null;
+}
+/** A provider and its models. */
+export interface ModelGroup {
+    provider: string;
+    status: string;
+    attention?: boolean;
+    models?: ModelRow[];
+    loading?: string | null;
+}
+/** `/model`. */
+export interface ModelsView {
+    groups?: ModelGroup[];
+    selected?: number;
+    effort?: number | null;
+    error?: string | null;
+}
+/** Grouped by provider, capabilities as letters, an effort row under it. */
+export declare function models(p: ModelsView, w: number, m: boolean): Item[];
+/** Where history was summarized. */
+export interface CompactView {
+    /** `done`, `running`, `failed`; `done` when absent. */
+    state?: string;
+    stats?: string;
+    busy?: string | null;
+    summary?: string;
+    open?: boolean;
+    selected?: boolean;
+    note?: string | null;
+}
+/** A full-width rule in the thread. */
+export declare function compaction(p: CompactView, w: number, m: boolean): Item[];

package/dist/el/extensions.d.ts

@@ -0,0 +1,90 @@
+/**
+ * `/extensions` (plan 39 T3.5, decision 0100 §1): one list of every
+ * extension, installed or not, its filters, its search and the required roles;
+ * the processes behind `p`; one row's details behind Enter — port of
+ * `el/extensions.rs`. The host formats every row (`orrery_registry::browse`);
+ * this draws them. The marks are glyphs (● ○ ↑) and every state is also in
+ * words, so mono reads the same. Read-only for now: no selection, no acts.
+ */
+import { type Item } from "../cells";
+/** One row of the list, as the host formats it (`orrery_registry::browse::Row`). The chat draws the same fields. */
+export interface ExtRowV {
+    id: string;
+    /** The installed version, else the listed one. */
+    version?: string;
+    /** What it is, kebab-case: `tools`, `session-store`. */
+    kinds?: string[];
+    author?: string;
+    description?: string;
+    installed?: boolean;
+    /** Installed and not turned off; an installed row that is not is dimmed. */
+    loaded?: boolean;
+    /** Comes with Orrery: never offered an update here. */
+    builtin?: boolean;
+    /** The newer version the list has. */
+    update?: string | null;
+    /** `installed`, `available` or `update`: the ● ○ ↑ mark in words. */
+    mark?: string;
+    /** The line under the name. */
+    subtitle?: string;
+    keywords?: string[];
+    source?: string;
+    repository?: string;
+    /** It crashed or broke: the subtitle names `orrery ext show`. */
+    failed?: boolean;
+}
+export interface ProcRowV {
+    pid: string;
+    runtime: string;
+    mem: string;
+    cpu: string;
+    up: string;
+    hosts: string;
+}
+/** One row's details. A third item is the value's style class (`d` is dim). */
+export interface DetailV {
+    title: string;
+    lines: [string, string, string?][];
+    failed?: boolean;
+}
+/** How the list was read: `age` is absent when there is no list. */
+export interface ListV {
+    age?: string | null;
+    refreshing?: boolean;
+    offline?: boolean;
+    failed?: string | null;
+}
+export interface CountsV {
+    all?: number;
+    installed?: number;
+    updates?: number;
+    unloaded?: number;
+}
+/** The required roles (decision 0099 §2) and what fills each; null is missing. */
+export interface RolesV {
+    "session-store"?: string | null;
+    provider?: string | null;
+    client?: string | null;
+}
+/** The overlay's props. `detail` set means the details view; otherwise `view` names the list or the processes. */
+export interface ExtensionsView {
+    view?: string;
+    /** `all`, `installed` or `updates`. */
+    filter?: string;
+    /** The search, while `/` is on. */
+    query?: string | null;
+    rows?: ExtRowV[];
+    counts?: CountsV | null;
+    list?: ListV | null;
+    roles?: RolesV | null;
+    procs?: ProcRowV[];
+    totals?: string;
+    detail?: DetailV | null;
+    /** The row under the cursor (the client's). */
+    cursor?: number | null;
+    selected?: number | null;
+    /** The screen rows the client has for the overlay: past it the rows are windowed around the cursor, the head, totals and keys always drawn. */
+    height?: number | null;
+}
+/** Draw the overlay at `w` cells: the list, the processes, or one row's details. */
+export declare function extensions(p: ExtensionsView, w: number, m: boolean): Item[];

package/dist/el/feedback.d.ts

@@ -0,0 +1,98 @@
+/**
+ * List 2 · System feedback: toasts, the retry banner, the update notice, the
+ * git slot, the status line, the exit summary, notifications — port of
+ * `el/feedback.rs`.
+ */
+import { type Item, type Line } from "../cells";
+import { type FooterView } from "./chrome";
+/** A toast. */
+export interface Toast {
+    /** `success`, `info`, `warning`. */
+    kind: string;
+    text: string;
+}
+/** Toasts over the input (at most two). */
+export interface ToastView {
+    toasts: Toast[];
+}
+/** One toast row, right-aligned. */
+export declare function toastLine(x: Toast, w: number, m: boolean): Line;
+/** Right-aligned on the row above the input; never focused. */
+export declare function toast(p: ToastView, w: number, m: boolean): Item[];
+/** A request backing off. */
+export interface RetryView {
+    /** `waiting`, `retrying`, `gave-up`; `waiting` when absent. */
+    state?: string;
+    /** The mono word; `retry` when absent. */
+    word?: string;
+    text?: string;
+    countdown?: string;
+    /** How much of the wait is left, 0–10. */
+    left?: number;
+}
+/** One row and a draining bar above the input. */
+export declare function retry(p: RetryView, w: number, m: boolean): Item[];
+/** A newer runtime. */
+export interface UpdateView {
+    /** `available`, `installing`, `done`, `failed`, `managed`; `available` when absent. */
+    state?: string;
+    latest: string;
+    current?: string;
+    progress?: number;
+    error?: string | null;
+    selected?: boolean;
+}
+/** One dim line under the banner at launch. */
+export declare function update(p: UpdateView, w: number, m: boolean): Item[];
+/** The workspace's git state. */
+export interface GitView {
+    /** `ok`, `loading`, `none`, `error`, `detached`; `ok` when absent. */
+    state?: string;
+    branch?: string;
+    dirty?: number;
+    ahead?: number;
+    behind?: number;
+    error?: string | null;
+}
+/** The git slot's runs. */
+export declare function gitLine(p: GitView, m: boolean): Line;
+/** Branch, dirty count, ahead/behind, in plain marks. */
+export declare function git(p: GitView, w: number, m: boolean): Item[];
+/** A slot on the status line. */
+export interface Slot {
+    /** `mode`, `git`, `ctx`, `cmd`, `model`. */
+    kind: string;
+    text?: string;
+    mono?: string | null;
+    label?: string;
+    /** `ok`, `loading`, `error`; `ok` when absent. */
+    state?: string;
+}
+/** `statusline = [...]` and what it draws. */
+export interface StatusLineView {
+    config: string;
+    slots?: Slot[];
+    editing?: number | null;
+    footer?: FooterView | null;
+}
+/** The slots, left to right. */
+export declare function statusline(p: StatusLineView, w: number, m: boolean): Item[];
+/** Printed to the normal screen on the way out. */
+export interface ExitView {
+    harness?: string | null;
+    /** `[label, value]` rows. */
+    rows?: [string, string][];
+    resume?: string | null;
+    error?: string | null;
+}
+/** Duration, cost, files changed, the exact resume command. */
+export declare function exit(p: ExitView, w: number, m: boolean): Item[];
+/** What the terminal is told when a turn ends or needs you. */
+export interface NotifyView {
+    title: string;
+    body?: string;
+    focused?: boolean;
+    off?: boolean;
+}
+/** Title, bell, OS notification. */
+export declare function notify(p: NotifyView, w: number, _m: boolean): Item[];

package/dist/el/helpers.d.ts

@@ -0,0 +1,18 @@
+/** Helpers shared by the elements — `el/mod.rs`'s crate-private functions. */
+import { type Item, type Line, type Seg } from "../cells";
+/** Lines as an element's rows. */
+export declare function out(lines: Line[]): Item[];
+/** A selection flag that reads `true`, `1` or a string (serde `de_flag`). */
+export declare function flag(v: unknown): boolean;
+/** An overlay: a titled box, accent (heavy in mono), an optional label on the right of its top edge. */
+export declare function ov(rows: Line[], w: number, m: boolean, title: string, right?: string | null): Line[];
+/** `✗ text`, wrapped, in the error class. */
+export declare function errLines(text: string, w: number, m: boolean): Line[];
+/** `▲ text`, wrapped, in the attention class. */
+export declare function warnLines(text: string, w: number, m: boolean, word: string): Line[];
+/** `s` with the first match of `q` (case-insensitive) marked. */
+export declare function hl(s: string, q: string, m: boolean): Line;
+/** `❯ ` on the cursor's row, two spaces elsewhere. */
+export declare function arrow(on: boolean): Seg;
+/** A dock panel's head: a rule with the title and count, the key on the right. */
+export declare function panelHead(w: number, title: string, count: Line, key: string | null, focused: boolean, m: boolean): Line;