@glbgpt/cli 0.1.0-test.1

package/dist/src/tui/chatController.d.ts

@@ -0,0 +1,188 @@
+import type { ChatMessage, ClientTool, ToolResult } from '../core/types.js';
+import { type AttachmentContext } from './attachments.js';
+import { Session } from '../core/session.js';
+import type { TurnLoop } from '../core/turnLoop.js';
+import type { TaskEvent } from '../media/taskManager.js';
+/** One rendered entry in the conversation timeline. */
+export type TimelineItem = {
+    kind: 'user';
+    text: string;
+} | {
+    kind: 'assistant';
+    text: string;
+} | {
+    kind: 'tool';
+    id: string;
+    name: string;
+    status: 'running' | 'done';
+    args?: Record<string, unknown>;
+    result?: ToolResult;
+} | {
+    kind: 'note';
+    text: string;
+} | {
+    kind: 'media';
+    taskId: string;
+    status: 'done' | 'failed';
+    localPath?: string;
+    reason?: string;
+} | {
+    kind: 'error';
+    text: string;
+};
+export interface ViewState {
+    model: string;
+    items: TimelineItem[];
+    /** True while a turn is in flight (input disabled, spinner shown). */
+    busy: boolean;
+    /** Generation tasks currently polling in the background (drives the task summary bar). */
+    runningTasks: RunningTask[];
+    /** Messages typed while busy — attachments already resolved (snapshot at Enter time);
+     *  sent automatically, in order, when the turn ends. */
+    queued: QueuedMessage[];
+    /** Cumulative session usage (chat tokens are informational; billing is server-side). */
+    sessionUsage: SessionUsage;
+}
+/** A message resolved at Enter time and waiting for the current turn to finish. */
+export interface QueuedMessage {
+    content: string | import('../core/types.js').ContentPart[];
+    display: string;
+}
+export interface SessionUsage {
+    promptTokens: number;
+    completionTokens: number;
+    turns: number;
+    /** Sum of estimated credits for media tasks submitted this session (estimates, not the bill). */
+    mediaCreditsEstimated: number;
+    mediaSubmits: number;
+}
+/** A background generation task still in flight. */
+export interface RunningTask {
+    taskId: string;
+    status: string;
+    elapsedMs: number;
+}
+/** Optional capabilities wired in by run.tsx; each slash command degrades gracefully without one. */
+export interface ControllerExtras {
+    /** The same media tool instances the model uses (shared confirmation/ledger/polling path). */
+    mediaTools?: {
+        image?: ClientTool;
+        video?: ClientTool;
+    };
+    /** Recent task records for `/tasks` (e.g. TaskLedger.list). */
+    listRecentTasks?: () => Promise<Array<{
+        taskId: string;
+        model: string;
+        prompt: string;
+    }>>;
+    /** One extra status line for `/status` (e.g. plan/balance from the account API). */
+    fetchAccountLine?: () => Promise<string | null>;
+    /** Full multi-line account summary for `/account` (email · plan · balance). */
+    fetchAccount?: () => Promise<string>;
+    /** Recent spend lines for `/transactions` (authoritative billing). */
+    fetchTransactions?: () => Promise<string>;
+    /** Re-authenticate in place (`/login`), hot-swapping the token everywhere; returns a status line. */
+    reauth?: (mode: 'browser' | 'no-browser') => Promise<string>;
+    /** Sign out (`/logout`): clear stored credentials; returns a status line. */
+    logout?: () => Promise<string>;
+    /** Injectable attachment IO overrides (tests). */
+    attachmentIO?: Pick<AttachmentContext, 'readFile' | 'readClipboard'>;
+}
+/**
+ * Headless controller for the chat TUI: owns the view state and maps the engine's
+ * EngineEvent stream into a renderable timeline. Contains no Ink/React so it can be
+ * unit-tested deterministically; the Ink view is a thin layer over it.
+ */
+export declare class ChatController {
+    private session;
+    private readonly turnLoop;
+    private readonly extras;
+    private state;
+    private readonly subscribers;
+    /** Index of the assistant item currently collecting deltas, or -1 if none is open. */
+    private openAssistant;
+    /** Abort controller for the in-flight turn (null when idle). */
+    private turnAbort;
+    /** Serializes busy-time enqueues so rapid submits keep keystroke order. */
+    private enqueueChain;
+    /** Output URL of the most recently completed generation (for `@image` attachments). */
+    private lastMediaUrl;
+    /** Session start (for the exit summary). */
+    readonly startedAt: number;
+    constructor(session: Session, turnLoop: TurnLoop, extras?: ControllerExtras);
+    getState(): ViewState;
+    /**
+     * Timeline items safe to persist: a tool row still 'running' mid-turn has no outcome —
+     * persisting it would resurrect as a forever-spinning zombie on resume. The settled row
+     * re-persists when the turn ends.
+     */
+    getPersistableItems(): TimelineItem[];
+    /** The session currently being edited (swapped by `/new`); used for persistence. */
+    getSession(): Session;
+    /**
+     * Restore the visible timeline on `resume`. Prefers the PERSISTED transcript (stored
+     * alongside the messages, Codex-rollout style); falls back to deriving it from the
+     * model messages for sessions saved before transcripts were persisted.
+     */
+    hydrateFromSession(persisted?: unknown[]): void;
+    /** Subscribe to state changes. Returns an unsubscribe function. */
+    subscribe(cb: (state: ViewState) => void): () => void;
+    switchModel(model: string): void;
+    /** Start a fresh conversation (a new session id), keeping the current model. */
+    reset(): void;
+    showHelp(): void;
+    /** Track background generation tasks: progress updates the summary bar; completion hits the timeline. */
+    handleTaskEvent(e: TaskEvent): void;
+    /**
+     * `/image` / `/video`: run the same client tool the model uses, so the confirmation gate,
+     * ledger, background polling, and error mapping are identical to the natural-language path.
+     * `rest` accepts the CLI's flag syntax (`a cat --ar 16:9 --res 2K -m nano-banana-2 ...`).
+     */
+    runMedia(kind: 'image' | 'video', rest: string): Promise<void>;
+    /** `/tasks`: running tasks plus recent history. */
+    showTasks(): Promise<void>;
+    /** `/status`: session/model basics immediately, account line when it arrives. */
+    showStatus(): Promise<void>;
+    /** `/models`: list chat + image/video models available (server-driven catalog applied). */
+    showModels(): void;
+    /** `/account`: full account summary (email · plan · balance). */
+    showAccount(): Promise<void>;
+    /** `/transactions`: authoritative recent spend. */
+    showTransactions(): Promise<void>;
+    /** `/login`: re-authenticate in place, hot-swapping the token everywhere. */
+    reauth(mode: 'browser' | 'no-browser'): Promise<void>;
+    /** `/logout`: clear stored credentials. */
+    logout(): Promise<void>;
+    /** `/resume`: swap in a previously saved session and rebuild the timeline. */
+    replaceSession(session: Session, persistedTimeline?: unknown[]): void;
+    note(text: string): void;
+    /**
+     * Submit a user message and run one turn to completion, updating the timeline as events
+     * arrive. `displayText` (when given) is what the transcript shows — e.g. "[Image #1]"
+     * placeholders — while `text` carries the expanded form for attachment resolution.
+     *
+     * Attachments resolve at ENTER time (snapshot semantics — @clipboard reads the clipboard
+     * now, not minutes later when a queued message flushes), and the queue stores the RESOLVED
+     * content so pasted images survive queueing.
+     */
+    submit(text: string, displayText?: string): Promise<void>;
+    /** Resolve `@…` attachments into a queueable message; null → error already noted. */
+    private resolveForSubmit;
+    /** Run one turn whose attachments are already resolved. Caller owns the busy flag. */
+    private runResolvedTurn;
+    /** Send the next queued (already-resolved) message, if any (runs after each turn settles). */
+    private flushQueued;
+    /** Accumulate the estimated cost of a submitted media task (estimates only, not the bill). */
+    private recordMediaSubmit;
+    /** `/cost`: session usage breakdown. Authoritative spend lives in `glbgpt account transactions`. */
+    showCost(): void;
+    /** Interrupt the in-flight turn (Esc). Partial output is kept; no-op when idle. */
+    interrupt(): void;
+    private onEvent;
+    private addItem;
+    private replaceItem;
+    private setState;
+    private emit;
+}
+/** Convert a stored message history into renderable timeline items (for resume). */
+export declare function timelineFromMessages(messages: ChatMessage[]): TimelineItem[];