@ngandu/ulicode 0.0.6

package/dist/tui.d.ts

@@ -0,0 +1,1013 @@
+import { Container, Focusable, TUI, MarkdownTheme, Editor, EditorTheme, ProcessTerminal, Text, CombinedAutocompleteProvider, Box, Input } from '@mariozechner/pi-tui';
+import { HarnessMessage, OMStatus, OMProgressState, TaskItem, Harness } from '@mastra/core/harness';
+export { OMProgressState, OMStatus } from '@mastra/core/harness';
+import { Workspace } from '@mastra/core/workspace';
+import { H as HookManager, A as AuthStorage, a as McpManager, P as ProjectInfo, O as OAuthProviderInterface } from './project-q9WpahUs.js';
+
+/**
+ * Onboarding "packs" — predefined model configurations for each mode.
+ *
+ * Each pack assigns a default model to every configured mode,
+ * plus an OM (observational memory) model.
+ */
+interface ModePack {
+    id: string;
+    name: string;
+    description: string;
+    models: Record<string, string>;
+}
+interface ModePackOption {
+    id: string;
+    label: string;
+    color?: string;
+}
+interface OMPack {
+    id: string;
+    name: string;
+    description: string;
+    modelId: string;
+}
+
+/**
+ * Inline onboarding component.
+ *
+ * Walks the user through a multi-step wizard:
+ *  1. Welcome
+ *  2. Auth / Login prompt
+ *  3. Mode pack selection (model preset for every configured mode)
+ *  4. OM pack selection (observational memory model)
+ *  5. YOLO mode toggle
+ *
+ * The component renders each step inline in the conversation stream.
+ * On completion it fires `onComplete` with the collected choices.
+ */
+
+interface OnboardingResult {
+    modePack: ModePack;
+    omPack: OMPack;
+    yolo: boolean;
+    /** True if the user chose to log in (auth flow handled externally). */
+    loginRequested: boolean;
+    loginProvider?: string;
+}
+/** Previously saved selections to pre-populate when re-running /setup. */
+interface PreviousSetupChoices {
+    modePackId: string | null;
+    omPackId: string | null;
+    yolo: boolean | null;
+}
+interface OnboardingOptions {
+    tui: TUI;
+    /** OAuth providers available for login. label=display name, value=provider id */
+    authProviders: Array<{
+        label: string;
+        value: string;
+        loggedIn: boolean;
+    }>;
+    /** Whether to show the direct API-key login method in the auth step. */
+    allowApiKeyLogin?: boolean;
+    /** Available mode packs (pre-filtered by provider access). */
+    modePacks: ModePack[];
+    /** Ordered mode metadata used for pack rendering and custom pack selection. */
+    packModes: ModePackOption[];
+    /** Available OM packs (pre-filtered by provider access). */
+    omPacks: OMPack[];
+    /** Whether the user has any provider access (API key or OAuth) — even for providers without a built-in pack. */
+    hasProviderAccess: boolean;
+    /** Previously saved choices — used to highlight current selections when re-running. */
+    previous?: PreviousSetupChoices;
+    /** Called when the wizard completes. */
+    onComplete: (result: OnboardingResult) => void;
+    /** Called if the user cancels the wizard (Esc on welcome). */
+    onCancel: () => void;
+    /** Called when the user requests login during onboarding. */
+    onLogin: (providerId: string, done: () => void) => void;
+    /** Called when the user chooses the direct API-key login flow during onboarding. */
+    onSetApiKey: (done: () => void) => void;
+    /** Show the model selector overlay and return the chosen model ID (or undefined on cancel). */
+    onSelectModel: (title: string, modeColor?: string) => Promise<string | undefined>;
+}
+declare class OnboardingInlineComponent extends Container implements Focusable {
+    private tui;
+    private options;
+    private currentStep;
+    private stepBox;
+    private selectList?;
+    private activeInlineQuestion?;
+    private _finished;
+    private loginRequested;
+    private loginProvider?;
+    private selectedModePack;
+    private selectedOmPack;
+    private selectedYolo;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    constructor(options: OnboardingOptions);
+    get finished(): boolean;
+    /** Programmatically cancel the wizard (e.g. on Ctrl+C). */
+    cancel(): void;
+    /** Refresh the available mode packs (e.g. after a login grants new provider access). */
+    updateModePacks(packs: ModePack[]): void;
+    /** Refresh the available OM packs (e.g. after a login grants new provider access). */
+    updateOmPacks(packs: OMPack[]): void;
+    /** Update whether the user has any provider access (e.g. after a login). */
+    updateHasProviderAccess(hasAccess: boolean): void;
+    private clearStep;
+    private renderStep;
+    private stepCount;
+    private makeBox;
+    private renderWelcome;
+    private renderAuth;
+    private renderClaudeMaxWarning;
+    /** Text component showing details for the currently highlighted mode pack. */
+    private modePackDetail?;
+    private renderModePack;
+    private updateModePackDetail;
+    private promptCustomPackName;
+    private runCustomPackFlow;
+    private renderOmPack;
+    private runCustomOmFlow;
+    private renderYolo;
+    private renderDone;
+    private collapseStep;
+    handleInput(data: string): void;
+}
+
+/**
+ * Metadata for a slash command
+ */
+interface SlashCommandMetadata {
+    /** Command name (e.g., "git:commit") */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** The command template with variables */
+    template: string;
+    /** Source file path */
+    sourcePath: string;
+    /** Namespace derived from directory structure */
+    namespace?: string;
+}
+
+/**
+ * Inline ask question component.
+ * Shows a question with either selectable options or free-text input
+ * directly in the conversation flow instead of as an overlay dialog.
+ */
+
+interface AskQuestionInlineOptions {
+    question: string;
+    options?: Array<{
+        label: string;
+        description?: string;
+    }>;
+    /** Format the text shown after an answer is selected. Defaults to `question → answer`. */
+    formatResult?: (answer: string) => string;
+    /** If provided, determines whether an answer should be shown with error styling (red ✗). */
+    isNegativeAnswer?: (answer: string) => boolean;
+    /** Allow submitting an empty string in free-text mode. */
+    allowEmptyInput?: boolean;
+    onSubmit: (answer: string) => void;
+    onCancel: () => void;
+}
+declare class AskQuestionInlineComponent extends Container implements Focusable {
+    private contentBox;
+    private selectList?;
+    private input?;
+    private onSubmit;
+    private onCancel;
+    private formatResult?;
+    private isNegativeAnswer?;
+    private allowEmptyInput;
+    private answered;
+    private questionText;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    constructor(options: AskQuestionInlineOptions, _ui: TUI);
+    private buildSelectMode;
+    private buildInputMode;
+    private handleAnswer;
+    private handleCancel;
+    handleInput(data: string): void;
+}
+
+/**
+ * Component that renders an assistant message with streaming support.
+ */
+
+declare class AssistantMessageComponent extends Container {
+    private contentContainer;
+    private hideThinkingBlock;
+    private markdownTheme;
+    private lastMessage?;
+    private _id;
+    constructor(message?: HarnessMessage, hideThinkingBlock?: boolean, markdownTheme?: MarkdownTheme);
+    invalidate(): void;
+    setHideThinkingBlock(hide: boolean): void;
+    updateContent(message: HarnessMessage): void;
+}
+
+/**
+ * Platform-specific clipboard image extraction.
+ *
+ * Checks the system clipboard for image data and returns it as base64.
+ * Uses synchronous execution (execSync) since this only runs on paste events.
+ */
+interface ClipboardImage {
+    data: string;
+    mimeType: string;
+}
+
+/**
+ * Custom editor that handles app-level keybindings for Mastra Code.
+ */
+
+type AppAction = 'clear' | 'exit' | 'suspend' | 'undo' | 'toggleThinking' | 'expandTools' | 'followUp' | 'cycleMode' | 'toggleYolo';
+declare class CustomEditor extends Editor {
+    private actionHandlers;
+    onCtrlD?: () => void;
+    escapeEnabled: boolean;
+    onImagePaste?: (image: ClipboardImage) => void;
+    onOpenFileSelector?: () => void;
+    private pendingBracketedPaste;
+    constructor(tui: TUI, theme: EditorTheme);
+    onAction(action: AppAction, handler: () => unknown): void;
+    private maybeHandleBracketedPaste;
+    private shouldPasteClipboardImage;
+    private getClipboardImageForPastedRemoteImageUrl;
+    private readPastedImageSource;
+    private normalizePastedPathLike;
+    private normalizePastedImageUrl;
+    private normalizePastedFilePath;
+    private getImageMimeType;
+    private handleExplicitPaste;
+    handleInput(data: string): void;
+}
+
+interface PendingFileAttachment {
+    absolutePath: string;
+    relativePath: string;
+}
+
+/**
+ * Manages the gradient sweep animation state.
+ * Call `start()` when agent begins working, `stop()` when idle.
+ * On each tick, call `getOffset()` to get the current sweep position.
+ */
+declare class GradientAnimator {
+    private offset;
+    private intervalId;
+    private onTick;
+    private _isFadingOut;
+    private _isFadingIn;
+    private _fadeProgress;
+    constructor(onTick: () => void);
+    start(): void;
+    /**
+     * Smoothly fade the gradient to idle state over ~500ms.
+     */
+    fadeOut(): void;
+    stop(): void;
+    getOffset(): number;
+    /** 0 = full animation, 1 = fully idle. Use to interpolate colors. */
+    getFadeProgress(): number;
+    isFadingOut(): boolean;
+    isRunning(): boolean;
+}
+
+/**
+ * TUI component for rendering OM observation markers in chat history.
+ * Supports updating in-place (start → end/failed).
+ */
+
+type OMMarkerData = {
+    type: 'om_observation_start';
+    tokensToObserve: number;
+    operationType?: 'observation' | 'reflection';
+} | {
+    type: 'om_observation_end';
+    tokensObserved: number;
+    observationTokens: number;
+    durationMs: number;
+    operationType?: 'observation' | 'reflection';
+} | {
+    type: 'om_observation_failed';
+    error: string;
+    tokensAttempted?: number;
+    operationType?: 'observation' | 'reflection';
+} | {
+    type: 'om_buffering_start';
+    operationType: 'observation' | 'reflection';
+    tokensToBuffer: number;
+} | {
+    type: 'om_buffering_end';
+    operationType: 'observation' | 'reflection';
+    tokensBuffered: number;
+    bufferedTokens: number;
+    observations?: string;
+} | {
+    type: 'om_buffering_failed';
+    operationType: 'observation' | 'reflection';
+    error: string;
+} | {
+    type: 'om_activation';
+    operationType: 'observation' | 'reflection';
+    tokensActivated: number;
+    observationTokens: number;
+};
+/**
+ * Renders an inline OM observation marker in the chat history.
+ * Can be updated in-place to transition from start → end/failed.
+ */
+declare class OMMarkerComponent extends Container {
+    private textChild;
+    constructor(data: OMMarkerData);
+    /**
+     * Update the marker in-place (e.g., from start → end).
+     */
+    update(data: OMMarkerData): void;
+}
+
+/**
+ * Observational Memory progress indicator component.
+ * Shows when OM is observing or reflecting on conversation history.
+ */
+
+/**
+ * Component that displays OM progress in the status line area.
+ * Shows a compact indicator when observation/reflection is happening.
+ */
+declare class OMProgressComponent extends Container {
+    private state;
+    private statusText;
+    constructor();
+    updateProgress(progress: {
+        pendingTokens: number;
+        threshold: number;
+        thresholdPercent: number;
+        observationTokens: number;
+        reflectionThreshold: number;
+        reflectionThresholdPercent: number;
+    }): void;
+    startObservation(cycleId: string, _tokensToObserve: number): void;
+    endObservation(): void;
+    startReflection(cycleId: string): void;
+    endReflection(): void;
+    failOperation(): void;
+    getStatus(): OMStatus;
+    private updateDisplay;
+    private renderProgressBar;
+    private spinnerFrame;
+    private getSpinner;
+    render(maxWidth: number): string[];
+}
+/**
+ * @deprecated Use formatObservationStatus and formatReflectionStatus instead
+ */
+declare function formatOMStatus(state: OMProgressState): string;
+
+/**
+ * Inline plan approval component.
+ * Shows a submitted plan as rendered markdown with Approve/Reject/Request Changes options
+ * directly in the conversation flow.
+ */
+
+interface PlanApprovalInlineOptions {
+    planId: string;
+    title: string;
+    plan: string;
+    onApprove: () => void;
+    onReject: (feedback?: string) => void;
+}
+declare class PlanApprovalInlineComponent extends Container implements Focusable {
+    private contentBox;
+    private selectList?;
+    private feedbackInput?;
+    private onApprove;
+    private onReject;
+    private resolved;
+    private mode;
+    private planTitle;
+    private planContent;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    constructor(options: PlanApprovalInlineOptions, _ui: TUI);
+    private handleSelection;
+    private handleApprove;
+    private handleReject;
+    private switchToFeedbackMode;
+    private showResult;
+    handleInput(data: string): void;
+}
+
+/**
+ * SlashCommandComponent - renders a bordered box for slash command messages
+ * showing the command name as a heading and truncated content that can be
+ * expanded with ctrl+e. The full content is still sent to the assistant.
+ */
+
+declare class SlashCommandComponent extends Container {
+    private commandName;
+    private contentLines;
+    private expanded;
+    constructor(commandName: string, content?: string);
+    setExpanded(expanded: boolean): void;
+    private rebuild;
+}
+
+/**
+ * Common interface and shared types for tool execution components
+ */
+interface ToolResult {
+    content: Array<{
+        type: string;
+        text?: string;
+        data?: string;
+        mimeType?: string;
+    }>;
+    isError: boolean;
+}
+interface IToolExecutionComponent {
+    updateArgs(args: unknown): void;
+    updateResult(result: ToolResult, isPartial?: boolean): void;
+    setExpanded(expanded: boolean): void;
+    /** Append streaming output for shell commands */
+    appendStreamingOutput?(output: string): void;
+}
+
+/**
+ * Subagent execution rendering component.
+ * Shows real-time activity from a delegated subagent task using
+ * the same bordered box style as shell/view tools:
+ *  - Top border
+ *  - Task description (always visible)
+ *  - Streaming tool call activity (capped rolling window)
+ *  - Bottom border with agent type, model, status, duration
+ */
+
+interface SubagentExecutionOptions {
+    /** When true, auto-collapse to a single summary line on completion. Default false. */
+    collapseOnComplete?: boolean;
+}
+declare class SubagentExecutionComponent extends Container implements IToolExecutionComponent {
+    private ui;
+    private agentType;
+    private task;
+    private modelId?;
+    private toolCalls;
+    private done;
+    private isError;
+    private startTime;
+    private durationMs;
+    private finalResult?;
+    private expanded;
+    private collapseOnComplete;
+    constructor(agentType: string, task: string, ui: TUI, modelId?: string, options?: SubagentExecutionOptions);
+    addToolStart(name: string, args: unknown): void;
+    addToolEnd(name: string, result: unknown, isError: boolean): void;
+    finish(isError: boolean, durationMs: number, result?: string): void;
+    setExpanded(expanded: boolean): void;
+    toggleExpanded(): void;
+    updateArgs(_args: unknown): void;
+    updateResult(_result: unknown, _isPartial: boolean): void;
+    private rebuild;
+}
+
+/**
+ * Task progress component for the TUI.
+ * Shows a persistent, compact display of the current task list.
+ * Hidden when no tasks exist OR when all tasks are completed.
+ * Renders between status and editor.
+ */
+
+declare class TaskProgressComponent extends Container {
+    private tasks;
+    constructor();
+    /**
+     * Replace the entire task list and re-render.
+     */
+    updateTasks(tasks: TaskItem[]): void;
+    /**
+     * Get the current task list (read-only copy).
+     */
+    getTasks(): TaskItem[];
+    private rebuildDisplay;
+    private formatTaskLine;
+}
+
+/**
+ * Component that renders a user message.
+ */
+
+declare class UserMessageComponent extends Container {
+    constructor(text: string, markdownTheme?: MarkdownTheme);
+}
+
+/**
+ * Shared TUI state — the single source of truth for all mutable state
+ * in the Mastra TUI. Extracted so that slash commands, event handlers,
+ * and other modules can operate on the state without coupling to the
+ * MastraTUI class.
+ */
+
+interface MastraTUIOptions {
+    /** The harness instance to control */
+    harness: Harness<any>;
+    /** Hook manager for session lifecycle hooks */
+    hookManager?: HookManager;
+    /** Auth storage for OAuth login/logout */
+    authStorage?: AuthStorage;
+    /** MCP manager for server status and reload */
+    mcpManager?: McpManager;
+    /**
+     * @deprecated Workspace is now obtained from the Harness.
+     * Configure workspace via HarnessConfig.workspace instead.
+     * Kept as fallback for backward compatibility.
+     */
+    workspace?: Workspace;
+    /** Initial message to send on startup */
+    initialMessage?: string;
+    /** Whether to show verbose startup info */
+    verbose?: boolean;
+    /** App name for header */
+    appName?: string;
+    /** App version for header */
+    version?: string;
+    /** Use inline questions instead of dialog overlays */
+    inlineQuestions?: boolean;
+}
+interface TUIState {
+    harness: Harness<any>;
+    options: MastraTUIOptions;
+    hookManager?: HookManager;
+    authStorage?: AuthStorage;
+    mcpManager?: McpManager;
+    workspace?: Workspace;
+    ui: TUI;
+    chatContainer: Container;
+    editorContainer: Container;
+    editor: CustomEditor;
+    footer: Container;
+    terminal: ProcessTerminal;
+    isInitialized: boolean;
+    gradientAnimator?: GradientAnimator;
+    streamingComponent?: AssistantMessageComponent;
+    streamingMessage?: HarnessMessage;
+    pendingTools: Map<string, IToolExecutionComponent>;
+    /** Position hint for task_write inline rendering when streaming */
+    taskWriteInsertIndex: number;
+    /** Track all tool IDs seen during current stream (prevents duplicates) */
+    seenToolCallIds: Set<string>;
+    /** Track subagent tool call IDs to skip in trailing content logic */
+    subagentToolCallIds: Set<string>;
+    /** Track all tools for expand/collapse */
+    allToolComponents: IToolExecutionComponent[];
+    /** Track slash command boxes for expand/collapse */
+    allSlashCommandComponents: SlashCommandComponent[];
+    /** Track active subagent tasks */
+    pendingSubagents: Map<string, SubagentExecutionComponent>;
+    toolOutputExpanded: boolean;
+    hideThinkingBlock: boolean;
+    quietMode: boolean;
+    /** True when we want a new thread but haven't created it yet */
+    pendingNewThread: boolean;
+    /** Track the most recent ask_user tool for inline question placement */
+    lastAskUserComponent?: IToolExecutionComponent;
+    /** Saved editor text for Alt+Z undo */
+    lastClearedText: string;
+    lastClearedFileAttachments: PendingFileAttachment[];
+    activeInlineQuestion?: AskQuestionInlineComponent;
+    /** Queue of pending inline questions waiting to be shown (when one is already active) */
+    pendingInlineQuestions: Array<() => void>;
+    activeInlinePlanApproval?: PlanApprovalInlineComponent;
+    activeOnboarding?: OnboardingInlineComponent;
+    lastSubmitPlanComponent?: IToolExecutionComponent;
+    /** User-message follow-ups queued while the agent is running */
+    pendingFollowUpMessages: Array<{
+        content: string;
+        displayContent: string;
+        images?: Array<{
+            data: string;
+            mimeType: string;
+        }>;
+    }>;
+    /** FIFO ordering across queued follow-up messages and slash commands */
+    pendingQueuedActions: Array<'message' | 'slash'>;
+    /** Follow-up messages rendered while streaming so tool output stays above them */
+    followUpComponents: UserMessageComponent[];
+    /** Slash commands queued while the agent is running */
+    pendingSlashCommands: string[];
+    /** Active approval dialog dismiss callback — called on Ctrl+C to unblock the dialog */
+    pendingApprovalDismiss: (() => void) | null;
+    projectInfo: ProjectInfo;
+    statusLine?: Text;
+    memoryStatusLine?: Text;
+    modelAuthStatus: {
+        hasAuth: boolean;
+        apiKeyEnvVar?: string;
+    };
+    omProgressComponent?: OMProgressComponent;
+    activeOMMarker?: OMMarkerComponent;
+    activeBufferingMarker?: OMMarkerComponent;
+    activeActivationMarker?: OMMarkerComponent;
+    taskProgress?: TaskProgressComponent;
+    autocompleteProvider?: CombinedAutocompleteProvider;
+    customSlashCommands: SlashCommandMetadata[];
+    /** Pending images from clipboard paste */
+    pendingImages: Array<{
+        data: string;
+        mimeType: string;
+    }>;
+    pendingFileAttachments: PendingFileAttachment[];
+    composerAttachmentLine?: Text;
+    lastCtrlCTime: number;
+    /** Track user-initiated aborts (Ctrl+C/Esc) vs system aborts */
+    userInitiatedAbort: boolean;
+    unsubscribe?: () => void;
+}
+/**
+ * Create the initial TUIState from options.
+ * Instantiates TUI framework objects (terminal, containers, editor)
+ * and sets all mutable fields to their defaults.
+ */
+declare function createTUIState(options: MastraTUIOptions): TUIState;
+
+declare class MastraTUI {
+    private state;
+    private updateCheckTimer;
+    private hasShownUpdateBanner;
+    private static readonly DOUBLE_CTRL_C_MS;
+    constructor(options: MastraTUIOptions);
+    /**
+     * Run the TUI. This is the main entry point.
+     */
+    run(): Promise<void>;
+    /**
+     * Fire off a message without blocking the main loop.
+     * Errors are handled via harness events.
+     */
+    private fireMessage;
+    private queueFollowUpMessage;
+    private openProjectFileSelector;
+    /**
+     * Stop the TUI and clean up.
+     */
+    stop(): void;
+    private init;
+    private refreshModelAuthStatus;
+    /** Cached event context – built once, reused for every event. */
+    private _ectx;
+    private getEventContext;
+    private handleEvent;
+    private buildProviderAccess;
+    private syncThreadActivePackMetadata;
+    private showHookWarnings;
+    private runStopHook;
+    private runUserPromptHook;
+    /**
+     * Insert a child into the chat container before any follow-up user messages.
+     * If no follow-ups are pending, appends to end.
+     */
+    private addChildBeforeFollowUps;
+    private getUserInput;
+    /**
+     * One-time startup check: if the user has Anthropic OAuth credentials and
+     * hasn't yet acknowledged the Claude Max ToS warning, show it now.
+     */
+    private checkClaudeMaxOAuthWarning;
+    /**
+     * Get the workspace, preferring harness-owned workspace over the direct option.
+     */
+    private getResolvedWorkspace;
+    private buildCommandContext;
+    private buildEventContext;
+    private handleSlashCommand;
+    performLogin(providerId: string): Promise<void>;
+    performApiKeyLogin(): Promise<void>;
+    showOnboarding(): Promise<void>;
+    private applyOnboardingResult;
+    private shouldShowOnboarding;
+    /**
+    * Check GitHub releases for a newer version and prompt the user to update.
+     * - If the user previously dismissed this version, show a passive note instead.
+     * - If the fetch fails or we're already up-to-date, silently return.
+     * @param passive When true, only show an info message (used for periodic rechecks).
+     */
+    private checkForUpdate;
+    /**
+     * Show an inline Y/N prompt offering to auto-update.
+     */
+    private showUpdatePrompt;
+}
+
+/**
+ * Enhanced tool execution component with better collapsible support.
+ * This will replace the existing tool-execution.ts
+ */
+
+interface ToolExecutionOptions {
+    showImages?: boolean;
+    autoCollapse?: boolean;
+    collapsedByDefault?: boolean;
+}
+/**
+ * Enhanced tool execution component with collapsible sections
+ */
+declare class ToolExecutionComponentEnhanced extends Container implements IToolExecutionComponent {
+    private contentBox;
+    private toolName;
+    private args;
+    private expanded;
+    private isPartial;
+    private ui;
+    private result?;
+    private options;
+    private collapsible?;
+    private startTime;
+    private streamingOutput;
+    constructor(toolName: string, args: unknown, options: ToolExecutionOptions | undefined, ui: TUI);
+    updateArgs(args: unknown): void;
+    updateResult(result: ToolResult, isPartial?: boolean): void;
+    /**
+     * Append streaming shell output.
+     * Only for execute_command tool - shows live output while command runs.
+     */
+    appendStreamingOutput(output: string): void;
+    setExpanded(expanded: boolean): void;
+    toggleExpanded(): void;
+    invalidate(): void;
+    private updateBgColor;
+    /**
+     * Full clear-and-rebuild. Called when:
+     * - args change (updateArgs)
+     * - result arrives or changes (updateResult)
+     * - expand/collapse on a tool with no collapsible child
+     * - initial construction
+     */
+    private rebuild;
+    private renderViewToolEnhanced;
+    private renderBashToolEnhanced;
+    private renderProcessToolEnhanced;
+    private renderEditToolEnhanced;
+    private parseLSPDiagnostics;
+    private generateDiffLines;
+    private renderWriteToolEnhanced;
+    private renderListFilesEnhanced;
+    private renderTaskWriteEnhanced;
+    private renderWebSearchEnhanced;
+    /**
+     * Format web search results as a clean list of titles + URLs.
+     * Handles both Anthropic provider results (JSON array with encryptedContent)
+     * and Tavily results (markdown-formatted text).
+     */
+    private formatWebSearchResults;
+    private renderGenericToolEnhanced;
+    /**
+     * Format a compact args preview as key="value" pairs.
+     * Long values are truncated, multiline values show first line + count.
+     * Returns an array of formatted lines.
+     */
+    private formatArgsPreview;
+    private getStatusIndicator;
+    private getDurationSuffix;
+    private getFormattedOutput;
+    /**
+     * Render an error result using the enhanced error display component
+     */
+    private renderErrorResult;
+}
+
+/**
+ * Model selector component for switching between available models.
+ * Uses pi-tui overlay pattern with search and fuzzy filtering.
+ */
+
+interface ModelItem {
+    /** Full model ID (e.g., "anthropic/claude-sonnet-4") */
+    id: string;
+    /** Provider name (e.g., "anthropic") */
+    provider: string;
+    /** Model name without provider (e.g., "claude-sonnet-4") */
+    modelName: string;
+    /** Whether the API key for this provider is available */
+    hasApiKey: boolean;
+    /** Environment variable name for the API key (e.g., "ANTHROPIC_API_KEY") */
+    apiKeyEnvVar?: string;
+    /** Number of times this model has been selected (for ranking) */
+    useCount?: number;
+}
+interface ModelSelectorOptions {
+    /** TUI instance for rendering */
+    tui: TUI;
+    /** List of available models */
+    models: ModelItem[];
+    /** Currently selected model ID */
+    currentModelId?: string;
+    /** Optional title for the selector */
+    title?: string;
+    /** Optional hex color for the title background (e.g. mode color) */
+    titleColor?: string;
+    /** Callback when a model is selected */
+    onSelect: (model: ModelItem) => void;
+    /** Callback when selection is cancelled */
+    onCancel: () => void;
+}
+declare class ModelSelectorComponent extends Box implements Focusable {
+    private searchInput;
+    private listContainer;
+    private allModels;
+    private filteredModels;
+    private selectedIndex;
+    private currentModelId?;
+    private onSelectCallback;
+    private onCancelCallback;
+    private tui;
+    private title;
+    private titleColor?;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    constructor(options: ModelSelectorOptions);
+    private buildUI;
+    private sortModels;
+    /** Whether the custom "Use: ..." item is showing at the top */
+    private hasCustomItem;
+    private filterModels;
+    private makeCustomModelItem;
+    private updateList;
+    handleInput(keyData: string): void;
+    private handleSelect;
+    getSearchInput(): Input;
+}
+
+/**
+ * OAuth provider selector component for /login and /logout commands
+ */
+
+/**
+ * Interface for auth provider that the selector needs.
+ * Can be satisfied by Harness or AuthStorage.
+ */
+interface AuthProviderSource {
+    getOAuthProviders(): OAuthProviderInterface[];
+    isLoggedIn(providerId: string): boolean;
+}
+declare class LoginSelectorComponent extends Box {
+    private listContainer;
+    private allProviders;
+    private selectedIndex;
+    private mode;
+    private authSource;
+    private onSelectCallback;
+    private onCancelCallback;
+    constructor(mode: 'login' | 'logout', authSource: AuthProviderSource, onSelect: (providerId: string) => void, onCancel: () => void);
+    private loadProviders;
+    private updateList;
+    handleInput(keyData: string): void;
+}
+
+/**
+ * Login dialog component - handles OAuth login flow UI
+ */
+
+declare class LoginDialogComponent extends Box implements Focusable {
+    private onComplete;
+    private contentContainer;
+    private input;
+    private tui;
+    private abortController;
+    private inputResolver?;
+    private inputRejecter?;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    constructor(tui: TUI, providerId: string, onComplete: (success: boolean, message?: string) => void);
+    get signal(): AbortSignal;
+    private cancel;
+    /**
+     * Called by onAuth callback - show URL and optional instructions
+     */
+    showAuth(url: string, instructions?: string): void;
+    /**
+     * Called by onPrompt callback - show prompt and wait for input
+     */
+    showPrompt(message: string, placeholder?: string): Promise<string>;
+    /**
+     * Show progress message
+     */
+    showProgress(message: string): void;
+    handleInput(data: string): void;
+}
+
+/**
+ * Theme system for the Mastra Code TUI.
+ * Simplified from pi-mono's theme system.
+ */
+
+type ThemeMode = 'dark' | 'light';
+declare function getThemeMode(): ThemeMode;
+declare const mastraBrand: {
+    readonly purple: "#7f45e0";
+    readonly green: "#059669";
+    readonly orange: "#fdac53";
+    readonly pink: "#ff69cc";
+    readonly blue: "#2563eb";
+    readonly red: "#DC5663";
+    readonly yellow: "#e7e67b";
+};
+interface MastraSurface {
+    bg: string;
+    antiGrid: string;
+    elevationSm: string;
+    elevationLg: string;
+    hover: string;
+    white: string;
+    specialGray: string;
+    mainGray: string;
+    darkGray: string;
+    borderAntiGrid: string;
+    borderElevation: string;
+}
+type MastraPalette = typeof mastraBrand & MastraSurface;
+/** Mastra palette — brand colors are constant, surface colors adapt to theme mode. */
+declare const mastra: MastraPalette;
+type ThemeColor = 'accent' | 'border' | 'borderAccent' | 'borderMuted' | 'success' | 'error' | 'warning' | 'muted' | 'dim' | 'text' | 'thinkingText' | 'userMessageText' | 'toolTitle' | 'toolOutput' | 'toolBorderPending' | 'toolBorderSuccess' | 'toolBorderError' | 'function' | 'path' | 'number';
+type ThemeBg = 'selectedBg' | 'userMessageBg' | 'systemReminderBg' | 'toolPendingBg' | 'toolSuccessBg' | 'toolErrorBg' | 'overlayBg' | 'errorBg';
+interface ThemeColors {
+    accent: string;
+    border: string;
+    borderAccent: string;
+    borderMuted: string;
+    success: string;
+    error: string;
+    warning: string;
+    muted: string;
+    dim: string;
+    text: string;
+    thinkingText: string;
+    userMessageBg: string;
+    userMessageText: string;
+    systemReminderBg: string;
+    toolPendingBg: string;
+    toolSuccessBg: string;
+    toolErrorBg: string;
+    toolBorderPending: string;
+    toolBorderSuccess: string;
+    toolBorderError: string;
+    toolTitle: string;
+    toolOutput: string;
+    selectedBg: string;
+    overlayBg: string;
+    errorBg: string;
+    path: string;
+    number: string;
+    function: string;
+}
+/**
+ * Get the current theme colors.
+ */
+declare function getTheme(): ThemeColors;
+/**
+ * Set the current theme.
+ */
+declare function setTheme(colors: ThemeColors): void;
+/**
+ * Apply a theme mode, updating both the surface palette and the theme colors.
+ */
+declare function applyThemeMode(mode: ThemeMode): void;
+/**
+ * Apply foreground color from theme.
+ */
+declare function fg(color: ThemeColor, text: string): string;
+/**
+ * Apply background color from theme.
+ */
+declare function bg(color: ThemeBg, text: string): string;
+/**
+ * Apply bold styling.
+ */
+declare function bold(text: string): string;
+/**
+ * Apply italic styling.
+ */
+declare function italic(text: string): string;
+/**
+ * Apply dim styling.
+ */
+declare function dim(text: string): string;
+declare const theme: {
+    fg: typeof fg;
+    bg: typeof bg;
+    bold: typeof bold;
+    italic: typeof italic;
+    dim: typeof dim;
+    getTheme: typeof getTheme;
+    setTheme: typeof setTheme;
+};
+declare function getMarkdownTheme(): MarkdownTheme;
+declare function getEditorTheme(): EditorTheme;
+
+export { AssistantMessageComponent, type IToolExecutionComponent, LoginDialogComponent, LoginSelectorComponent, MastraTUI, type MastraTUIOptions, type ModelItem, ModelSelectorComponent, type ModelSelectorOptions, OMProgressComponent, type TUIState, type ThemeBg, type ThemeColor, type ThemeColors, type ThemeMode, ToolExecutionComponentEnhanced, type ToolExecutionOptions, type ToolResult, UserMessageComponent, applyThemeMode, createTUIState, formatOMStatus, getEditorTheme, getMarkdownTheme, getThemeMode, mastra, mastraBrand, theme };