mermaid-cli 0.7.1

Open-source AI pair programmer with agentic capabilities. Local-first with Ollama, native tool calling, and beautiful TUI.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

//! Stateless TUI widgets.
//!
//! Each widget takes explicit props; the compose function in
//! `render::mod` pulls those props from `State` per frame. No widget
//! holds a reference to any god-object.

mod attachment;
mod chat;
mod conversation_list;
mod input;
mod slash_palette;
mod status;
mod status_banner;
mod status_line;

pub use attachment::AttachmentWidget;
pub use chat::{ChatState, ChatWidget, ImageClickTarget};
pub use conversation_list::ConversationListWidget;
pub use input::{InputState, InputWidget};
pub use slash_palette::SlashPaletteWidget;
pub use status::StatusWidget;
pub use status_banner::StatusBannerWidget;
pub use status_line::StatusLineWidget;

/// Local-to-render-layer generation phase enum. The compose function
/// converts from `domain::TurnState` + `domain::GenPhase` into one of
/// these four states; widgets render off this local view so they
/// don't need to pattern-match the full domain enum.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum GenerationStatus {
    Idle,
    Sending,
    Thinking,
    Streaming,
}

impl GenerationStatus {
    pub fn display_text(&self) -> &str {
        match self {
            GenerationStatus::Idle => "Idle",
            GenerationStatus::Sending => "Sending",
            GenerationStatus::Thinking => "Thinking",
            GenerationStatus::Streaming => "Streaming",
        }
    }

    /// Convert from the reducer's typed turn state. `TurnState::Idle`
    /// maps to `Idle`; `Generating.phase` maps 1:1; every other
    /// active variant maps to `Streaming` (the status-line widget
    /// doesn't distinguish beyond the basic upstream/downstream
    /// arrow).
    pub fn from_turn(turn: &crate::domain::TurnState) -> Self {
        use crate::domain::{GenPhase, TurnState};
        match turn {
            TurnState::Idle => GenerationStatus::Idle,
            TurnState::Generating { phase, .. } => match phase {
                GenPhase::Sending => GenerationStatus::Sending,
                GenPhase::Thinking => GenerationStatus::Thinking,
                GenPhase::Streaming => GenerationStatus::Streaming,
            },
            TurnState::ExecutingTools { .. }
            | TurnState::Compacting { .. }
            | TurnState::Cancelling { .. } => GenerationStatus::Streaming,
        }
    }
}