Struct App 

pub struct App {

    pub input: String,
    pub cursor_position: usize,
    pub running: bool,
    pub context: ProjectContext,
    pub current_response: String,
    pub working_dir: String,
    pub error_log: Vec<ErrorEntry>,
    pub app_state: AppState,
    pub model_state: ModelState,
    pub ui_state: UIState,
    pub session_state: SessionState,
    pub operation_state: OperationState,
    pub status_state: StatusState,
}

Application state

Fields

input: String

User input buffer

cursor_position: usize

Cursor position in the input string

running: bool

Is the app running?

context: ProjectContext

Project context

current_response: String

Current model response (for streaming)

working_dir: String

Current working directory

error_log: Vec<ErrorEntry>

Error log - keeps last N errors for visibility (no more silent failures!)

app_state: AppState

State machine for application lifecycle

model_state: ModelState

Model state - LLM configuration

ui_state: UIState

UI state - visual presentation and widget states

session_state: SessionState

Session state - conversation history and persistence

operation_state: OperationState

Operation state - mode, confirmations, and plan execution

status_state: StatusState

Status state - UI status messages

Implementations

impl App

pub fn new( model: Box<dyn Model>, context: ProjectContext, model_id: String, ) -> Self

Create a new app instance

pub fn set_context_manager(&mut self, manager: ContextManager)

Set the context manager for dynamic context reloading

pub async fn reload_context_if_needed(&mut self) -> Result<()>

Update context if file tree has changed since last message

pub fn add_message(&mut self, role: MessageRole, content: String)

Add a message to the chat

pub fn clear_input(&mut self)

Clear the input buffer

pub fn set_status(&mut self, message: impl Into<String>)

Set status message

pub fn clear_status(&mut self)

Clear status message

pub fn set_terminal_title(&self, title: &str)

Set terminal window title

pub async fn generate_conversation_title(&mut self)

Generate conversation title from current messages

pub fn log_error(&mut self, entry: ErrorEntry)

Log an error to the error log (no more silent failures!)

pub fn log_error_msg(&mut self, severity: ErrorSeverity, msg: impl Into<String>)

Convenience: log a simple error message

pub fn log_error_with_context( &mut self, severity: ErrorSeverity, msg: impl Into<String>, context: impl Into<String>, )

Convenience: log error with context

pub fn recent_errors(&self, count: usize) -> Vec<&ErrorEntry>

Get recent errors (last N)

pub fn scroll_up(&mut self, amount: u16)

Scroll chat view up

pub fn scroll_down(&mut self, amount: u16)

Scroll chat view down

pub fn quit(&mut self)

Quit the application

pub fn cycle_mode(&mut self)

Cycle to the next operation mode

pub fn cycle_mode_reverse(&mut self)

Cycle to the previous operation mode

pub fn set_mode(&mut self, mode: OperationMode)

Set a specific operation mode

pub fn toggle_bypass_mode(&mut self)

Toggle bypass mode (Ctrl+Y shortcut)

pub fn build_message_history(&self) -> Vec<ChatMessage>

Build message history for sending to the model Includes only user and assistant messages (not system messages from the UI)

pub fn build_managed_message_history( &self, max_context_tokens: usize, reserve_tokens: usize, ) -> Vec<ChatMessage>

Build message history with token management Ensures the conversation doesn’t exceed the model’s context window

pub fn load_conversation(&mut self, conversation: ConversationHistory)

Load a conversation history

pub fn save_conversation(&mut self) -> Result<()>

Save the current conversation

pub fn auto_save_conversation(&mut self)

Auto-save the conversation (called on exit)

pub fn start_generation(&mut self, abort_handle: AbortHandle)

Start generation - transitions to Generating state with Sending status

pub fn transition_to_thinking(&mut self)

Transition from Sending to Thinking status

pub fn transition_to_streaming(&mut self)

Transition from Thinking/Sending to Streaming status

pub fn increment_tokens(&mut self, count: usize)

Increment tokens received during generation

pub fn stop_generation(&mut self)

Stop generation - transitions back to Idle state

pub fn abort_generation(&mut self) -> Option<AbortHandle>

Abort generation and return the abort handle if present

pub fn set_pending_action( &mut self, action: AgentAction, executor: ModeAwareExecutor, )

Set pending action - transitions to AwaitingActionConfirmation state

pub fn clear_pending_action(&mut self)

Clear pending action - transitions back to Idle state

pub fn set_plan(&mut self, plan: Plan)

Set active plan and enter approval state

pub fn cancel_plan(&mut self)

Cancel the active plan

pub fn start_plan_execution(&mut self)

Start executing the active plan

pub fn plan_next_action(&self) -> Option<&PlannedAction>

Get the next pending action from the plan

pub fn mark_plan_action_completed(&mut self, result: Option<ActionResult>)

Mark current plan action as completed

pub fn mark_plan_action_failed(&mut self, error: String)

Mark current plan action as failed

pub fn is_plan_complete(&self) -> bool

Check if plan execution is complete

pub fn get_plan_stats(&self) -> Option<PlanStats>

Get plan statistics