a3s 0.8.1

a3s — A3S coding agent CLI; `a3s code` launches the interactive TUI
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
125
126
127
128

//! One immutable snapshot of the dynamic bottom-pane rows for a render pass.
//!
//! Plan, subagent, and queue rows used to be recomputed independently by the
//! viewport, cursor, and renderer. Keeping them in one projection makes row
//! ownership explicit and prevents a terminal event from leaving a one-frame
//! gap or stale footer row.

use super::super::*;

/// Spacer, transient activity, composer top rule, footer separator, and the
/// single Codex-style footer. The composer itself is accounted separately.
pub(crate) const FIXED_ROWS_EXCLUDING_INPUT: u16 = 5;
/// Footer separator plus the single footer row below the composer.
pub(crate) const FIXED_ROWS_BELOW_INPUT: u16 = 2;

#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub(crate) struct BottomPaneProjection {
    pub(crate) plan: Vec<String>,
    pub(crate) subagents: Vec<String>,
    pub(crate) tasks: Vec<String>,
}

impl BottomPaneProjection {
    pub(crate) fn dynamic_rows(&self) -> usize {
        self.plan
            .len()
            .saturating_add(self.subagents.len())
            .saturating_add(self.tasks.len())
    }

    pub(crate) fn rows_below_input(&self) -> usize {
        self.subagents.len().saturating_add(self.tasks.len())
    }

    pub(crate) fn input_cursor_row(
        &self,
        terminal_height: u16,
        input_height: u16,
        input_cursor_row: u16,
    ) -> u16 {
        let dynamic_below = self.rows_below_input().min(u16::MAX as usize) as u16;
        let below = FIXED_ROWS_BELOW_INPUT.saturating_add(dynamic_below);
        terminal_height
            .saturating_sub(below.saturating_add(input_height))
            .saturating_add(input_cursor_row)
    }
}

impl App {
    pub(crate) fn bottom_pane_projection(&self) -> BottomPaneProjection {
        BottomPaneProjection {
            plan: self.plan_lines(),
            subagents: self.subagent_lines(),
            tasks: self.task_lines(),
        }
    }

    /// Rows between an overlay's bottom edge and the terminal bottom.
    ///
    /// The overlay replaces the transcript-to-activity spacer, so the activity
    /// row, other fixed chrome, auto-growing composer, and every dynamic
    /// bottom-pane row remain below it.
    pub(crate) fn overlay_rows_below(&self) -> usize {
        overlay_rows_below_for(
            self.input_height(),
            self.bottom_pane_projection().dynamic_rows(),
        )
    }
}

fn overlay_rows_below_for(input_height: u16, dynamic_rows: usize) -> usize {
    usize::from(FIXED_ROWS_EXCLUDING_INPUT.saturating_sub(1))
        .saturating_add(usize::from(input_height))
        .saturating_add(dynamic_rows)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn projection_counts_each_owned_surface_once() {
        let projection = BottomPaneProjection {
            plan: vec!["plan".into(), "plan 2".into()],
            subagents: vec!["agents".into()],
            tasks: vec!["queue".into(), "queue 2".into()],
        };

        assert_eq!(projection.dynamic_rows(), 5);
        assert_eq!(projection.rows_below_input(), 3);
    }

    #[test]
    fn terminal_projection_has_no_phantom_dynamic_rows() {
        let projection = BottomPaneProjection::default();

        assert_eq!(projection.dynamic_rows(), 0);
        assert_eq!(projection.rows_below_input(), 0);
    }

    #[test]
    fn terminal_transition_restores_the_baseline_cursor_row() {
        let baseline = BottomPaneProjection::default();
        let active = BottomPaneProjection {
            subagents: vec!["agent 1".into(), "agent 2".into()],
            tasks: vec!["queued".into()],
            ..BottomPaneProjection::default()
        };

        assert_eq!(baseline.input_cursor_row(30, 1, 0), 27);
        assert_eq!(active.input_cursor_row(30, 1, 0), 24);
        assert_eq!(
            BottomPaneProjection::default().input_cursor_row(30, 1, 0),
            27
        );
    }

    #[test]
    fn overlay_rows_preserve_the_default_composer_position() {
        assert_eq!(overlay_rows_below_for(1, 0), 5);
    }

    #[test]
    fn overlay_rows_follow_multiline_input_and_dynamic_bottom_surfaces() {
        assert_eq!(overlay_rows_below_for(3, 0), 7);
        assert_eq!(overlay_rows_below_for(3, 4), 11);
    }
}