@sigrun/tui 0.1.1 → 0.2.1

package/dist/ui/composer.d.ts

@@ -1,66 +0,0 @@
-/**
- * The composer's pure pieces (Task 7): slash-input parsing, the fetch-once
- * command catalog, and error-line formatting. The composer itself is NOT
- * its own component — it is the pi-tui `Editor` the shell owns plus the
- * wiring in `app.ts` (busy tracking, the dispatch); these are the parts
- * that carry no app state.
- */
-import type { SlashCommand, SigrunClient } from "../api.js";
-/** A parsed `/name args…` line. */
-export interface SlashInput {
-    /** The bare command name (no slash), lowercased. */
-    readonly name: string;
-    /** Everything after the first space, trimmed ("" when absent). */
-    readonly args: string;
-}
-/** Whether a command name is the skills channel (`/skill:name`, Task 2c):
- *  expansion is server-side at admission, and an UNKNOWN skill passes
- *  through unchanged — so a `skill:`-prefixed line is ALWAYS a submission,
- *  never an endpoint command or a local error. (Checked on the LOWERCASED
- *  parse; the line itself is submitted verbatim either way.) */
-export declare function isSkillCommandName(name: string): boolean;
-/** The text a command-picker selection inserts into the composer: an
- *  EXPAND entry (Task 2c — a prompt template or a skill) inserts
- *  `/name ` ALWAYS (args are its whole point; a skill carries no argsHint
- *  but takes them), an arg-taking endpoint command inserts `/name ` for
- *  its args, and an argless endpoint command inserts bare `/name` for
- *  immediate execution. */
-export declare function commandInsertText(command: SlashCommand): string;
-/**
- * Parse a slash-prefixed composer line; `undefined` when the input is not
- * a command (only a LEADING slash routes — "look at /etc" stays a message).
- * A bare "/" parses to an empty name (the caller renders the empty-command
- * error).
- */
-export declare function parseSlashInput(input: string): SlashInput | undefined;
-/**
- * The server's slash-command catalog, cached per session. The server
- * re-scans its skill/template roots on every `GET /v1/commands` request —
- * the cache is a SESSION SNAPSHOT, not a boot constant — so a lookup
- * that misses ({@link SlashCatalog.get}) can re-check the live catalog
- * via {@link SlashCatalog.getFresh} before declaring a name unknown. A
- * failed fetch is NOT cached: the rejected promise is dropped so the
- * next `/` retries.
- */
-export declare class SlashCatalog {
-    #private;
-    constructor(client: SigrunClient);
-    /** The catalog entry for `name` (bare, lowercased) from the CACHED
-     *  snapshot, or undefined. */
-    get(name: string): Promise<SlashCommand | undefined>;
-    /** The live-catalog re-check: refetch NOW (replacing the cache with the
-     *  fresh response) and look `name` up again — the one retry a dispatch
-     *  makes when the cached snapshot lacks a name (the server re-scans
-     *  per request, so a template added mid-session becomes submittable
-     *  without a restart). Throws through on a failed fetch, like `get`. */
-    getFresh(name: string): Promise<SlashCommand | undefined>;
-    /** Every catalog name (the vim `:` Tab completion's source, C4). */
-    names(): Promise<string[]>;
-}
-/**
- * Format a failed composer action for the pane's error line. A
- * {@link SigrunApiError} renders the status plus the server's own
- * `{error: …}` body (Review Focus 2 — the server's words, never a generic
- * "something failed"); anything else renders its message.
- */
-export declare function describeCommandError(action: string, error: unknown): string;

package/dist/ui/composer.js

@@ -1,125 +0,0 @@
-/**
- * The composer's pure pieces (Task 7): slash-input parsing, the fetch-once
- * command catalog, and error-line formatting. The composer itself is NOT
- * its own component — it is the pi-tui `Editor` the shell owns plus the
- * wiring in `app.ts` (busy tracking, the dispatch); these are the parts
- * that carry no app state.
- */
-import { SigrunApiError } from "../api.js";
-/** Whether a command name is the skills channel (`/skill:name`, Task 2c):
- *  expansion is server-side at admission, and an UNKNOWN skill passes
- *  through unchanged — so a `skill:`-prefixed line is ALWAYS a submission,
- *  never an endpoint command or a local error. (Checked on the LOWERCASED
- *  parse; the line itself is submitted verbatim either way.) */
-export function isSkillCommandName(name) {
-    return name.startsWith("skill:");
-}
-/** The text a command-picker selection inserts into the composer: an
- *  EXPAND entry (Task 2c — a prompt template or a skill) inserts
- *  `/name ` ALWAYS (args are its whole point; a skill carries no argsHint
- *  but takes them), an arg-taking endpoint command inserts `/name ` for
- *  its args, and an argless endpoint command inserts bare `/name` for
- *  immediate execution. */
-export function commandInsertText(command) {
-    return command.kind === "expand" || command.argsHint !== undefined
-        ? `/${command.name} `
-        : `/${command.name}`;
-}
-/**
- * Parse a slash-prefixed composer line; `undefined` when the input is not
- * a command (only a LEADING slash routes — "look at /etc" stays a message).
- * A bare "/" parses to an empty name (the caller renders the empty-command
- * error).
- */
-export function parseSlashInput(input) {
-    if (!input.startsWith("/"))
-        return undefined;
-    const space = input.indexOf(" ");
-    if (space === -1)
-        return { name: input.slice(1).toLowerCase(), args: "" };
-    return {
-        name: input.slice(1, space).toLowerCase(),
-        args: input.slice(space + 1).trim(),
-    };
-}
-/**
- * The server's slash-command catalog, cached per session. The server
- * re-scans its skill/template roots on every `GET /v1/commands` request —
- * the cache is a SESSION SNAPSHOT, not a boot constant — so a lookup
- * that misses ({@link SlashCatalog.get}) can re-check the live catalog
- * via {@link SlashCatalog.getFresh} before declaring a name unknown. A
- * failed fetch is NOT cached: the rejected promise is dropped so the
- * next `/` retries.
- */
-export class SlashCatalog {
-    #client;
-    #cache;
-    constructor(client) {
-        this.#client = client;
-    }
-    /** The catalog entry for `name` (bare, lowercased) from the CACHED
-     *  snapshot, or undefined. */
-    async get(name) {
-        try {
-            this.#cache ??= this.#client.getCommands();
-            const response = await this.#cache;
-            return response.commands.find((command) => command.name === name);
-        }
-        catch (error) {
-            this.#cache = undefined;
-            throw error;
-        }
-    }
-    /** The live-catalog re-check: refetch NOW (replacing the cache with the
-     *  fresh response) and look `name` up again — the one retry a dispatch
-     *  makes when the cached snapshot lacks a name (the server re-scans
-     *  per request, so a template added mid-session becomes submittable
-     *  without a restart). Throws through on a failed fetch, like `get`. */
-    async getFresh(name) {
-        this.#cache = undefined;
-        return await this.get(name);
-    }
-    /** Every catalog name (the vim `:` Tab completion's source, C4). */
-    async names() {
-        try {
-            this.#cache ??= this.#client.getCommands();
-            return (await this.#cache).commands.map((command) => command.name);
-        }
-        catch (error) {
-            this.#cache = undefined;
-            throw error;
-        }
-    }
-}
-/**
- * Format a failed composer action for the pane's error line. A
- * {@link SigrunApiError} renders the status plus the server's own
- * `{error: …}` body (Review Focus 2 — the server's words, never a generic
- * "something failed"); anything else renders its message.
- */
-export function describeCommandError(action, error) {
-    if (error instanceof SigrunApiError) {
-        const body = error.body;
-        const detail = typeof body === "object" &&
-            body !== null &&
-            "error" in body &&
-            typeof body.error === "string"
-            ? body.error
-            : undefined;
-        // A failed extension command/run names its contributor (W5 Task 3's
-        // `command_failed` + `extension` body) — the slug is what the operator
-        // needs next, so it rides the same line.
-        const extension = typeof body === "object" &&
-            body !== null &&
-            "extension" in body &&
-            typeof body.extension === "string"
-            ? body.extension
-            : undefined;
-        const suffix = extension === undefined ? "" : ` (${extension})`;
-        return detail === undefined
-            ? `${action} failed (${error.status})`
-            : `${action} failed (${error.status}): ${detail}${suffix}`;
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    return `${action} failed: ${message}`;
-}

package/dist/ui/conversation-pane.d.ts

@@ -1,123 +0,0 @@
-/**
- * The conversation pane (Task 6; restyled in C2, UI refresh): renders a
- * `ConversationViewWire`'s entries as TURNS (B1's `groupTurns`) instead
- * of raw entries — a user turn is the accent `▎` bar on every line, an
- * assistant turn is prose plus ONE collapsible activity line
- * (`▸ Thinking · 2 tools`; `▾` when open) that unfolds into the thinking
- * text and `✓ tool  preview` rows (`✗` error, `·` no result yet — the
- * wire carries no per-tool running marker, so `·` covers pending too).
- * `pi.compaction` renders the centred `── context compacted ──` divider. The `[tool]`/`[thinking]` tags of
- * the entry-era pane are gone.
- *
- * Task 2c: an EXPANDED input (`/skill:name`, a prompt template) is one
- * entry (`sigrun.user.expanded`, `data {typed, command}`, the expanded
- * text on `model`) that groups as a USER turn — the body is the TYPED
- * command with a dim `▸ expanded from /name` chip line that folds the
- * full admitted text open/closed (closed by default).
- *
- * Focus (the C3 action layer's seam): `focusIndex` names the focused
- * turn (`undefined` = none — the ScrollView follows the end), the
- * focused turn's FIRST line carries the `surface2` background and a `›`
- * gutter marker; `lineRangeOf` reports the turn's line offsets from the
- * last render for `ScrollView.scrollTo`; `textOf`/`entryIdOf` are the
- * copy payload and wire identity of a turn.
- *
- * Mouse (additive — the pane is fully keyboard-usable): each activity
- * line is a `MouseRegion` whose left click toggles the fold; a click on
- * a turn's body sets the focus to that turn.
- *
- * The SSE contract (Task 4): every snapshot/frame is a FULL revision, so
- * {@link showView} REPLACES the rendered state wholesale. Folds and
- * focus are keyed by turn INDEX within the latest view — a replacement
- * re-derives the turns and keeps the index-based state (the action
- * layer owns re-targeting when the structure shifts).
- *
- * Unknown entry kinds render a fail-visible fallback naming the kind
- * (the webui's rule — a new server-side kind must never vanish silently).
- *
- * Error/notice lines (Task 7): the composer surfaces its immediate
- * failures as `[error]`/`[notice]` rows. They are NOT stream state, so
- * {@link showView}'s wholesale replacement preserves them (fix wave F4:
- * the shell discards them on every conversation swap via
- * {@link ConversationPane.clearNotices}).
- */
-import { type Component } from "@earendil-works/pi-tui";
-import { type Turn } from "@sigrun/shared/turns";
-import { type TuiTheme } from "../theme.js";
-import type { ConversationViewWire } from "../api.js";
-/** One §5 message's structural shape (B1's `TurnMessage` + content parts). */
-interface MessageShape {
-    readonly role: string;
-    readonly content: string | readonly {
-        readonly type: string;
-        readonly text?: string;
-        readonly thinking?: string;
-        readonly path?: string;
-        readonly id?: string;
-        readonly name?: string;
-        readonly arguments?: unknown;
-    }[];
-    readonly toolCallId?: string;
-    readonly toolName?: string;
-    readonly isError?: boolean;
-}
-/** One §5 entry's structural shape (kind + optional model messages). */
-export interface EntryShape {
-    readonly id: number;
-    readonly kind: string;
-    readonly model?: readonly MessageShape[];
-    /** The entry's kind-specific JSON payload — an expanded input's
-     *  `{typed, command}` (see `expandedUserEntry`). */
-    readonly data?: unknown;
-}
-export interface ConversationPaneOptions {
-    /** The token theme; defaults to the plain (identity) fallback. */
-    readonly theme?: TuiTheme;
-}
-export declare class ConversationPane implements Component {
-    #private;
-    constructor(options?: ConversationPaneOptions);
-    /** The current view's turns (B1 grouping), in render order. */
-    turns(): readonly Turn<EntryShape>[];
-    /** The focused turn index; `undefined` = none (follow the end). */
-    get focusIndex(): number | undefined;
-    /** Focus a turn (or clear with `undefined`); repaints the marker. */
-    setFocus(index: number | undefined): void;
-    /** Open/close an assistant turn's activity fold — or an expanded user
-     *  turn's chip disclosure (Task 2c: the full admitted text hides behind
-     *  the `expanded from /name` line, same fold state, same seam). */
-    toggleFold(index: number): void;
-    /**
-     * The turn's line offsets from the last render (for
-     * `ScrollView.scrollTo`): `start` is the turn's first line, `end` the
-     * first line after it. Undefined before a render or out of range.
-     */
-    lineRangeOf(index: number): {
-        start: number;
-        end: number;
-    } | undefined;
-    /** The turn's markdown source (the copy payload). */
-    textOf(index: number): string;
-    /** The turn's wire identity: the user entry id / assistant lastEntryId. */
-    entryIdOf(index: number): number;
-    /**
-     * Replace the pane with the projection of `wire` (the SSE rule: a full
-     * revision replaces; a reconnect's snapshot subsumes missed frames).
-     * Composer notices are not stream state: they re-render after the
-     * turns.
-     */
-    showView(wire: ConversationViewWire): void;
-    /** Append an `[error]` line (a failed composer action's surface). */
-    showError(text: string): void;
-    /** Append a `[notice]` line (an outcome, e.g. an abort that settled). */
-    showNotice(text: string): void;
-    /**
-     * Discard all composer-surfaced lines (fix wave F4): the shell calls
-     * this on every conversation swap so a stale error never renders in
-     * the new conversation.
-     */
-    clearNotices(): void;
-    render(width: number): string[];
-    invalidate(): void;
-}
-export {};