@opencode-cockpit/trust 0.0.0-stage → 0.8.0

package/types/core/view/rows.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Rows of styled runs — every Trust surface, pure so a test can measure it.
+ *
+ * Tones name a meaning, never a colour; `tui/render.ts` is the only place that knows what a tone
+ * looks like, so the preview CLI and OpenCode draw the same rows (docs/building/terminal-ui.md).
+ * The helpers are Subagents' (`core/view/rows.ts`), copied rather than imported: bays never import
+ * each other.
+ */
+export type Tone = "text" | "muted" | "accent" | "info" | "tool" | "success" | "error" | "warning" | "border"
+/** Text cut out of a solid fill (a focused button): the colour of what the dialog is drawn on. */
+ | "ink";
+/**
+ * What sits behind a run. Two cover a whole row — the row under the cursor and the card's raised
+ * panel — and the rest a few cells: an agent's chip, a button, a focused button, and the tinted
+ * badges that say success, warning and error. A tint is the tone's colour faded into the dialog's
+ * own, so it follows the theme (`TINTS`; `tui/render.ts` mixes it).
+ */
+export type Fill = "none" | "selected" | "panel" | "chip" | "button" | "buttonOn" | "ok" | "warn" | "err";
+/**
+ * The tinted fills: which tone each is made of, and how much of it is mixed into the dialog's
+ * background. Little enough that the tone's own text on it stays legible; enough to be seen.
+ */
+export declare const TINTS: Readonly<Record<"chip" | "ok" | "warn" | "err", {
+    tone: Tone;
+    amount: number;
+}>>;
+export interface Run {
+    text: string;
+    tone?: Tone;
+    fill?: Fill;
+    bold?: boolean;
+    faint?: boolean;
+}
+export type Row = Run[];
+export declare const rowText: (row: Row) => string;
+/** Columns a string takes. Wide characters (CJK, most emoji) take two. */
+export declare function widthOf(text: string, limit?: number): number;
+/** `text` in at most `width` columns, ending in `…` when cut. */
+export declare function cut(text: string, width: number): string;
+/**
+ * A row exactly `width` columns wide: runs cut where they overflow, padded in the last run's fill
+ * where they fall short. Every row every surface draws goes through here; the grid test holds it.
+ */
+export declare function fit(row: Row, width: number): Row;
+/** The fill a row is drawn on: the last row-wide fill among its runs. A chip at its end is not one. */
+export declare function rowFillOf(row: Row): Fill | undefined;
+/** Left and right parts on one row, the right part flush against the edge; the left gives way. */
+export declare function spread(left: Row, right: Row, width: number): Row;
+/**
+ * A row on one surface — the row under the cursor, the card's panel. A run with a fill of its own
+ * (a chip, a badge, a button) keeps it: the surface is what is behind them.
+ */
+export declare const filled: (row: Row, fill: Fill) => Row;
+/**
+ * The row under the cursor: `▌` in its first cell — the margin every row keeps for it — and the
+ * selected fill to both edges (docs/building/design-system.md: `▌` is the cursor and nothing else).
+ */
+export declare function cursorRow(row: Row, width: number): Row;
+/** How long ago, in the fewest characters that still read: `now`, `5m`, `2h`, `3d`. */
+export declare function ago(ms: number): string;

package/types/core/view/sidebar.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The sidebar block: what Trust answered for you in this window, and what it is counting now.
+ *
+ *   Trust                     4 auto
+ *   ● git status                  7×
+ *   ● edit src/app.ts             3×
+ *   ○ docker compose up          2/3
+ *
+ * A filled dot is an answer Trust gave, with how many times it has answered that in all; a hollow
+ * one is a request on screen now and how far it is from being trusted. Answers are visible every
+ * time — that is the bargain that makes answering for you acceptable — but the block says nothing
+ * when there is nothing to say: no answers yet, nothing counting, not paused. A failure always speaks.
+ *
+ * Asked for (`shown`: the setting, or the palette's toggle), the heading says where the project
+ * stands rather than only this window — `Trust  2 auto · 5 trusted · 1 counting` — since a window
+ * just opened has answered nothing yet while the ledger holds plenty. It is never silent then: a
+ * project with nothing learned says so, or showing the block looks like a command that did nothing.
+ *
+ * An answer given through a family you widened says so — `● ls -R docs · any ls  1×` — because
+ * that rule was never approved by itself, and the answer should not look as if it had been.
+ * Commands are shown the way the ledger shows them (`family.showSubject`): `echo "---"`, never a
+ * bare `---` a font can merge into a line.
+ *
+ * Plain geometric marks, not ⚡: the emoji draws two columns wide in most terminals and one in some,
+ * which breaks a grid that has to be exact; Subagents' sidebar uses the same dots.
+ */
+import type { Answered, Pending } from "../engine.ts";
+import { type State, type Thresholds } from "../ledger.ts";
+import { type Row } from "./rows.ts";
+export interface SidebarInput {
+    width: number;
+    /** Answers in this window, newest first. */
+    recent: readonly Answered[];
+    /** How many answers in this window. */
+    count: number;
+    pending: readonly Pending[];
+    state: State;
+    /** Something went wrong and you should know: drawn whatever else is going on. */
+    trouble?: string;
+    /** Answers listed; the count in the heading covers the rest. */
+    limit: number;
+    /**
+     * You asked for the block: its heading tallies the project (`project`), and it draws even with
+     * nothing to say this window.
+     */
+    shown?: boolean;
+    /** The project's commands, from the whole ledger (`tally`). */
+    project?: Tally;
+}
+/** Commands in the project's ledger: trusted by some agent, or on their way there. */
+export interface Tally {
+    trusted: number;
+    counting: number;
+}
+/**
+ * One count per command, however many agents it was approved for — as the ledger lists them: trusted
+ * when any agent trusts it, counting when none does yet but one has approvals that still count.
+ */
+export declare function tally(state: State, settings: Thresholds, now: number): Tally;
+/** `edit src/app.ts`, but a command is just the command: bash is the common case. */
+export declare function labelOf(permission: string, label: string): Row;
+export declare function sidebarRows(input: SidebarInput): Row[];

package/types/tui/index.d.ts

@@ -0,0 +1,15 @@
+/** @jsxImportSource @opentui/solid */
+import { type Host } from "@opencode-cockpit/client/host";
+import { type TrustConfig } from "../core/config.ts";
+export type TrustTuiOptions = TrustConfig;
+/** Trust's interface half as a factory, so the `opencode-cockpit` bundle can include it. */
+export declare function createTrustTui({ source }?: {
+    source?: string;
+}): (api: Host, rawOptions?: unknown) => Promise<void>;
+/** One entry for both OpenCodes: v1 calls `tui`, v2 calls `setup` (docs/opencode/v2.md). */
+declare const _default: {
+    id: string;
+    tui: (api: import("@opencode-ai/plugin/tui").TuiPluginApi, options?: unknown) => Promise<void>;
+    setup: (ctx: import("@opencode-cockpit/client/host").V2Context) => Promise<() => void>;
+};
+export default _default;

package/types/tui/journal.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The ledger file, read and appended without ever blocking the interface thread.
+ *
+ * Every read and every append goes through one chain, so this window's writes and reads never
+ * overlap each other (the lesson of Review's trace: unserialised appends dropped lines). Other
+ * windows append to the same file between our reads; `read` takes whatever whole lines arrived since
+ * the last one and leaves a line still being written for next time.
+ */
+import { type Event } from "../core/ledger.ts";
+import type { TrustPaths } from "../core/paths.ts";
+export interface Journal {
+    /** Events added since the last read, by anyone, in file order. `reset`: the file was replaced. */
+    read: () => Promise<{
+        events: Event[];
+        reset: boolean;
+    }>;
+    append: (events: readonly Event[]) => Promise<void>;
+}
+export declare function createJournal(paths: TrustPaths): Journal;

package/types/tui/render.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The only place that knows what a tone looks like: every colour from the user's OpenCode theme,
+ * through the host (so OpenCode 2's tokens arrive under the same names — client/host `themeFromV2`).
+ */
+import type { Theme } from "@opencode-cockpit/client/host";
+import type { RGBA } from "@opentui/core";
+import { type Fill, type Tone } from "../core/view/rows.ts";
+export declare function toneColour(theme: Theme, tone: Tone | undefined): RGBA;
+/**
+ * What sits behind a run. The row-wide surfaces and the buttons are the theme's raised element; a
+ * focused button is the accent; a chip or a badge is its tone's tint, and — on a theme whose dialog
+ * has no colour to tint — no fill at all: the word keeps its tone and still says what it is.
+ */
+export declare function fillColour(theme: Theme, fill: Fill | undefined): RGBA | undefined;

package/types/tui/source.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Trust's reach into a specific OpenCode: its events, its reply, its config and its pending list.
+ * The only file past `Host` — through `api.v1` / `api.v2`, as Subagents' source does — and every call
+ * was measured or read from the version's own client (docs/opencode/permissions.md):
+ *
+ * | | OpenCode 1 | OpenCode 2 |
+ * | --- | --- | --- |
+ * | events | `api.event.on(type)` | `ctx.data.listen` |
+ * | answer | `client.permission.reply({ requestID, reply })` | `client.permission.reply({ sessionID, requestID, decision })` |
+ * | config | `client.config.get()` — merged | `client.config.get({ location })` — documents, lowest first |
+ * | pending | `client.permission.list()` | not read (see `pending` below) |
+ *
+ * What it hears becomes `Seen` through the pure adapters in `core/adapt/`.
+ */
+import type { Host } from "@opencode-cockpit/client/host";
+import type { Log } from "@opencode-cockpit/client/log";
+import { type Seen } from "../core/adapt/seen.ts";
+import type { Request } from "../core/keys.ts";
+export interface Source {
+    /** Says "once" to a request: the only answer Trust ever gives. */
+    approve: (request: Request) => Promise<void>;
+    /** OpenCode's config, as its `config.get` returns it, for `rulesFrom`. */
+    config: () => Promise<unknown>;
+    /** Requests pending now, by the host's own account; undefined when it cannot say. */
+    pending: () => Promise<Seen[] | undefined>;
+    /** The call's command line from the host's own store, when its events have not said it yet. */
+    call: (request: Request) => {
+        line?: string;
+        workdir?: string;
+    } | undefined;
+    /** The agent a session runs as, from the host's own store. */
+    agent: (sessionID: string, messageID?: string) => string | undefined;
+    dispose: () => void;
+}
+export declare function createSource(api: Host, log: Log, emit: (seen: Seen[]) => void): Source;

package/types/tui/view/dialog.d.ts

@@ -0,0 +1,24 @@
+/** @jsxImportSource @opentui/solid */
+import type { Host, Layer } from "@opencode-cockpit/client/host";
+import type { JSX } from "solid-js";
+import type { Row } from "../../core/view/rows.ts";
+export interface DialogProps {
+    api: Host;
+    rows: () => readonly Row[];
+    /**
+     * The dialog's keys. Registered from inside the dialog, as Shell's console does: while the host's
+     * dialog is open it takes the keys, so a global layer would never hear them, and a layer owned by
+     * the component goes when the dialog does — on either OpenCode.
+     */
+    keys: () => Layer;
+    /** The wheel moves the cursor, three rows a notch, and the list follows it as `j`/`k` do. */
+    onScroll: (by: number) => void;
+    /** A click, in the rows' own cells: column and row from their top-left corner. */
+    onClick: (x: number, y: number) => void;
+}
+/**
+ * Trust's dialog in the host's: rows from `core/view/` — the activity or the ledger — and the keys and
+ * clicks that act on them. Clicks are read on release: on press, anything a click opens is up in time
+ * to catch the release and take it for its own (Review's overlay learned this).
+ */
+export declare function Dialog(props: DialogProps): JSX.Element;

package/types/tui/view/rows.d.ts

@@ -0,0 +1,19 @@
+/** @jsxImportSource @opentui/solid */
+import type { Host } from "@opencode-cockpit/client/host";
+import type { BoxRenderable } from "@opentui/core";
+import { type JSX } from "solid-js";
+import type { Row } from "../../core/view/rows.ts";
+export interface RowsProps {
+    api: Host;
+    /** The rows `core/view/` produced; a signal, so `<For>` redraws them. */
+    rows: () => readonly Row[];
+    onReady?: (box: BoxRenderable) => void;
+}
+/**
+ * Rows of runs, one `<text>` per row — the drawing both the sidebar block and the ledger dialog use.
+ *
+ * Shell's and Subagents' pattern, proven live on both OpenCodes: a signal read by `<For>` redraws,
+ * where anything decided once in a slot's tree never would (docs/opencode/gotchas.md, "Slots").
+ * The shape never changes; only the list of rows does.
+ */
+export declare function Rows(props: RowsProps): JSX.Element;