@turri-dev/cli 0.1.16 → 0.1.17-next.63f454c

package/dist/chat-ui.js

@@ -0,0 +1,192 @@
+/** Notices kept for a hidden chat: the most recent. */
+const NOTICES_KEPT = 10;
+export function createChatUi(options) {
+    let screen;
+    let lastScreen;
+    const waiting = [];
+    let asking = false;
+    let notices = [];
+    let draft = "";
+    // What the chat keeps on the screen, to put back each time it is shown.
+    const widgets = new Map();
+    const statuses = new Map();
+    const kept = new Map();
+    const inputHandlers = new Map();
+    const providers = [];
+    const any = () => screen ?? lastScreen ?? options.screen();
+    const call = (name, args) => screen[name](...args);
+    /** Its questions, asked one after another while it is shown. */
+    const askWaiting = async () => {
+        if (asking)
+            return;
+        asking = true;
+        try {
+            while (screen !== undefined && waiting.length > 0) {
+                const next = waiting.shift();
+                options.onChange?.();
+                try {
+                    next.resolve(await next.ask(screen));
+                }
+                catch (error) {
+                    next.reject(error);
+                }
+            }
+        }
+        finally {
+            asking = false;
+        }
+    };
+    const dialog = (name, none) => (...args) => {
+        if (screen !== undefined && waiting.length === 0)
+            return call(name, args);
+        return new Promise((resolve, reject) => {
+            waiting.push({ ask: (shown) => shown[name](...args), resolve, reject, none });
+            options.onChange?.();
+            void askWaiting();
+        });
+    };
+    // What it keeps on the screen: written down, and drawn when it is shown.
+    const keep = (name) => (...args) => {
+        kept.set(name, args);
+        if (screen !== undefined)
+            call(name, args);
+    };
+    const overrides = {
+        select: dialog("select", undefined),
+        confirm: dialog("confirm", false),
+        input: dialog("input", undefined),
+        editor: dialog("editor", undefined),
+        custom: dialog("custom", undefined),
+        notify: (message, type) => {
+            if (screen !== undefined)
+                screen.notify(message, type);
+            else
+                notices = [...notices, [message, type]].slice(-NOTICES_KEPT);
+        },
+        setWidget: (key, ...rest) => {
+            if (rest[0] === undefined)
+                widgets.delete(key);
+            else
+                widgets.set(key, [key, ...rest]);
+            if (screen !== undefined)
+                call("setWidget", [key, ...rest]);
+        },
+        setStatus: (key, text) => {
+            if (text === undefined)
+                statuses.delete(key);
+            else
+                statuses.set(key, text);
+            if (screen !== undefined)
+                screen.setStatus(key, text);
+        },
+        setWorkingMessage: keep("setWorkingMessage"),
+        setWorkingVisible: keep("setWorkingVisible"),
+        setWorkingIndicator: keep("setWorkingIndicator"),
+        setHiddenThinkingLabel: keep("setHiddenThinkingLabel"),
+        setFooter: keep("setFooter"),
+        setHeader: keep("setHeader"),
+        setTitle: keep("setTitle"),
+        setEditorComponent: keep("setEditorComponent"),
+        onTerminalInput: (handler) => {
+            inputHandlers.set(handler, screen?.onTerminalInput(handler));
+            return () => {
+                inputHandlers.get(handler)?.();
+                inputHandlers.delete(handler);
+            };
+        },
+        addAutocompleteProvider: (factory) => {
+            providers.push(factory);
+            if (screen !== undefined)
+                call("addAutocompleteProvider", [factory]);
+        },
+        getEditorText: () => (screen !== undefined ? screen.getEditorText() : draft),
+        setEditorText: (text) => {
+            if (screen !== undefined)
+                screen.setEditorText(text);
+            else
+                draft = text;
+        },
+        pasteToEditor: (text) => {
+            if (screen !== undefined)
+                screen.pasteToEditor(text);
+            else
+                draft += text;
+        },
+    };
+    // What the screen has besides, forwarded to the screen as it is when called: one function a name, kept.
+    const forwarders = new Map();
+    const read = (key) => {
+        if (typeof key === "string" && key in overrides)
+            return overrides[key];
+        const target = any();
+        if (target === undefined)
+            return undefined;
+        const value = Reflect.get(target, key);
+        if (typeof value !== "function")
+            return value;
+        let forward = forwarders.get(key);
+        if (forward === undefined) {
+            forward = (...args) => Reflect.get(any(), key).apply(any(), args);
+            forwarders.set(key, forward);
+        }
+        return forward;
+    };
+    const keys = () => [...new Set([...Object.keys(overrides), ...(any() !== undefined ? Reflect.ownKeys(any()) : [])])];
+    // pi copies the ui it is given - `{ ...ui }` - so every name is the stand-in's own, not only read through it.
+    const ui = new Proxy({}, {
+        get: (_target, key) => read(key),
+        has: (_target, key) => keys().includes(key),
+        ownKeys: () => keys().filter((key) => typeof key !== "number"),
+        getOwnPropertyDescriptor: (_target, key) => (keys().includes(key) ? { value: read(key), enumerable: true, configurable: true, writable: false } : undefined),
+    });
+    return {
+        ui,
+        get shown() {
+            return screen !== undefined;
+        },
+        show(next) {
+            screen = next;
+            lastScreen = next;
+            for (const args of widgets.values())
+                call("setWidget", args);
+            for (const [key, text] of statuses)
+                next.setStatus(key, text);
+            for (const [name, args] of kept)
+                call(name, args);
+            for (const handler of inputHandlers.keys())
+                inputHandlers.set(handler, next.onTerminalInput(handler));
+            for (const factory of providers)
+                call("addAutocompleteProvider", [factory]);
+            if (draft !== "")
+                next.setEditorText(draft);
+            draft = "";
+            for (const [message, type] of notices)
+                next.notify(message, type);
+            notices = [];
+            options.onChange?.();
+            void askWaiting();
+        },
+        hide() {
+            if (screen === undefined)
+                return;
+            try {
+                draft = screen.getEditorText();
+                screen.setEditorText("");
+            }
+            catch {
+                draft = "";
+            }
+            // pi takes them off the screen as it shows another chat; they are put on again when this one is shown.
+            for (const handler of inputHandlers.keys())
+                inputHandlers.set(handler, undefined);
+            screen = undefined;
+            options.onChange?.();
+        },
+        waiting: () => waiting.length,
+        close() {
+            for (const next of waiting.splice(0))
+                next.resolve(next.none);
+            screen = undefined;
+        },
+    };
+}

package/dist/chats.d.ts

@@ -0,0 +1,192 @@
+import type { AgentSession, ExtensionAPI, ExtensionContext, ExtensionFactory, ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import { type ChatScope } from "./chat-scope.ts";
+import { type RunRecord } from "./chat-records.ts";
+import { type ChatUi } from "./chat-ui.ts";
+import type { AskUserIO } from "./ask.ts";
+import type { Job, JobRegistry } from "./regenerate/jobs.ts";
+/**
+ * The chats of a turri session.
+ *
+ * One turri process is one session on one project, and holds up to MAX_CHATS chats: conversations, each with its own
+ * history, model, thinking level, stack and questions, each working while another is shown. What they share is the
+ * session's: the one job registry and work loop the project's pulses run in - a pulse any chat starts is in every
+ * chat's side panel - the coding model, steering, releases and the ledger.
+ *
+ * A chat is a pi session with turri's extension in it. The extension, built once for each, links itself to its chat
+ * here (`attach`); its tools, commands and handlers then run inside the chat's scope (chat-scope.ts), so a pulse knows
+ * which chat asked for it, and is reported back there when it ends - to the chat shown, when that one is closed.
+ *
+ * Where the chats live is a driver's: the terminal's (chat-terminal.ts) swaps which one pi's screen shows; a host's
+ * (`createTurri`) makes a session for each and shows them in its own windows.
+ */
+/** The most chats a session has open at once. */
+export declare const MAX_CHATS = 9;
+/** What a chat is called until something is said in it. */
+export declare const NEW_CHAT_TITLE = "new chat";
+export type ChatStatus = "idle" | "working" | "question" | "unread";
+export interface ChatInfo {
+    id: string;
+    title: string;
+    /** What it is doing: a turn running, a question waiting for it to be shown, something said since it was last shown. */
+    status: ChatStatus;
+    /** On the screen now - the terminal's, or the window the host said it shows (`focus`). */
+    shown: boolean;
+}
+/** What turri tells and asks a host that runs its conversation itself. */
+export interface TurriHost {
+    /** A job started, moved to another stage, did something, or ended. */
+    onJobChange?(job: Job): void;
+    /** What is planned changed with no job - a module being planned, or planned. */
+    onPlanChange?(): void;
+    /** The dialogs ask_user puts its questions in - the conversation's and a skill's interview - instead of the terminal's. */
+    dialogs?: AskUserIO;
+    /**
+     * The host's own UI, in its own words: the views it has in place of the terminal's, what its marks and buttons mean,
+     * where questions appear. Given, turri tells the model none of the terminal's - its keys, the side panel, regen,
+     * /pulses - and gives it this instead, as a `<surface>` block in turri's identity. Absent, the terminal is the surface.
+     */
+    surface?: string;
+    /**
+     * The last word on the whole system prompt, as turri has built it for this turn - after its own before_agent_start
+     * work: what it returns is what is sent. For a host that needs to change anything else.
+     */
+    systemPrompt?(prompt: string): string;
+}
+/** What a chat's extension does for its chat when the session asks. */
+export interface ChatInstance {
+    /** A pulse it asked for ended: said in the chat, and its agent told. */
+    announce(job: Job): void;
+    /** The jobs changed: what it draws of them is drawn again. */
+    jobsChanged(): void;
+    /** How hard the chat's model thinks now: sub-agents started from it think as hard. */
+    thinkingLevel(): string | undefined;
+    /** The chat's context, as its tools get it - for its model and its providers. */
+    context(): ExtensionContext | undefined;
+}
+/** A chat's extension, linked to its chat. */
+export interface ChatLink {
+    readonly id: string;
+    readonly scope: ChatScope;
+    /** The host's dialogs, for this chat's questions - undefined in the terminal. */
+    readonly dialogs: AskUserIO | undefined;
+    /** The extension built for the chat - again, when pi rebuilds it - and what it does for it. */
+    live(instance: ChatInstance): void;
+}
+/** Where chats live: the terminal's screen, or a host's windows. */
+export interface ChatDriver {
+    /** pi's terminal: the chats are switched between with its keys and /chat. */
+    terminal?: boolean;
+    /** A session for the chat - its saved one, when `sessionFile` - with the session's extension built for it. */
+    create(chat: ChatState, sessionFile: string | undefined): Promise<void>;
+    /** Put the chat on the screen. */
+    show?(chat: ChatState, from: ChatState | undefined): Promise<void>;
+    /** The chat is closed or the session ends: its session let go. */
+    dispose(chat: ChatState): Promise<void>;
+}
+/** A chat, as the session keeps it. */
+export interface ChatState {
+    id: string;
+    scope: ChatScope;
+    /** Its title as recorded, until it says one of its own. */
+    recordedTitle?: string;
+    session?: AgentSession;
+    /** pi's services the session was made with - the terminal's driver hands them to pi with it. */
+    services?: unknown;
+    /** What it draws on, in the terminal. */
+    ui?: ChatUi;
+    instance?: ChatInstance;
+    dialogs?: AskUserIO;
+    working: boolean;
+    unread: boolean;
+    unsubscribe?: () => void;
+}
+export interface TurriCore {
+    readonly cwd: string;
+    readonly host: TurriHost;
+    readonly jobs: JobRegistry;
+    /** turri's extension, for pi to build into each chat's session. */
+    readonly extension: ExtensionFactory;
+    /** Whether chats can be opened beside the one there is - with a driver that has somewhere to put them. */
+    readonly canOpen: boolean;
+    /** Whether the chats are the terminal's, switched between with /chat and its keys. */
+    readonly terminal: boolean;
+    chats(): ChatInfo[];
+    /** The chat's pi session. */
+    session(id: string): AgentSession | undefined;
+    /** The chat shown now. */
+    shown(): string | undefined;
+    /** Open a chat - fresh, or the saved one `sessionFile` is - shown at once unless `hidden`. */
+    open(options?: {
+        sessionFile?: string;
+        hidden?: boolean;
+        title?: string;
+    }): Promise<ChatInfo>;
+    close(id: string): Promise<void>;
+    /** Show the chat - in the terminal, put it on the screen; for a host, the one its person looks at now. */
+    show(id: string): Promise<void>;
+    onChats(listener: () => void): () => void;
+    /** For a driver: something about the chats changed - a question waiting, one shown - and those listening are told. */
+    changed(): void;
+    /** Said in the chat shown - or the first one shown, when none is yet. */
+    notify(message: string, level: "info" | "warning" | "error"): void;
+    /** Every chat let go, but the one pi is letting go itself. */
+    dispose(options?: {
+        except?: AgentSession;
+    }): Promise<void>;
+    /** For the extension: the chat a pi API is built for (see ChatLink). */
+    attach(pi: ExtensionAPI): ChatLink;
+    /** For a driver: the chat whose session this is, or none. */
+    chatOfSession(session: AgentSession): ChatState | undefined;
+    /** For a driver: the chat shown now, as the session keeps it. */
+    shownChat(): ChatState | undefined;
+    /** For the terminal's driver: the chat made by pi itself, its session now known - the first, or one pi rebuilt. */
+    adopt(session: AgentSession, services: unknown): ChatState;
+    /** For a driver: `chat` is on the screen now. */
+    showing(chat: ChatState): void;
+    /** For the extension: a pulse ended - told to the chat that asked for it. */
+    jobFinished(job: Job): void;
+    /** For the extension: the jobs changed - every chat draws them again. */
+    jobsChanged(): void;
+    /** The chat whose work this is, else the one shown: its instance. */
+    instanceInScope(): ChatInstance | undefined;
+    setDriver(driver: ChatDriver): void;
+    /** Reopen a run's chats - `--continue` - beside the first, which pi reopened itself. */
+    restore(run: RunRecord, options?: {
+        skipFirst?: boolean;
+    }): Promise<void>;
+}
+export interface CoreOptions {
+    cwd: string;
+    host: TurriHost;
+    jobs: JobRegistry;
+    /** The extension, as it builds itself into a chat. */
+    extension: (pi: ExtensionAPI, link: ChatLink) => void;
+    /** Record the open chats in .turri/chats.json - not for pi's print, json and rpc modes. */
+    persist?: boolean;
+    /** The host's dialogs, a chat's own. */
+    dialogs?: (chat: string) => AskUserIO | undefined;
+}
+/** A chat's session, as stopping what it does reaches it. */
+export type Stoppable = Pick<AgentSession, "isStreaming" | "isCompacting" | "isRetrying" | "isBashRunning" | "abort" | "abortBash">;
+/** A second interrupt this soon after one that stopped something stops nothing more and ends nothing: one pressed twice to be sure. */
+export declare const INTERRUPT_SETTLE_MS = 500;
+/**
+ * ctrl+c in a chat, the terminal's or a host's: what the chat is doing stopped - its turn, a skill or a tool in it, a
+ * `!` command, a compaction, a retry - and nothing in the other chats. `stopTurn` ends its turn: pi's own esc in the
+ * terminal. A chat doing nothing gets `idle`'s answer - the session ended - unless the last interrupt, at `lastStop`,
+ * stopped something a moment ago: then it is `ignored`.
+ */
+export declare function interruptChat<R>(session: Stoppable, asked: {
+    lastStop: number;
+    now?: number;
+    stopTurn?: () => void;
+    idle: () => R;
+}): "stopped" | "ignored" | R;
+export declare function createChats(options: CoreOptions): TurriCore;
+/**
+ * pi's extension API for a chat: every tool, command, shortcut and handler the extension registers runs inside the
+ * chat's scope - its stack, and its id on what it starts.
+ */
+export declare function scopedToChat(pi: ExtensionAPI, scope: ChatScope): ExtensionAPI;
+/** A chat's stand-in for the screen, for the terminal's driver. */
+export declare function terminalUi(chat: ChatState, screen: () => ExtensionUIContext | undefined, onChange: () => void): ChatUi;