deepseek-tui 0.3.32

Terminal UI for DeepSeek
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! Cached transcript rendering for the TUI.

use ratatui::text::Line;

use crate::tui::app::TranscriptSpacing;
use crate::tui::history::{HistoryCell, TranscriptRenderOptions};
use crate::tui::scrolling::TranscriptLineMeta;

/// Cache of rendered transcript lines for the current viewport.
#[derive(Debug)]
pub struct TranscriptViewCache {
    width: u16,
    version: u64,
    options: TranscriptRenderOptions,
    lines: Vec<Line<'static>>,
    line_meta: Vec<TranscriptLineMeta>,
}

impl TranscriptViewCache {
    /// Create an empty cache.
    #[must_use]
    pub fn new() -> Self {
        Self {
            width: 0,
            version: 0,
            options: TranscriptRenderOptions::default(),
            lines: Vec::new(),
            line_meta: Vec::new(),
        }
    }

    /// Ensure cached lines match the provided cells/width/version.
    pub fn ensure(
        &mut self,
        cells: &[HistoryCell],
        width: u16,
        version: u64,
        options: TranscriptRenderOptions,
    ) {
        if self.width == width && self.version == version && self.options == options {
            return;
        }
        self.width = width;
        self.version = version;
        self.options = options;

        let mut lines = Vec::new();
        let mut meta = Vec::new();

        for (cell_index, cell) in cells.iter().enumerate() {
            let cell_lines = cell.lines_with_options(width, options);
            if cell_lines.is_empty() {
                continue;
            }
            for (line_in_cell, line) in cell_lines.into_iter().enumerate() {
                lines.push(line);
                meta.push(TranscriptLineMeta::CellLine {
                    cell_index,
                    line_in_cell,
                });
            }

            if let Some(next_cell) = cells.get(cell_index + 1) {
                let spacer_rows = spacer_rows_between(cell, next_cell, options.spacing);
                for _ in 0..spacer_rows {
                    lines.push(Line::from(""));
                    meta.push(TranscriptLineMeta::Spacer);
                }
            }
        }

        self.lines = lines;
        self.line_meta = meta;
    }

    /// Return cached lines.
    #[must_use]
    pub fn lines(&self) -> &[Line<'static>] {
        &self.lines
    }

    /// Return cached line metadata.
    #[must_use]
    pub fn line_meta(&self) -> &[TranscriptLineMeta] {
        &self.line_meta
    }

    /// Return total cached lines.
    #[must_use]
    pub fn total_lines(&self) -> usize {
        self.lines.len()
    }
}

fn spacer_rows_between(
    current: &HistoryCell,
    next: &HistoryCell,
    spacing: TranscriptSpacing,
) -> usize {
    if current.is_stream_continuation() {
        return 0;
    }

    let conversational_gap = match spacing {
        TranscriptSpacing::Compact => 0,
        TranscriptSpacing::Comfortable => 1,
        TranscriptSpacing::Spacious => 2,
    };
    let secondary_gap = match spacing {
        TranscriptSpacing::Compact => 0,
        TranscriptSpacing::Comfortable => 1,
        TranscriptSpacing::Spacious => 1,
    };

    if current.is_conversational() && next.is_conversational() {
        conversational_gap
    } else if matches!(current, HistoryCell::System { .. } | HistoryCell::Tool(_))
        || matches!(next, HistoryCell::System { .. } | HistoryCell::Tool(_))
    {
        secondary_gap
    } else {
        0
    }
}