Embedding in a CLI

use ftui_core::event::Event;
use ftui_core::geometry::Rect;
use ftui_render::frame::Frame;
use ftui_runtime::{App, Cmd, Model, ScreenMode};
use ftui_widgets::block::Block;
use ftui_widgets::paragraph::Paragraph;
 
pub struct BuildUi {
    pub tasks_done: u32,
    pub tasks_total: u32,
    pub current_target: String,
}
 
#[derive(Debug, Clone)]
pub enum UiMsg {
    Progress { done: u32, total: u32, target: String },
    Quit,
}
 
impl From<Event> for UiMsg {
    fn from(e: Event) -> Self {
        match e {
            Event::Key(k) if k.is_char('q') => UiMsg::Quit,
            // Progress events arrive via Cmd::perform, not keyboard.
            _ => UiMsg::Progress { done: 0, total: 0, target: String::new() },
        }
    }
}
 
impl Model for BuildUi {
    type Message = UiMsg;
 
    fn update(&mut self, msg: UiMsg) -> Cmd<UiMsg> {
        match msg {
            UiMsg::Progress { done, total, target } => {
                self.tasks_done = done;
                self.tasks_total = total;
                self.current_target = target;
                Cmd::none()
            }
            UiMsg::Quit => Cmd::quit(),
        }
    }
 
    fn view(&self, frame: &mut Frame) {
        let height = frame.height();
        let width = frame.width();
        let outer = Rect::new(0, 0, width, height);
 
        let block = Block::default().title(" build ").bordered();
        block.render(outer, frame);
 
        let pct = if self.tasks_total == 0 {
            0
        } else {
            (self.tasks_done * 100) / self.tasks_total
        };
        let summary = format!(
            " {}/{} ({}%) — {}  (q to cancel)",
            self.tasks_done, self.tasks_total, pct, self.current_target,
        );
        let inner = Rect::new(1, 1, width.saturating_sub(2), 1);
        Paragraph::new(summary).render(inner, frame);
    }
}
 
pub fn run(initial: BuildUi) -> std::io::Result<()> {
    App::new(initial)
        .screen_mode(ScreenMode::Inline { ui_height: 4 })
        .run()
}

use tracing_subscriber::EnvFilter;
 
fn main() -> std::io::Result<()> {
    tracing_subscriber::fmt()
        .with_writer(std::io::stderr)
        .with_env_filter(EnvFilter::from_default_env())
        .init();
 
    tracing::info!("starting build");
    // ... your existing logic, emitting tracing events ...
    ui::run(ui::BuildUi {
        tasks_done: 0,
        tasks_total: 42,
        current_target: String::new(),
    })
}