wires up app run logic

Author: dingfeli

crates/chat-cli-ui/Cargo.toml

@@ -10,6 +10,10 @@ license.workspace = true
 [lints]
 workspace = true
 
+[[example]]
+name = "inline_input"
+path = "examples/inline_input.rs"
+
 [dependencies]
 tracing.workspace = true
 tracing-appender.workspace = true

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

@@ -0,0 +1,82 @@
+use std::sync::Arc;
+
+use chat_cli_ui::ui::config::Config;
+use chat_cli_ui::ui::{
+    App,
+    Component,
+    InputBar,
+};
+use eyre::Result;
+use tracing_appender::non_blocking::WorkerGuard;
+use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::util::SubscriberInitExt;
+use tracing_subscriber::{
+    EnvFilter,
+    fmt,
+};
+
+fn setup_logging() -> Result<WorkerGuard> {
+    // Read log file path from environment variable
+    // Default to "app.log" if not set
+    let log_file_path = std::env::var("LOG_FILE").unwrap_or_else(|_| "app.log".to_string());
+
+    // Parse the path to get directory and filename
+    let path = std::path::Path::new(&log_file_path);
+    let directory = path.parent().unwrap_or_else(|| std::path::Path::new("."));
+    let filename = path.file_name().and_then(|n| n.to_str()).unwrap_or("app.log");
+
+    // Create a file appender with daily rotation
+    let file_appender = tracing_appender::rolling::daily(directory, filename);
+
+    // Create a non-blocking writer
+    let (non_blocking, _guard) = tracing_appender::non_blocking(file_appender);
+
+    // Set up the tracing subscriber with file output
+    tracing_subscriber::registry()
+        .with(EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")))
+        .with(
+            fmt::layer()
+                .with_writer(non_blocking)
+                .with_ansi(false)
+                .with_target(true)
+                .with_thread_ids(true)
+                .with_file(true)
+                .with_line_number(true),
+        )
+        .init();
+
+    tracing::info!("Logging initialized. Log file: {}", log_file_path);
+
+    // Keep the guard alive by leaking it
+    // This ensures the non-blocking writer continues to work
+
+    Ok(_guard)
+}
+
+fn main() -> Result<()> {
+    // Initialize logging before anything else
+    let _guard = setup_logging()?;
+
+    tracing::info!("Starting inline_input example");
+
+    let rt = tokio::runtime::Builder::new_multi_thread().enable_all().build()?;
+
+    let mut app = App {
+        config: Config::default(),
+        should_quit: false,
+        components: {
+            let mut components = Vec::<Box<dyn Component>>::new();
+
+            let input_bar = Box::new(InputBar::default());
+            components.push(input_bar);
+
+            Arc::new(tokio::sync::Mutex::new(components))
+        },
+    };
+
+    tracing::info!("App initialized, starting run loop");
+    let _ = rt.block_on(app.run());
+    tracing::info!("App finished");
+
+    Ok(())
+}

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

@@ -1,5 +1,4 @@
 pub mod conduit;
-pub mod input_bar;
 pub mod legacy_ui_util;
 pub mod protocol;
 pub mod ui;

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

@@ -1,7 +1,16 @@
 #![allow(dead_code)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+use serde::{
+    Deserialize,
+    Serialize,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Action {
-    Quit,
     Tick,
-    Noop,
+    Render,
+    Resize(u16, u16),
+    Quit,
+    ClearScreen,
+    Error(String),
+    Help,
 }

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

@@ -1,46 +1,183 @@
+use std::sync::Arc;
+
+use crossterm::event::KeyEventKind;
 use eyre::Result;
+use tokio::sync::Mutex;
 use tokio::sync::mpsc::unbounded_channel;
 use tracing::error;
 
+use super::Component;
 use crate::ui::action::Action;
-use crate::ui::tui::Tui;
+use crate::ui::config::{
+    Config,
+    Mode,
+};
+use crate::ui::tui::{
+    Event,
+    Tui,
+};
 
 pub struct App {
+    pub config: Config,
     pub should_quit: bool,
+    pub components: Arc<Mutex<Vec<Box<dyn Component>>>>,
 }
 
 impl App {
     pub async fn run(&mut self) -> Result<()> {
-        let (_render_tx, mut render_rx) = unbounded_channel::<()>();
-        let (action_tx, mut _action_rx) = unbounded_channel::<Action>();
+        let (render_tx, mut render_rx) = unbounded_channel::<()>();
+        let (action_tx, mut action_rx) = unbounded_channel::<Action>();
 
         let mut tui = Tui::new(4.0, 60.0)?;
         // 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 components_clone = self.components.clone();
 
         // Render Task
         tokio::spawn(async move {
             while render_rx.recv().await.is_some() {
-                // TODO: render here
-                tui.terminal.draw(|_f| {})?;
+                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()) {
+                            error!("Error rendering component {:?}", e);
+                        }
+                    }
+                })?;
             }
 
             Ok::<(), Box<dyn std::error::Error + Send + Sync + 'static>>(())
         });
 
         // Event monitoring task
+        let config = self.config.clone();
+        let action_tx_clone = action_tx.clone();
+        let components_clone = self.components.clone();
+
         tokio::spawn(async move {
-            while let Some(_event) = event_receiver.recv().await {
-                // TODO: derive action from the main component
-                let action = Action::Tick;
-                if let Err(e) = action_tx.send(action) {
-                    error!("Error sending action: {:?}", e);
+            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");
+                    continue;
+                };
+
+                tracing::info!("action: {:?}", action);
+
+                match action {
+                    Some(action) => {
+                        if let Err(e) = action_tx_clone.send(action) {
+                            error!("Error sending action: {:?}", e);
+                        }
+                    },
+                    None => {
+                        // The received input did not correspond to any actions, we'll let each
+                        // component handle the event
+                        let mut components = components_clone.lock().await;
+
+                        for component in components.iter_mut() {
+                            match component.handle_events(event.clone()) {
+                                Ok(action) => {
+                                    if let Some(action) = action {
+                                        if let Err(e) = action_tx_clone.send(action) {
+                                            error!("Error sending action from component handle event: {:?}", e);
+                                        }
+                                    }
+                                },
+                                Err(e) => {
+                                    error!("Error handling event by component: {:?}", e);
+                                },
+                            }
+                        }
+                    },
                 }
             }
         });
 
+        // 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);
+                    }
+                },
+                Action::Tick => {},
+                Action::Resize(_, _) => {},
+                Action::Quit => {},
+                Action::ClearScreen => {},
+                Action::Error(_) => {},
+                Action::Help => {},
+            }
+
+            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),
+                }
+            }
+        }
+
         Ok(())
     }
 }
+
+fn handle_events(
+    event: &Event,
+    key_event_buf: &mut Vec<crossterm::event::KeyEvent>,
+    config: &Config,
+) -> Result<Option<Action>> {
+    match event {
+        Event::Quit => Ok(Some(Action::Quit)),
+        Event::Tick => Ok(Some(Action::Tick)),
+        Event::Render => Ok(Some(Action::Render)),
+        Event::Resize(x, y) => Ok(Some(Action::Resize(*x, *y))),
+        Event::Key(key) => {
+            match key.kind {
+                KeyEventKind::Release => {
+                    let mut idx = None::<usize>;
+                    for (i, event) in key_event_buf.iter().enumerate() {
+                        if event.code == key.code {
+                            idx.replace(i);
+                        }
+                    }
+
+                    if let Some(idx) = idx {
+                        key_event_buf.remove(idx);
+                    }
+
+                    Ok(Some(Action::Tick))
+                },
+                KeyEventKind::Press => {
+                    let Some(keybindings) = &config.keybindings.0.get(&Mode::default()) else {
+                        return Ok(None);
+                    };
+
+                    match keybindings.get(&vec![*key]) {
+                        Some(action) => Ok(Some(action.clone())),
+                        _ => {
+                            // If the key was not handled as a single key action,
+                            // then consider it for multi-key combinations.
+                            key_event_buf.push(*key);
+
+                            // Check for multi-key combinations
+                            Ok(keybindings.get(key_event_buf).cloned())
+                        },
+                    }
+                },
+                _ | KeyEventKind::Repeat => Ok(None),
+            }
+        },
+        _ => Err(eyre::eyre!("Event not yet supported")),
+    }
+}