@travisennis/acai 0.0.8 → 0.0.10

package/dist/tui/components/editor.js

@@ -1,4 +1,4 @@
-import { isCtrlC, isEnter, isEscape, isNavigationKey, isTab, } from "../../terminal/keys.js";
+import { isCtrlC, isCtrlG, isEnter, isEscape, isNavigationKey, isTab, } from "../../terminal/keys.js";
 import { getSegmenter } from "../../terminal/segmenter.js";
 import style from "../../terminal/style.js";
 import { visibleWidth } from "../utils.js";
@@ -174,6 +174,7 @@ export class Editor {
     // Custom key handlers for coding-agent
     onEscape;
     onRenderRequested;
+    onExternalEditor;
     constructor(theme) {
         // Default theme if none provided (backward compatibility)
         this.theme = theme || {
@@ -181,6 +182,12 @@ export class Editor {
         };
         this.borderColor = this.theme.borderColor;
     }
+    /**
+     * Get the current history (for testing purposes).
+     */
+    getHistory() {
+        return this.history;
+    }
     /**
      * Add a prompt to history for up/down arrow navigation.
      * Called after successful submission.
@@ -201,6 +208,18 @@ export class Editor {
     setAutocompleteProvider(provider) {
         this.autocompleteProvider = provider;
     }
+    async launchExternalEditor() {
+        if (!this.onExternalEditor)
+            return;
+        const currentContent = this.getText();
+        const result = await this.onExternalEditor(currentContent);
+        if (!result.aborted) {
+            this.setText(result.content);
+            if (this.onRenderRequested) {
+                this.onRenderRequested();
+            }
+        }
+    }
     isEditorEmpty() {
         return this.state.lines.length === 1 && this.state.lines[0] === "";
     }
@@ -311,193 +330,247 @@ export class Editor {
         return result;
     }
     handleInput(data) {
-        // Handle bracketed paste mode
-        // Start of paste: \x1b[200~
-        // End of paste: \x1b[201~
-        // Check if we're starting a bracketed paste
-        if (data.includes("\x1b[200~")) {
-            this.isInPaste = true;
-            this.pasteBuffer = "";
-            // Remove the start marker and keep the rest
-            const cleanedData = data.replace("\x1b[200~", "");
-            // Process the remaining data
-            this.processInputData(cleanedData);
-            return;
-        }
-        // If we're in a paste, buffer the data
-        if (this.isInPaste) {
-            // Append data to buffer first (end marker could be split across chunks)
-            this.pasteBuffer += data;
-            // Check if the accumulated buffer contains the end marker
-            const endIndex = this.pasteBuffer.indexOf("\x1b[201~");
-            if (endIndex !== -1) {
-                // Extract content before the end marker
-                const pasteContent = this.pasteBuffer.substring(0, endIndex);
-                // Process the complete paste
-                this.handlePaste(pasteContent);
-                // Reset paste state
-                this.isInPaste = false;
-                // Process any remaining data after the end marker
-                const remaining = this.pasteBuffer.substring(endIndex + 6); // 6 = length of \x1b[201~
-                this.pasteBuffer = "";
-                if (remaining.length > 0) {
-                    this.handleInput(remaining);
+        const pasteStart = "\x1b[200~";
+        const pasteEnd = "\x1b[201~";
+        let input = data;
+        while (input.length > 0) {
+            if (!this.isInPaste) {
+                const startIndex = input.indexOf(pasteStart);
+                if (startIndex === -1)
+                    break;
+                const before = input.slice(0, startIndex);
+                if (before.length > 0) {
+                    this.processInputData(before);
                 }
-                return;
+                this.isInPaste = true;
+                this.pasteBuffer = "";
+                input = input.slice(startIndex + pasteStart.length);
+                continue;
             }
-            // Still accumulating, wait for more data
-            return;
+            this.pasteBuffer += input;
+            const endIndex = this.pasteBuffer.indexOf(pasteEnd);
+            if (endIndex === -1)
+                return;
+            const pasteContent = this.pasteBuffer.slice(0, endIndex);
+            const remaining = this.pasteBuffer.slice(endIndex + pasteEnd.length);
+            this.handlePaste(pasteContent);
+            this.isInPaste = false;
+            this.pasteBuffer = "";
+            input = remaining;
         }
-        // Intercept Escape key - but only if autocomplete is NOT active
-        // (let parent handle escape for autocomplete cancellation)
-        if (isEscape(data) && this.onEscape && !this.isShowingAutocomplete()) {
+        if (input.length === 0)
+            return;
+        if (isEscape(input) && this.onEscape && !this.isShowingAutocomplete()) {
             this.onEscape();
             return;
         }
-        // Intercept Ctrl+C
-        if (isCtrlC(data)) {
+        if (isCtrlC(input)) {
             return;
         }
-        // Process regular input data
-        this.processInputData(data);
+        this.processInputData(input);
     }
     processInputData(data) {
-        // Handle special key combinations first
         // Ctrl+C - Exit (let parent handle this)
         if (data.charCodeAt(0) === 3) {
             return;
         }
-        // Handle autocomplete special keys first (but don't block other input)
-        if (this.isAutocompleting && this.autocompleteList) {
-            // Escape - cancel autocomplete
-            if (isEscape(data)) {
+        // Delegate to specialized handlers - return true if input was handled
+        if (this.handleAutocompleteInput(data))
+            return;
+        if (this.handleTabKey(data))
+            return;
+        if (this.handleExternalEditor(data))
+            return;
+        if (this.handleControlKey(data))
+            return;
+        if (this.handlePlainEnter(data))
+            return;
+        if (this.handleModifiedEnterKey(data))
+            return;
+        if (this.handleBackspaceKey(data))
+            return;
+        if (this.handleHomeEndKeys(data))
+            return;
+        if (this.handleForwardDeleteKey(data))
+            return;
+        if (this.handleWordNavigation(data))
+            return;
+        if (this.handleArrowKeys(data))
+            return;
+        // Default: insert printable character
+        if (data.charCodeAt(0) >= 32) {
+            this.insertCharacter(data);
+        }
+    }
+    handleAutocompleteInput(data) {
+        if (!this.isAutocompleting || !this.autocompleteList) {
+            return false;
+        }
+        // Escape - cancel autocomplete
+        if (isEscape(data)) {
+            this.cancelAutocomplete();
+            return true;
+        }
+        // Enter - apply selection
+        if (isEnter(data)) {
+            const selected = this.autocompleteList.getSelectedItem();
+            if (selected && this.autocompleteProvider) {
+                const result = this.autocompleteProvider.applyCompletion(this.state.lines, this.state.cursorLine, this.state.cursorCol, selected, this.autocompletePrefix);
+                this.state.lines = result.lines;
+                this.state.cursorLine = result.cursorLine;
+                this.state.cursorCol = result.cursorCol;
                 this.cancelAutocomplete();
-                return;
-            }
-            // Enter - apply selection
-            if (isEnter(data)) {
-                const selected = this.autocompleteList.getSelectedItem();
-                if (selected && this.autocompleteProvider) {
-                    const result = this.autocompleteProvider.applyCompletion(this.state.lines, this.state.cursorLine, this.state.cursorCol, selected, this.autocompletePrefix);
-                    this.state.lines = result.lines;
-                    this.state.cursorLine = result.cursorLine;
-                    this.state.cursorCol = result.cursorCol;
-                    this.cancelAutocomplete();
-                    if (this.onChange) {
-                        this.onChange(this.getText());
-                    }
+                if (this.onChange) {
+                    this.onChange(this.getText());
                 }
-                return;
             }
-            // Navigation keys (arrows, Tab, Shift+Tab) - pass to autocomplete list
-            if (isNavigationKey(data)) {
-                this.autocompleteList.handleInput(data);
-                return;
-            }
-            // For other keys (like regular typing), DON'T return here
-            // Let them fall through to normal character handling
+            return true;
         }
-        // Tab key - context-aware completion (but not when already autocompleting)
+        // Navigation keys (arrows, Tab, Shift+Tab) - pass to autocomplete list
+        if (isNavigationKey(data)) {
+            this.autocompleteList.handleInput(data);
+            return true;
+        }
+        return false;
+    }
+    handleTabKey(data) {
         if (isTab(data) && !this.isAutocompleting) {
             void this.handleTabCompletion();
-            return;
+            return true;
+        }
+        return false;
+    }
+    handleExternalEditor(data) {
+        if (isCtrlG(data) && this.onExternalEditor) {
+            void this.launchExternalEditor();
+            return true;
         }
-        // Continue with rest of input handling
+        return false;
+    }
+    handleControlKey(data) {
+        const charCode = data.charCodeAt(0);
         // Ctrl+K - Delete to end of line
-        if (data.charCodeAt(0) === 11) {
+        if (charCode === 11) {
             this.deleteToEndOfLine();
+            return true;
         }
         // Ctrl+U - Delete to start of line
-        else if (data.charCodeAt(0) === 21) {
+        if (charCode === 21) {
             this.deleteToStartOfLine();
+            return true;
         }
         // Ctrl+W - Delete word backwards
-        else if (data.charCodeAt(0) === 23) {
+        if (charCode === 23) {
             this.deleteWordBackwards();
+            return true;
         }
         // Option/Alt+Backspace (e.g. Ghostty sends ESC + DEL)
-        else if (data === "\x1b\x7f") {
+        if (data === "\x1b\x7f") {
             this.deleteWordBackwards();
+            return true;
         }
         // Ctrl+A - Move to start of line
-        else if (data.charCodeAt(0) === 1) {
+        if (charCode === 1) {
             this.moveToLineStart();
+            return true;
         }
         // Ctrl+E - Move to end of line
-        else if (data.charCodeAt(0) === 5) {
+        if (charCode === 5) {
             this.moveToLineEnd();
+            return true;
         }
+        return false;
+    }
+    handlePlainEnter(data) {
         // Plain Enter (char code 13 for CR) - create new line
-        else if (data.charCodeAt(0) === 13 && data.length === 1) {
+        if (data.charCodeAt(0) === 13 && data.length === 1) {
             this.addNewLine();
+            return true;
         }
-        // Modified Enter keys (Shift+Enter, Ctrl+Enter, etc.) - submit
-        else if (this.isModifiedEnter(data)) {
-            // If submit is disabled, do nothing
-            if (this.disableSubmit) {
-                return;
-            }
-            // Get text and substitute paste markers with actual content
-            let result = this.state.lines.join("\n").trim();
-            // Replace all [paste #N +xxx lines] or [paste #N xxx chars] markers with actual paste content
-            for (const [pasteId, pasteContent] of this.pastes) {
-                // Match formats: [paste #N], [paste #N +xxx lines], or [paste #N xxx chars]
-                const markerRegex = new RegExp(`\\[paste #${pasteId}( (\\+\\d+ lines|\\d+ chars))?\\]`, "g");
-                result = result.replace(markerRegex, pasteContent);
-            }
-            // Reset editor and clear pastes
-            this.state = {
-                lines: [""],
-                cursorLine: 0,
-                cursorCol: 0,
-            };
-            this.pastes.clear();
-            this.pasteCounter = 0;
-            this.historyIndex = -1; // Exit history browsing mode
-            // Notify that editor is now empty
-            if (this.onChange) {
-                this.onChange("");
-            }
-            if (this.onSubmit) {
-                this.onSubmit(result);
-            }
+        return false;
+    }
+    handleModifiedEnterKey(data) {
+        if (!this.isModifiedEnter(data)) {
+            return false;
         }
-        // Backspace
-        else if (data.charCodeAt(0) === 127 || data.charCodeAt(0) === 8) {
+        // If submit is disabled, do nothing
+        if (this.disableSubmit) {
+            return true;
+        }
+        // Get text and substitute paste markers with actual content
+        let result = this.state.lines.join("\n").trim();
+        // Replace all [paste #N +xxx lines] or [paste #N xxx chars] markers with actual paste content
+        for (const [pasteId, pasteContent] of this.pastes) {
+            // Match formats: [paste #N], [paste #N +xxx lines], or [paste #N xxx chars]
+            const markerRegex = new RegExp(`\\[paste #${pasteId}( (\\+\\d+ lines|\\d+ chars))?\\]`, "g");
+            result = result.replace(markerRegex, pasteContent);
+        }
+        // Reset editor and clear pastes
+        this.state = {
+            lines: [""],
+            cursorLine: 0,
+            cursorCol: 0,
+        };
+        this.pastes.clear();
+        this.pasteCounter = 0;
+        this.historyIndex = -1; // Exit history browsing mode
+        this.addToHistory(result); // Save submitted text to history
+        // Notify that editor is now empty
+        if (this.onChange) {
+            this.onChange("");
+        }
+        if (this.onSubmit) {
+            this.onSubmit(result);
+        }
+        return true;
+    }
+    handleBackspaceKey(data) {
+        if (data.charCodeAt(0) === 127 || data.charCodeAt(0) === 8) {
             this.handleBackspace();
+            return true;
         }
-        // Line navigation shortcuts (Home/End keys)
-        else if (data === "\x1b[H" || data === "\x1b[1~" || data === "\x1b[7~") {
-            // Home key
+        return false;
+    }
+    handleHomeEndKeys(data) {
+        // Home key: \x1b[H, \x1b[1~, or \x1b[7~
+        if (data === "\x1b[H" || data === "\x1b[1~" || data === "\x1b[7~") {
             this.moveToLineStart();
+            return true;
         }
-        else if (data === "\x1b[F" || data === "\x1b[4~" || data === "\x1b[8~") {
-            // End key
+        // End key: \x1b[F, \x1b[4~, or \x1b[8~
+        if (data === "\x1b[F" || data === "\x1b[4~" || data === "\x1b[8~") {
             this.moveToLineEnd();
+            return true;
         }
+        return false;
+    }
+    handleForwardDeleteKey(data) {
         // Forward delete (Fn+Backspace or Delete key)
-        else if (data === "\x1b[3~") {
-            // Delete key
+        if (data === "\x1b[3~") {
             this.handleForwardDelete();
+            return true;
         }
+        return false;
+    }
+    handleWordNavigation(data) {
         // Word navigation (Option/Alt + Arrow or Ctrl + Arrow)
         // Option+Left: \x1b[1;3D or \x1bb
         // Option+Right: \x1b[1;3C or \x1bf
         // Ctrl+Left: \x1b[1;5D
         // Ctrl+Right: \x1b[1;5C
-        else if (data === "\x1b[1;3D" || data === "\x1bb" || data === "\x1b[1;5D") {
-            // Word left
+        if (data === "\x1b[1;3D" || data === "\x1bb" || data === "\x1b[1;5D") {
             this.moveWordBackwards();
+            return true;
         }
-        else if (data === "\x1b[1;3C" ||
-            data === "\x1bf" ||
-            data === "\x1b[1;5C") {
-            // Word right
+        if (data === "\x1b[1;3C" || data === "\x1bf" || data === "\x1b[1;5C") {
             this.moveWordForwards();
+            return true;
         }
-        // Arrow keys
-        else if (data === "\x1b[A") {
-            // Up - history navigation or cursor movement
+        return false;
+    }
+    handleArrowKeys(data) {
+        // Up arrow
+        if (data === "\x1b[A") {
             if (this.isEditorEmpty()) {
                 this.navigateHistory(-1); // Start browsing history
             }
@@ -507,28 +580,29 @@ export class Editor {
             else {
                 this.moveCursor(-1, 0); // Cursor movement (within text or history entry)
             }
+            return true;
         }
-        else if (data === "\x1b[B") {
-            // Down - history navigation or cursor movement
+        // Down arrow
+        if (data === "\x1b[B") {
             if (this.historyIndex > -1 && this.isOnLastVisualLine()) {
                 this.navigateHistory(1); // Navigate to newer history entry or clear
             }
             else {
                 this.moveCursor(1, 0); // Cursor movement (within text or history entry)
             }
+            return true;
         }
-        else if (data === "\x1b[C") {
-            // Right
+        // Right arrow
+        if (data === "\x1b[C") {
             this.moveCursor(0, 1);
+            return true;
         }
-        else if (data === "\x1b[D") {
-            // Left
+        // Left arrow
+        if (data === "\x1b[D") {
             this.moveCursor(0, -1);
+            return true;
         }
-        // Regular characters (printable characters and unicode, but not control characters)
-        else if (data.charCodeAt(0) >= 32) {
-            this.insertCharacter(data);
-        }
+        return false;
     }
     layoutText(contentWidth) {
         const layoutLines = [];
@@ -610,7 +684,7 @@ export class Editor {
         this.setTextInternal(text);
     }
     // All the editor methods from before...
-    insertCharacter(char) {
+    insertCharacter(char, suppressAutocomplete = false) {
         this.historyIndex = -1; // Exit history browsing mode
         const line = this.state.lines[this.state.cursorLine] || "";
         const before = line.slice(0, this.state.cursorCol);
@@ -620,50 +694,16 @@ export class Editor {
         if (this.onChange) {
             this.onChange(this.getText());
         }
+        // Skip autocomplete triggering during paste operations
+        if (suppressAutocomplete) {
+            return;
+        }
         // Check if we should trigger or update autocomplete
         if (!this.isAutocompleting) {
-            // Auto-trigger for "/" at the start of a line (slash commands)
-            if (char === "/" && this.isAtStartOfMessage()) {
-                void this.tryTriggerAutocomplete();
-            }
-            // Auto-trigger for "@" file reference (fuzzy search)
-            else if (char === "@") {
+            if (this.autocompleteProvider) {
                 const currentLine = this.state.lines[this.state.cursorLine] || "";
                 const textBeforeCursor = currentLine.slice(0, this.state.cursorCol);
-                // Only trigger if @ is after whitespace or at start of line
-                const charBeforeAt = textBeforeCursor[textBeforeCursor.length - 2];
-                if (textBeforeCursor.length === 1 ||
-                    charBeforeAt === " " ||
-                    charBeforeAt === "\t") {
-                    void this.tryTriggerAutocomplete();
-                }
-            }
-            // Auto-trigger for "#" file search
-            else if (char === "#") {
-                const currentLine = this.state.lines[this.state.cursorLine] || "";
-                const textBeforeCursor = currentLine.slice(0, this.state.cursorCol);
-                // Only trigger if # is after whitespace or at start of line
-                const charBeforeHash = textBeforeCursor[textBeforeCursor.length - 2];
-                if (textBeforeCursor.length === 1 ||
-                    charBeforeHash === " " ||
-                    charBeforeHash === "\t") {
-                    void this.tryTriggerAutocomplete();
-                }
-            }
-            // Also auto-trigger when typing letters in a slash command context
-            else if (/[a-zA-Z0-9]/.test(char)) {
-                const currentLine = this.state.lines[this.state.cursorLine] || "";
-                const textBeforeCursor = currentLine.slice(0, this.state.cursorCol);
-                // Check if we're in a slash command (with or without space for arguments)
-                if (textBeforeCursor.trimStart().startsWith("/")) {
-                    void this.tryTriggerAutocomplete();
-                }
-                // Check if we're in an @ file reference context
-                else if (textBeforeCursor.match(/(?:^|[\s])@[^\s]*$/)) {
-                    void this.tryTriggerAutocomplete();
-                }
-                // Check if we're in a # file search context
-                else if (textBeforeCursor.match(/(?:^|[\s])#[^\s]*$/)) {
+                if (this.autocompleteProvider.matchesContext(textBeforeCursor)) {
                     void this.tryTriggerAutocomplete();
                 }
             }
@@ -696,7 +736,7 @@ export class Editor {
                 ? `[paste #${pasteId} +${pastedLines.length} lines]`
                 : `[paste #${pasteId} ${totalChars} chars]`;
             for (const char of marker) {
-                this.insertCharacter(char);
+                this.insertCharacter(char, true);
             }
             return;
         }
@@ -704,7 +744,7 @@ export class Editor {
             // Single line - just insert each character
             const text = pastedLines[0] || "";
             for (const char of text) {
-                this.insertCharacter(char);
+                this.insertCharacter(char, true);
             }
             return;
         }
@@ -779,12 +819,10 @@ export class Editor {
         if (this.isAutocompleting) {
             void this.updateAutocomplete();
         }
-        else {
-            // Check if we should trigger autocomplete after backspace in slash command context
+        else if (this.autocompleteProvider) {
             const currentLine = this.state.lines[this.state.cursorLine] || "";
             const textBeforeCursor = currentLine.slice(0, this.state.cursorCol);
-            // Trigger autocomplete if we're in a slash command context (typing command name)
-            if (textBeforeCursor.startsWith("/") && !textBeforeCursor.includes(" ")) {
+            if (this.autocompleteProvider.matchesContext(textBeforeCursor)) {
                 void this.tryTriggerAutocomplete();
             }
         }
@@ -1063,13 +1101,6 @@ export class Editor {
         }
         this.state.cursorCol = newCol;
     }
-    // Helper method to check if cursor is at start of message (for slash command detection)
-    isAtStartOfMessage() {
-        const currentLine = this.state.lines[this.state.cursorLine] || "";
-        const beforeCursor = currentLine.slice(0, this.state.cursorCol);
-        // At start if line is empty, only contains whitespace, or is just "/"
-        return beforeCursor.trim() === "" || beforeCursor.trim() === "/";
-    }
     // Autocomplete methods
     async tryTriggerAutocomplete(explicitTab = false) {
         if (!this.autocompleteProvider)
@@ -1111,41 +1142,12 @@ export class Editor {
         if (beforeCursor.trimStart().startsWith("/")) {
             await this.handleSlashCommandCompletion();
         }
-        else {
-            await this.forceFileAutocomplete();
-        }
     }
     async handleSlashCommandCompletion() {
         // For now, fall back to regular autocomplete (slash commands)
         // This can be extended later to handle command-specific argument completion
         await this.tryTriggerAutocomplete(true);
     }
-    async forceFileAutocomplete() {
-        if (!this.autocompleteProvider)
-            return;
-        // Check if provider has the force method
-        const provider = this.autocompleteProvider;
-        if (!provider.getForceFileSuggestions) {
-            await this.tryTriggerAutocomplete(true);
-            return;
-        }
-        const suggestions = await provider.getForceFileSuggestions(this.state.lines, this.state.cursorLine, this.state.cursorCol);
-        if (suggestions && suggestions.items.length > 0) {
-            this.autocompletePrefix = suggestions.prefix;
-            if (this.autocompleteList) {
-                this.autocompleteList.updateItems(suggestions.items);
-            }
-            else {
-                this.autocompleteList = new SelectList(suggestions.items, 5, this.theme.selectList);
-            }
-            this.isAutocompleting = true;
-            // Request re-render to show autocomplete list
-            this.onRenderRequested?.();
-        }
-        else {
-            this.cancelAutocomplete();
-        }
-    }
     cancelAutocomplete() {
         this.isAutocompleting = false;
         this.autocompleteList = undefined;
@@ -1158,28 +1160,18 @@ export class Editor {
     isShowingAutocomplete() {
         return this.isAutocompleting;
     }
+    wantsNavigationKeys() {
+        return this.isAutocompleting;
+    }
     async updateAutocomplete() {
         if (!this.isAutocompleting || !this.autocompleteProvider)
             return;
         // Check if the current text still matches our autocomplete context
-        // This prevents unnecessary updates when typing unrelated text
         const currentLine = this.state.lines[this.state.cursorLine] || "";
         const textBeforeCursor = currentLine.slice(0, this.state.cursorCol);
-        // If we're no longer in the context that triggered autocomplete, cancel it
-        // For slash commands, @ file attachments, and # file search, allow progressive typing
-        // For other file paths, check if we're still in the same path context
-        if (textBeforeCursor.startsWith("/") ||
-            textBeforeCursor.match(/(?:^|[\s])@[^\s]*$/) ||
-            textBeforeCursor.match(/(?:^|[\s])#[^\s]*$/)) {
-            // For slash commands, @ file attachments, and # file search,
-            // continue autocomplete as long as we're in the right context
-        }
-        else {
-            // For other file paths, check if we're still in the same path context
-            if (!textBeforeCursor.endsWith(this.autocompletePrefix)) {
-                this.cancelAutocomplete();
-                return;
-            }
+        if (!this.autocompleteProvider.matchesContext(textBeforeCursor)) {
+            this.cancelAutocomplete();
+            return;
         }
         // Clear any existing debounce timer
         if (this.autocompleteDebounceTimer) {

package/dist/tui/components/footer.d.ts

@@ -1,24 +1,26 @@
-import type { LanguageModelUsage } from "ai";
 import type { AgentState } from "../../agent/index.ts";
 import type { ModelManager } from "../../models/manager.ts";
 import type { ProjectStatusData } from "../../repl/project-status.ts";
+import type { TokenTracker } from "../../tokens/tracker.ts";
 import { type Component } from "../tui.ts";
 type State = {
     projectStatus: ProjectStatusData;
     currentContextWindow: number;
     contextWindow: number;
-    usage?: LanguageModelUsage;
     agentState?: AgentState;
+    currentMode?: string;
 };
 export declare class FooterComponent implements Component {
     private modelManager;
+    private tokenTracker?;
     private state;
     private progressBar;
-    private usage?;
     private agentState?;
-    constructor(modelManager: ModelManager, state: State);
+    private currentMode;
+    constructor(modelManager: ModelManager, tokenTracker: TokenTracker | undefined, state: State);
     setState(state: State): void;
     resetState(): void;
+    getProjectStatus(): ProjectStatusData;
     render(width: number): string[];
 }
 export {};