762 lines
34 KiB
Rust
762 lines
34 KiB
Rust
//! Top-level TUI render pipeline: layouts the terminal into chat / input
|
|
//! / status regions, dispatches overlay rendering, and floats toast
|
|
//! notifications over the top-right corner.
|
|
|
|
pub mod chat;
|
|
pub mod markdown;
|
|
pub mod status;
|
|
pub mod theme;
|
|
pub mod workflow;
|
|
|
|
use ratatui::layout::{Constraint, Direction, Layout, Rect};
|
|
use ratatui::style::{Style, Modifier};
|
|
use ratatui::text::{Line, Span};
|
|
use ratatui::widgets::{Block, Borders, Clear, Paragraph, Wrap};
|
|
use ratatui::Frame;
|
|
use theme::Theme;
|
|
|
|
/// Top-level render entry point called once per TUI frame.
|
|
///
|
|
/// Flow: split the frame into main / input / status regions → if an
|
|
/// overlay is active, render it inside the main region; otherwise render
|
|
/// the chat transcript → always render the input bar and status bar →
|
|
/// overlay toast notifications in the top-right corner.
|
|
///
|
|
/// Why: a single function owns the layout so every state change
|
|
/// re-renders the whole UI from a known template.
|
|
///
|
|
/// Return: nothing; writes directly into `frame`.
|
|
pub fn draw(frame: &mut Frame, state: &crate::app::state::rest::AppStateRest) {
|
|
let area = frame.area();
|
|
|
|
let show_todo = !state.misc.todo_content.is_empty() || state.misc.overlay == crate::app::state::types::Overlay::Todo;
|
|
let (main_area, todo_area) = if show_todo && area.width > 60 {
|
|
let h_chunks = Layout::default()
|
|
.direction(Direction::Horizontal)
|
|
.constraints([
|
|
Constraint::Min(40),
|
|
Constraint::Length(30),
|
|
])
|
|
.split(area);
|
|
(h_chunks[0], Some(h_chunks[1]))
|
|
} else {
|
|
(area, None)
|
|
};
|
|
|
|
let chunks = Layout::default()
|
|
.direction(Direction::Vertical)
|
|
.constraints([
|
|
Constraint::Min(3),
|
|
Constraint::Length(3),
|
|
Constraint::Length(1),
|
|
])
|
|
.split(main_area);
|
|
|
|
let chat_area = chunks[0];
|
|
let input_area = chunks[1];
|
|
let status_area = chunks[2];
|
|
|
|
if state.misc.overlay.is_active() && state.misc.overlay != crate::app::state::types::Overlay::Todo {
|
|
let overlay = state.misc.overlay;
|
|
render_overlay(frame, chat_area, overlay, state);
|
|
} else {
|
|
render_main_panel(frame, chat_area, state);
|
|
}
|
|
|
|
render_input_bar(frame, input_area, state);
|
|
status::draw_status_bar(frame, status_area, state);
|
|
|
|
if let Some(todo_rect) = todo_area {
|
|
render_todo_panel(frame, todo_rect, state);
|
|
}
|
|
|
|
// Toast notifications at top-right (like Hyprland)
|
|
render_toasts(frame, state);
|
|
}
|
|
|
|
fn render_todo_panel(frame: &mut Frame, area: Rect, state: &crate::app::state::rest::AppStateRest) {
|
|
let block = Block::default()
|
|
.title(" Todo ")
|
|
.borders(Borders::ALL)
|
|
.border_style(Style::default().fg(Theme::PRIMARY))
|
|
.style(Style::default().bg(Theme::BG));
|
|
|
|
let content = if state.misc.todo_content.is_empty() {
|
|
"No tasks yet."
|
|
} else {
|
|
&state.misc.todo_content
|
|
};
|
|
|
|
let paragraph = Paragraph::new(content)
|
|
.block(block)
|
|
.wrap(Wrap { trim: false });
|
|
|
|
frame.render_widget(paragraph, area);
|
|
}
|
|
|
|
fn render_main_panel(frame: &mut Frame, area: Rect, state: &crate::app::state::rest::AppStateRest) {
|
|
chat::draw_chat(frame, area, state);
|
|
}
|
|
|
|
/// Render the active modal overlay (Help, Settings, Workflow, Bash, Editor, etc.).
|
|
///
|
|
/// Flow: compute a centered sub-area → clear it to make the rest of the
|
|
/// frame visible behind → match on the Overlay variant to pick the
|
|
/// panel's title, content Lines, and styling → render as a Paragraph or
|
|
/// delegate to a specialized drawer (e.g. `workflow::draw_workflow_panel`).
|
|
///
|
|
/// Why: each Overlay variant has its own data sources (settings,
|
|
/// session_runtime, app_config) and its own visual treatment, so they
|
|
/// are dispatched individually rather than table-driven.
|
|
///
|
|
/// Return: nothing; draws directly into `frame`.
|
|
fn render_overlay(frame: &mut Frame, area: Rect, overlay: crate::app::state::types::Overlay, state: &crate::app::state::rest::AppStateRest) {
|
|
let overlay_area = centered_rect(area, 70, 60);
|
|
|
|
frame.render_widget(Clear, overlay_area);
|
|
|
|
let block = Block::default()
|
|
.borders(Borders::ALL)
|
|
.border_style(Style::default().fg(Theme::PRIMARY))
|
|
.style(Style::default().bg(Theme::BG));
|
|
|
|
match overlay {
|
|
crate::app::state::types::Overlay::None => {}
|
|
crate::app::state::types::Overlay::Help => {
|
|
let block = block.title(" Help ");
|
|
let content = crate::resources::HELP_TEXT;
|
|
let paragraph = Paragraph::new(content)
|
|
.block(block)
|
|
.wrap(Wrap { trim: false });
|
|
frame.render_widget(paragraph, overlay_area);
|
|
}
|
|
crate::app::state::types::Overlay::Settings => {
|
|
let block = block.title(" Settings ");
|
|
let lines = vec![
|
|
Line::from(Span::styled(
|
|
format!("Provider: {}", state.settings.provider),
|
|
Style::default().fg(Theme::TEXT),
|
|
)),
|
|
Line::from(Span::styled(
|
|
format!("Model: {}", state.settings.model),
|
|
Style::default().fg(Theme::TEXT),
|
|
)),
|
|
Line::from(Span::styled(
|
|
format!("Max tokens: {}", state.settings.max_tokens.map(|v| v.to_string()).unwrap_or_else(|| "auto".to_string())),
|
|
Style::default().fg(Theme::TEXT),
|
|
)),
|
|
Line::from(Span::styled(
|
|
format!("Temperature: {}", state.settings.temperature.map(|v| format!("{:.1}", v)).unwrap_or_else(|| "auto".to_string())),
|
|
Style::default().fg(Theme::TEXT),
|
|
)),
|
|
Line::from(Span::styled(
|
|
format!("Internet mode: {:?}", state.settings.internet_mode),
|
|
Style::default().fg(Theme::TEXT),
|
|
)),
|
|
Line::from(Span::styled(
|
|
format!("Review enabled: {}", state.settings.review_enabled),
|
|
Style::default().fg(Theme::TEXT),
|
|
)),
|
|
];
|
|
let paragraph = Paragraph::new(lines).block(block);
|
|
frame.render_widget(paragraph, overlay_area);
|
|
}
|
|
|
|
crate::app::state::types::Overlay::Bash => {
|
|
let block = block.title(" Bash ");
|
|
let lines: Vec<Line> = state.session_runtime.as_ref().map(|r| {
|
|
r.bash_jobs.iter().map(|job| {
|
|
Line::from(Span::styled(
|
|
format!("[{}] {} - {}", job.id, job.command, if job.running { "running" } else { "done" }),
|
|
Style::default().fg(Theme::TEXT),
|
|
))
|
|
}).collect()
|
|
}).unwrap_or_default();
|
|
let paragraph = if lines.is_empty() {
|
|
Paragraph::new(Line::from(Span::styled(
|
|
"No active bash jobs",
|
|
Style::default().fg(Theme::DIM),
|
|
))).block(block)
|
|
} else {
|
|
Paragraph::new(lines).block(block)
|
|
};
|
|
frame.render_widget(paragraph, overlay_area);
|
|
}
|
|
crate::app::state::types::Overlay::QuitConfirm => {
|
|
let block = block
|
|
.title(" Quit ")
|
|
.border_style(Style::default().fg(Theme::ERROR));
|
|
let lines = vec![
|
|
Line::from(Span::styled(
|
|
"Are you sure you want to quit?",
|
|
Style::default().fg(Theme::WARNING).add_modifier(Modifier::BOLD),
|
|
)),
|
|
Line::from(Span::styled(
|
|
"",
|
|
Style::default(),
|
|
)),
|
|
Line::from(Span::styled(
|
|
"Press Enter to confirm, Esc to cancel.",
|
|
Style::default().fg(Theme::DIM),
|
|
)),
|
|
];
|
|
let paragraph = Paragraph::new(lines).block(block);
|
|
frame.render_widget(paragraph, overlay_area);
|
|
}
|
|
crate::app::state::types::Overlay::Workflow => {
|
|
workflow::draw_workflow_panel(frame, overlay_area, state);
|
|
}
|
|
|
|
crate::app::state::types::Overlay::KeyInput => {
|
|
let block = block.title(" Input ");
|
|
let input_text = &state.input.buffer;
|
|
let display = if input_text.is_empty() {
|
|
"Type your input..."
|
|
} else {
|
|
input_text.as_str()
|
|
};
|
|
let paragraph = Paragraph::new(display)
|
|
.block(block);
|
|
frame.render_widget(paragraph, overlay_area);
|
|
}
|
|
crate::app::state::types::Overlay::Editor => {
|
|
let block = block.title(" Editor ");
|
|
let lines = vec![
|
|
Line::from(Span::styled(
|
|
"Editor Mode",
|
|
Style::default().fg(Theme::TEXT).add_modifier(Modifier::BOLD),
|
|
)),
|
|
Line::from(Span::styled(
|
|
"",
|
|
Style::default(),
|
|
)),
|
|
Line::from(Span::styled(
|
|
"Current input buffer:",
|
|
Style::default().fg(Theme::DIM),
|
|
)),
|
|
Line::from(Span::styled(
|
|
&state.input.buffer,
|
|
Style::default().fg(Theme::TEXT),
|
|
)),
|
|
Line::from(Span::styled(
|
|
"",
|
|
Style::default(),
|
|
)),
|
|
Line::from(Span::styled(
|
|
format!("Cursor at position {} / {}", state.input.cursor, state.input.buffer.len()),
|
|
Style::default().fg(Theme::DIM),
|
|
)),
|
|
];
|
|
let paragraph = Paragraph::new(lines).block(block);
|
|
frame.render_widget(paragraph, overlay_area);
|
|
}
|
|
crate::app::state::types::Overlay::Effort => {
|
|
let block = block.title(" Effort Level ");
|
|
let levels = crate::app::mode::effort::EFFORT_LEVELS;
|
|
let current_idx = crate::app::mode::effort::current_effort(state);
|
|
let mut lines: Vec<Line> = levels.iter().enumerate().map(|(i, l)| {
|
|
let selected = i == current_idx;
|
|
Line::from(Span::styled(
|
|
if selected { format!("> {} (current)", l) } else { format!(" {}", l) },
|
|
if selected {
|
|
Style::default().fg(Theme::HIGHLIGHT).add_modifier(Modifier::BOLD)
|
|
} else {
|
|
Style::default().fg(Theme::TEXT)
|
|
},
|
|
))
|
|
}).collect();
|
|
lines.insert(0, Line::from(Span::styled(
|
|
"Use arrow keys to change effort level",
|
|
Style::default().fg(Theme::DIM),
|
|
)));
|
|
let paragraph = Paragraph::new(lines).block(block);
|
|
frame.render_widget(paragraph, overlay_area);
|
|
}
|
|
crate::app::state::types::Overlay::Mcp => {
|
|
let block = block.title(" MCP Servers ");
|
|
let lines: Vec<Line> = vec![
|
|
Line::from(Span::styled(
|
|
"MCP Server Management",
|
|
Style::default().fg(Theme::TEXT).add_modifier(Modifier::BOLD),
|
|
)),
|
|
Line::from(Span::styled(
|
|
"",
|
|
Style::default(),
|
|
)),
|
|
Line::from(Span::styled(
|
|
format!("Session dir: {}", state.session_dir.display()),
|
|
Style::default().fg(Theme::DIM),
|
|
)),
|
|
Line::from(Span::styled(
|
|
"No MCP servers configured.",
|
|
Style::default().fg(Theme::INFO),
|
|
)),
|
|
Line::from(Span::styled(
|
|
"",
|
|
Style::default(),
|
|
)),
|
|
Line::from(Span::styled(
|
|
"Press Ctrl+P to configure provider settings.",
|
|
Style::default().fg(Theme::DIM),
|
|
)),
|
|
];
|
|
let paragraph = Paragraph::new(lines).block(block);
|
|
frame.render_widget(paragraph, overlay_area);
|
|
}
|
|
crate::app::state::types::Overlay::Todo => {
|
|
let block = block.title(" Tasks ");
|
|
let msg_count = state.transcript_cache.messages.len();
|
|
let lines = vec![
|
|
Line::from(Span::styled(
|
|
"Session Activity",
|
|
Style::default().fg(Theme::TEXT).add_modifier(Modifier::BOLD),
|
|
)),
|
|
Line::from(Span::styled(
|
|
"",
|
|
Style::default(),
|
|
)),
|
|
Line::from(Span::styled(
|
|
format!("Messages: {}", msg_count),
|
|
Style::default().fg(Theme::INFO),
|
|
)),
|
|
|
|
Line::from(Span::styled(
|
|
format!("Overlay: {:?}", state.misc.overlay),
|
|
Style::default().fg(Theme::DIM),
|
|
)),
|
|
];
|
|
let paragraph = Paragraph::new(lines).block(block);
|
|
frame.render_widget(paragraph, overlay_area);
|
|
}
|
|
crate::app::state::types::Overlay::Rewind => {
|
|
let block = block.title(" Rewind ");
|
|
let mut lines: Vec<Line> = vec![
|
|
Line::from(Span::styled(
|
|
"Session History",
|
|
Style::default().fg(Theme::TEXT).add_modifier(Modifier::BOLD),
|
|
)),
|
|
Line::from(Span::styled(
|
|
"",
|
|
Style::default(),
|
|
)),
|
|
];
|
|
let messages = &state.transcript_cache.messages;
|
|
if messages.is_empty() {
|
|
lines.push(Line::from(Span::styled(
|
|
"No messages in current session.",
|
|
Style::default().fg(Theme::DIM),
|
|
)));
|
|
} else {
|
|
let start = if messages.len() > 5 { messages.len() - 5 } else { 0 };
|
|
for msg in &messages[start..] {
|
|
let role_str = match msg.role {
|
|
crate::dto::chat::message::Role::User => "User",
|
|
crate::dto::chat::message::Role::Assistant => "Asst",
|
|
crate::dto::chat::message::Role::System => "Sys",
|
|
crate::dto::chat::message::Role::Tool => "Tool",
|
|
};
|
|
let preview: String = msg.content.chars().take(60).collect();
|
|
lines.push(Line::from(Span::styled(
|
|
format!("[{}] {}", role_str, preview),
|
|
Style::default().fg(if matches!(msg.role, crate::dto::chat::message::Role::User) { Theme::INFO } else { Theme::TEXT }),
|
|
)));
|
|
}
|
|
if messages.len() > 5 {
|
|
lines.push(Line::from(Span::styled(
|
|
format!("... and {} more messages", messages.len() - 5),
|
|
Style::default().fg(Theme::DIM),
|
|
)));
|
|
}
|
|
}
|
|
let paragraph = Paragraph::new(lines).block(block);
|
|
frame.render_widget(paragraph, overlay_area);
|
|
}
|
|
crate::app::state::types::Overlay::Learning => {
|
|
let h_chunks = Layout::default()
|
|
.direction(Direction::Horizontal)
|
|
.constraints([
|
|
Constraint::Percentage(40), // Left: List
|
|
Constraint::Percentage(60), // Right: Details
|
|
])
|
|
.split(overlay_area);
|
|
|
|
let left_block = Block::default()
|
|
.title(" Lessons ")
|
|
.borders(Borders::ALL)
|
|
.border_style(Style::default().fg(Theme::PRIMARY))
|
|
.style(Style::default().bg(Theme::BG));
|
|
|
|
let right_block = Block::default()
|
|
.title(" Lesson Details ")
|
|
.borders(Borders::ALL)
|
|
.border_style(Style::default().fg(Theme::PRIMARY))
|
|
.style(Style::default().bg(Theme::BG));
|
|
|
|
let items = crate::app::mode::learning::get_learning_items(state);
|
|
let mut left_lines = Vec::new();
|
|
if items.is_empty() {
|
|
left_lines.push(Line::from(Span::styled(
|
|
"No lessons found.",
|
|
Style::default().fg(Theme::DIM),
|
|
)));
|
|
} else {
|
|
for (i, item) in items.iter().enumerate() {
|
|
let is_selected = i == state.misc.selected_index;
|
|
let prefix = if is_selected { "▸ " } else { " " };
|
|
let (label, style) = match item {
|
|
crate::app::mode::learning::LearningItem::Pending { name, .. } => {
|
|
(
|
|
format!("{}[Pending] {}", prefix, name),
|
|
if is_selected {
|
|
Style::default().fg(Theme::WARNING).bg(Theme::HIGHLIGHT).add_modifier(Modifier::BOLD)
|
|
} else {
|
|
Style::default().fg(Theme::WARNING)
|
|
}
|
|
)
|
|
}
|
|
crate::app::mode::learning::LearningItem::Stored { name, lifecycle, .. } => {
|
|
let status = if lifecycle == "stale" { "Stale" } else { "Active" };
|
|
(
|
|
format!("{}[{}] {}", prefix, status, name),
|
|
if is_selected {
|
|
Style::default().fg(Theme::TEXT).bg(Theme::HIGHLIGHT).add_modifier(Modifier::BOLD)
|
|
} else {
|
|
Style::default().fg(Theme::TEXT)
|
|
}
|
|
)
|
|
}
|
|
};
|
|
left_lines.push(Line::from(Span::styled(label, style)));
|
|
}
|
|
}
|
|
|
|
// Scroll the left list so the selected index is always visible
|
|
let max_lines = h_chunks[0].height.saturating_sub(2) as usize;
|
|
let selected = state.misc.selected_index;
|
|
let start_idx = if selected >= max_lines {
|
|
selected - max_lines + 1
|
|
} else {
|
|
0
|
|
};
|
|
let end_idx = (start_idx + max_lines).min(left_lines.len());
|
|
let visible_lines = if left_lines.is_empty() {
|
|
Vec::new()
|
|
} else {
|
|
left_lines[start_idx..end_idx].to_vec()
|
|
};
|
|
|
|
let left_paragraph = Paragraph::new(visible_lines).block(left_block);
|
|
frame.render_widget(left_paragraph, h_chunks[0]);
|
|
|
|
let mut right_lines = Vec::new();
|
|
if let Some(item) = items.get(selected) {
|
|
match item {
|
|
crate::app::mode::learning::LearningItem::Pending { name, content, scope, confidence } => {
|
|
right_lines.push(Line::from(Span::styled("Name:", Style::default().fg(Theme::DIM))));
|
|
right_lines.push(Line::from(Span::styled(name, Style::default().fg(Theme::TEXT).add_modifier(Modifier::BOLD))));
|
|
right_lines.push(Line::from(""));
|
|
right_lines.push(Line::from(Span::styled("Status: Pending Approval", Style::default().fg(Theme::WARNING))));
|
|
right_lines.push(Line::from(Span::styled(format!("Scope: {}", scope), Style::default().fg(Theme::TEXT))));
|
|
right_lines.push(Line::from(Span::styled(format!("Confidence: {}", confidence), Style::default().fg(Theme::TEXT))));
|
|
right_lines.push(Line::from(""));
|
|
right_lines.push(Line::from(Span::styled("Content:", Style::default().fg(Theme::DIM))));
|
|
for line in content.lines() {
|
|
right_lines.push(Line::from(Span::styled(line, Style::default().fg(Theme::TEXT))));
|
|
}
|
|
right_lines.push(Line::from(""));
|
|
right_lines.push(Line::from(Span::styled("Keys:", Style::default().fg(Theme::DIM))));
|
|
right_lines.push(Line::from(Span::styled(" [Enter] or [a] to Accept", Style::default().fg(Theme::SUCCESS))));
|
|
right_lines.push(Line::from(Span::styled(" [Backspace]/[Delete]/[r] to Reject", Style::default().fg(Theme::ERROR))));
|
|
}
|
|
crate::app::mode::learning::LearningItem::Stored { name, content, lifecycle, scope, description } => {
|
|
right_lines.push(Line::from(Span::styled("Name:", Style::default().fg(Theme::DIM))));
|
|
right_lines.push(Line::from(Span::styled(name, Style::default().fg(Theme::TEXT).add_modifier(Modifier::BOLD))));
|
|
right_lines.push(Line::from(""));
|
|
let status_color = if lifecycle == "stale" { Theme::WARNING } else { Theme::SUCCESS };
|
|
right_lines.push(Line::from(Span::styled(format!("Status: {}", lifecycle), Style::default().fg(status_color))));
|
|
right_lines.push(Line::from(Span::styled(format!("Scope: {}", scope), Style::default().fg(Theme::TEXT))));
|
|
right_lines.push(Line::from(Span::styled(format!("Description: {}", description), Style::default().fg(Theme::TEXT))));
|
|
right_lines.push(Line::from(""));
|
|
right_lines.push(Line::from(Span::styled("Content:", Style::default().fg(Theme::DIM))));
|
|
for line in content.lines() {
|
|
right_lines.push(Line::from(Span::styled(line, Style::default().fg(Theme::TEXT))));
|
|
}
|
|
right_lines.push(Line::from(""));
|
|
right_lines.push(Line::from(Span::styled("Keys:", Style::default().fg(Theme::DIM))));
|
|
right_lines.push(Line::from(Span::styled(" [Backspace]/[Delete]/[d] to Delete Lesson", Style::default().fg(Theme::ERROR))));
|
|
}
|
|
}
|
|
} else {
|
|
right_lines.push(Line::from(Span::styled(
|
|
"Select a lesson on the left to see details.",
|
|
Style::default().fg(Theme::DIM),
|
|
)));
|
|
}
|
|
let right_paragraph = Paragraph::new(right_lines).block(right_block).wrap(Wrap { trim: false });
|
|
frame.render_widget(right_paragraph, h_chunks[1]);
|
|
}
|
|
crate::app::state::types::Overlay::Usage => {
|
|
let block = block.title(" Usage ");
|
|
let runtime = state.session_runtime.as_ref();
|
|
let (tokens_in, tokens_out, api_calls, review_tokens, session_start) = runtime.map(|r| {
|
|
(r.usage.tokens_in, r.usage.tokens_out, r.usage.api_calls, r.usage.review_tokens, r.session_start)
|
|
}).unwrap_or((0, 0, 0, 0, 0));
|
|
let (edit_count, lesson_count, review_count, consec_empty) = runtime.map(|r| {
|
|
(r.edit_count, r.lesson_count, r.review_count, r.consecutive_empty_reviews)
|
|
}).unwrap_or((0, 0, 0, 0));
|
|
let elapsed_ms = chrono::Utc::now().timestamp_millis().saturating_sub(session_start);
|
|
let hours = elapsed_ms / 3600000;
|
|
let minutes = (elapsed_ms % 3600000) / 60000;
|
|
let seconds = (elapsed_ms % 60000) / 1000;
|
|
let total_tokens = tokens_in.saturating_add(tokens_out);
|
|
let self_learning_total = review_tokens;
|
|
let main_tokens = total_tokens.saturating_sub(self_learning_total);
|
|
let lines = vec![
|
|
Line::from(Span::styled(
|
|
"Usage Dashboard",
|
|
Style::default().fg(Theme::PRIMARY).add_modifier(Modifier::BOLD),
|
|
)),
|
|
Line::from(Span::styled("", Style::default())),
|
|
Line::from(Span::styled("── Token Usage ──", Style::default().fg(Theme::DIM))),
|
|
Line::from(Span::styled(
|
|
format!(" Main agent tokens: {}", main_tokens),
|
|
Style::default().fg(Theme::TEXT),
|
|
)),
|
|
Line::from(Span::styled(
|
|
format!(" Self-learning tokens: {}", self_learning_total),
|
|
Style::default().fg(Theme::INFO),
|
|
)),
|
|
Line::from(Span::styled(
|
|
format!(" Total tokens: {}", total_tokens),
|
|
Style::default().fg(Theme::INFO).add_modifier(Modifier::BOLD),
|
|
)),
|
|
Line::from(Span::styled(
|
|
format!(" API calls: {}", api_calls),
|
|
Style::default().fg(Theme::TEXT),
|
|
)),
|
|
Line::from(Span::styled("", Style::default())),
|
|
Line::from(Span::styled("── Quality Trends ──", Style::default().fg(Theme::DIM))),
|
|
Line::from(Span::styled(
|
|
format!(" Edits this session: {}", edit_count),
|
|
Style::default().fg(Theme::TEXT),
|
|
)),
|
|
Line::from(Span::styled(
|
|
format!(" Reviews completed: {}", review_count),
|
|
Style::default().fg(Theme::TEXT),
|
|
)),
|
|
Line::from(Span::styled(
|
|
format!(" Lessons found: {}", lesson_count),
|
|
Style::default().fg(Theme::INFO),
|
|
)),
|
|
Line::from(Span::styled(
|
|
format!(" Consecutive empty revs: {}", consec_empty),
|
|
Style::default().fg(if consec_empty > 3 { Theme::WARNING } else { Theme::DIM }),
|
|
)),
|
|
Line::from(Span::styled("", Style::default())),
|
|
Line::from(Span::styled("── Session ──", Style::default().fg(Theme::DIM))),
|
|
Line::from(Span::styled(
|
|
format!(" Duration: {}h {}m {}s", hours, minutes, seconds),
|
|
Style::default().fg(Theme::DIM),
|
|
)),
|
|
];
|
|
let paragraph = Paragraph::new(lines).block(block);
|
|
frame.render_widget(paragraph, overlay_area);
|
|
}
|
|
crate::app::state::types::Overlay::Loading => {
|
|
let block = block.title(" Loading ");
|
|
let content = "Processing, please wait...";
|
|
let paragraph = Paragraph::new(content)
|
|
.block(block);
|
|
frame.render_widget(paragraph, overlay_area);
|
|
}
|
|
crate::app::state::types::Overlay::ModelSelector => {
|
|
let block = block.title(" Model Selector ");
|
|
let mut lines: Vec<Line> = vec![
|
|
Line::from(Span::styled(
|
|
format!("Current: {} / {}", state.settings.provider, state.settings.model),
|
|
Style::default().fg(Theme::INFO).add_modifier(Modifier::BOLD),
|
|
)),
|
|
Line::from(Span::styled("", Style::default())),
|
|
Line::from(Span::styled("Providers:", Style::default().fg(Theme::DIM))),
|
|
];
|
|
let providers: Vec<(&String, &crate::model::app_config::ProviderConfig)> = state.app_config.providers.iter().collect();
|
|
for (i, (name, cfg)) in providers.iter().enumerate() {
|
|
let is_current = *name == &state.settings.provider;
|
|
let is_selected = i == state.misc.selected_index;
|
|
let prefix = if is_selected { "▸ " } else { " " };
|
|
let model_str = cfg.default_model.as_deref().unwrap_or("(any)");
|
|
let label = format!("{}{} ({})", prefix, name, model_str);
|
|
let style = if is_current {
|
|
Style::default().fg(Theme::HIGHLIGHT).add_modifier(Modifier::BOLD)
|
|
} else if is_selected {
|
|
Style::default().fg(Theme::BG).bg(Theme::HIGHLIGHT)
|
|
} else {
|
|
Style::default().fg(Theme::TEXT)
|
|
};
|
|
lines.push(Line::from(Span::styled(label, style)));
|
|
}
|
|
lines.push(Line::from(Span::styled("", Style::default())));
|
|
lines.push(Line::from(Span::styled(
|
|
"↑↓ navigate · Enter select · Esc close · /model add <name> <url> to add",
|
|
Style::default().fg(Theme::DIM),
|
|
)));
|
|
let paragraph = Paragraph::new(lines).block(block);
|
|
frame.render_widget(paragraph, overlay_area);
|
|
}
|
|
crate::app::state::types::Overlay::ClearConfirm => {
|
|
let block = block.title(" Clear Transcript ");
|
|
let lines = vec![
|
|
Line::from(Span::styled(
|
|
"Clear all messages from the transcript?",
|
|
Style::default().fg(Theme::TEXT),
|
|
)),
|
|
Line::from(Span::styled("", Style::default())),
|
|
Line::from(Span::styled(
|
|
"Enter to confirm · Esc to cancel",
|
|
Style::default().fg(Theme::DIM),
|
|
)),
|
|
];
|
|
let paragraph = Paragraph::new(lines).block(block);
|
|
frame.render_widget(paragraph, overlay_area);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
/// Render the bottom input bar including the autocomplete dropdown above it.
|
|
///
|
|
/// Flow: if autocomplete is open and has candidates, draw a borderless
|
|
/// dropdown anchored just above the input bar showing up to 10 candidates
|
|
/// with the current selection highlighted → then render the prompt,
|
|
/// placeholder, and the buffer with a single-character highlight under
|
|
/// the cursor position.
|
|
///
|
|
/// Why: the cursor highlight is drawn by splitting the buffer at
|
|
/// `state.input.cursor` and styling one character (or trailing space)
|
|
/// with the highlight color, since ratatui Paragraph does not expose a
|
|
/// native cursor widget.
|
|
///
|
|
/// Return: nothing; draws directly into `frame` at `area`.
|
|
fn render_input_bar(frame: &mut Frame, area: Rect, state: &crate::app::state::rest::AppStateRest) {
|
|
// Render autocomplete dropdown if visible
|
|
if state.input.autocomplete_visible && !state.input.autocomplete_candidates.is_empty() {
|
|
let n = state.input.autocomplete_candidates.len().min(10) as u16;
|
|
let dropdown_height = n + 2; // border + items
|
|
let dropdown_area = Rect {
|
|
x: area.x,
|
|
y: area.y.saturating_sub(dropdown_height),
|
|
width: area.width.min(40),
|
|
height: dropdown_height,
|
|
};
|
|
let dropdown_block = Block::default()
|
|
.borders(Borders::ALL)
|
|
.border_style(Style::default().fg(Theme::BORDER))
|
|
.title(" Commands ");
|
|
|
|
let mut lines: Vec<Line> = Vec::new();
|
|
let selected = state.input.autocomplete_idx;
|
|
for (i, candidate) in state.input.autocomplete_candidates.iter().enumerate().take(10) {
|
|
let prefix = if i == selected { "▸ " } else { " " };
|
|
let style = if i == selected {
|
|
Style::default().fg(Theme::BG).bg(Theme::HIGHLIGHT)
|
|
} else {
|
|
Style::default().fg(Theme::TEXT)
|
|
};
|
|
let label = format!("{}{}", prefix, candidate);
|
|
lines.push(Line::from(Span::styled(label, style)));
|
|
}
|
|
let dropdown = Paragraph::new(lines).block(dropdown_block);
|
|
frame.render_widget(dropdown, dropdown_area);
|
|
}
|
|
|
|
let block = Block::default()
|
|
.borders(Borders::TOP)
|
|
.border_style(Style::default().fg(Theme::BORDER));
|
|
|
|
let input_text = &state.input.buffer;
|
|
let cursor_pos = state.input.cursor;
|
|
|
|
let prompt = Span::styled(
|
|
"> ",
|
|
Style::default().fg(Theme::PRIMARY).add_modifier(Modifier::BOLD),
|
|
);
|
|
|
|
let mut spans = vec![prompt];
|
|
|
|
if input_text.is_empty() {
|
|
spans.push(Span::styled(
|
|
"Type a message...",
|
|
Style::default().fg(Theme::DIM),
|
|
));
|
|
} else {
|
|
let (before, after) = input_text.split_at(cursor_pos);
|
|
spans.push(Span::raw(before.to_string()));
|
|
spans.push(Span::styled(
|
|
if after.is_empty() { " " } else { &after[..1] },
|
|
Style::default().bg(Theme::HIGHLIGHT).fg(Theme::BG),
|
|
));
|
|
if after.len() > 1 {
|
|
spans.push(Span::raw(after[1..].to_string()));
|
|
}
|
|
}
|
|
|
|
let line = Line::from(spans);
|
|
let paragraph = Paragraph::new(line).block(block);
|
|
frame.render_widget(paragraph, area);
|
|
}
|
|
|
|
/// Render active toasts as a floating stack at top-right of the terminal.
|
|
/// Each toast auto-expires after its lifetime_ms. Max 4 visible at once.
|
|
fn render_toasts(frame: &mut Frame, state: &crate::app::state::rest::AppStateRest) {
|
|
let now_ms = chrono::Utc::now().timestamp_millis();
|
|
let active: Vec<&crate::app::state::types::Toast> = state.misc.toasts.iter()
|
|
.filter(|t| !t.expired(now_ms))
|
|
.collect();
|
|
if active.is_empty() {
|
|
return;
|
|
}
|
|
let area = frame.area();
|
|
let toast_w: u16 = 45;
|
|
let x = area.width.saturating_sub(toast_w).saturating_sub(2);
|
|
let mut y: u16 = 1;
|
|
|
|
for toast in active.iter().rev().take(4) {
|
|
let line_count = toast.message.lines().count().max(1) as u16;
|
|
let h = line_count + 2; // border top + border bottom
|
|
let toast_area = Rect { x, y, width: toast_w, height: h };
|
|
if toast_area.bottom() > area.height {
|
|
break;
|
|
}
|
|
frame.render_widget(ratatui::widgets::Clear, toast_area);
|
|
|
|
let border_color = match toast.kind {
|
|
crate::app::state::types::ToastKind::Success => Theme::SUCCESS,
|
|
crate::app::state::types::ToastKind::Warning => Theme::WARNING,
|
|
crate::app::state::types::ToastKind::Error => Theme::ERROR,
|
|
crate::app::state::types::ToastKind::Info => Theme::INFO,
|
|
crate::app::state::types::ToastKind::Lesson => Theme::PRIMARY,
|
|
};
|
|
let block = ratatui::widgets::Block::default()
|
|
.borders(ratatui::widgets::Borders::ALL)
|
|
.border_style(ratatui::style::Style::default().fg(border_color))
|
|
.style(ratatui::style::Style::default().bg(ratatui::style::Color::Black));
|
|
let paragraph = ratatui::widgets::Paragraph::new(toast.message.as_str())
|
|
.block(block)
|
|
.wrap(ratatui::widgets::Wrap { trim: false });
|
|
frame.render_widget(paragraph, toast_area);
|
|
y = y.saturating_add(h).saturating_add(1);
|
|
}
|
|
}
|
|
|
|
fn centered_rect(area: Rect, percent_x: u16, percent_y: u16) -> Rect {
|
|
let x_pad = (area.width.saturating_sub(area.width * percent_x / 100)) / 2;
|
|
let y_pad = (area.height.saturating_sub(area.height * percent_y / 100)) / 2;
|
|
|
|
Rect {
|
|
x: area.x.saturating_add(x_pad),
|
|
y: area.y.saturating_add(y_pad),
|
|
width: area.width.saturating_sub(x_pad * 2).max(40),
|
|
height: area.height.saturating_sub(y_pad * 2).max(10),
|
|
}
|
|
}
|