@pmndrs/pine 0.0.0-stage → 0.1.0

package/src/tui/app.d.ts

@@ -0,0 +1,209 @@
+import { type SelectItem, type Terminal, TuiAltScreen } from "@earendil-works/pi-tui";
+import type { Client } from "./client.ts";
+export interface LinkSpan {
+    line: number;
+    from: number;
+    to: number;
+    url: string;
+}
+/**
+ * Web addresses in a block of plain screen lines, with the cells each one covers. A long address
+ * is wrapped over several lines; a line that runs to the right edge is read together with the next,
+ * and every piece of the address points to the whole of it.
+ */
+export declare function findLinks(lines: string[], width: number): LinkSpan[];
+/** The address under a cell, if any. */
+export declare function urlAt(lines: string[], y: number, x: number, width: number): string | undefined;
+/**
+ * Text that a terminal pastes when files are dropped on it: one or more paths, with spaces
+ * escaped or the path in quotes, sometimes as file:// URLs. Returns the files (with `folders`: the folders) only when every
+ * piece of the text is an existing one; otherwise the text is ordinary input.
+ */
+export declare function droppedFiles(text: string, folders?: boolean): string[] | null;
+/**
+ * Entries that match what was typed: every word must occur somewhere in the name or description,
+ * in any position ("dee" finds opencode-go/deepseek-v4.1-flash). If nothing matches that way,
+ * fall back to loose matching so a typo still finds something.
+ */
+export declare function searchItems(items: SelectItem[], query: string): SelectItem[];
+/**
+ * The screen, with one addition: while a menu or question is open, a click next to it goes to the
+ * app (which closes the menu) instead of to whatever lies underneath.
+ */
+declare class Screen extends TuiAltScreen {
+    onOutside?: (e: any) => boolean;
+    protected dispatchMouseToOverlay(event: any): any;
+    /**
+     * A real picture is drawn above all text, so it would lie across a menu opened over it. Pictures
+     * that a menu or dialog covers are drawn as text for as long as it is there.
+     */
+    protected compositeOverlays(lines: string[], width: number, height: number): string[];
+}
+export interface TuiOptions {
+    client: Client;
+    terminal: Terminal;
+    /** Called once when the user quits. */
+    onQuit?: () => void | Promise<void>;
+    /** Shown in the footer, for example "embedded daemon". */
+    mode?: string;
+    /** Hands a video file to a player when "open in player" is clicked. Default: the system's player. */
+    openFile?: (file: string) => void;
+    /** Opens a web address when it is clicked. Default: the system's browser. */
+    openUrl?: (url: string) => void;
+    /** Lets the user pick a folder; resolves with nothing when they do not. Default: the system's folder chooser (macOS). */
+    chooseFolder?: () => Promise<string | undefined>;
+    /** The folder pine was started in, offered in the folder menu. Default: the process's. */
+    cwd?: string;
+    /** MCP server administration that needs this machine: connection states and browser sign-in. */
+    mcp?: {
+        /** The configured servers. `states` also asks each one whether it connects, which takes a moment. */
+        list(states?: boolean): Promise<Array<{
+            name: string;
+            scope: string;
+            agents: string[];
+            target: string;
+            state?: string;
+        }>>;
+        login(name: string, onOutput: (text: string) => void): Promise<number>;
+    };
+}
+/** The terminal UI: one tab per conversation, a live event tab, slash commands, approval prompts. */
+export declare class PineTui {
+    client: Client;
+    tui: Screen;
+    private editor;
+    private header;
+    private status;
+    private footer;
+    private dock;
+    private tabs;
+    private active;
+    private nextTabId;
+    private agents;
+    private commands;
+    private connected;
+    private notice;
+    private noticeTimer?;
+    private spinner?;
+    private frame;
+    private unsubscribe?;
+    private dialog?;
+    /** When a menu or question last closed. A key that closed it is not also a key for what lies under it. */
+    private dialogClosedAt;
+    /** Videos fetched from the daemon, as files for ffmpeg and the player. Removed when the UI closes. */
+    private mediaDir?;
+    private mediaCount;
+    private headerHits;
+    private footerHits;
+    private attachHits;
+    private attach;
+    private sessionModes;
+    private lastCtrlC;
+    private taints;
+    private bypassWhenTainted;
+    private opts;
+    private stopped;
+    /** While the tabs of last time are being opened again. */
+    private restoring;
+    /** The pane beside a conversation: changes, files, tool output. */
+    private code;
+    private codeOpen;
+    private codeRule;
+    constructor(opts: TuiOptions);
+    start(): Promise<void>;
+    /** Remember which conversations are open, so that the next start opens the same tabs. */
+    private saveTabs;
+    stop(): Promise<void>;
+    /** What is on screen, without colours. For tests and debugging. */
+    screen(): string[];
+    private newTab;
+    openTab(agent: string, session: string): Promise<void>;
+    /**
+     * Open a tab on one task, typically a sub-agent: what it was given, what it thought and wrote,
+     * every tool call with the start of its result. A running task is followed live.
+     */
+    openTask(id: number): Promise<void>;
+    private taskSummary;
+    private renderEntry;
+    private openEvents;
+    private activate;
+    private cycle;
+    /**
+     * The tab of a conversation other than an agent's main one is closed: what it was subscribed to
+     * on its own ends, the conversation itself stays in the agent's list. (The main conversation is
+     * the agent; its subscriptions stay.)
+     */
+    private endLocal;
+    private closeTab;
+    /** Open or close the pane beside the conversation, optionally on one of its views. */
+    private showCode;
+    /** Give a conversation a folder to work in, or with `null` take it back to the agent's own workspace. */
+    private setFolder;
+    private pickFolder;
+    /**
+     * `pine <folder>`: a tab on the conversation that works in that folder. The one that already
+     * does is opened again; otherwise the main agent gets a new conversation named after the folder.
+     */
+    openFolder(dir: string): Promise<void>;
+    private add;
+    private say;
+    /** A line that opens something on a click. */
+    private button;
+    /**
+     * Reserve a place for a picture and fill it once the picture is fetched and prepared, so it lands
+     * where it belongs however long that takes. Display only: nothing here reaches a model.
+     */
+    private picture;
+    private fill;
+    /** A video that came over the API needs to be a file for ffmpeg and for the player. Kept until the UI closes. */
+    private keepVideo;
+    private video;
+    /**
+     * The pictures an answer points at with ![caption](target). A file in the agent's workspace is
+     * shown at once. A web address is not fetched until it is clicked: an address can carry
+     * information out, and an answer may repeat what a web page told the agent to write.
+     */
+    private answerPictures;
+    /** An event that woke the agent, shown as what it is and not as something you typed: the source, and the start of what it reported. */
+    private eventLine;
+    private user;
+    /** Context and cache figures of a finished task, for the bottom bar. */
+    private takeStats;
+    private renderPast;
+    private flash;
+    /** Keys the app handles before the editor sees them. Returns true when the key is used up. */
+    private onKey;
+    /** A click on a web address. Only the web: nothing an answer contains may launch a program or open a file. */
+    private open;
+    private submit;
+    private attachFile;
+    /** Open a list over the conversation and resolve with what was chosen. */
+    private pick;
+    private pickAgent;
+    private pickSession;
+    private pickModel;
+    private pickReasoning;
+    private pickMode;
+    private isTainted;
+    private setMode;
+    private adopt;
+    private stopRunning;
+    private defineCommands;
+    private run;
+    private help;
+    private ask;
+    private closeDialog;
+    private answer;
+    private tabFor;
+    private onEvent;
+    /** Show one live event of a task in a tab. `depth` is counted from what the tab shows: 0 is its own task. */
+    private live;
+    private logEvent;
+    private refreshTaints;
+    private bypassPaused;
+    private renderHeader;
+    private renderAttachments;
+    private renderStatus;
+    private renderFooter;
+}
+export {};