1pub use super::types::{SettingsChange, SettingsMenuEntry, SettingsMenuEntryKind, SettingsMenuValue};
2use acp_utils::config_meta::{ConfigOptionMeta, SelectOptionMeta};
3use acp_utils::config_option_id::{ConfigOptionId, THEME_CONFIG_ID};
4use agent_client_protocol::{SessionConfigKind, SessionConfigOption, SessionConfigSelectOptions};
5use tui::{Component, Event, Frame, Line, SelectItem, SelectList, SelectListMessage, ViewContext};
6
7pub struct SettingsMenu {
8 list: SelectList<SettingsMenuEntry>,
9}
10
11pub enum SettingMenuMessage {
12 CloseAll,
13 OpenSelectedPicker,
14 OpenMcpServers,
15 OpenProviderLogins,
16 OpenModelSelector,
17}
18
19impl SelectItem for SettingsMenuEntry {
20 fn render_item(&self, selected: bool, ctx: &ViewContext) -> Line {
21 let current_name = self
22 .display_name
23 .as_deref()
24 .or_else(|| self.values.get(self.current_value_index).map(|v| v.name.as_str()))
25 .unwrap_or("?");
26 let current_disabled =
27 self.display_name.is_none() && self.values.get(self.current_value_index).is_some_and(|v| v.is_disabled);
28 let text = format!("{}: {}", self.title, current_name);
29 if current_disabled {
30 Line::styled(text, ctx.theme.muted())
31 } else if selected {
32 Line::with_style(text, ctx.theme.selected_row_style())
33 } else {
34 Line::new(text)
35 }
36 }
37}
38
39impl Component for SettingsMenu {
40 type Message = SettingMenuMessage;
41
42 async fn on_event(&mut self, event: &Event) -> Option<Vec<Self::Message>> {
43 let outcome = self.list.on_event(event).await;
44 match outcome.as_deref() {
45 Some([SelectListMessage::Close]) => Some(vec![SettingMenuMessage::CloseAll]),
46 Some([SelectListMessage::Select(_)]) => {
47 let msg = match self.list.selected_item() {
48 Some(e) if e.entry_kind == SettingsMenuEntryKind::McpServers => SettingMenuMessage::OpenMcpServers,
49 Some(e) if e.entry_kind == SettingsMenuEntryKind::ProviderLogins => {
50 SettingMenuMessage::OpenProviderLogins
51 }
52 Some(e) if e.multi_select => SettingMenuMessage::OpenModelSelector,
53 _ => SettingMenuMessage::OpenSelectedPicker,
54 };
55 Some(vec![msg])
56 }
57 _ => outcome.map(|_| vec![]),
58 }
59 }
60
61 fn render(&mut self, context: &ViewContext) -> Frame {
62 self.list.render(context)
63 }
64}
65
66impl SettingsMenu {
67 pub fn from_config_options(options: &[SessionConfigOption]) -> Self {
68 let entries: Vec<SettingsMenuEntry> = options
69 .iter()
70 .filter(|opt| opt.id.0.as_ref() != ConfigOptionId::ReasoningEffort.as_str())
71 .filter_map(|opt| {
72 let SessionConfigKind::Select(ref select) = opt.kind else {
73 return None;
74 };
75
76 let flat_options = match &select.options {
77 SessionConfigSelectOptions::Ungrouped(opts) => opts.clone(),
78 SessionConfigSelectOptions::Grouped(groups) => {
79 groups.iter().flat_map(|g| g.options.clone()).collect()
80 }
81 _ => return None,
82 };
83
84 if flat_options.is_empty() {
85 return None;
86 }
87
88 let current_value_index =
89 flat_options.iter().position(|o| o.value == select.current_value).unwrap_or(0);
90
91 let values: Vec<SettingsMenuValue> = flat_options
92 .into_iter()
93 .map(|o| SettingsMenuValue {
94 value: o.value.0.to_string(),
95 name: o.name,
96 is_disabled: o.description.as_deref().is_some_and(|d| d.starts_with("Unavailable:")),
97 description: o.description,
98 meta: SelectOptionMeta::from_meta(o.meta.as_ref()),
99 })
100 .collect();
101
102 let multi_select = ConfigOptionMeta::from_meta(opt.meta.as_ref()).multi_select;
103
104 let display_name = if multi_select && select.current_value.0.contains(',') {
105 let parts: Vec<&str> = select.current_value.0.split(',').map(str::trim).collect();
106
107 let names: Vec<&str> = parts
108 .iter()
109 .filter_map(|val| values.iter().find(|v| v.value == *val).map(|v| v.name.as_str()))
110 .collect();
111
112 if names.is_empty() { Some(format!("{} models", parts.len())) } else { Some(names.join(", ")) }
113 } else {
114 None
115 };
116
117 Some(SettingsMenuEntry {
118 config_id: opt.id.0.to_string(),
119 title: opt.name.clone(),
120 values,
121 current_value_index,
122 current_raw_value: select.current_value.0.to_string(),
123 entry_kind: SettingsMenuEntryKind::Select,
124 multi_select,
125 display_name,
126 })
127 })
128 .collect();
129
130 Self { list: SelectList::new(entries, "no settings options") }
131 }
132
133 #[allow(dead_code)] pub fn from_entries(entries: Vec<SettingsMenuEntry>) -> Self {
135 Self { list: SelectList::new(entries, "no settings options") }
136 }
137
138 #[cfg(test)]
139 pub fn options(&self) -> &[SettingsMenuEntry] {
140 self.list.items()
141 }
142
143 #[cfg(test)]
144 pub fn selected_index(&self) -> usize {
145 self.list.selected_index()
146 }
147
148 pub fn add_theme_entry(&mut self, current_theme_file: Option<&str>, theme_files: &[String]) {
149 let mut values = Vec::with_capacity(theme_files.len() + 1);
150 values.push(SettingsMenuValue {
151 value: String::new(),
152 name: "Default".to_string(),
153 description: None,
154 is_disabled: false,
155 meta: SelectOptionMeta::default(),
156 });
157
158 values.extend(theme_files.iter().map(|file| SettingsMenuValue {
159 value: file.clone(),
160 name: file.clone(),
161 description: None,
162 is_disabled: false,
163 meta: SelectOptionMeta::default(),
164 }));
165
166 let current_value_index =
167 current_theme_file.and_then(|file| values.iter().position(|v| v.value == file)).unwrap_or(0);
168 let current_raw_value = values.get(current_value_index).map(|v| v.value.clone()).unwrap_or_default();
169
170 self.list.push(SettingsMenuEntry {
171 config_id: THEME_CONFIG_ID.to_string(),
172 title: "Theme".to_string(),
173 values,
174 current_value_index,
175 current_raw_value,
176 entry_kind: SettingsMenuEntryKind::Select,
177 multi_select: false,
178 display_name: None,
179 });
180 }
181
182 pub fn add_mcp_servers_entry(&mut self, summary: &str) {
183 self.list.push(SettingsMenuEntry {
184 config_id: "__mcp_servers".to_string(),
185 title: "MCP Servers".to_string(),
186 values: vec![SettingsMenuValue {
187 value: String::new(),
188 name: summary.to_string(),
189 description: None,
190 is_disabled: false,
191 meta: SelectOptionMeta::default(),
192 }],
193 current_value_index: 0,
194 current_raw_value: String::new(),
195 entry_kind: SettingsMenuEntryKind::McpServers,
196 multi_select: false,
197 display_name: None,
198 });
199 }
200
201 pub fn add_provider_logins_entry(&mut self, summary: &str) {
202 self.list.push(SettingsMenuEntry {
203 config_id: "__provider_logins".to_string(),
204 title: "Provider Logins".to_string(),
205 values: vec![SettingsMenuValue {
206 value: String::new(),
207 name: summary.to_string(),
208 description: None,
209 is_disabled: false,
210 meta: SelectOptionMeta::default(),
211 }],
212 current_value_index: 0,
213 current_raw_value: String::new(),
214 entry_kind: SettingsMenuEntryKind::ProviderLogins,
215 multi_select: false,
216 display_name: None,
217 });
218 }
219
220 pub fn update_options(&mut self, options: &[SessionConfigOption]) {
221 let prev_index = self.list.selected_index();
222 *self = Self::from_config_options(options);
223 let max = self.list.len().saturating_sub(1);
224 self.list.set_selected(prev_index.min(max));
225 }
226
227 pub fn selected_entry(&self) -> Option<&SettingsMenuEntry> {
228 self.list.selected_item()
229 }
230
231 pub fn apply_change(&mut self, change: &SettingsChange) {
232 let Some(entry) = self.list.items_mut().iter_mut().find(|entry| entry.config_id == change.config_id) else {
233 return;
234 };
235
236 entry.current_raw_value.clone_from(&change.new_value);
237 if let Some(index) = entry.values.iter().position(|value| value.value == change.new_value) {
238 entry.current_value_index = index;
239 }
240 }
241}
242
243#[cfg(test)]
244mod tests {
245 use super::*;
246 use agent_client_protocol::{SessionConfigOption, SessionConfigOptionCategory, SessionConfigSelectOption};
247 use tui::{KeyCode, KeyEvent, KeyModifiers};
248
249 fn sel(id: &str, name: &str, current: &str, values: &[(&str, &str)]) -> SessionConfigOption {
250 let options: Vec<SessionConfigSelectOption> =
251 values.iter().map(|(v, n)| SessionConfigSelectOption::new(v.to_string(), n.to_string())).collect();
252 SessionConfigOption::select(id.to_string(), name.to_string(), current.to_string(), options)
253 }
254
255 fn menu(opts: &[SessionConfigOption]) -> SettingsMenu {
256 SettingsMenu::from_config_options(opts)
257 }
258
259 fn key(code: KeyCode) -> Event {
260 Event::Key(KeyEvent::new(code, KeyModifiers::NONE))
261 }
262
263 async fn press(menu: &mut SettingsMenu, code: KeyCode) -> Option<Vec<SettingMenuMessage>> {
264 menu.on_event(&key(code)).await
265 }
266
267 fn theme_files() -> Vec<String> {
268 vec!["catppuccin.tmTheme".into(), "nord.tmTheme".into()]
269 }
270
271 fn theme_menu(current: Option<&str>) -> SettingsMenu {
272 let mut m = menu(&[]);
273 m.add_theme_entry(current, &theme_files());
274 m
275 }
276
277 #[test]
278 fn from_config_options_builds_entries() {
279 let m = menu(&[
280 sel("model", "Model", "gpt-4o", &[("gpt-4o", "GPT-4o"), ("claude", "Claude")]),
281 sel("mode", "Mode", "code", &[("code", "Code"), ("chat", "Chat")]),
282 ]);
283 assert_eq!(m.options().len(), 2);
284 assert_eq!(m.options()[0].config_id, "model");
285 assert_eq!(m.options()[0].current_value_index, 0);
286 assert_eq!(m.options()[0].display_name, None);
287 assert_eq!(m.options()[1].config_id, "mode");
288 }
289
290 #[test]
291 fn from_config_options_finds_current_value() {
292 let m =
293 menu(&[sel("model", "Model", "claude", &[("gpt-4o", "GPT-4o"), ("claude", "Claude"), ("llama", "Llama")])]);
294 assert_eq!(m.options()[0].current_value_index, 1);
295 }
296
297 #[tokio::test]
298 async fn navigation_wraps_around() {
299 let mut m = menu(&[
300 sel("a", "A", "v1", &[("v1", "V1")]),
301 sel("b", "B", "v1", &[("v1", "V1")]),
302 sel("c", "C", "v1", &[("v1", "V1")]),
303 ]);
304 assert_eq!(m.selected_index(), 0);
305
306 press(&mut m, KeyCode::Up).await;
307 assert_eq!(m.selected_index(), 2);
308
309 press(&mut m, KeyCode::Down).await;
310 assert_eq!(m.selected_index(), 0);
311
312 for _ in 0..3 {
313 press(&mut m, KeyCode::Down).await;
314 }
315 assert_eq!(m.selected_index(), 0);
316 }
317
318 #[test]
319 fn update_options_clamps_index() {
320 let mut m = menu(&[
321 sel("a", "A", "v1", &[("v1", "V1")]),
322 sel("b", "B", "v1", &[("v1", "V1")]),
323 sel("c", "C", "v1", &[("v1", "V1")]),
324 ]);
325 m.list.set_selected(2);
326 m.update_options(&[sel("a", "A", "v1", &[("v1", "V1")])]);
327 assert_eq!(m.selected_index(), 0);
328 }
329
330 #[test]
331 fn update_options_preserves_index_when_within_bounds() {
332 let mut m = menu(&[
333 sel("provider", "Provider", "a", &[("a", "A"), ("b", "B")]),
334 sel("model", "Model", "m1", &[("m1", "M1"), ("m2", "M2")]),
335 ]);
336 m.list.set_selected(1);
337 m.update_options(&[
338 sel("provider", "Provider", "b", &[("a", "A"), ("b", "B")]),
339 sel("model", "Model", "m3", &[("m3", "M3")]),
340 ]);
341 assert_eq!(m.selected_index(), 1);
342 }
343
344 #[test]
345 fn from_config_options_skips_empty_values() {
346 let empty = SessionConfigOption::select("x", "X", "v", Vec::<SessionConfigSelectOption>::new());
347 let m = menu(&[empty, sel("model", "Model", "a", &[("a", "A")])]);
348 assert_eq!(m.options().len(), 1);
349 assert_eq!(m.options()[0].config_id, "model");
350 }
351
352 #[test]
353 fn from_config_options_with_category() {
354 let opt = sel("model", "Model", "gpt-4o", &[("gpt-4o", "GPT-4o")]).category(SessionConfigOptionCategory::Model);
355 let m = menu(&[opt]);
356 assert_eq!(m.options().len(), 1);
357 assert_eq!(m.options()[0].title, "Model");
358 }
359
360 #[tokio::test]
361 async fn key_enter_opens_picker_and_escape_closes() {
362 for (code, expected) in [(KeyCode::Enter, "OpenSelectedPicker"), (KeyCode::Esc, "CloseAll")] {
363 let mut m = menu(&[sel("model", "Model", "a", &[("a", "A")])]);
364 let msgs = press(&mut m, code).await.unwrap();
365 let tag = match &msgs[..] {
366 [SettingMenuMessage::OpenSelectedPicker] => "OpenSelectedPicker",
367 [SettingMenuMessage::CloseAll] => "CloseAll",
368 _ => "other",
369 };
370 assert_eq!(tag, expected, "key {code:?} should produce {expected}");
371 }
372 }
373
374 #[test]
375 fn multi_select_detected_from_meta() {
376 for (has_meta, expected) in [(true, true), (false, false)] {
377 let mut opt = sel("model", "Model", "a", &[("a", "A"), ("b", "B")]);
378 if has_meta {
379 opt = opt.meta(ConfigOptionMeta { multi_select: true }.into_meta());
380 }
381 let m = menu(&[opt]);
382 assert_eq!(m.options()[0].multi_select, expected, "meta={has_meta}");
383 }
384 }
385
386 #[tokio::test]
387 async fn multi_select_entry_opens_model_selector() {
388 let opt = sel("model", "Model", "a", &[("a", "A"), ("b", "B")])
389 .meta(ConfigOptionMeta { multi_select: true }.into_meta());
390 let mut m = menu(&[opt]);
391 let msgs = press(&mut m, KeyCode::Enter).await.unwrap();
392 assert!(matches!(msgs.as_slice(), [SettingMenuMessage::OpenModelSelector]));
393 }
394
395 #[test]
396 fn multi_select_with_comma_value_shows_model_names() {
397 let opt = sel("model", "Model", "a,b", &[("a", "Alpha"), ("b", "Beta")])
398 .meta(ConfigOptionMeta { multi_select: true }.into_meta());
399 let display = menu(&[opt]).options()[0].display_name.as_deref().unwrap().to_string();
400 assert!(display.contains("Alpha"), "display: {display}");
401 assert!(display.contains("Beta"), "display: {display}");
402 }
403
404 #[test]
405 fn apply_change_updates_matching_entry_value_and_index() {
406 let mut m = theme_menu(None);
407 m.apply_change(&SettingsChange {
408 config_id: THEME_CONFIG_ID.to_string(),
409 new_value: "nord.tmTheme".to_string(),
410 });
411 assert_eq!(m.options()[0].current_raw_value, "nord.tmTheme");
412 assert_eq!(m.options()[0].current_value_index, 2);
413 }
414
415 #[test]
416 fn add_theme_entry_inserts_theme_row() {
417 let m = theme_menu(None);
418 assert_eq!(m.options().len(), 1);
419 let t = &m.options()[0];
420 assert_eq!(t.config_id, THEME_CONFIG_ID);
421 assert_eq!(t.title, "Theme");
422 assert_eq!(t.entry_kind, SettingsMenuEntryKind::Select);
423 assert!(!t.multi_select);
424 assert_eq!(t.values.len(), 3);
425 assert_eq!(t.values[0].name, "Default");
426 assert_eq!(t.values[0].value, "");
427 assert_eq!(t.values[1].value, "catppuccin.tmTheme");
428 assert_eq!(t.values[2].value, "nord.tmTheme");
429 }
430
431 #[test]
432 fn add_theme_entry_selects_correct_index() {
433 let cases: &[(Option<&str>, usize, &str)] =
434 &[(None, 0, ""), (Some("nord.tmTheme"), 2, "nord.tmTheme"), (Some("missing.tmTheme"), 0, "")];
435 for &(current, expected_idx, expected_raw) in cases {
436 let m = theme_menu(current);
437 let t = &m.options()[0];
438 assert_eq!(t.current_value_index, expected_idx, "current={current:?}");
439 assert_eq!(t.current_raw_value, expected_raw, "current={current:?}");
440 }
441 }
442
443 #[test]
444 fn from_config_options_excludes_reasoning_effort_entry() {
445 let m = menu(&[
446 sel("model", "Model", "gpt-4o", &[("gpt-4o", "GPT-4o"), ("claude", "Claude")]),
447 sel(
448 "reasoning_effort",
449 "Reasoning Effort",
450 "high",
451 &[("none", "None"), ("low", "Low"), ("medium", "Medium"), ("high", "High")],
452 ),
453 ]);
454 assert!(m.options().iter().any(|e| e.config_id == "model"));
455 assert!(!m.options().iter().any(|e| e.config_id == "reasoning_effort"));
456 }
457}