anveesa 0.3.6 → 0.3.8

package/src/tui.rs

@@ -0,0 +1,1159 @@
+use std::{path::PathBuf, time::Duration};
+
+use anyhow::{Context, Result};
+use crossterm::event::{
+    DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEvent, KeyModifiers,
+    MouseEvent, MouseEventKind,
+};
+use ratatui::{
+    DefaultTerminal, Frame,
+    layout::{Constraint, Layout, Rect},
+    style::{Color, Modifier, Style},
+    text::{Line, Span},
+    widgets::{Block, Borders, Paragraph, Wrap},
+};
+use tokio::sync::{mpsc, oneshot};
+
+use crate::{
+    cli::AskOptions,
+    config::AppConfig,
+    provider::{
+        ApprovalDecision, ApprovalPolicy, ChatMessage, ChatRole, ImageAttachment, PromptRequest,
+        StreamEvent, ToolConfirmPreview, Usage,
+    },
+};
+
+// ── Public stream event type ──────────────────────────────────────────────────
+
+pub enum TuiEvent {
+    Token(String),
+    Status(String),
+    ToolCall(String),
+    ToolDone { summary: String, ok: bool },
+    FileOp { verb: String, path: String, added: usize, removed: usize },
+    Confirm { summary: String, reply: oneshot::Sender<ApprovalDecision> },
+    Usage(Usage),
+    Error(String),
+    PlanSet(Vec<String>),
+    PlanTaskDone(usize),
+}
+
+// ── Display message types ─────────────────────────────────────────────────────
+
+#[derive(Debug)]
+enum Msg {
+    User { text: String },
+    Assistant { text: String },
+    Tool { icon: &'static str, text: String, ok: bool },
+    FileOp { verb: String, path: String, added: usize, removed: usize },
+    Error(String),
+    System(String),
+}
+
+#[derive(Debug)]
+struct PendingConfirm {
+    summary: String,
+    reply: oneshot::Sender<ApprovalDecision>,
+}
+
+#[derive(Debug, PartialEq)]
+enum Mode {
+    Input,
+    Streaming,
+    Confirming,
+}
+
+// ── Application state ─────────────────────────────────────────────────────────
+
+pub struct App {
+    // conversation display
+    messages: Vec<Msg>,
+    streaming_buf: String,
+    accumulated_response: String, // full assistant text across tool calls
+    tool_status: String,
+    plan_tasks: Vec<String>,
+    plan_done: Vec<bool>,
+
+    // pending turn tracking
+    pending_prompt: String,
+
+    // input
+    input: String,
+    input_cursor: usize,
+    input_history: Vec<String>,
+    hist_idx: Option<usize>,
+    hist_saved: String,
+    pending_image: Option<ImageAttachment>,
+    last_image_fp: Option<String>,
+    images_available: bool,
+
+    // scroll
+    scroll: usize,
+    auto_scroll: bool,
+    total_lines: usize,
+
+    // status info
+    provider: String,
+    model: String,
+    usage: Usage,
+    cwd: String,
+
+    // mode
+    mode: Mode,
+    confirm: Option<PendingConfirm>,
+
+    // history & session
+    history: Vec<ChatMessage>,
+    session_path: Option<PathBuf>,
+    pub last_saved_at: u64,
+
+    // request params
+    pub config: AppConfig,
+    pub options: AskOptions,
+    pub workspace_context: Option<String>,
+    pub policy: ApprovalPolicy,
+
+    // channels
+    stream_rx: mpsc::UnboundedReceiver<TuiEvent>,
+    stream_tx: mpsc::UnboundedSender<TuiEvent>,
+    key_rx: mpsc::UnboundedReceiver<Event>,
+
+    quit: bool,
+    spinner_frame: usize,
+}
+
+impl App {
+    pub fn new(
+        provider: String,
+        model: String,
+        cwd: String,
+        history: Vec<ChatMessage>,
+        images_available: bool,
+        session_path: Option<PathBuf>,
+        last_saved_at: u64,
+        input_history: Vec<String>,
+        config: AppConfig,
+        options: AskOptions,
+        workspace_context: Option<String>,
+        policy: ApprovalPolicy,
+        key_rx: mpsc::UnboundedReceiver<Event>,
+    ) -> Self {
+        let (stream_tx, stream_rx) = mpsc::unbounded_channel();
+        let messages = history
+            .iter()
+            .map(|m| match m.role {
+                ChatRole::User => Msg::User { text: m.content.clone() },
+                ChatRole::Assistant => Msg::Assistant { text: m.content.clone() },
+            })
+            .collect();
+
+        Self {
+            messages,
+            streaming_buf: String::new(),
+            accumulated_response: String::new(),
+            tool_status: String::new(),
+            plan_tasks: vec![],
+            plan_done: vec![],
+            pending_prompt: String::new(),
+
+            input: String::new(),
+            input_cursor: 0,
+            input_history,
+            hist_idx: None,
+            hist_saved: String::new(),
+            pending_image: None,
+            last_image_fp: None,
+            images_available,
+
+            scroll: usize::MAX,
+            auto_scroll: true,
+            total_lines: 0,
+
+            provider,
+            model,
+            usage: Usage::default(),
+            cwd,
+
+            mode: Mode::Input,
+            confirm: None,
+
+            history,
+            session_path,
+            last_saved_at,
+
+            config,
+            options,
+            workspace_context,
+            policy,
+
+            stream_rx,
+            stream_tx,
+            key_rx,
+
+            quit: false,
+            spinner_frame: 0,
+        }
+    }
+}
+
+// ── Main TUI loop ─────────────────────────────────────────────────────────────
+
+pub async fn run(mut app: App) -> Result<Vec<ChatMessage>> {
+    crossterm::execute!(std::io::stdout(), EnableMouseCapture)?;
+    let mut terminal = ratatui::init();
+    terminal.clear()?;
+    let result = event_loop(&mut terminal, &mut app).await;
+    ratatui::restore();
+    crossterm::execute!(std::io::stdout(), DisableMouseCapture)?;
+    result
+}
+
+async fn event_loop(terminal: &mut DefaultTerminal, app: &mut App) -> Result<Vec<ChatMessage>> {
+    loop {
+        terminal.draw(|f| render(f, app))?;
+        if app.quit {
+            break;
+        }
+        tokio::select! {
+            Some(ev) = app.key_rx.recv() => {
+                handle_event(app, ev).await?;
+            }
+            Some(tui_ev) = app.stream_rx.recv() => {
+                handle_stream_event(app, tui_ev).await;
+            }
+            _ = tokio::time::sleep(Duration::from_millis(80)) => {
+                if app.mode == Mode::Streaming {
+                    app.spinner_frame = app.spinner_frame.wrapping_add(1);
+                }
+            }
+        }
+    }
+    Ok(app.history.clone())
+}
+
+// ── Event handling ────────────────────────────────────────────────────────────
+
+async fn handle_event(app: &mut App, event: Event) -> Result<()> {
+    match event {
+        Event::Mouse(MouseEvent { kind, .. }) => handle_mouse(app, kind),
+        Event::Key(key) => handle_key(app, key).await?,
+        Event::Resize(_, _) => {}
+        _ => {}
+    }
+    Ok(())
+}
+
+fn handle_mouse(app: &mut App, kind: MouseEventKind) {
+    match kind {
+        MouseEventKind::ScrollUp => {
+            app.auto_scroll = false;
+            app.scroll = app.scroll.saturating_sub(3);
+        }
+        MouseEventKind::ScrollDown => {
+            app.scroll = app.scroll.saturating_add(3);
+            if app.scroll >= app.total_lines {
+                app.auto_scroll = true;
+            }
+        }
+        _ => {}
+    }
+}
+
+async fn handle_key(app: &mut App, KeyEvent { code, modifiers, .. }: KeyEvent) -> Result<()> {
+    // ── Confirming mode: y/a/n only ───────────────────────────────────────────
+    if app.mode == Mode::Confirming {
+        if let Some(confirm) = app.confirm.take() {
+            let decision = match code {
+                KeyCode::Char('y') | KeyCode::Enter => ApprovalDecision::AllowOnce,
+                KeyCode::Char('a') => ApprovalDecision::AllowForTurn,
+                _ => ApprovalDecision::Deny,
+            };
+            let _ = confirm.reply.send(decision);
+            app.mode = Mode::Streaming;
+        }
+        return Ok(());
+    }
+
+    // ── Streaming mode: scroll only ───────────────────────────────────────────
+    if app.mode == Mode::Streaming {
+        match code {
+            KeyCode::PageUp => {
+                app.auto_scroll = false;
+                app.scroll = app.scroll.saturating_sub(10);
+            }
+            KeyCode::PageDown => {
+                app.scroll = app.scroll.saturating_add(10);
+                if app.scroll >= app.total_lines {
+                    app.auto_scroll = true;
+                }
+            }
+            _ => {}
+        }
+        return Ok(());
+    }
+
+    // ── Input mode ────────────────────────────────────────────────────────────
+    match code {
+        // Submit (Enter) or newline (Shift+Enter)
+        KeyCode::Enter if modifiers.contains(KeyModifiers::SHIFT) => {
+            app.input.insert(app.input_cursor, '\n');
+            app.input_cursor += 1;
+            app.hist_idx = None;
+        }
+        KeyCode::Enter => {
+            let text = app.input.trim().to_string();
+            if text.is_empty() {
+                return Ok(());
+            }
+            if !handle_slash_command(app, &text) {
+                submit_prompt(app, text).await?;
+            }
+        }
+
+        // Ctrl shortcuts
+        KeyCode::Char('c') if modifiers.contains(KeyModifiers::CONTROL) => {
+            if app.input.is_empty() {
+                app.quit = true;
+            } else {
+                app.input.clear();
+                app.input_cursor = 0;
+                app.hist_idx = None;
+            }
+        }
+        KeyCode::Char('d') if modifiers.contains(KeyModifiers::CONTROL) && app.input.is_empty() => {
+            app.quit = true;
+        }
+        KeyCode::Char('u') if modifiers.contains(KeyModifiers::CONTROL) => {
+            app.input.drain(..app.input_cursor);
+            app.input_cursor = 0;
+            app.hist_idx = None;
+        }
+        KeyCode::Char('w') if modifiers.contains(KeyModifiers::CONTROL) => {
+            delete_word_before(&mut app.input, &mut app.input_cursor);
+            app.hist_idx = None;
+        }
+        KeyCode::Char('v') if modifiers.contains(KeyModifiers::CONTROL) && app.images_available => {
+            if let Some(img) = crate::grab_clipboard_image() {
+                app.pending_image = Some(img);
+                app.last_image_fp = None; // force re-attach
+            }
+        }
+
+        // Editing
+        KeyCode::Backspace => {
+            if app.input_cursor > 0 {
+                let len = prev_char_len(&app.input, app.input_cursor);
+                let start = app.input_cursor - len;
+                app.input.drain(start..app.input_cursor);
+                app.input_cursor = start;
+                app.hist_idx = None;
+            }
+        }
+        KeyCode::Delete => {
+            if app.input_cursor < app.input.len() {
+                let len = next_char_len(&app.input, app.input_cursor);
+                app.input.drain(app.input_cursor..app.input_cursor + len);
+                app.hist_idx = None;
+            }
+        }
+
+        // Cursor movement
+        KeyCode::Left => move_cursor_left(&app.input.clone(), &mut app.input_cursor),
+        KeyCode::Right => move_cursor_right(&app.input.clone(), &mut app.input_cursor),
+        KeyCode::Home => app.input_cursor = 0,
+        KeyCode::End => app.input_cursor = app.input.len(),
+
+        // History navigation
+        KeyCode::Up => {
+            if !app.input_history.is_empty() {
+                let new_idx = match app.hist_idx {
+                    None => {
+                        app.hist_saved = app.input.clone();
+                        app.input_history.len() - 1
+                    }
+                    Some(0) => 0,
+                    Some(i) => i - 1,
+                };
+                app.hist_idx = Some(new_idx);
+                app.input = app.input_history[new_idx].clone();
+                app.input_cursor = app.input.len();
+            }
+        }
+        KeyCode::Down => {
+            match app.hist_idx {
+                None => {}
+                Some(i) if i + 1 >= app.input_history.len() => {
+                    app.hist_idx = None;
+                    app.input = std::mem::take(&mut app.hist_saved);
+                    app.input_cursor = app.input.len();
+                }
+                Some(i) => {
+                    app.hist_idx = Some(i + 1);
+                    app.input = app.input_history[i + 1].clone();
+                    app.input_cursor = app.input.len();
+                }
+            }
+        }
+
+        // Scroll
+        KeyCode::PageUp => {
+            app.auto_scroll = false;
+            app.scroll = app.scroll.saturating_sub(10);
+        }
+        KeyCode::PageDown => {
+            app.scroll = app.scroll.saturating_add(10);
+            if app.scroll >= app.total_lines {
+                app.auto_scroll = true;
+            }
+        }
+
+        // Printable characters
+        KeyCode::Char(c) => {
+            let s = c.to_string();
+            app.input.insert_str(app.input_cursor, &s);
+            app.input_cursor += s.len();
+            app.hist_idx = None;
+        }
+
+        _ => {}
+    }
+    Ok(())
+}
+
+// Returns true if the command was consumed (don't send to AI).
+fn handle_slash_command(app: &mut App, text: &str) -> bool {
+    match text {
+        "/exit" | "/quit" | ":q" => {
+            app.quit = true;
+            true
+        }
+        "/clear" => {
+            app.messages.clear();
+            app.history.clear();
+            app.streaming_buf.clear();
+            app.accumulated_response.clear();
+            app.usage = Usage::default();
+            app.pending_image = None;
+            app.input.clear();
+            app.input_cursor = 0;
+            if let Some(path) = &app.session_path {
+                let _ = std::fs::remove_file(path);
+            }
+            true
+        }
+        "/help" => {
+            app.messages.push(Msg::System(
+                "Commands: /clear  /export [path]  /model [name]  /provider [name]  /status  /exit\n\
+                 Keys: ↑/↓ history  ←/→ cursor  Home/End  Shift+Enter newline\n\
+                 Ctrl+W delete-word  Ctrl+U clear-line  Ctrl+V paste image\n\
+                 PageUp/Dn or scroll wheel to scroll history".into(),
+            ));
+            app.input.clear();
+            app.input_cursor = 0;
+            true
+        }
+        "/status" => {
+            let u = &app.usage;
+            app.messages.push(Msg::System(format!(
+                "provider: {}  model: {}  turns: {}  tokens: {}↓ {}↑ {} total",
+                app.provider,
+                app.model,
+                app.history.len() / 2,
+                u.prompt_tokens,
+                u.completion_tokens,
+                u.total_tokens,
+            )));
+            app.input.clear();
+            app.input_cursor = 0;
+            true
+        }
+        s if s.starts_with("/export") => {
+            let arg = s.strip_prefix("/export").unwrap().trim();
+            let path = if arg.is_empty() {
+                std::path::PathBuf::from(format!("anveesa-export-{}.md", crate::unix_now()))
+            } else {
+                std::path::PathBuf::from(arg)
+            };
+            match crate::export_conversation(&path, &app.history) {
+                Ok(()) => app.messages.push(Msg::System(format!("Exported → {}", path.display()))),
+                Err(e) => app.messages.push(Msg::Error(format!("export failed: {e:#}"))),
+            }
+            app.input.clear();
+            app.input_cursor = 0;
+            true
+        }
+        s if s.starts_with("/model") => {
+            let arg = s.strip_prefix("/model").unwrap().trim();
+            if arg.is_empty() {
+                let current = app.model.clone();
+                app.messages.push(Msg::System(format!("current model: {current}")));
+            } else {
+                app.model = arg.to_string();
+                app.options.model = Some(arg.to_string());
+                app.messages.push(Msg::System(format!("switched to model: {arg}")));
+            }
+            app.input.clear();
+            app.input_cursor = 0;
+            true
+        }
+        s if s.starts_with("/provider") => {
+            let arg = s.strip_prefix("/provider").unwrap().trim();
+            if arg.is_empty() {
+                let current = app.provider.clone();
+                app.messages.push(Msg::System(format!("current provider: {current}")));
+            } else {
+                // Validate provider exists
+                if app.config.providers.contains_key(arg) {
+                    app.provider = arg.to_string();
+                    app.options.provider = Some(arg.to_string());
+                    // Update model to provider default
+                    if let Some(m) = app.config.providers.get(arg)
+                        .and_then(|p| p.default_model())
+                    {
+                        app.model = m.to_string();
+                        app.options.model = Some(m.to_string());
+                    }
+                    app.messages.push(Msg::System(format!("switched to provider: {arg}")));
+                } else {
+                    app.messages.push(Msg::Error(format!("unknown provider '{arg}'")));
+                }
+            }
+            app.input.clear();
+            app.input_cursor = 0;
+            true
+        }
+        _ => false,
+    }
+}
+
+async fn submit_prompt(app: &mut App, text: String) -> Result<()> {
+    // Save to input history
+    if app.input_history.last().map(|s| s.as_str()) != Some(&text) {
+        app.input_history.push(text.clone());
+    }
+    app.hist_idx = None;
+    app.pending_prompt = text.clone();
+    app.accumulated_response.clear();
+
+    // Auto-attach clipboard image if nothing was explicitly Ctrl+V'd
+    let image = app.pending_image.take().or_else(|| {
+        if !app.images_available { return None; }
+        let img = crate::grab_clipboard_image()?;
+        let fp = crate::image_fingerprint(&img);
+        if app.last_image_fp.as_deref() == Some(&fp) {
+            return None; // same image as last time
+        }
+        app.last_image_fp = Some(fp);
+        Some(img)
+    });
+
+    app.messages.push(Msg::User { text: text.clone() });
+    app.input.clear();
+    app.input_cursor = 0;
+    app.auto_scroll = true;
+    app.mode = Mode::Streaming;
+    app.tool_status = "Thinking".to_string();
+    app.spinner_frame = 0;
+
+    let provider_name = app
+        .config
+        .provider_name(app.options.provider.as_deref())
+        .context("unknown provider")?
+        .to_string();
+
+    let (stream_tx_inner, stream_rx_inner) = mpsc::unbounded_channel::<StreamEvent>();
+
+    // Clone everything needed for the spawned tasks
+    let config = app.config.clone();
+    let options = app.options.clone();
+    let history = app.history.clone();
+    let workspace_context = app.workspace_context.clone();
+    let policy = app.policy;
+    let tui_tx = app.stream_tx.clone();
+    let tui_tx2 = app.stream_tx.clone();
+
+    // Task 1: call the provider
+    tokio::spawn(async move {
+        let request = PromptRequest {
+            prompt: text,
+            model: options.model.clone(),
+            system: options.system.clone(),
+            workspace_context,
+            history,
+            image,
+        };
+        let result = crate::provider::ask(&config, &provider_name, request, policy, &stream_tx_inner).await;
+        drop(stream_tx_inner);
+        match result {
+            Ok(turn) => {
+                let _ = tui_tx.send(TuiEvent::Usage(turn.usage.unwrap_or_default()));
+            }
+            Err(e) => {
+                let _ = tui_tx.send(TuiEvent::Error(format!("{e:#}")));
+            }
+        }
+    });
+
+    // Task 2: relay StreamEvents → TuiEvents
+    tokio::spawn(async move {
+        let mut rx = stream_rx_inner;
+        while let Some(ev) = rx.recv().await {
+            let tui_ev = match ev {
+                StreamEvent::Token(t) => TuiEvent::Token(t),
+                StreamEvent::Status { message } => TuiEvent::Status(message),
+                StreamEvent::ToolCall { summary } => TuiEvent::ToolCall(summary),
+                StreamEvent::ToolResult { summary, ok, .. } => TuiEvent::ToolDone { summary, ok },
+                StreamEvent::FileOp { verb, path, added, removed, .. } =>
+                    TuiEvent::FileOp { verb, path, added, removed },
+                StreamEvent::Confirm { preview, reply } => {
+                    let summary = match &preview {
+                        ToolConfirmPreview::FileOp { verb, path, added, removed, .. } =>
+                            format!("{verb} {path}  +{added} -{removed}"),
+                        ToolConfirmPreview::CreateDir { path } => format!("mkdir {path}"),
+                        ToolConfirmPreview::Generic { summary } => summary.clone(),
+                    };
+                    TuiEvent::Confirm { summary, reply }
+                }
+                StreamEvent::Usage(u) => TuiEvent::Usage(u),
+                StreamEvent::PlanSet { tasks } => TuiEvent::PlanSet(tasks),
+                StreamEvent::PlanTaskDone { index } => TuiEvent::PlanTaskDone(index),
+            };
+            if tui_tx2.send(tui_ev).is_err() { break; }
+        }
+    });
+
+    Ok(())
+}
+
+async fn handle_stream_event(app: &mut App, ev: TuiEvent) {
+    match ev {
+        TuiEvent::Token(text) => {
+            app.streaming_buf.push_str(&text);
+            app.auto_scroll = true;
+        }
+        TuiEvent::Status(msg) => {
+            app.tool_status = msg;
+        }
+        TuiEvent::ToolCall(summary) => {
+            flush_streaming_buf(app);
+            app.messages.push(Msg::Tool { icon: "⚙", text: summary, ok: true });
+            app.tool_status = "Running".to_string();
+        }
+        TuiEvent::ToolDone { summary, ok } => {
+            if let Some(Msg::Tool { text, ok: tool_ok, .. }) = app.messages.last_mut() {
+                *text = summary;
+                *tool_ok = ok;
+            }
+            app.tool_status = "Thinking".to_string();
+        }
+        TuiEvent::FileOp { verb, path, added, removed } => {
+            flush_streaming_buf(app);
+            app.messages.push(Msg::FileOp { verb, path, added, removed });
+        }
+        TuiEvent::Confirm { summary, reply } => {
+            flush_streaming_buf(app);
+            app.confirm = Some(PendingConfirm { summary, reply });
+            app.mode = Mode::Confirming;
+        }
+        TuiEvent::Usage(u) => {
+            app.usage.prompt_tokens += u.prompt_tokens;
+            app.usage.completion_tokens += u.completion_tokens;
+            app.usage.total_tokens += u.total_tokens;
+            app.usage.cache_read_tokens += u.cache_read_tokens;
+            app.usage.cache_write_tokens += u.cache_write_tokens;
+            finish_turn(app);
+        }
+        TuiEvent::Error(msg) => {
+            flush_streaming_buf(app);
+            app.messages.push(Msg::Error(msg));
+            app.mode = Mode::Input;
+            app.tool_status.clear();
+        }
+        TuiEvent::PlanSet(tasks) => {
+            app.plan_done = vec![false; tasks.len()];
+            app.plan_tasks = tasks;
+        }
+        TuiEvent::PlanTaskDone(i) => {
+            if i < app.plan_done.len() { app.plan_done[i] = true; }
+        }
+    }
+}
+
+/// Flush streaming_buf to messages and accumulated_response.
+fn flush_streaming_buf(app: &mut App) {
+    if !app.streaming_buf.is_empty() {
+        let text = std::mem::take(&mut app.streaming_buf);
+        app.accumulated_response.push_str(&text);
+        app.messages.push(Msg::Assistant { text });
+    }
+}
+
+/// Commit the completed turn to history and save session.
+fn finish_turn(app: &mut App) {
+    flush_streaming_buf(app);
+    let response = std::mem::take(&mut app.accumulated_response);
+    if !response.is_empty() {
+        let prompt = std::mem::take(&mut app.pending_prompt);
+        app.history.push(ChatMessage::user(prompt));
+        app.history.push(ChatMessage::assistant(response));
+        if let Some(path) = &app.session_path {
+            if let Ok(cwd) = std::env::current_dir() {
+                let _ = crate::save_interactive_session_pub(
+                    path, &cwd, &app.provider, &app.options, &app.history,
+                );
+                app.last_saved_at = crate::unix_now();
+            }
+        }
+    }
+    app.mode = Mode::Input;
+    app.tool_status.clear();
+}
+
+// ── Rendering ─────────────────────────────────────────────────────────────────
+
+fn render(frame: &mut Frame, app: &mut App) {
+    let area = frame.area();
+    let input_lines = app.input.lines().count().max(1);
+    let input_height = (input_lines as u16).clamp(1, 5) + 2;
+
+    let chunks = Layout::vertical([
+        Constraint::Length(1),
+        Constraint::Min(3),
+        Constraint::Length(input_height),
+        Constraint::Length(1),
+    ])
+    .split(area);
+
+    render_header(frame, chunks[0], app);
+    render_messages(frame, chunks[1], app);
+    render_input(frame, chunks[2], app);
+    render_status(frame, chunks[3], app);
+}
+
+fn render_header(frame: &mut Frame, area: Rect, app: &App) {
+    let version = env!("CARGO_PKG_VERSION");
+    let token_str = if app.usage.total_tokens > 0 {
+        format!("  {}↓ {}↑", app.usage.prompt_tokens, app.usage.completion_tokens)
+    } else {
+        String::new()
+    };
+    let left = format!(" anveesa v{version}{token_str}");
+    let right = format!("{} · {}  ", app.provider, app.model);
+    let gap = (area.width as usize).saturating_sub(left.chars().count() + right.chars().count());
+    let title = format!("{left}{}{right}", " ".repeat(gap));
+    frame.render_widget(
+        Paragraph::new(title).style(Style::default().fg(Color::Black).bg(Color::Rgb(97, 175, 239))),
+        area,
+    );
+}
+
+fn render_messages(frame: &mut Frame, area: Rect, app: &mut App) {
+    let width = area.width.saturating_sub(4) as usize;
+    let mut lines: Vec<Line<'static>> = vec![Line::from("")];
+
+    for msg in &app.messages {
+        match msg {
+            Msg::User { text } => {
+                lines.push(user_header());
+                for l in wrap_text(text, width) {
+                    lines.push(Line::from(format!("    {l}")));
+                }
+                lines.push(Line::from(""));
+            }
+            Msg::Assistant { text } => {
+                lines.push(assistant_header(&app.model));
+                for l in format_assistant_lines(text, width) {
+                    lines.push(l);
+                }
+                lines.push(Line::from(""));
+            }
+            Msg::Tool { icon, text, ok } => {
+                let color = if *ok { Color::Rgb(229, 192, 123) } else { Color::Rgb(224, 108, 117) };
+                lines.push(Line::from(Span::styled(
+                    format!("  {icon} {text}"),
+                    Style::default().fg(color),
+                )));
+                lines.push(Line::from(""));
+            }
+            Msg::FileOp { verb, path, added, removed } => {
+                lines.push(Line::from(vec![
+                    Span::styled("  📄 ", Style::default().fg(Color::Rgb(229, 192, 123))),
+                    Span::styled(format!("{verb} "), Style::default().fg(Color::White)),
+                    Span::styled(path.clone(), Style::default().fg(Color::Rgb(97, 175, 239))),
+                    Span::styled(format!("  +{added}"), Style::default().fg(Color::Rgb(152, 195, 121))),
+                    Span::styled(format!(" -{removed}"), Style::default().fg(Color::Rgb(224, 108, 117))),
+                ]));
+                lines.push(Line::from(""));
+            }
+            Msg::Error(msg) => {
+                lines.push(Line::from(Span::styled(
+                    format!("  ✗ {msg}"),
+                    Style::default().fg(Color::Rgb(224, 108, 117)),
+                )));
+                lines.push(Line::from(""));
+            }
+            Msg::System(msg) => {
+                for l in msg.lines() {
+                    lines.push(Line::from(Span::styled(
+                        format!("  · {l}"),
+                        Style::default().fg(Color::DarkGray),
+                    )));
+                }
+                lines.push(Line::from(""));
+            }
+        }
+    }
+
+    // In-progress streaming
+    if !app.streaming_buf.is_empty() || app.mode == Mode::Streaming {
+        lines.push(assistant_header(&app.model));
+        if !app.streaming_buf.is_empty() {
+            for l in format_assistant_lines(&app.streaming_buf, width) {
+                lines.push(l);
+            }
+        } else {
+            let dots = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+            let dot = dots[app.spinner_frame % dots.len()];
+            let status = if app.tool_status.is_empty() { "Thinking" } else { &app.tool_status };
+            lines.push(Line::from(Span::styled(
+                format!("    {dot} {status}"),
+                Style::default().fg(Color::DarkGray),
+            )));
+        }
+        lines.push(Line::from(""));
+    }
+
+    let total = lines.len();
+    app.total_lines = total;
+    let visible = area.height as usize;
+    let scroll = if app.auto_scroll || app.scroll == usize::MAX {
+        total.saturating_sub(visible)
+    } else {
+        app.scroll.min(total.saturating_sub(visible))
+    };
+    app.scroll = scroll;
+
+    frame.render_widget(
+        Paragraph::new(lines).scroll((scroll as u16, 0)),
+        area,
+    );
+}
+
+fn user_header() -> Line<'static> {
+    Line::from(Span::styled(
+        "  ● You",
+        Style::default().fg(Color::Rgb(97, 175, 239)).add_modifier(Modifier::BOLD),
+    ))
+}
+
+fn assistant_header(model: &str) -> Line<'static> {
+    Line::from(Span::styled(
+        format!("  ● {model}"),
+        Style::default().fg(Color::Rgb(152, 195, 121)).add_modifier(Modifier::BOLD),
+    ))
+}
+
+fn render_input(frame: &mut Frame, area: Rect, app: &App) {
+    let block = Block::default()
+        .borders(Borders::TOP)
+        .border_style(Style::default().fg(Color::Rgb(60, 60, 80)));
+    let inner = block.inner(area);
+    frame.render_widget(block, area);
+
+    let label = if app.pending_image.is_some() { "  [📎] ❯ " } else { "  ❯ " };
+    let label_w = label.chars().count();
+    let display = format!("{label}{}", app.input);
+
+    frame.render_widget(
+        Paragraph::new(display).style(Style::default().fg(Color::White)).wrap(Wrap { trim: false }),
+        inner,
+    );
+
+    // Position cursor
+    let cursor_chars = label_w + app.input[..app.input_cursor].chars().count();
+    let w = inner.width.max(1) as usize;
+    frame.set_cursor_position((
+        inner.x + (cursor_chars % w) as u16,
+        inner.y + (cursor_chars / w) as u16,
+    ));
+}
+
+fn render_status(frame: &mut Frame, area: Rect, app: &App) {
+    let (text, style) = if app.mode == Mode::Confirming {
+        let summary = app.confirm.as_ref().map(|c| c.summary.as_str()).unwrap_or("?");
+        (
+            format!(" ⚠  Allow: {summary}   [y]es  [a]ll  [n]o "),
+            Style::default().fg(Color::Black).bg(Color::Rgb(229, 192, 123)),
+        )
+    } else {
+        let hints = "PageUp/Dn · scroll · /help";
+        let left = format!(" {}", app.cwd);
+        let right = format!("{hints} ");
+        let gap = (area.width as usize)
+            .saturating_sub(left.chars().count() + right.chars().count());
+        (
+            format!("{left}{}{right}", " ".repeat(gap)),
+            Style::default().fg(Color::DarkGray).bg(Color::Rgb(30, 30, 46)),
+        )
+    };
+    frame.render_widget(Paragraph::new(text).style(style), area);
+}
+
+// ── Text formatting ───────────────────────────────────────────────────────────
+
+fn wrap_text(text: &str, width: usize) -> Vec<String> {
+    if width == 0 { return vec![text.to_string()]; }
+    let mut out = Vec::new();
+    for line in text.lines() {
+        if line.is_empty() { out.push(String::new()); continue; }
+        let mut current = String::new();
+        let mut col = 0usize;
+        for word in line.split_whitespace() {
+            let wlen = word.chars().count();
+            if col > 0 && col + 1 + wlen > width {
+                out.push(current.clone());
+                current.clear();
+                col = 0;
+            }
+            if col > 0 { current.push(' '); col += 1; }
+            current.push_str(word);
+            col += wlen;
+        }
+        out.push(current);
+    }
+    out
+}
+
+fn format_assistant_lines(text: &str, width: usize) -> Vec<Line<'static>> {
+    let mut out = Vec::new();
+    let mut in_code = false;
+    let mut code_lang = String::new();
+
+    for raw in text.lines() {
+        if raw.starts_with("```") {
+            if in_code {
+                in_code = false;
+                code_lang.clear();
+                out.push(Line::from(Span::styled(
+                    "    └──────────────────────".to_string(),
+                    Style::default().fg(Color::Rgb(50, 50, 70)),
+                )));
+            } else {
+                in_code = true;
+                code_lang = raw[3..].trim().to_string();
+                let lang = if code_lang.is_empty() { String::new() } else { format!(" {} ", code_lang) };
+                out.push(Line::from(Span::styled(
+                    format!("    ┌─{lang}"),
+                    Style::default().fg(Color::Rgb(50, 50, 70)),
+                )));
+            }
+            continue;
+        }
+
+        if in_code {
+            out.push(highlight_code_line(raw, &code_lang));
+        } else {
+            let wrapped = if width > 4 && raw.chars().count() + 4 > width {
+                wrap_text(raw, width.saturating_sub(4))
+            } else {
+                vec![raw.to_string()]
+            };
+            for l in wrapped {
+                out.push(format_prose_line(&l));
+            }
+        }
+    }
+    out
+}
+
+fn format_prose_line(line: &str) -> Line<'static> {
+    if line.is_empty() { return Line::from(""); }
+
+    if line.starts_with("### ") {
+        return Line::from(Span::styled(
+            format!("    {}", &line[4..]),
+            Style::default().fg(Color::Rgb(198, 160, 246)).add_modifier(Modifier::BOLD),
+        ));
+    }
+    if line.starts_with("## ") {
+        return Line::from(Span::styled(
+            format!("    {}", &line[3..]),
+            Style::default().fg(Color::Rgb(198, 160, 246)).add_modifier(Modifier::BOLD | Modifier::UNDERLINED),
+        ));
+    }
+    if line.starts_with("# ") {
+        return Line::from(Span::styled(
+            format!("    {}", &line[2..]),
+            Style::default().fg(Color::Rgb(198, 160, 246)).add_modifier(Modifier::BOLD | Modifier::UNDERLINED),
+        ));
+    }
+
+    let (prefix, rest) = if let Some(s) = line.strip_prefix("- ").or_else(|| line.strip_prefix("* ")) {
+        ("    • ", s)
+    } else {
+        ("    ", line)
+    };
+
+    Line::from(parse_inline(&format!("{prefix}{rest}")))
+}
+
+fn parse_inline(text: &str) -> Vec<Span<'static>> {
+    let mut spans = Vec::new();
+    let mut chars = text.chars().peekable();
+    let mut buf = String::new();
+
+    while let Some(c) = chars.next() {
+        if c == '`' {
+            if !buf.is_empty() { spans.push(Span::raw(buf.clone())); buf.clear(); }
+            let mut code = String::new();
+            for ch in chars.by_ref() { if ch == '`' { break; } code.push(ch); }
+            spans.push(Span::styled(code, Style::default().fg(Color::Rgb(229, 192, 123)).bg(Color::Rgb(40, 40, 55))));
+        } else if c == '*' && chars.peek() == Some(&'*') {
+            chars.next();
+            if !buf.is_empty() { spans.push(Span::raw(buf.clone())); buf.clear(); }
+            let mut bold = String::new();
+            loop {
+                match chars.next() {
+                    Some('*') if chars.peek() == Some(&'*') => { chars.next(); break; }
+                    Some(ch) => bold.push(ch),
+                    None => break,
+                }
+            }
+            spans.push(Span::styled(bold, Style::default().add_modifier(Modifier::BOLD)));
+        } else if c == '*' {
+            if !buf.is_empty() { spans.push(Span::raw(buf.clone())); buf.clear(); }
+            let mut italic = String::new();
+            for ch in chars.by_ref() { if ch == '*' { break; } italic.push(ch); }
+            spans.push(Span::styled(italic, Style::default().add_modifier(Modifier::ITALIC)));
+        } else {
+            buf.push(c);
+        }
+    }
+    if !buf.is_empty() { spans.push(Span::raw(buf)); }
+    spans
+}
+
+fn highlight_code_line(line: &str, _lang: &str) -> Line<'static> {
+    static KEYWORDS: &[&str] = &[
+        "fn", "let", "mut", "const", "struct", "enum", "impl", "trait", "use", "pub",
+        "mod", "return", "if", "else", "for", "while", "loop", "match", "async", "await",
+        "self", "Self", "true", "false", "Some", "None", "Ok", "Err", "type", "where",
+        "def", "class", "import", "from", "pass", "with", "as", "in", "not", "and", "or",
+        "var", "function", "new", "this", "typeof", "instanceof", "yield", "break", "continue",
+        "int", "str", "bool", "float", "None", "True", "False", "null", "undefined",
+        "interface", "extends", "implements", "static", "final", "void", "package",
+    ];
+
+    let bg = Color::Rgb(28, 28, 40);
+    let mut spans: Vec<Span<'static>> = vec![
+        Span::styled("      ".to_string(), Style::default().bg(bg)),
+    ];
+
+    let mut chars = line.chars().peekable();
+    let mut buf = String::new();
+    let mut in_string = false;
+    let mut string_char = '"';
+
+    let flush = |buf: &mut String, spans: &mut Vec<Span<'static>>| {
+        if buf.is_empty() { return; }
+        let s = buf.clone();
+        let style = if KEYWORDS.contains(&s.as_str()) {
+            Style::default().fg(Color::Rgb(198, 120, 221)).bg(bg)
+        } else {
+            Style::default().fg(Color::Rgb(171, 178, 191)).bg(bg)
+        };
+        spans.push(Span::styled(s, style));
+        buf.clear();
+    };
+
+    while let Some(c) = chars.next() {
+        if in_string {
+            buf.push(c);
+            if c == string_char {
+                let s = buf.clone();
+                spans.push(Span::styled(s, Style::default().fg(Color::Rgb(152, 195, 121)).bg(bg)));
+                buf.clear();
+                in_string = false;
+            }
+            continue;
+        }
+
+        // Line comments
+        if (c == '/' && chars.peek() == Some(&'/')) || c == '#' {
+            flush(&mut buf, &mut spans);
+            let rest: String = std::iter::once(c).chain(chars.by_ref()).collect();
+            spans.push(Span::styled(rest, Style::default().fg(Color::Rgb(92, 99, 112)).bg(bg)));
+            break;
+        }
+
+        // String start
+        if c == '"' || c == '\'' {
+            flush(&mut buf, &mut spans);
+            in_string = true;
+            string_char = c;
+            buf.push(c);
+            continue;
+        }
+
+        // Numbers
+        if c.is_ascii_digit() && buf.is_empty() {
+            flush(&mut buf, &mut spans);
+            let mut num = c.to_string();
+            while let Some(&n) = chars.peek() {
+                if n.is_ascii_alphanumeric() || n == '.' || n == '_' { num.push(n); chars.next(); }
+                else { break; }
+            }
+            spans.push(Span::styled(num, Style::default().fg(Color::Rgb(209, 154, 102)).bg(bg)));
+            continue;
+        }
+
+        if c.is_alphanumeric() || c == '_' {
+            buf.push(c);
+        } else {
+            flush(&mut buf, &mut spans);
+            spans.push(Span::styled(c.to_string(), Style::default().fg(Color::Rgb(171, 178, 191)).bg(bg)));
+        }
+    }
+    flush(&mut buf, &mut spans);
+
+    // Fill remainder with bg color
+    let content_len: usize = spans.iter().map(|s| s.content.chars().count()).sum();
+    if content_len < 84 {
+        spans.push(Span::styled(" ".repeat(84 - content_len), Style::default().bg(bg)));
+    }
+
+    Line::from(spans)
+}
+
+// ── String/cursor helpers ─────────────────────────────────────────────────────
+
+fn prev_char_len(s: &str, pos: usize) -> usize {
+    s[..pos].chars().next_back().map(|c| c.len_utf8()).unwrap_or(0)
+}
+
+fn next_char_len(s: &str, pos: usize) -> usize {
+    s[pos..].chars().next().map(|c| c.len_utf8()).unwrap_or(0)
+}
+
+fn move_cursor_left(s: &str, pos: &mut usize) {
+    *pos = pos.saturating_sub(prev_char_len(s, *pos));
+}
+
+fn move_cursor_right(s: &str, pos: &mut usize) {
+    *pos = (*pos + next_char_len(s, *pos)).min(s.len());
+}
+
+fn delete_word_before(s: &mut String, pos: &mut usize) {
+    while *pos > 0 && s[..*pos].ends_with(|c: char| c == ' ' || c == '\n') {
+        let len = prev_char_len(s, *pos);
+        let start = *pos - len;
+        s.drain(start..*pos);
+        *pos = start;
+    }
+    while *pos > 0 && !s[..*pos].ends_with(|c: char| c == ' ' || c == '\n') {
+        let len = prev_char_len(s, *pos);
+        let start = *pos - len;
+        s.drain(start..*pos);
+        *pos = start;
+    }
+}