@tomsun28/pizza 0.0.9 → 0.1.1

package/dist/modes/interactive/components/user-message-selector.d.ts

@@ -0,0 +1,29 @@
+import { type Component, Container } from "@earendil-works/pi-tui";
+interface UserMessageItem {
+    id: string;
+    text: string;
+    timestamp?: string;
+}
+/**
+ * Custom user message list component with selection
+ */
+declare class UserMessageList implements Component {
+    private messages;
+    private selectedIndex;
+    onSelect?: (entryId: string) => void;
+    onCancel?: () => void;
+    private maxVisible;
+    constructor(messages: UserMessageItem[], initialSelectedId?: string);
+    invalidate(): void;
+    render(width: number): string[];
+    handleInput(keyData: string): void;
+}
+/**
+ * Component that renders a user message selector for branching
+ */
+export declare class UserMessageSelectorComponent extends Container {
+    private messageList;
+    constructor(messages: UserMessageItem[], onSelect: (entryId: string) => void, onCancel: () => void, initialSelectedId?: string);
+    getMessageList(): UserMessageList;
+}
+export {};

package/dist/modes/interactive/components/user-message-selector.js

@@ -0,0 +1,110 @@
+import { Container, getKeybindings, Spacer, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { theme } from "../theme/theme.js";
+import { DynamicBorder } from "./dynamic-border.js";
+/**
+ * Custom user message list component with selection
+ */
+class UserMessageList {
+    constructor(messages, initialSelectedId) {
+        this.messages = [];
+        this.selectedIndex = 0;
+        this.maxVisible = 10; // Max messages visible
+        // Store messages in chronological order (oldest to newest)
+        this.messages = messages;
+        const initialIndex = initialSelectedId ? messages.findIndex((message) => message.id === initialSelectedId) : -1;
+        // Start with selected message if provided, else default to the most recent
+        this.selectedIndex = initialIndex >= 0 ? initialIndex : Math.max(0, messages.length - 1);
+    }
+    invalidate() {
+        // No cached state to invalidate currently
+    }
+    render(width) {
+        const lines = [];
+        if (this.messages.length === 0) {
+            lines.push(theme.fg("muted", "  No user messages found"));
+            return lines;
+        }
+        // Calculate visible range with scrolling
+        const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.messages.length - this.maxVisible));
+        const endIndex = Math.min(startIndex + this.maxVisible, this.messages.length);
+        // Render visible messages (2 lines per message + blank line)
+        for (let i = startIndex; i < endIndex; i++) {
+            const message = this.messages[i];
+            const isSelected = i === this.selectedIndex;
+            // Normalize message to single line
+            const normalizedMessage = message.text.replace(/\n/g, " ").trim();
+            // First line: cursor + message
+            const cursor = isSelected ? theme.fg("accent", "› ") : "  ";
+            const maxMsgWidth = width - 2; // Account for cursor (2 chars)
+            const truncatedMsg = truncateToWidth(normalizedMessage, maxMsgWidth);
+            const messageLine = cursor + (isSelected ? theme.bold(truncatedMsg) : truncatedMsg);
+            lines.push(messageLine);
+            // Second line: metadata (position in history)
+            const position = i + 1;
+            const metadata = `  Message ${position} of ${this.messages.length}`;
+            const metadataLine = theme.fg("muted", metadata);
+            lines.push(metadataLine);
+            lines.push(""); // Blank line between messages
+        }
+        // Add scroll indicator if needed
+        if (startIndex > 0 || endIndex < this.messages.length) {
+            const scrollInfo = theme.fg("muted", `  (${this.selectedIndex + 1}/${this.messages.length})`);
+            lines.push(scrollInfo);
+        }
+        return lines;
+    }
+    handleInput(keyData) {
+        const kb = getKeybindings();
+        // Up arrow - go to previous (older) message, wrap to bottom when at top
+        if (kb.matches(keyData, "tui.select.up")) {
+            this.selectedIndex = this.selectedIndex === 0 ? this.messages.length - 1 : this.selectedIndex - 1;
+        }
+        // Down arrow - go to next (newer) message, wrap to top when at bottom
+        else if (kb.matches(keyData, "tui.select.down")) {
+            this.selectedIndex = this.selectedIndex === this.messages.length - 1 ? 0 : this.selectedIndex + 1;
+        }
+        // Enter - select message and branch
+        else if (kb.matches(keyData, "tui.select.confirm")) {
+            const selected = this.messages[this.selectedIndex];
+            if (selected && this.onSelect) {
+                this.onSelect(selected.id);
+            }
+        }
+        // Escape - cancel
+        else if (kb.matches(keyData, "tui.select.cancel")) {
+            if (this.onCancel) {
+                this.onCancel();
+            }
+        }
+    }
+}
+/**
+ * Component that renders a user message selector for branching
+ */
+export class UserMessageSelectorComponent extends Container {
+    constructor(messages, onSelect, onCancel, initialSelectedId) {
+        super();
+        // Add header
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(theme.bold("Fork from Message"), 1, 0));
+        this.addChild(new Text(theme.fg("muted", "Select a user message to copy the active path up to that point into a new session"), 1, 0));
+        this.addChild(new Spacer(1));
+        this.addChild(new DynamicBorder());
+        this.addChild(new Spacer(1));
+        // Create message list
+        this.messageList = new UserMessageList(messages, initialSelectedId);
+        this.messageList.onSelect = onSelect;
+        this.messageList.onCancel = onCancel;
+        this.addChild(this.messageList);
+        // Add bottom border
+        this.addChild(new Spacer(1));
+        this.addChild(new DynamicBorder());
+        // Auto-cancel if no messages
+        if (messages.length === 0) {
+            setTimeout(() => onCancel(), 100);
+        }
+    }
+    getMessageList() {
+        return this.messageList;
+    }
+}

package/dist/modes/interactive/components/user-message.d.ts

@@ -0,0 +1,9 @@
+import { Container, type MarkdownTheme } from "@earendil-works/pi-tui";
+/**
+ * Component that renders a user message
+ */
+export declare class UserMessageComponent extends Container {
+    private contentBox;
+    constructor(text: string, markdownTheme?: MarkdownTheme);
+    render(width: number): string[];
+}

package/dist/modes/interactive/components/user-message.js

@@ -0,0 +1,27 @@
+import { Box, Container, Markdown } from "@earendil-works/pi-tui";
+import { getMarkdownTheme, theme } from "../theme/theme.js";
+const OSC133_ZONE_START = "\x1b]133;A\x07";
+const OSC133_ZONE_END = "\x1b]133;B\x07";
+const OSC133_ZONE_FINAL = "\x1b]133;C\x07";
+/**
+ * Component that renders a user message
+ */
+export class UserMessageComponent extends Container {
+    constructor(text, markdownTheme = getMarkdownTheme()) {
+        super();
+        this.contentBox = new Box(1, 1, (content) => theme.bg("userMessageBg", content));
+        this.contentBox.addChild(new Markdown(text, 0, 0, markdownTheme, {
+            color: (content) => theme.fg("userMessageText", content),
+        }));
+        this.addChild(this.contentBox);
+    }
+    render(width) {
+        const lines = super.render(width);
+        if (lines.length === 0) {
+            return lines;
+        }
+        lines[0] = OSC133_ZONE_START + lines[0];
+        lines[lines.length - 1] = OSC133_ZONE_END + OSC133_ZONE_FINAL + lines[lines.length - 1];
+        return lines;
+    }
+}

package/dist/modes/interactive/components/visual-truncate.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared utility for truncating text to visual lines (accounting for line wrapping).
+ * Used by both tool-execution.ts and bash-execution.ts for consistent behavior.
+ */
+export interface VisualTruncateResult {
+    /** The visual lines to display */
+    visualLines: string[];
+    /** Number of visual lines that were skipped (hidden) */
+    skippedCount: number;
+}
+/**
+ * Truncate text to a maximum number of visual lines (from the end).
+ * This accounts for line wrapping based on terminal width.
+ *
+ * @param text - The text content (may contain newlines)
+ * @param maxVisualLines - Maximum number of visual lines to show
+ * @param width - Terminal/render width
+ * @param paddingX - Horizontal padding for Text component (default 0).
+ *                   Use 0 when result will be placed in a Box (Box adds its own padding).
+ *                   Use 1 when result will be placed in a plain Container.
+ * @returns The truncated visual lines and count of skipped lines
+ */
+export declare function truncateToVisualLines(text: string, maxVisualLines: number, width: number, paddingX?: number): VisualTruncateResult;

package/dist/modes/interactive/components/visual-truncate.js

@@ -0,0 +1,32 @@
+/**
+ * Shared utility for truncating text to visual lines (accounting for line wrapping).
+ * Used by both tool-execution.ts and bash-execution.ts for consistent behavior.
+ */
+import { Text } from "@earendil-works/pi-tui";
+/**
+ * Truncate text to a maximum number of visual lines (from the end).
+ * This accounts for line wrapping based on terminal width.
+ *
+ * @param text - The text content (may contain newlines)
+ * @param maxVisualLines - Maximum number of visual lines to show
+ * @param width - Terminal/render width
+ * @param paddingX - Horizontal padding for Text component (default 0).
+ *                   Use 0 when result will be placed in a Box (Box adds its own padding).
+ *                   Use 1 when result will be placed in a plain Container.
+ * @returns The truncated visual lines and count of skipped lines
+ */
+export function truncateToVisualLines(text, maxVisualLines, width, paddingX = 0) {
+    if (!text) {
+        return { visualLines: [], skippedCount: 0 };
+    }
+    // Create a temporary Text component to render and get visual lines
+    const tempText = new Text(text, paddingX, 0);
+    const allVisualLines = tempText.render(width);
+    if (allVisualLines.length <= maxVisualLines) {
+        return { visualLines: allVisualLines, skippedCount: 0 };
+    }
+    // Take the last N visual lines
+    const truncatedLines = allVisualLines.slice(-maxVisualLines);
+    const skippedCount = allVisualLines.length - maxVisualLines;
+    return { visualLines: truncatedLines, skippedCount };
+}

package/dist/modes/interactive/interactive-mode.d.ts

@@ -0,0 +1,394 @@
+/**
+ * Interactive mode for the coding agent.
+ * Handles TUI rendering and user interaction, delegating business logic to SessionFacade.
+ */
+import type { ImageContent } from "@earendil-works/pi-ai/compat";
+import type { CreateSessionFacadeResult } from "../../core/session-facade-factory.js";
+/**
+ * Options for InteractiveMode initialization.
+ */
+export interface InteractiveModeOptions {
+    /** Warning message if session model couldn't be restored */
+    modelFallbackMessage?: string;
+    /** Initial message to send on startup (can include @file content) */
+    initialMessage?: string;
+    /** Images to attach to the initial message */
+    initialImages?: ImageContent[];
+    /** Additional messages to send after the initial message */
+    initialMessages?: string[];
+    /** Force verbose startup (overrides quietStartup setting) */
+    verbose?: boolean;
+}
+export declare class InteractiveMode {
+    private facade;
+    private facadeResult?;
+    private options;
+    private _isStreaming;
+    private _isCompacting;
+    private _retryAttempt;
+    private _streamingText;
+    private ui;
+    private chatContainer;
+    private pendingMessagesContainer;
+    private statusContainer;
+    private defaultEditor;
+    private editor;
+    private autocompleteProvider;
+    private fdPath;
+    private editorContainer;
+    private footer;
+    private footerDataProvider;
+    private keybindings;
+    private version;
+    private isInitialized;
+    private onInputCallback?;
+    private loadingAnimation;
+    private pendingWorkingMessage;
+    private workingIndicatorOptions;
+    private readonly defaultWorkingMessage;
+    private readonly defaultHiddenThinkingLabel;
+    private hiddenThinkingLabel;
+    private lastSigintTime;
+    private lastEscapeTime;
+    private anthropicSubscriptionWarningShown;
+    private lastStatusSpacer;
+    private lastStatusText;
+    private streamingComponent;
+    private streamingMessage;
+    private pendingTools;
+    private isFirstUserMessage;
+    private toolOutputExpanded;
+    private hideThinkingBlock;
+    private skillCommands;
+    private unsubscribe?;
+    private signalCleanupHandlers;
+    private isBashMode;
+    private bashComponent;
+    private pendingBashComponents;
+    private autoCompactionLoader;
+    private autoCompactionEscapeHandler?;
+    private retryLoader;
+    private retryCountdown;
+    private retryEscapeHandler?;
+    private compactionQueuedMessages;
+    private shutdownRequested;
+    private extensionSelector;
+    private extensionInput;
+    private extensionEditor;
+    private extensionTerminalInputUnsubscribers;
+    private extensionWidgetsAbove;
+    private extensionWidgetsBelow;
+    private widgetContainerAbove;
+    private widgetContainerBelow;
+    private customFooter;
+    private headerContainer;
+    private builtInHeader;
+    private customHeader;
+    private taskHistoryProjection;
+    private taskHistoryUnsubscribe;
+    private get modelRegistryValue();
+    private get extensionRunnerValue();
+    private get resourceLoaderValue();
+    private get currentModel();
+    private getCurrentModelFromFacade;
+    private get currentThinkingLevel();
+    private get isStreaming();
+    private get isCompacting();
+    private get autoCompactionEnabled();
+    private get promptTemplatesValue();
+    private get pendingMessageCountValue();
+    private get messagesValue();
+    private get retryAttemptValue();
+    private get systemPromptValue();
+    private get isBashRunningValue();
+    private compactFacade;
+    private getContextUsageFacade;
+    private abortCompactionFacade;
+    private abortRetryFacade;
+    private abortBashFacade;
+    private abortBranchSummaryFacade;
+    private setModelFacade;
+    private setThinkingLevelFacade;
+    private setAutoCompactionEnabledFacade;
+    private cycleModelFacade;
+    private cycleThinkingLevelFacade;
+    private getAvailableThinkingLevelsFacade;
+    private navigateTreeFacade;
+    private getSteeringMessagesFacade;
+    private getFollowUpMessagesFacade;
+    private clearQueueFacade;
+    private getUserMessagesForForkingFacade;
+    private getLastAssistantTextFacade;
+    private exportToHtmlFacade;
+    private reloadFacade;
+    private executeBashFacade;
+    private recordBashResultFacade;
+    private waitForIdleFacade;
+    private get projectionSessionManager();
+    /** Session directory (workspace dir in agent storage) */
+    private get sessionDir();
+    /** Current session reference string for session selector */
+    private get sessionFile();
+    private get facadeCwd();
+    private get settingsManager();
+    private getExtensionSessionManager;
+    /**
+     * Create InteractiveMode with SessionFacade (event-sourced architecture).
+     */
+    static fromFacade(facadeResult: CreateSessionFacadeResult, options?: InteractiveModeOptions): InteractiveMode;
+    /** Shared UI initialization */
+    private initUI;
+    private createFacadeFooterInfo;
+    private getAutocompleteSourceTag;
+    private prefixAutocompleteDescription;
+    private getBuiltInCommandConflictDiagnostics;
+    private setupAutocomplete;
+    private showStartupNoticesIfNeeded;
+    private initializeTaskHistoryHeader;
+    private updateTaskHistoryHeader;
+    init(): Promise<void>;
+    /**
+     * Update terminal title with session name and cwd.
+     */
+    private updateTerminalTitle;
+    /**
+     * Run the interactive mode. This is the main entry point.
+     * Initializes the UI, shows warnings, processes initial messages, and starts the interactive loop.
+     */
+    run(): Promise<void>;
+    private checkTmuxKeyboardSetup;
+    private getMarkdownThemeWithSettings;
+    private formatDisplayPath;
+    private formatContextPath;
+    private getStartupExpansionState;
+    /**
+     * Get a short path relative to the package root for display.
+     */
+    private getShortPath;
+    private getCompactPathLabel;
+    private getCompactPackageSourceLabel;
+    private getCompactExtensionLabel;
+    private getCompactDisplayPathSegments;
+    private getCompactNonPackageExtensionLabel;
+    private getCompactExtensionLabels;
+    private getDisplaySourceInfo;
+    private getScopeGroup;
+    private isPackageSource;
+    private buildScopeGroups;
+    private formatScopeGroups;
+    private findSourceInfoForPath;
+    private formatPathWithSource;
+    private formatDiagnostics;
+    private showLoadedResources;
+    /**
+     * Initialize the extension system with TUI-based UI context.
+     */
+    private bindCurrentSessionExtensions;
+    private applyRuntimeSettings;
+    private rebindCurrentSession;
+    private handleFatalRuntimeError;
+    private renderCurrentSessionState;
+    /**
+     * Get a registered tool definition by name (for custom rendering).
+     */
+    private getRegisteredToolDefinition;
+    /**
+     * Set up keyboard shortcuts registered by extensions.
+     */
+    private setupExtensionShortcuts;
+    /**
+     * Set extension status text in the footer.
+     */
+    private setExtensionStatus;
+    private setWorkingIndicator;
+    private setHiddenThinkingLabel;
+    /**
+     * Set an extension widget (string array or custom component).
+     */
+    private setExtensionWidget;
+    private clearExtensionWidgets;
+    private resetExtensionUI;
+    private static readonly MAX_WIDGET_LINES;
+    /**
+     * Render all extension widgets to the widget container.
+     */
+    private renderWidgets;
+    private renderWidgetContainer;
+    /**
+     * Set a custom footer component, or restore the built-in footer.
+     */
+    private setExtensionFooter;
+    /**
+     * Set a custom header component, or restore the built-in header.
+     */
+    private setExtensionHeader;
+    private addExtensionTerminalInputListener;
+    private clearExtensionTerminalInputListeners;
+    /**
+     * Create the ExtensionUIContext for extensions.
+     */
+    private createExtensionUIContext;
+    /**
+     * Show a selector for extensions.
+     */
+    private showExtensionSelector;
+    /**
+     * Hide the extension selector.
+     */
+    private hideExtensionSelector;
+    /**
+     * Show a confirmation dialog for extensions.
+     */
+    private showExtensionConfirm;
+    private promptForMissingSessionCwd;
+    /**
+     * Show a text input for extensions.
+     */
+    private showExtensionInput;
+    /**
+     * Hide the extension input.
+     */
+    private hideExtensionInput;
+    /**
+     * Show a multi-line editor for extensions (with Ctrl+G support).
+     */
+    private showExtensionEditor;
+    /**
+     * Hide the extension editor.
+     */
+    private hideExtensionEditor;
+    /**
+     * Set a custom editor component from an extension.
+     * Pass undefined to restore the default editor.
+     */
+    private setCustomEditorComponent;
+    /**
+     * Show a notification for extensions.
+     */
+    private showExtensionNotify;
+    /** Show a custom component with keyboard focus. Overlay mode renders on top of existing content. */
+    private showExtensionCustom;
+    /**
+     * Show an extension error in the UI.
+     */
+    private showExtensionError;
+    private setupKeyHandlers;
+    private handleClipboardImagePaste;
+    private setupEditorSubmitHandler;
+    /**
+     * Prompt via facade or session, depending on mode.
+     */
+    private promptFacadeOrSession;
+    private subscribeToAgent;
+    /**
+     * Subscribe to SessionFacade events (TypedEvent → ModeEvent).
+     */
+    private subscribeToFacade;
+    /**
+     * Handle ModeEvent (converted from TypedEvent via ModeEventMapper).
+     */
+    private handleModeEvent;
+    /** Extract text content from a user message */
+    private getUserMessageText;
+    /**
+     * Show a status message in the chat.
+     *
+     * If multiple status messages are emitted back-to-back (without anything else being added to the chat),
+     * we update the previous status line instead of appending new ones to avoid log spam.
+     */
+    private showStatus;
+    private addMessageToChat;
+    /**
+     * Render session context to chat. Used for initial load and rebuild after compaction.
+     * @param sessionContext Session context to render
+     * @param options.updateFooter Update footer state
+     * @param options.populateHistory Add user messages to editor history
+     */
+    private renderSessionContext;
+    renderInitialMessages(): void;
+    getUserInput(): Promise<string>;
+    private rebuildChatFromMessages;
+    private handleCtrlC;
+    private handleCtrlD;
+    /**
+     * Gracefully shutdown the agent.
+     * Emits shutdown event to extensions, then exits.
+     */
+    private isShuttingDown;
+    private shutdown;
+    /**
+     * Check if shutdown was requested and perform shutdown if so.
+     */
+    private checkShutdownRequested;
+    private registerSignalHandlers;
+    private unregisterSignalHandlers;
+    private handleCtrlZ;
+    private handleFollowUp;
+    private handleDequeue;
+    private updateEditorBorderColor;
+    private cycleThinkingLevel;
+    private cycleModel;
+    private toggleToolOutputExpansion;
+    private setToolsExpanded;
+    private toggleThinkingBlockVisibility;
+    private openExternalEditor;
+    clearEditor(): void;
+    showError(errorMessage: string): void;
+    showWarning(warningMessage: string): void;
+    private getAllQueuedMessages;
+    /**
+     * Clear all queued messages and return their contents.
+     * Clears both session queue and compaction queue.
+     */
+    private clearAllQueues;
+    private updatePendingMessagesDisplay;
+    private restoreQueuedMessagesToEditor;
+    private queueCompactionMessage;
+    private isExtensionCommand;
+    private flushCompactionQueue;
+    /** Move pending bash components from pending area to chat */
+    private flushPendingBashComponents;
+    /**
+     * Shows a selector component in place of the editor.
+     * @param create Factory that receives a `done` callback and returns the component and focus target
+     */
+    private showSelector;
+    private showSettingsSelector;
+    private handleModelCommand;
+    private findExactModelMatch;
+    private getModelCandidates;
+    /** Update the footer's available provider count from current model candidates */
+    private updateAvailableProviderCount;
+    private maybeWarnAboutAnthropicSubscriptionAuth;
+    private showModelSelector;
+    private showRewindSelector;
+    private showTreeSelector;
+    private handleResumeSession;
+    private showOAuthSelector;
+    private showLoginDialog;
+    private handleReloadCommand;
+    private handleExportCommand;
+    private getPathCommandArgument;
+    private handleShareCommand;
+    private handleCopyCommand;
+    private handleStatsCommand;
+    /**
+     * Capitalize keybinding for display (e.g., "ctrl+c" -> "Ctrl+C").
+     */
+    private capitalizeKey;
+    /**
+     * Get capitalized display string for an app keybinding action.
+     */
+    private getAppKeyDisplay;
+    /**
+     * Get capitalized display string for an editor keybinding action.
+     */
+    private getEditorKeyDisplay;
+    private handleHotkeysCommand;
+    private handleDebugCommand;
+    private handleDaxnuts;
+    private checkDaxnutsEasterEgg;
+    private handleBashCommand;
+    private handleCompactCommand;
+    stop(): void;
+}