integrates viewend into main loop

Author: dingfeli

app.log.2025-10-24

@@ -1,5 +1,6 @@
 use std::sync::Arc;
 
+use chat_cli_ui::conduit::get_event_conduits;
 use chat_cli_ui::ui::config::Config;
 use chat_cli_ui::ui::{
     App,
@@ -61,9 +62,14 @@ fn main() -> Result<()> {
 
     let rt = tokio::runtime::Builder::new_multi_thread().enable_all().build()?;
 
+    let (view_end, input_receiver, control_end) = get_event_conduits();
+    _ = input_receiver;
+    _ = control_end;
+
     let mut app = App {
         config: Config::default(),
         should_quit: false,
+        view_end,
         components: {
             let mut components = Vec::<Box<dyn Component>>::new();
 

crates/chat-cli-ui/examples/inline_input.rs

@@ -622,6 +622,25 @@ pub fn get_legacy_conduits(
     )
 }
 
+pub fn get_event_conduits() -> (ViewEnd, InputReceiver, ControlEnd<DestinationStructuredOutput>) {
+    let (state_tx, state_rx) = tokio::sync::mpsc::unbounded_channel::<Event>();
+    let (input_tx, input_rx) = tokio::sync::mpsc::channel::<InputEvent>(10);
+
+    (
+        ViewEnd {
+            sender: input_tx,
+            receiver: state_rx,
+        },
+        input_rx,
+        ControlEnd {
+            current_event: None,
+            should_send_structured_event: true,
+            sender: state_tx.clone(),
+            pass_through_destination: PhantomData,
+        },
+    )
+}
+
 pub trait InterimEvent {
     type Error: std::error::Error;
     fn insert_content(&mut self, content: &[u8]) -> Result<(), Self::Error>;

crates/chat-cli-ui/src/conduit.rs

@@ -1,4 +1,39 @@
+use std::sync::Arc;
+
+use ui::config::Config;
+use ui::{
+    App,
+    ChatWindow,
+    Component,
+    InputBar,
+};
+
 pub mod conduit;
 pub mod legacy_ui_util;
 pub mod protocol;
 pub mod ui;
+
+pub fn get_app(view_end: conduit::ViewEnd) -> App {
+    App {
+        config: Config::default(),
+        should_quit: false,
+        view_end,
+        components: {
+            let mut components = Vec::<Box<dyn Component>>::new();
+
+            // Add ChatWindow to display message content
+            let chat_window = {
+                let (width, height) = crossterm::terminal::size().expect("Failed to retrieve terminal size");
+                let chat_window = ChatWindow::new(height, width);
+                Box::new(chat_window)
+            };
+            components.push(chat_window);
+
+            // Add InputBar for user input
+            let input_bar = Box::new(InputBar::default());
+            components.push(input_bar);
+
+            Arc::new(tokio::sync::Mutex::new(components))
+        },
+    }
+}

crates/chat-cli-ui/src/lib.rs

@@ -498,6 +498,7 @@ impl Event {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum InputEvent {
     Text(String),
     Interrupt,

crates/chat-cli-ui/src/protocol.rs

@@ -4,6 +4,8 @@ use serde::{
     Serialize,
 };
 
+use crate::protocol::InputEvent;
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Action {
     Tick,
@@ -13,4 +15,5 @@ pub enum Action {
     ClearScreen,
     Error(String),
     Help,
+    Input(InputEvent),
 }

crates/chat-cli-ui/src/ui/action.rs

@@ -7,6 +7,7 @@ use tokio::sync::mpsc::unbounded_channel;
 use tracing::error;
 
 use super::Component;
+use crate::conduit::ViewEnd;
 use crate::ui::action::Action;
 use crate::ui::config::{
     Config,
@@ -20,6 +21,7 @@ use crate::ui::tui::{
 pub struct App {
     pub config: Config,
     pub should_quit: bool,
+    pub view_end: ViewEnd,
     pub components: Arc<Mutex<Vec<Box<dyn Component>>>>,
 }
 
@@ -32,16 +34,37 @@ impl App {
         // TODO: make a defer routine that restores the terminal on exit
         tui.enter()?;
 
-        let mut event_receiver = tui.event_rx.take().expect("Missing event receiver");
+        let mut terminal_event_receiver = tui.event_rx.take().expect("Missing event receiver");
         let components_clone = self.components.clone();
 
         // Render Task
         tokio::spawn(async move {
             while render_rx.recv().await.is_some() {
                 let mut components = components_clone.lock().await;
                 tui.terminal.draw(|f| {
-                    for component in components.iter_mut() {
-                        if let Err(e) = component.draw(f, f.area()) {
+                    use ratatui::layout::{
+                        Constraint,
+                        Layout,
+                    };
+
+                    // Split the screen: chat window takes most space, input bar at bottom
+                    let chunks = Layout::vertical([
+                        Constraint::Min(1),    // Chat window takes remaining space
+                        Constraint::Length(3), // Input bar has fixed height of 3 lines
+                    ])
+                    .split(f.area());
+
+                    // Render each component in its designated area
+                    // First component (ChatWindow) gets the top area
+                    // Second component (InputBar) gets the bottom area
+                    for (i, component) in components.iter_mut().enumerate() {
+                        let rect = if i == 0 {
+                            chunks[0] // ChatWindow
+                        } else {
+                            chunks[1] // InputBar
+                        };
+
+                        if let Err(e) = component.draw(f, rect) {
                             error!("Error rendering component {:?}", e);
                         }
                     }
@@ -59,14 +82,12 @@ impl App {
         tokio::spawn(async move {
             let mut key_event_buf = Vec::<crossterm::event::KeyEvent>::new();
 
-            while let Some(event) = event_receiver.recv().await {
-                let Ok(action) = handle_events(&event, &mut key_event_buf, &config) else {
-                    error!("Error covnerting tui events to action");
+            while let Some(event) = terminal_event_receiver.recv().await {
+                let Ok(action) = handle_ui_events(&event, &mut key_event_buf, &config) else {
+                    error!("Error converting tui events to action");
                     continue;
                 };
 
-                tracing::info!("action: {:?}", action);
-
                 match action {
                     Some(action) => {
                         if let Err(e) = action_tx_clone.send(action) {
@@ -79,7 +100,7 @@ impl App {
                         let mut components = components_clone.lock().await;
 
                         for component in components.iter_mut() {
-                            match component.handle_events(event.clone()) {
+                            match component.handle_terminal_events(event.clone()) {
                                 Ok(action) => {
                                     if let Some(action) = action {
                                         if let Err(e) = action_tx_clone.send(action) {
@@ -97,42 +118,76 @@ impl App {
             }
         });
 
-        // Main loop
-        while let Some(action) = action_rx.recv().await {
-            match action {
-                Action::Render => {
-                    if let Err(e) = render_tx.send(()) {
-                        error!("Error sending rendering message to rendering thread: {:?}", e);
+        loop {
+            tokio::select! {
+                session_event = self.view_end.receiver.recv() => {
+                    let Some(session_event) = session_event else {
+                        break;
+                    };
+
+                    let mut components = self.components.lock().await;
+                    for component in components.iter_mut() {
+                        match component.handle_session_events(session_event.clone()) {
+                            Ok(subsequent_action) => {
+                                if let Some(subsequent_action) = subsequent_action {
+                                    if let Err(e) = action_tx.send(subsequent_action) {
+                                        error!("Error sending subsequent action: {:?}", e);
+                                    }
+                                }
+                            },
+                            Err(e) => error!("Error updating component: {:?}", e),
+                        }
                     }
                 },
-                Action::Tick => {},
-                Action::Resize(_, _) => {},
-                Action::Quit => {},
-                Action::ClearScreen => {},
-                Action::Error(_) => {},
-                Action::Help => {},
-            }
+                action = action_rx.recv() => {
+                    let Some(action) = action else {
+                        break;
+                    };
 
-            let mut components = self.components.lock().await;
-            for component in components.iter_mut() {
-                match component.update(action.clone()) {
-                    Ok(subsequent_action) => {
-                        if let Some(subsequent_action) = subsequent_action {
-                            if let Err(e) = action_tx.send(subsequent_action) {
-                                error!("Error sending subsequent action: {:?}", e);
+                    match &action {
+                        Action::Render => {
+                            if let Err(e) = render_tx.send(()) {
+                                error!("Error sending rendering message to rendering thread: {:?}", e);
+                            }
+                        },
+                        Action::Tick => {},
+                        Action::Resize(_, _) => {},
+                        Action::Quit => {},
+                        Action::ClearScreen => {},
+                        Action::Error(_) => {},
+                        Action::Help => {},
+                        Action::Input(input_event) => {
+                            if let Err(e) = self.view_end.sender.send(input_event.clone()).await {
+                                error!("Error sending input event to control end: {:?}", e);
                             }
                         }
-                    },
-                    Err(e) => error!("Error updating component: {:?}", e),
-                }
+                    }
+
+                    let mut components = self.components.lock().await;
+                    for component in components.iter_mut() {
+                        match component.update(action.clone()) {
+                            Ok(subsequent_action) => {
+                                if let Some(subsequent_action) = subsequent_action {
+                                    if let Err(e) = action_tx.send(subsequent_action) {
+                                        error!("Error sending subsequent action: {:?}", e);
+                                    }
+                                }
+                            },
+                            Err(e) => error!("Error updating component: {:?}", e),
+                        }
+                    }
+                },
+
             }
         }
+        // Main loop
 
         Ok(())
     }
 }
 
-fn handle_events(
+#[inline]
+fn handle_ui_events(
     event: &Event,
     key_event_buf: &mut Vec<crossterm::event::KeyEvent>,
     config: &Config,
@@ -175,7 +230,7 @@ fn handle_events(
                         },
                     }
                 },
-                _ | KeyEventKind::Repeat => Ok(None),
+                KeyEventKind::Repeat => Ok(None),
             }
         },
         _ => Err(eyre::eyre!("Event not yet supported")),