feat: Use eye-declare for more performant and flexible AI TUI (#3343)

This PR replaces the mess of custom rendering code in Atuin AI with
[eye-declare](https://github.com/BinaryMuse/eye-declare), and updates
the TUI to feel more terminal-native: output appears inline and persists
in scrollback, so you can scroll up and look at previous conversations
for reference.

The "review" state — which used to exist between the LLM generating a
response and the user either executing or following up — has been
removed; just start typing to follow up with the LLM, or press `enter`
at the empty input box to execute the suggested command.

<img width="1203" height="633" alt="image"
src="https://github.com/user-attachments/assets/159ee447-9a2a-4edd-b56e-a79bf1aaaa94"
/>

2 files changed, 751 insertions, 0 deletions

diff --git a/crates/atuin-ai/src/tui/view/mod.rs b/crates/atuin-ai/src/tui/view/mod.rs
new file mode 100644
index 00000000..a1b32518
--- /dev/null
+++ b/crates/atuin-ai/src/tui/view/mod.rs
@@ -0,0 +1,342 @@
+//! View function that builds the eye-declare element tree from app state.
+
+use eye_declare::{
+    Column, Component, Elements, HStack, Line, Span, Spinner, TextBlock, VStack, WidthConstraint,
+    element, impl_slot_children,
+};
+use ratatui_core::style::{Color, Modifier, Style};
+
+use super::components::atuin_ai::AtuinAi;
+use super::components::input_box::InputBox;
+use super::components::markdown::Markdown;
+use super::state::{AppMode, AppState};
+
+mod turn;
+
+#[derive(Default)]
+struct Padding {
+    top: u16,
+    left: u16,
+    right: u16,
+    bottom: u16,
+}
+
+impl Component for Padding {
+    type State = ();
+
+    fn content_inset(&self, _state: &Self::State) -> eye_declare::Insets {
+        eye_declare::Insets::ZERO
+            .left(self.left)
+            .right(self.right)
+            .top(self.top)
+            .bottom(self.bottom)
+    }
+
+    fn desired_height(&self, _width: u16, _state: &Self::State) -> u16 {
+        0
+    }
+
+    fn render(
+        &self,
+        _area: ratatui::layout::Rect,
+        _buf: &mut ratatui::buffer::Buffer,
+        _state: &(),
+    ) {
+    }
+}
+
+impl_slot_children!(Padding);
+
+/// Build the element tree from current state.
+///
+/// Layout (top to bottom):
+/// - Conversation messages (user messages, agent responses, tool status)
+/// - Streaming content (if actively streaming)
+/// - Error display (if in error state)
+/// - Spacer
+/// - Input box (bordered, with contextual keybindings)
+pub fn ai_view(state: &AppState) -> Elements {
+    let mut turn_builder = turn::TurnBuilder::new();
+
+    for event in &state.events {
+        turn_builder.add_event(event);
+    }
+    let turns = turn_builder.build();
+
+    let busy = state.mode == AppMode::Streaming || state.mode == AppMode::Generating;
+    let last_index = turns.len().saturating_sub(1);
+
+    element! {
+        AtuinAi(
+            mode: state.mode.clone(),
+            has_command: state.has_any_command(),
+            is_input_blank: state.is_input_blank,
+            pending_confirmation: state.confirmation_pending,
+        ) {
+            #(for (index, turn) in turns.iter().enumerate() {
+                #(match turn {
+                    turn::UiTurn::User { events } => {
+                        user_turn_view(events, index == 0)
+                    }
+                    turn::UiTurn::Agent { events } => {
+                        agent_turn_view(events, busy && index == last_index)
+                    }
+                    turn::UiTurn::OutOfBand { events } => {
+                        out_of_band_turn_view(events)
+                    }
+                })
+            })
+
+            #(if !state.is_exiting() {
+                TextBlock { Line { Span(text: "") } }
+                InputBox(
+                    key: "input",
+                    title: "Generate a command or ask a question",
+                    title_right: "Atuin AI",
+                    footer: state.footer_text(),
+                    active: state.mode == AppMode::Input && !state.confirmation_pending,
+                )
+
+                #(if state.is_input_blank && state.has_any_command() && state.mode == AppMode::Input {
+                    #(if state.confirmation_pending {
+                        TextBlock { Line { Span(text: "[Enter] Confirm dangerous command  [Esc] Cancel", style: Style::default().fg(Color::Gray)) } }
+                    } else {
+                        TextBlock { Line { Span(text: "[Enter] Execute suggested command  [Tab] Insert Command", style: Style::default().fg(Color::Gray)) } }
+                    })
+                })
+            })
+        }
+    }
+}
+
+fn user_turn_view(events: &[turn::UiEvent], first_turn: bool) -> Elements {
+    let label_style = Style::default()
+        .fg(Color::Cyan)
+        .add_modifier(Modifier::BOLD);
+
+    element! {
+        VStack {
+            TextBlock {
+                #(if !first_turn {
+                    Line { Span() }
+                })
+                Line {
+                    Span(text: "You", style: label_style)
+                }
+            }
+            #(for event in events {
+                #(match event {
+                    turn::UiEvent::Text { content } => {
+                        element! {
+                            Padding(left: 2u16) {
+                                TextBlock {
+                                    Line {
+                                        Span(text: content, style: Style::default())
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    _ => element!{}
+                })
+            })
+        }
+    }
+}
+
+fn agent_turn_view(events: &[turn::UiEvent], busy: bool) -> Elements {
+    let label_style = Style::default()
+        .fg(Color::Yellow)
+        .add_modifier(Modifier::BOLD);
+
+    element! {
+        VStack {
+            Spinner(
+                label: "Atuin AI",
+                label_style: label_style,
+                done_label_style: label_style,
+                hide_checkmark: true,
+                label_first: true,
+                done: !busy,
+            )
+            #(for event in events {
+                #(match event {
+                    turn::UiEvent::Text { content } => {
+                        element! {
+                            Padding(left: 2u16) {
+                                Markdown(source: content)
+                            }
+                        }
+                    },
+                    turn::UiEvent::ToolSummary(summary) => {
+                        tool_summary_view(summary)
+                    },
+                    turn::UiEvent::SuggestedCommand(details) => {
+                        suggested_command_view(details)
+                    },
+                    _ => element!{}
+                })
+            })
+        }
+    }
+}
+
+fn out_of_band_turn_view(events: &[turn::UiEvent]) -> Elements {
+    element! {
+        VStack {
+            TextBlock {
+                Line { Span(text: "System", style: Style::default().fg(Color::Blue).add_modifier(Modifier::BOLD)) }
+            }
+            #(for event in events {
+                #(match event {
+                    turn::UiEvent::OutOfBandOutput(details) => {
+                        out_of_band_output_view(details)
+                    }
+                    _ => element!{}
+                })
+            })
+        }
+    }
+}
+
+fn out_of_band_output_view(details: &turn::OutOfBandOutputDetails) -> Elements {
+    element! {
+        Padding(left: 2u16) {
+            #(if details.command.is_some() {
+                TextBlock {
+                    Line {
+                        Span(text: details.command.as_ref().unwrap(), style: Style::default().fg(Color::Blue))
+                    }
+                }
+            })
+            Markdown(source: details.content.clone())
+        }
+    }
+}
+
+fn tool_summary_view(summary: &turn::ToolSummary) -> Elements {
+    element! {
+        Spinner(label: summary.summary(), done: !summary.any_pending())
+    }
+}
+
+fn suggested_command_view(details: &turn::SuggestedCommandDetails) -> Elements {
+    let is_dangerous = matches!(
+        details.danger_level,
+        turn::DangerLevel::High(_) | turn::DangerLevel::Medium(_)
+    );
+    let danger_notes = details.danger_level.notes();
+    let danger_style = match details.danger_level {
+        turn::DangerLevel::High(_) => Style::default().fg(Color::Red),
+        turn::DangerLevel::Medium(_) => Style::default().fg(Color::Yellow),
+        turn::DangerLevel::Low(_) => Style::default().fg(Color::Green),
+        turn::DangerLevel::Unknown(_) => Style::default().fg(Color::Green),
+    };
+    let danger_text = match details.danger_level {
+        turn::DangerLevel::High(_) => "High",
+        turn::DangerLevel::Medium(_) => "Medium",
+        turn::DangerLevel::Low(_) => "Low",
+        turn::DangerLevel::Unknown(_) => "Unknown",
+    };
+
+    let low_confidence = matches!(
+        details.confidence_level,
+        turn::ConfidenceLevel::Low(_) | turn::ConfidenceLevel::Medium(_)
+    );
+
+    let confidence_level = match details.confidence_level {
+        turn::ConfidenceLevel::Low(_) => "Low",
+        turn::ConfidenceLevel::Medium(_) => "Medium",
+        turn::ConfidenceLevel::High(_) => "High",
+        turn::ConfidenceLevel::Unknown(_) => "Unknown",
+    };
+
+    let confidence_notes = details.confidence_level.notes();
+
+    element! {
+        VStack {
+            TextBlock {
+                #(if !details.first_event_in_turn {
+                    Line { Span() }
+                })
+                Line {
+                    Span(text: "  Suggested command:", style: Style::default().fg(Color::Cyan))
+                }
+            }
+            HStack {
+                Column(width: WidthConstraint::Fixed(2)) {
+                    TextBlock {
+                        Line {
+                            #(if is_dangerous || low_confidence {
+                                Span(text: "! ", style: Style::default().fg(Color::Yellow))
+                            } else {
+                                Span(text: "$ ", style: Style::default().fg(Color::Blue))
+                            })
+                        }
+                    }
+                }
+                Column {
+                    TextBlock {
+                        Line {
+                            Span(text: &details.command, style: Style::default().fg(Color::Green))
+                        }
+                    }
+                }
+            }
+            #(if is_dangerous {
+                Padding(left: 2u16) {
+                    TextBlock {
+                        Line {
+                            Span(text: "Danger: ", style: danger_style)
+                            Span(text: danger_text, style: danger_style.add_modifier(Modifier::BOLD))
+                        }
+                    }
+                }
+            })
+            #(if is_dangerous && danger_notes.is_some() {
+                Padding(left: 2u16) {
+                    HStack {
+                        Column(width: WidthConstraint::Fixed(2)) {
+                            TextBlock {
+                                Line {
+                                    Span(text: "└")
+                                }
+                            }
+                        }
+                        Column(width: WidthConstraint::Fill) {
+                            Markdown(source: danger_notes.unwrap())
+                        }
+                    }
+                }
+            })
+            #(if low_confidence {
+                Padding(left: 2u16) {
+                    TextBlock {
+                        Line {
+                            Span(text: "Confidence: ", style: Style::default().fg(Color::Blue))
+                            Span(text: confidence_level, style: Style::default().fg(Color::Blue).add_modifier(Modifier::BOLD))
+                        }
+                    }
+                }
+            })
+            #(if low_confidence && confidence_notes.is_some() {
+                Padding(left: 2u16) {
+                    HStack {
+                        Column(width: WidthConstraint::Fixed(2)) {
+                            TextBlock {
+                                Line {
+                                    Span(text: "└")
+                                }
+                            }
+                        }
+                        Column(width: WidthConstraint::Fill) {
+                            Markdown(source: confidence_notes.unwrap())
+                        }
+                    }
+                }
+            })
+        }
+    }
+}
+
+// ai_view_old removed — superseded by ai_view above
diff --git a/crates/atuin-ai/src/tui/view/turn.rs b/crates/atuin-ai/src/tui/view/turn.rs
new file mode 100644
index 00000000..861da64c
--- /dev/null
+++ b/crates/atuin-ai/src/tui/view/turn.rs
@@ -0,0 +1,409 @@
+use crate::tui::ConversationEvent;
+
+#[derive(Debug)]
+pub(crate) enum DangerLevel {
+    Low(Option<String>),
+    Medium(Option<String>),
+    High(Option<String>),
+    Unknown(Option<String>),
+}
+
+impl DangerLevel {
+    pub(crate) fn notes(&self) -> Option<&String> {
+        match self {
+            DangerLevel::Low(notes) => notes.as_ref(),
+            DangerLevel::Medium(notes) => notes.as_ref(),
+            DangerLevel::High(notes) => notes.as_ref(),
+            DangerLevel::Unknown(notes) => notes.as_ref(),
+        }
+    }
+}
+
+impl From<(&String, &String)> for DangerLevel {
+    fn from((danger_level, danger_notes): (&String, &String)) -> Self {
+        let notes = if danger_notes.is_empty() {
+            None
+        } else {
+            Some(danger_notes.to_string())
+        };
+
+        match danger_level.as_str() {
+            "low" => DangerLevel::Low(notes),
+            "medium" => DangerLevel::Medium(notes),
+            "med" => DangerLevel::Medium(notes),
+            "high" => DangerLevel::High(notes),
+            _ => DangerLevel::Unknown(notes),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) enum ConfidenceLevel {
+    Low(Option<String>),
+    Medium(Option<String>),
+    High(Option<String>),
+    Unknown(Option<String>),
+}
+
+impl ConfidenceLevel {
+    pub(crate) fn notes(&self) -> Option<&String> {
+        match self {
+            ConfidenceLevel::Low(notes) => notes.as_ref(),
+            ConfidenceLevel::Medium(notes) => notes.as_ref(),
+            ConfidenceLevel::High(notes) => notes.as_ref(),
+            ConfidenceLevel::Unknown(notes) => notes.as_ref(),
+        }
+    }
+}
+
+impl From<(&String, &String)> for ConfidenceLevel {
+    fn from((confidence_level, confidence_notes): (&String, &String)) -> Self {
+        let notes = if confidence_notes.is_empty() {
+            None
+        } else {
+            Some(confidence_notes.to_string())
+        };
+
+        match confidence_level.as_str() {
+            "low" => ConfidenceLevel::Low(notes),
+            "medium" => ConfidenceLevel::Medium(notes),
+            "med" => ConfidenceLevel::Medium(notes),
+            "high" => ConfidenceLevel::High(notes),
+            _ => ConfidenceLevel::Unknown(notes),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) enum UiEvent {
+    Text { content: String },
+    ToolCall(ToolCallDetails),
+    ToolSummary(ToolSummary),
+    SuggestedCommand(SuggestedCommandDetails),
+    OutOfBandOutput(OutOfBandOutputDetails),
+}
+
+#[derive(Debug)]
+pub(crate) struct ToolCallDetails {
+    tool_use_id: String,
+    name: String,
+    status: ToolResultStatus,
+}
+
+#[derive(Debug)]
+pub(crate) struct SuggestedCommandDetails {
+    pub(crate) command: String,
+    pub(crate) danger_level: DangerLevel,
+    pub(crate) confidence_level: ConfidenceLevel,
+    pub(crate) first_event_in_turn: bool,
+}
+
+#[derive(Debug)]
+pub(crate) struct OutOfBandOutputDetails {
+    pub(crate) command: Option<String>,
+    pub(crate) content: String,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) enum ToolResultStatus {
+    Pending,
+    Success,
+    Error,
+}
+
+#[derive(Debug)]
+pub(crate) enum UiTurn {
+    User { events: Vec<UiEvent> },
+    Agent { events: Vec<UiEvent> },
+    OutOfBand { events: Vec<UiEvent> },
+}
+
+pub(crate) struct TurnBuilder {
+    turns: Vec<UiTurn>,
+    current_turn: Option<UiTurn>,
+}
+
+impl TurnBuilder {
+    pub(crate) fn new() -> Self {
+        Self {
+            turns: Vec::new(),
+            current_turn: None,
+        }
+    }
+
+    pub(crate) fn add_event(&mut self, event: &ConversationEvent) {
+        match event {
+            ConversationEvent::UserMessage { content } => {
+                self.add_user_message(content);
+            }
+            ConversationEvent::Text { content } => {
+                self.add_agent_text(content);
+            }
+            ConversationEvent::ToolCall { id, name, input } => {
+                if name == "suggest_command" {
+                    self.add_suggested_command(input);
+                } else {
+                    self.add_tool_call(id, name, input);
+                }
+            }
+            ConversationEvent::ToolResult {
+                tool_use_id,
+                content,
+                is_error,
+            } => {
+                self.add_tool_result(tool_use_id, content, *is_error);
+            }
+            ConversationEvent::OutOfBandOutput {
+                name,
+                command,
+                content,
+            } => {
+                self.add_out_of_band_output(name, command.as_deref(), content);
+            }
+        }
+    }
+
+    pub(crate) fn build(&mut self) -> Vec<UiTurn> {
+        self.commit_turn();
+
+        // Collapse consecutive tool calls within each agent turn into ToolSummary
+        for turn in &mut self.turns {
+            if let UiTurn::Agent { events } = turn {
+                let mut new_events: Vec<UiEvent> = Vec::new();
+                let mut pending_tools: Vec<ToolCallDetails> = Vec::new();
+
+                for event in events.drain(..) {
+                    match event {
+                        UiEvent::ToolCall(details) => {
+                            pending_tools.push(details);
+                        }
+                        other => {
+                            if !pending_tools.is_empty() {
+                                new_events.push(UiEvent::ToolSummary(ToolSummary {
+                                    tool_calls: std::mem::take(&mut pending_tools),
+                                }));
+                            }
+                            new_events.push(other);
+                        }
+                    }
+                }
+
+                if !pending_tools.is_empty() {
+                    new_events.push(UiEvent::ToolSummary(ToolSummary {
+                        tool_calls: pending_tools,
+                    }));
+                }
+
+                *events = new_events;
+            }
+        }
+
+        std::mem::take(&mut self.turns)
+    }
+
+    fn commit_turn(&mut self) {
+        if let Some(turn) = self.current_turn.take() {
+            self.turns.push(turn);
+        }
+    }
+
+    fn start_user_turn(&mut self) {
+        if !matches!(self.current_turn, Some(UiTurn::User { .. })) {
+            self.commit_turn();
+            self.current_turn = Some(UiTurn::User { events: vec![] });
+        }
+    }
+
+    fn start_agent_turn(&mut self) {
+        if !matches!(self.current_turn, Some(UiTurn::Agent { .. })) {
+            self.commit_turn();
+            self.current_turn = Some(UiTurn::Agent { events: vec![] });
+        }
+    }
+
+    fn start_out_of_band_turn(&mut self) {
+        if !matches!(self.current_turn, Some(UiTurn::OutOfBand { .. })) {
+            self.commit_turn();
+            self.current_turn = Some(UiTurn::OutOfBand { events: vec![] });
+        }
+    }
+
+    fn turn_mut_unsafe(&mut self) -> &mut UiTurn {
+        self.current_turn.as_mut().unwrap()
+    }
+
+    fn add_user_message(&mut self, content: &str) {
+        self.start_user_turn();
+        if let UiTurn::User { events } = self.turn_mut_unsafe() {
+            events.push(UiEvent::Text {
+                content: content.to_string(),
+            });
+        }
+    }
+
+    fn add_agent_text(&mut self, content: &str) {
+        self.start_agent_turn();
+        if let UiTurn::Agent { events } = self.turn_mut_unsafe() {
+            events.push(UiEvent::Text {
+                content: content.to_string(),
+            });
+        }
+    }
+
+    fn add_suggested_command(&mut self, input: &serde_json::Value) {
+        let command = input
+            .get("command")
+            .and_then(|v| v.as_str())
+            .unwrap_or("")
+            .to_string();
+
+        if command.is_empty() {
+            return;
+        }
+
+        self.start_agent_turn();
+        if let UiTurn::Agent { events } = self.turn_mut_unsafe() {
+            let danger_level = input
+                .get("danger")
+                .and_then(|v| v.as_str())
+                .unwrap_or("")
+                .to_string();
+
+            let confidence_level = input
+                .get("confidence")
+                .and_then(|v| v.as_str())
+                .unwrap_or("")
+                .to_string();
+
+            let danger_notes = input
+                .get("danger_notes")
+                .and_then(|v| v.as_str())
+                .unwrap_or("")
+                .to_string();
+
+            let confidence_notes = input
+                .get("confidence_notes")
+                .and_then(|v| v.as_str())
+                .unwrap_or("")
+                .to_string();
+
+            let danger = DangerLevel::from((&danger_level, &danger_notes));
+            let confidence = ConfidenceLevel::from((&confidence_level, &confidence_notes));
+
+            let first_event_in_turn = events.is_empty();
+
+            events.push(UiEvent::SuggestedCommand(SuggestedCommandDetails {
+                command: input
+                    .get("command")
+                    .and_then(|v| v.as_str())
+                    .unwrap_or("")
+                    .to_string(),
+                danger_level: danger,
+                confidence_level: confidence,
+                first_event_in_turn,
+            }));
+        }
+    }
+
+    fn add_tool_call(&mut self, id: &str, name: &str, _input: &serde_json::Value) {
+        self.start_agent_turn();
+        if let UiTurn::Agent { events } = self.turn_mut_unsafe() {
+            events.push(UiEvent::ToolCall(ToolCallDetails {
+                tool_use_id: id.to_string(),
+                name: name.to_string(),
+                status: ToolResultStatus::Pending,
+            }));
+        }
+    }
+
+    fn add_tool_result(&mut self, tool_use_id: &str, _content: &str, is_error: bool) {
+        self.start_agent_turn();
+        if let UiTurn::Agent { events } = self.turn_mut_unsafe() {
+            let event = events.iter_mut().find(|e| match e {
+                UiEvent::ToolCall(ToolCallDetails {
+                    tool_use_id: id, ..
+                }) => id == tool_use_id,
+                _ => false,
+            });
+            if let Some(UiEvent::ToolCall(ToolCallDetails { status, .. })) = event {
+                *status = if is_error {
+                    ToolResultStatus::Error
+                } else {
+                    ToolResultStatus::Success
+                };
+            }
+        }
+    }
+
+    fn add_out_of_band_output(&mut self, _name: &str, command: Option<&str>, content: &str) {
+        self.start_out_of_band_turn();
+        if let UiTurn::OutOfBand { events } = self.turn_mut_unsafe() {
+            events.push(UiEvent::OutOfBandOutput(OutOfBandOutputDetails {
+                command: command.map(|c| c.to_string()),
+                content: content.to_string(),
+            }));
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct ToolSummary {
+    tool_calls: Vec<ToolCallDetails>,
+}
+
+impl ToolSummary {
+    /// Determines the summary line:
+    /// - If any call is pending, use present tense verb with `-ing`
+    /// - If multiple calls are complete, say "Used n tools"
+    /// - If a single call is complete, use past tense verb
+    pub(crate) fn summary(&self) -> String {
+        if self.any_pending() {
+            // Find the last pending tool for the active verb
+            if let Some(pending) = self
+                .tool_calls
+                .iter()
+                .rev()
+                .find(|t| t.status == ToolResultStatus::Pending)
+            {
+                return Self::progressive_verb(&pending.name);
+            }
+        }
+
+        if self.tool_calls.len() == 1 {
+            return Self::past_verb(&self.tool_calls[0].name);
+        }
+
+        format!("Used {} tools", self.tool_calls.len())
+    }
+
+    /// Determines if the spinner should be spinning
+    pub(crate) fn any_pending(&self) -> bool {
+        self.tool_calls
+            .iter()
+            .any(|tool_call| tool_call.status == ToolResultStatus::Pending)
+    }
+
+    /// Present-tense progressive verb for a tool name (e.g. "Searching...")
+    fn progressive_verb(name: &str) -> String {
+        match name {
+            "search" => "Searching...".into(),
+            "read" | "read_file" => "Reading file...".into(),
+            "write" | "write_file" => "Writing file...".into(),
+            "execute" | "run" | "bash" => "Running command...".into(),
+            "list" | "list_files" => "Listing files...".into(),
+            _ => format!("Running {}...", name.replace('_', " ")),
+        }
+    }
+
+    /// Past-tense verb for a tool name (e.g. "Searched")
+    fn past_verb(name: &str) -> String {
+        match name {
+            "search" => "Searched".into(),
+            "read" | "read_file" => "Read file".into(),
+            "write" | "write_file" => "Wrote file".into(),
+            "execute" | "run" | "bash" => "Ran command".into(),
+            "list" | "list_files" => "Listed files".into(),
+            _ => format!("Ran {}", name.replace('_', " ")),
+        }
+    }
+}