codewhale-tui 0.9.0

Terminal UI for open-source and open-weight coding models
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

//! Transactional preview / commit / rollback / cancel callbacks.
//!
//! Theme, model, and provider pickers share the same lifecycle:
//! navigate → preview, Enter → commit, Esc → rollback (+ close), and an
//! explicit cancel hook for hosts that need a distinct abort path.

use std::borrow::Cow;

/// Host-facing transactional callbacks for a settings picker.
///
/// The framework invokes these with the selected option id (or nothing, for
/// rollback/cancel). Concrete modals typically translate these into
/// `ViewAction` / `ViewEvent` values rather than mutating `App` directly.
#[allow(dead_code)] // transactional layer for model/provider migration (TUI-DOG-009)
pub struct TransactionCallbacks<FPreview, FCommit, FRollback, FCancel>
where
    FPreview: FnMut(&str),
    FCommit: FnMut(&str),
    FRollback: FnMut(),
    FCancel: FnMut(),
{
    pub preview: FPreview,
    pub commit: FCommit,
    pub rollback: FRollback,
    pub cancel: FCancel,
}

impl<FPreview, FCommit, FRollback, FCancel>
    TransactionCallbacks<FPreview, FCommit, FRollback, FCancel>
where
    FPreview: FnMut(&str),
    FCommit: FnMut(&str),
    FRollback: FnMut(),
    FCancel: FnMut(),
{
    #[allow(dead_code)] // callback runners for host adapters (TUI-DOG-009)
    pub fn run_preview(&mut self, id: &str) {
        (self.preview)(id);
    }

    #[allow(dead_code)]
    pub fn run_commit(&mut self, id: &str) {
        (self.commit)(id);
    }

    #[allow(dead_code)]
    pub fn run_rollback(&mut self) {
        (self.rollback)();
    }

    #[allow(dead_code)]
    pub fn run_cancel(&mut self) {
        (self.cancel)();
    }
}

/// Recorded transactional events for tests and host adapters.
#[derive(Debug, Clone, PartialEq, Eq)]
#[allow(dead_code)] // event log for matrix tests + pull-style hosts (TUI-DOG-009)
pub enum TransactionEvent {
    Preview {
        id: Cow<'static, str>,
    },
    Commit {
        id: Cow<'static, str>,
    },
    Rollback,
    Cancel,
    ItemAction {
        option_id: Cow<'static, str>,
        action_id: Cow<'static, str>,
    },
}

/// Simple recorder used by matrix tests and by hosts that prefer pull-style
/// integration over closures.
#[derive(Debug, Default, Clone)]
#[allow(dead_code)] // pull-style transaction log (TUI-DOG-009)
pub struct TransactionLog {
    pub events: Vec<TransactionEvent>,
}

impl TransactionLog {
    #[allow(dead_code)]
    pub fn preview(&mut self, id: impl Into<Cow<'static, str>>) {
        self.events
            .push(TransactionEvent::Preview { id: id.into() });
    }

    #[allow(dead_code)]
    pub fn commit(&mut self, id: impl Into<Cow<'static, str>>) {
        self.events.push(TransactionEvent::Commit { id: id.into() });
    }

    #[allow(dead_code)]
    pub fn rollback(&mut self) {
        self.events.push(TransactionEvent::Rollback);
    }

    #[allow(dead_code)]
    pub fn cancel(&mut self) {
        self.events.push(TransactionEvent::Cancel);
    }

    #[allow(dead_code)]
    pub fn item_action(
        &mut self,
        option_id: impl Into<Cow<'static, str>>,
        action_id: impl Into<Cow<'static, str>>,
    ) {
        self.events.push(TransactionEvent::ItemAction {
            option_id: option_id.into(),
            action_id: action_id.into(),
        });
    }

    #[must_use]
    #[allow(dead_code)]
    pub fn last(&self) -> Option<&TransactionEvent> {
        self.events.last()
    }
}