@pmndrs/pine 0.0.0-stage → 0.1.0

package/src/tui/client.d.ts

@@ -0,0 +1,178 @@
+import type { PineEvent, Task, TaskResult, TranscriptEntry } from "../types.ts";
+/** One conversation of an agent. `expires`: when it is removed by itself unless something more is said in it. */
+export interface Conversation {
+    session: string;
+    tasks: number;
+    last: number;
+    pinned: boolean;
+    open: boolean;
+    expires?: number;
+    /** The folder opened for it, if any. */
+    folder?: string;
+}
+export interface AgentInfo {
+    id: string;
+    main: boolean;
+    description: string;
+    workspace: string;
+    model: string;
+    mode: "manual" | "auto" | "bypass";
+    thinking: string;
+    delegates: string[];
+}
+/** Talks to a pine daemon over its control API. */
+export declare class Client {
+    base: string;
+    private token;
+    constructor(base: string, token: string);
+    private call;
+    /** A picture from the daemon, or undefined when there is none (or it is not an image). */
+    private picture;
+    toolImage: (id: string) => Promise<{
+        mime: string;
+        bytes: Buffer;
+    } | undefined>;
+    taskImage: (task: number, n: number) => Promise<{
+        mime: string;
+        bytes: Buffer;
+    } | undefined>;
+    workspaceImage: (agent: string, file: string, session?: string) => Promise<{
+        mime: string;
+        bytes: Buffer;
+    } | undefined>;
+    fetchImage: (url: string) => Promise<{
+        mime: string;
+        bytes: Buffer;
+    } | undefined>;
+    sources: () => Promise<any[]>;
+    subscribeTo: (agent: string, source: string, details?: Record<string, unknown>) => Promise<any>;
+    unsubscribeFrom: (agent: string, source: string, session?: string) => Promise<{
+        unsubscribed: boolean;
+        sessions: string[];
+    }>;
+    subscribeAll: (source: string, details?: Record<string, unknown>) => Promise<any>;
+    unsubscribeAll: (source: string) => Promise<{
+        unsubscribed: boolean;
+    }>;
+    /** Tell the daemon a conversation was closed here; returns the sources it was subscribed to on its own. */
+    closeSession: (agent: string, session: string) => Promise<{
+        unsubscribed: string[];
+    }>;
+    get: <T>(url: string) => Promise<T>;
+    post: <T>(url: string, body?: unknown) => Promise<T>;
+    agents: () => Promise<AgentInfo[]>;
+    status: () => Promise<any>;
+    models: () => Promise<string[]>;
+    sessions: (agent: string) => Promise<Conversation[]>;
+    removeSession: (agent: string, session: string) => Promise<{
+        removed: boolean;
+        unsubscribed: string[];
+        sources: string[];
+        servers: string[];
+    }>;
+    renameSession: (agent: string, session: string, to: string) => Promise<{
+        session: string;
+    }>;
+    pinSession: (agent: string, session: string, pinned: boolean) => Promise<{
+        pinned: boolean;
+    }>;
+    folder: (agent: string, session: string) => Promise<{
+        folder?: string;
+        workspace: string;
+    }>;
+    folders: (agent: string) => Promise<{
+        session: string;
+        folder: string;
+    }[]>;
+    setFolder: (agent: string, session: string, folder: string | null) => Promise<{
+        folder?: string;
+    }>;
+    changes: (agent: string, session: string) => Promise<{
+        root: string;
+        repo: boolean;
+        branch?: string;
+        files: Array<{
+            path: string;
+            status: string;
+            added?: number;
+            removed?: number;
+        }>;
+        more: boolean;
+    }>;
+    diff: (agent: string, session: string, file: string) => Promise<{
+        diff: string;
+        truncated: boolean;
+    }>;
+    tree: (agent: string, session: string, dir: string) => Promise<{
+        entries: Array<{
+            name: string;
+            dir: boolean;
+            size: number;
+        }>;
+        more: boolean;
+    }>;
+    file: (agent: string, session: string, file: string) => Promise<{
+        text?: string;
+        size: number;
+        binary: boolean;
+        truncated: boolean;
+    }>;
+    output: (task: number) => Promise<{
+        task: Task;
+        entries: TranscriptEntry[];
+    }>;
+    tabs: () => Promise<{
+        tabs: Array<{
+            agent: string;
+            session: string;
+        }>;
+        active: number;
+        code?: boolean;
+    }>;
+    saveTabs: (tabs: Array<{
+        agent: string;
+        session: string;
+    }>, active: number, code?: boolean) => Promise<{
+        ok: boolean;
+    }>;
+    history: (agent: string, session: string, limit?: number) => Promise<Task[]>;
+    prompt: (agent: string, prompt: string, session: string, attachments?: Array<{
+        name: string;
+        data: string;
+    }>) => Promise<{
+        task: number;
+    }>;
+    ask: (agent: string, prompt: string, session: string) => Promise<TaskResult>;
+    transcript: (task: number) => Promise<{
+        task: Task;
+        entries: TranscriptEntry[];
+    }>;
+    cancel: (task: number) => Promise<{
+        cancelled: boolean;
+    }>;
+    reset: (agent: string, session: string) => Promise<{
+        reset: boolean;
+    }>;
+    setThinking: (agent: string, level: string) => Promise<{
+        level: string;
+    }>;
+    setMode: (agent: string, mode: string, anyway?: string) => Promise<{
+        mode: string;
+    }>;
+    setModel: (agent: string, model: string) => Promise<{
+        model: string;
+    }>;
+    approvals: () => Promise<any[]>;
+    decide: (id: string, allow: boolean, always?: boolean, values?: Record<string, string>) => Promise<{
+        decided: boolean;
+    }>;
+    emit: (topic: string, payload: unknown) => Promise<{
+        id: number;
+    }>;
+    state: (pattern?: string) => Promise<{
+        key: string;
+        value: unknown;
+    }[]>;
+    /** Live events. Reconnects until the returned function is called. */
+    subscribe(onEvent: (e: PineEvent) => void, onState?: (connected: boolean) => void): () => void;
+}

package/src/tui/client.js

@@ -0,0 +1,116 @@
+/** Talks to a pine daemon over its control API. */
+export class Client {
+    base;
+    token;
+    constructor(base, token) {
+        this.base = base.replace(/\/$/, "");
+        this.token = token;
+    }
+    async call(method, url, body) {
+        const res = await fetch(this.base + url, {
+            method,
+            headers: { authorization: `Bearer ${this.token}`, ...(body !== undefined ? { "content-type": "application/json" } : {}) },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        const json = await res.json().catch(() => ({}));
+        if (!res.ok)
+            throw new Error(json.error ?? `HTTP ${res.status}`);
+        return json;
+    }
+    /** A picture from the daemon, or undefined when there is none (or it is not an image). */
+    async picture(method, url, body) {
+        const res = await fetch(this.base + url, {
+            method,
+            headers: { authorization: `Bearer ${this.token}`, ...(body !== undefined ? { "content-type": "application/json" } : {}) },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        if (res.status === 404)
+            return undefined;
+        if (!res.ok)
+            throw new Error((await res.json().catch(() => ({}))).error ?? `HTTP ${res.status}`);
+        return { mime: res.headers.get("content-type") ?? "", bytes: Buffer.from(await res.arrayBuffer()) };
+    }
+    toolImage = (id) => this.picture("GET", `/media/tool/${encodeURIComponent(id)}`);
+    taskImage = (task, n) => this.picture("GET", `/tasks/${task}/images/${n}`);
+    workspaceImage = (agent, file, session) => this.picture("GET", `/agents/${encodeURIComponent(agent)}/image?path=${encodeURIComponent(file)}${session ? `&session=${encodeURIComponent(session)}` : ""}`);
+    fetchImage = (url) => this.picture("POST", "/images/fetch", { url });
+    sources = () => this.get("/sources");
+    subscribeTo = (agent, source, details = {}) => this.post(`/agents/${agent}/subscribe`, { source, ...details });
+    unsubscribeFrom = (agent, source, session) => this.post(`/agents/${agent}/unsubscribe`, { source, session });
+    subscribeAll = (source, details = {}) => this.post("/subscribe", { source, ...details });
+    unsubscribeAll = (source) => this.post("/unsubscribe", { source });
+    /** Tell the daemon a conversation was closed here; returns the sources it was subscribed to on its own. */
+    closeSession = (agent, session) => this.post(`/agents/${agent}/close`, { session });
+    get = (url) => this.call("GET", url);
+    post = (url, body = {}) => this.call("POST", url, body);
+    agents = () => this.get("/agents");
+    status = () => this.get("/status");
+    models = () => this.get("/models");
+    sessions = (agent) => this.get(`/agents/${agent}/sessions`);
+    removeSession = (agent, session) => this.post(`/agents/${agent}/remove`, { session });
+    renameSession = (agent, session, to) => this.post(`/agents/${agent}/rename`, { session, to });
+    pinSession = (agent, session, pinned) => this.post(`/agents/${agent}/pin`, { session, pinned });
+    folder = (agent, session) => this.get(`/agents/${agent}/folder?session=${encodeURIComponent(session)}`);
+    folders = (agent) => this.get(`/agents/${agent}/folders`);
+    setFolder = (agent, session, folder) => this.post(`/agents/${agent}/folder`, { session, folder });
+    changes = (agent, session) => this.get(`/agents/${agent}/view/changes?session=${encodeURIComponent(session)}`);
+    diff = (agent, session, file) => this.get(`/agents/${agent}/view/diff?session=${encodeURIComponent(session)}&path=${encodeURIComponent(file)}`);
+    tree = (agent, session, dir) => this.get(`/agents/${agent}/view/tree?session=${encodeURIComponent(session)}&path=${encodeURIComponent(dir)}`);
+    file = (agent, session, file) => this.get(`/agents/${agent}/view/file?session=${encodeURIComponent(session)}&path=${encodeURIComponent(file)}`);
+    output = (task) => this.get(`/tasks/${task}/transcript?full=1`);
+    tabs = () => this.get("/ui/tabs");
+    saveTabs = (tabs, active, code = false) => this.post("/ui/tabs", { tabs, active, code });
+    history = (agent, session, limit = 30) => this.get(`/tasks?agent=${encodeURIComponent(agent)}&session=${encodeURIComponent(session)}&limit=${limit}`);
+    prompt = (agent, prompt, session, attachments) => this.post(`/agents/${agent}/prompt`, { prompt, session, wait: false, attachments });
+    ask = (agent, prompt, session) => this.post(`/agents/${agent}/prompt`, { prompt, session });
+    transcript = (task) => this.get(`/tasks/${task}/transcript`);
+    cancel = (task) => this.post(`/tasks/${task}/cancel`);
+    reset = (agent, session) => this.post(`/agents/${agent}/reset`, { session });
+    setThinking = (agent, level) => this.post(`/agents/${agent}/thinking`, { level });
+    setMode = (agent, mode, anyway) => this.post(`/agents/${agent}/mode`, { mode, session: anyway, anyway: anyway !== undefined });
+    setModel = (agent, model) => this.post(`/agents/${agent}/model`, { model });
+    approvals = () => this.get("/approvals");
+    decide = (id, allow, always = false, values) => this.post(`/approvals/${id}`, { allow, always, values });
+    emit = (topic, payload) => this.post("/events", { topic, payload });
+    state = (pattern = "#") => this.get(`/state?key=${encodeURIComponent(pattern)}`);
+    /** Live events. Reconnects until the returned function is called. */
+    subscribe(onEvent, onState = () => { }) {
+        const abort = new AbortController();
+        const loop = async () => {
+            while (!abort.signal.aborted) {
+                try {
+                    const res = await fetch(`${this.base}/events/stream?topic=%23`, { headers: { authorization: `Bearer ${this.token}` }, signal: abort.signal });
+                    if (!res.ok || !res.body)
+                        throw new Error(`HTTP ${res.status}`);
+                    onState(true);
+                    let buf = "";
+                    const decoder = new TextDecoder();
+                    for await (const chunk of res.body) {
+                        buf += decoder.decode(chunk, { stream: true });
+                        for (let i = buf.indexOf("\n\n"); i >= 0; i = buf.indexOf("\n\n")) {
+                            const block = buf.slice(0, i);
+                            buf = buf.slice(i + 2);
+                            if (!block.startsWith("data: "))
+                                continue;
+                            try {
+                                onEvent(JSON.parse(block.slice(6)));
+                            }
+                            catch {
+                                // A malformed frame is skipped; the stream goes on.
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // fall through to the retry
+                }
+                if (abort.signal.aborted)
+                    return;
+                onState(false);
+                await new Promise((r) => setTimeout(r, 1000));
+            }
+        };
+        void loop();
+        return () => abort.abort();
+    }
+}

package/src/tui/code-pane.d.ts

@@ -0,0 +1,51 @@
+import { VStack } from "@earendil-works/pi-tui";
+import type { Client } from "./client.ts";
+export type PaneView = "changes" | "files" | "output";
+export declare const PANE_VIEWS: PaneView[];
+/** The conversation a pane shows. */
+export interface PaneTarget {
+    agent: string;
+    session: string;
+}
+/** The lines of a diff as git prints it, in colours, without the lines that only name the file. */
+export declare function diffLines(diff: string): string[];
+export declare class CodePane {
+    /** What goes into the layout. */
+    readonly component: VStack;
+    private client;
+    private redraw;
+    private close;
+    private target;
+    private states;
+    private rows;
+    private scroll;
+    private hits;
+    private timer?;
+    private width;
+    /** Counts loads, so that an answer that arrives late does not overwrite a newer one. */
+    private turn;
+    constructor(opts: {
+        client: Client;
+        redraw: () => void;
+        close: () => void;
+        target: () => PaneTarget | undefined;
+    });
+    private get state();
+    get view(): PaneView;
+    /** Show one of the views, from its top level. Without a view: whatever was shown last, read again. */
+    show(view?: PaneView): void;
+    /** The conversation shown changed its folder: what was read from the old one is not shown any more. */
+    forget(target: PaneTarget): void;
+    /** Something happened that may have changed what is shown (a tool ran, a task ended): read it again in a moment. */
+    touch(): void;
+    stop(): void;
+    private load;
+    private fileRows;
+    private go;
+    private back;
+    private build;
+    private changesRows;
+    private filesRows;
+    private outputRows;
+    private renderHead;
+}