1use super::command;
2use crate::{DevelopmentWorkspace, ExperimentComparison};
3use glass_browser::browser_workspace::{
4 BrowserConnectionPhase, BrowserWorkspaceAction, BrowserWorkspaceAdapterKind,
5 BrowserWorkspaceController, BrowserWorkspaceEntity, BrowserWorkspaceIntent,
6 BrowserWorkspaceLayout,
7};
8use glass_browser::cli::args::TuiLayout;
9use serde::{Deserialize, Serialize};
10use std::path::Path;
11
12pub struct PendingConfirmation {
13 pub call: crate::development::ToolCall,
14 pub context: crate::tools::DevelopmentToolContext,
15 pub summary: String,
16}
17
18#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
19pub enum DevSurface {
20 Trust,
21 Agent,
22 Code,
23 App,
24 Terminal,
25 Tasks,
26 Git,
27 Debug,
28 More,
29}
30
31impl DevSurface {
32 pub const ALL: [Self; 8] = [
33 Self::Agent,
34 Self::Code,
35 Self::App,
36 Self::Terminal,
37 Self::Tasks,
38 Self::Git,
39 Self::Debug,
40 Self::More,
41 ];
42
43 pub const PRIMARY: [Self; 7] = [
44 Self::Agent,
45 Self::Code,
46 Self::App,
47 Self::Terminal,
48 Self::Tasks,
49 Self::Git,
50 Self::Debug,
51 ];
52
53 pub const PHONE: [Self; 5] = [Self::Agent, Self::Code, Self::App, Self::Tasks, Self::More];
54
55 pub fn label(self) -> &'static str {
56 match self {
57 Self::Trust => "Trust",
58 Self::Agent => "Agent",
59 Self::Code => "Code",
60 Self::App => "App",
61 Self::Terminal => "Terminal",
62 Self::Tasks => "Tasks",
63 Self::Git => "Git",
64 Self::Debug => "Debug",
65 Self::More => "More",
66 }
67 }
68}
69
70#[derive(Debug, Clone, Copy, PartialEq, Eq)]
71pub enum ResponsiveClass {
72 Desktop,
73 Compact,
74 Phone,
75}
76
77#[derive(Debug, Clone, Copy, PartialEq, Eq)]
78pub enum ProductMode {
79 Build,
80 Agent,
81 RunApp,
82 Debug,
83}
84
85pub struct DevTuiState {
86 pub workspace: DevelopmentWorkspace,
87 pub surface: DevSurface,
88 pub layout: TuiLayout,
89 pub quit: bool,
90 pub command_mode: bool,
91 pub command_input: String,
92 pub command_cursor: usize,
93 pub command_history: Vec<String>,
94 pub command_history_index: Option<usize>,
95 pub palette_error: Option<String>,
96 pub composer_mode: bool,
97 pub composer_input: String,
98 pub composer_cursor: usize,
99 pub selected_agent: Option<crate::AgentId>,
100 pub pending_confirmation: Option<PendingConfirmation>,
101 pub surface_scroll: std::collections::BTreeMap<DevSurface, usize>,
102 pub terminal_width: u16,
103 pub terminal_height: u16,
104 pub status: String,
105 pub agents: String,
106 pub agent_readiness: String,
107 pub agent_conversation: String,
108 pub tasks: String,
109 pub editor: String,
110 pub files: Vec<String>,
111 pub selected_file: usize,
112 pub code_edit_mode: bool,
113 pub lsp: String,
114 pub processes: String,
115 pub git: String,
116 pub tests: String,
117 pub kernels: String,
118 pub debugger: String,
119 pub replay: String,
120 pub browser: String,
121 pub browser_detail: String,
122 pub browser_workspace: BrowserWorkspaceController,
123 pub workflow: String,
124 pub workspace_status: String,
125 pub experiment_comparison: Option<ExperimentComparison>,
126 pub experiments: String,
127}
128
129impl DevTuiState {
130 pub fn product_mode(&self) -> ProductMode {
131 match self.surface {
132 DevSurface::Agent => ProductMode::Agent,
133 DevSurface::App => ProductMode::RunApp,
134 DevSurface::Debug => ProductMode::Debug,
135 _ => ProductMode::Build,
136 }
137 }
138 pub fn open(
139 root: impl AsRef<Path>,
140 layout: TuiLayout,
141 ) -> Result<Self, Box<dyn std::error::Error>> {
142 let workspace = DevelopmentWorkspace::open(root)?;
143 let trust_prompt = workspace.trust() == crate::WorkspaceTrust::Untrusted
144 && workspace
145 .trust_inspection()
146 .iter()
147 .any(|item| item.trust_required);
148 let mut state = Self {
149 workspace,
150 surface: if trust_prompt {
151 DevSurface::Trust
152 } else {
153 DevSurface::Agent
154 },
155 layout,
156 quit: false,
157 command_mode: false,
158 command_input: String::new(),
159 command_cursor: 0,
160 command_history: Vec::new(),
161 command_history_index: None,
162 palette_error: None,
163 composer_mode: false,
164 composer_input: String::new(),
165 composer_cursor: 0,
166 selected_agent: None,
167 pending_confirmation: None,
168 surface_scroll: std::collections::BTreeMap::new(),
169 terminal_width: 80,
170 terminal_height: 24,
171 status: if trust_prompt {
172 "Workspace trust required · I inspect · O untrusted · 1 trust once · T trust project".into()
173 } else {
174 "Ready · : opens the command palette · q quits".into()
175 },
176 agents: String::new(),
177 agent_readiness: crate::pi_runtime::pi_readiness()
178 .map(|readiness| format_pi_readiness(&readiness))
179 .unwrap_or_else(|error| format!("Agent unavailable · {error}")),
180 agent_conversation: "No conversation yet. Press i to compose a message.".into(),
181 tasks: String::new(),
182 editor: String::new(),
183 files: Vec::new(),
184 selected_file: 0,
185 code_edit_mode: false,
186 lsp: String::new(),
187 processes: String::new(),
188 git: String::new(),
189 tests: String::new(),
190 kernels: String::new(),
191 debugger: String::new(),
192 replay: String::new(),
193 browser: String::new(),
194 browser_detail: "No browser observation yet".into(),
195 browser_workspace: BrowserWorkspaceController::for_adapter(
196 match layout {
197 TuiLayout::Mobile => BrowserWorkspaceLayout::Phone,
198 TuiLayout::Compact => BrowserWorkspaceLayout::Compact,
199 TuiLayout::Auto | TuiLayout::Desktop => BrowserWorkspaceLayout::Desktop,
200 },
201 BrowserWorkspaceAdapterKind::EmbeddedDevelopment,
202 ),
203 workflow: "No workflow evidence yet".into(),
204 workspace_status: String::new(),
205 experiment_comparison: None,
206 experiments: "No experiments. :experiment create ID BRANCH [PORT]".into(),
207 };
208 state.refresh();
209 Ok(state)
210 }
211
212 pub fn responsive_class(&self, width: u16, height: u16) -> ResponsiveClass {
213 match self.layout {
214 TuiLayout::Desktop => ResponsiveClass::Desktop,
215 TuiLayout::Compact => ResponsiveClass::Compact,
216 TuiLayout::Mobile => ResponsiveClass::Phone,
217 TuiLayout::Auto if width < 72 || height < 22 => ResponsiveClass::Phone,
218 TuiLayout::Auto if width < 118 || height < 32 => ResponsiveClass::Compact,
219 TuiLayout::Auto => ResponsiveClass::Desktop,
220 }
221 }
222
223 pub fn open_palette(&mut self) {
224 self.command_mode = true;
225 self.command_input.clear();
226 self.command_cursor = 0;
227 self.command_history_index = None;
228 self.palette_error = None;
229 self.status = "Command palette · type help for routes".into();
230 }
231
232 pub fn close_palette(&mut self) {
233 self.command_mode = false;
234 self.command_input.clear();
235 self.command_cursor = 0;
236 self.command_history_index = None;
237 self.palette_error = None;
238 self.status = "Command cancelled".into();
239 }
240
241 pub fn submit_palette(&mut self) {
242 let input = std::mem::take(&mut self.command_input);
243 self.command_cursor = 0;
244 self.command_history_index = None;
245 self.command_mode = false;
246 if !input.trim().is_empty() && self.command_history.last() != Some(&input) {
247 self.command_history.push(input.clone());
248 if self.command_history.len() > 32 {
249 self.command_history.remove(0);
250 }
251 }
252 match command::execute(self, &input) {
253 Ok(message) => {
254 self.palette_error = None;
255 self.status = message;
256 }
257 Err(error) => {
258 self.palette_error = Some(error.clone());
259 self.status = format!("Error: {error}");
260 }
261 }
262 self.refresh();
263 }
264
265 pub fn insert_palette_char(&mut self, character: char) {
266 self.command_input.insert(self.command_cursor, character);
267 self.command_cursor += character.len_utf8();
268 self.palette_error = None;
269 self.command_history_index = None;
270 }
271
272 pub fn insert_palette_text(&mut self, text: &str) {
273 for character in text.replace(['\r', '\n'], " ").chars().take(8_192) {
274 self.insert_palette_char(character);
275 }
276 }
277
278 pub fn palette_backspace(&mut self) {
279 if self.command_cursor == 0 {
280 return;
281 }
282 let previous = self.command_input[..self.command_cursor]
283 .char_indices()
284 .next_back()
285 .map(|(index, _)| index)
286 .unwrap_or(0);
287 self.command_input.drain(previous..self.command_cursor);
288 self.command_cursor = previous;
289 self.command_history_index = None;
290 }
291
292 pub fn navigate_palette_history(&mut self, older: bool) {
293 if self.command_history.is_empty() {
294 return;
295 }
296 let last = self.command_history.len() - 1;
297 let index = match (self.command_history_index, older) {
298 (None, true) => last,
299 (None, false) => return,
300 (Some(index), true) => index.saturating_sub(1),
301 (Some(index), false) if index < last => index + 1,
302 (Some(_), false) => {
303 self.command_history_index = None;
304 self.command_input.clear();
305 self.command_cursor = 0;
306 return;
307 }
308 };
309 self.command_history_index = Some(index);
310 self.command_input.clone_from(&self.command_history[index]);
311 self.command_cursor = self.command_input.len();
312 }
313
314 pub fn complete_palette(&mut self) {
315 let Some(completion) = self.palette_matches().first().copied() else {
316 return;
317 };
318 let suffix = self
319 .command_input
320 .find(char::is_whitespace)
321 .map(|index| self.command_input[index..].to_string())
322 .unwrap_or_default();
323 self.command_input = format!("{completion}{suffix}");
324 self.command_cursor = self.command_input.len();
325 self.command_history_index = None;
326 self.status = format!("Completed `{completion}` · Enter runs · ↑/↓ history");
327 }
328
329 pub fn open_palette_with(&mut self, prefix: &str) {
330 self.open_palette();
331 self.command_input = prefix.into();
332 self.command_cursor = self.command_input.len();
333 }
334
335 pub fn move_palette_cursor(&mut self, right: bool) {
336 if right {
337 self.command_cursor = self.command_input[self.command_cursor..]
338 .char_indices()
339 .nth(1)
340 .map(|(offset, _)| self.command_cursor + offset)
341 .unwrap_or(self.command_input.len());
342 } else if self.command_cursor > 0 {
343 self.command_cursor = self.command_input[..self.command_cursor]
344 .char_indices()
345 .next_back()
346 .map(|(index, _)| index)
347 .unwrap_or(0);
348 }
349 }
350
351 pub fn palette_matches(&self) -> Vec<&'static str> {
352 const COMMANDS: [&str; 18] = [
353 "agent",
354 "browser",
355 "debug",
356 "editor",
357 "experiment",
358 "git",
359 "help",
360 "kernel",
361 "lsp",
362 "process",
363 "quit",
364 "replay",
365 "task",
366 "test",
367 "trust",
368 "view",
369 "workflow",
370 "workspace",
371 ];
372 let query = self
373 .command_input
374 .split_whitespace()
375 .next()
376 .unwrap_or_default();
377 COMMANDS
378 .into_iter()
379 .filter(|command| fuzzy_contains(command, query))
380 .take(6)
381 .collect()
382 }
383
384 pub fn open_composer(&mut self) {
385 self.composer_mode = true;
386 self.composer_cursor = self.composer_input.len();
387 self.status = "Agent composer · Enter sends · Esc cancels".into();
388 }
389
390 pub fn close_composer(&mut self) {
391 self.composer_mode = false;
392 self.status = "Composer closed".into();
393 }
394
395 pub fn insert_composer_text(&mut self, text: &str) {
396 for character in text.chars().take(16_384) {
397 self.composer_input.insert(self.composer_cursor, character);
398 self.composer_cursor += character.len_utf8();
399 }
400 }
401
402 pub fn composer_backspace(&mut self) {
403 if self.composer_cursor == 0 {
404 return;
405 }
406 let previous = self.composer_input[..self.composer_cursor]
407 .char_indices()
408 .next_back()
409 .map(|(index, _)| index)
410 .unwrap_or(0);
411 self.composer_input.drain(previous..self.composer_cursor);
412 self.composer_cursor = previous;
413 }
414
415 pub fn submit_composer(&mut self) {
416 let mut text = std::mem::take(&mut self.composer_input);
417 self.composer_cursor = 0;
418 self.composer_mode = false;
419 if text.trim().is_empty() {
420 self.status = "Message was empty".into();
421 return;
422 }
423 if !self.workspace.trust().permits_project_execution() {
424 self.status = "Agent requires trusted project execution · open Trust".into();
425 return;
426 }
427 if let Some(entity) = self.browser_workspace.state().selected() {
428 text.push_str(&format!(
429 "\n\n[Glass App context: {} `{}` at browser revision {}; use current browser evidence and preserve its lease/revision guards.]",
430 entity.role, entity.reference, entity.revision
431 ));
432 self.browser_workspace.state_mut().input_owner =
433 glass_browser::browser_workspace::BrowserInputOwner::Agent;
434 }
435 let current = self.selected_agent.clone().or_else(|| {
436 self.workspace
437 .agents()
438 .list()
439 .ok()?
440 .into_iter()
441 .find(|agent| {
442 !matches!(
443 agent.status,
444 crate::AgentStatus::Completed
445 | crate::AgentStatus::Failed
446 | crate::AgentStatus::Cancelled
447 )
448 })
449 .map(|agent| agent.id)
450 });
451 let result = if let Some(agent) = current {
452 self.selected_agent = Some(agent.clone());
453 let status = self
454 .workspace
455 .agents()
456 .snapshot(&agent)
457 .map(|item| item.status);
458 match status {
459 Ok(crate::AgentStatus::Working) => self.workspace.agents().follow_up(&agent, text),
460 Ok(_) => self.workspace.agents().prompt(&agent, text),
461 Err(error) => Err(error),
462 }
463 .map(|()| agent)
464 } else {
465 self.workspace
466 .agents()
467 .create(crate::AgentSpec::new("assistant", text))
468 };
469 match result {
470 Ok(agent) => {
471 self.selected_agent = Some(agent);
472 self.status = "Message queued".into();
473 }
474 Err(error) => self.status = format!("Message failed: {error}"),
475 }
476 self.refresh();
477 }
478
479 pub fn approve_confirmation(&mut self) {
480 let Some(pending) = self.pending_confirmation.take() else {
481 return;
482 };
483 match self.workspace.execute_tool(&pending.call, &pending.context) {
484 Ok(_) => self.status = format!("Approved once · {}", pending.summary),
485 Err(error) => self.status = format!("Approved action failed: {error}"),
486 }
487 self.refresh();
488 }
489
490 pub fn deny_confirmation(&mut self) {
491 if let Some(pending) = self.pending_confirmation.take() {
492 self.status = format!("Denied · {}", pending.summary);
493 }
494 }
495
496 pub fn handle_printable(&mut self, character: char) {
497 if self.surface == DevSurface::Trust {
498 let decision = match character {
499 'i' | 'I' => {
500 self.status = "Inspecting exact repository configuration".into();
501 return;
502 }
503 'o' | 'O' => Some(crate::LocalTrustDecision::OpenUntrusted),
504 '1' => Some(crate::LocalTrustDecision::TrustOnce),
505 'T' => Some(crate::LocalTrustDecision::TrustProject),
506 _ => None,
507 };
508 if let Some(decision) = decision {
509 match self.workspace.apply_local_trust_decision(decision) {
510 Ok(trust) => {
511 self.surface = DevSurface::Agent;
512 self.status = format!("Workspace opened with {trust:?} authority");
513 }
514 Err(error) => self.status = format!("Trust decision failed: {error}"),
515 }
516 return;
517 }
518 }
519 if self.responsive_class(self.terminal_width, self.terminal_height)
520 == ResponsiveClass::Phone
521 {
522 let surface = match character {
523 '1' => Some(DevSurface::Agent),
524 '2' => Some(DevSurface::Code),
525 '3' => Some(DevSurface::App),
526 '4' => Some(DevSurface::Tasks),
527 '5' => Some(DevSurface::More),
528 _ => None,
529 };
530 if let Some(surface) = surface {
531 self.surface = surface;
532 self.status = format!("{} · : for actions", surface.label());
533 return;
534 }
535 }
536 let surface = match character {
537 '1' | 'a' => Some(DevSurface::Agent),
538 '2' | 'c' => Some(DevSurface::Code),
539 '3' | 'v' => Some(DevSurface::App),
540 '4' => Some(DevSurface::Terminal),
541 '5' | 'w' => Some(DevSurface::Tasks),
542 '6' | 'g' => Some(DevSurface::Git),
543 '7' | 'd' => Some(DevSurface::Debug),
544 '8' | 'm' => Some(DevSurface::More),
545 _ => None,
546 };
547 if let Some(surface) = surface {
548 self.surface = surface;
549 self.status = format!("{} · : for actions", surface.label());
550 }
551 }
552
553 pub fn next_surface(&mut self) {
554 let surfaces: &[DevSurface] = if self
555 .responsive_class(self.terminal_width, self.terminal_height)
556 == ResponsiveClass::Phone
557 {
558 &DevSurface::PHONE
559 } else {
560 &DevSurface::PRIMARY
561 };
562 let index = surfaces
563 .iter()
564 .position(|surface| *surface == self.surface)
565 .unwrap_or(0);
566 self.surface = surfaces[(index + 1) % surfaces.len()];
567 }
568
569 pub fn scroll_surface(&mut self, delta: i32) {
570 let scroll = self.surface_scroll.entry(self.surface).or_default();
571 *scroll = (*scroll as i64 + i64::from(delta)).max(0) as usize;
572 }
573
574 pub fn current_scroll(&self) -> u16 {
575 self.surface_scroll
576 .get(&self.surface)
577 .copied()
578 .unwrap_or(0)
579 .min(u16::MAX as usize) as u16
580 }
581
582 pub fn move_file_selection(&mut self, delta: i32) {
583 if self.files.is_empty() {
584 self.selected_file = 0;
585 return;
586 }
587 self.selected_file = (self.selected_file as i32 + delta)
588 .clamp(0, self.files.len().saturating_sub(1) as i32)
589 as usize;
590 }
591
592 pub fn open_selected_file(&mut self) {
593 let Some(path) = self.files.get(self.selected_file).cloned() else {
594 self.status = "No project file selected".into();
595 return;
596 };
597 match self
598 .workspace
599 .project_mut()
600 .open_buffer(&path, crate::development::Actor::local())
601 {
602 Ok(_) => {
603 self.status = format!("Opened {path} · press i to edit");
604 self.refresh();
605 }
606 Err(error) => self.status = format!("Open failed: {error}"),
607 }
608 }
609
610 pub fn enter_code_edit(&mut self) {
611 if self.workspace.project().buffers().next().is_none() {
612 self.open_selected_file();
613 }
614 if self.workspace.project().buffers().next().is_some() {
615 self.code_edit_mode = true;
616 self.status =
617 "EDIT · arrows move · Ctrl-S save · Ctrl-Z/Y undo/redo · Esc close".into();
618 }
619 }
620
621 pub fn close_code_edit(&mut self) {
622 self.code_edit_mode = false;
623 self.status = "Code navigation".into();
624 }
625
626 pub fn edit_code_key(
627 &mut self,
628 code: crossterm::event::KeyCode,
629 modifiers: crossterm::event::KeyModifiers,
630 ) {
631 let Some(buffer) = self.workspace.project().buffers().next().cloned() else {
632 self.status = "No open buffer".into();
633 return;
634 };
635 let path = buffer.path.clone();
636 let result = match (code, modifiers) {
637 (crossterm::event::KeyCode::Char('s'), value)
638 if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
639 {
640 self.workspace.project_mut().save_buffer(&path).map(|_| ())
641 }
642 (crossterm::event::KeyCode::Char('z'), value)
643 if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
644 {
645 self.workspace.project_mut().undo_buffer(&path).map(|_| ())
646 }
647 (crossterm::event::KeyCode::Char('y'), value)
648 if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
649 {
650 self.workspace.project_mut().redo_buffer(&path).map(|_| ())
651 }
652 (crossterm::event::KeyCode::Left, _) => self.move_editor_cursor(&path, 0, -1),
653 (crossterm::event::KeyCode::Right, _) => self.move_editor_cursor(&path, 0, 1),
654 (crossterm::event::KeyCode::Up, _) => self.move_editor_cursor(&path, -1, 0),
655 (crossterm::event::KeyCode::Down, _) => self.move_editor_cursor(&path, 1, 0),
656 (crossterm::event::KeyCode::Enter, _) => self.insert_editor_text(&path, "\n"),
657 (crossterm::event::KeyCode::Backspace, _) => self.backspace_editor(&path),
658 (crossterm::event::KeyCode::Char(character), _) => {
659 self.insert_editor_text(&path, &character.to_string())
660 }
661 _ => Ok(()),
662 };
663 if let Err(error) = result {
664 self.status = format!("Editor action failed: {error}");
665 }
666 self.refresh();
667 }
668
669 fn move_editor_cursor(
670 &mut self,
671 path: &str,
672 line_delta: i32,
673 column_delta: i32,
674 ) -> crate::development::DevelopmentResult<()> {
675 let buffer = self
676 .workspace
677 .project()
678 .buffer(path)
679 .cloned()
680 .ok_or_else(|| {
681 crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
682 })?;
683 let lines = buffer.content.split('\n').collect::<Vec<_>>();
684 let line =
685 (buffer.cursor_line as i32 + line_delta).clamp(1, lines.len().max(1) as i32) as u32;
686 let max_column = lines
687 .get(line.saturating_sub(1) as usize)
688 .map(|line| line.chars().count() + 1)
689 .unwrap_or(1) as u32;
690 let column = if line_delta != 0 {
691 buffer.cursor_column.min(max_column)
692 } else {
693 (buffer.cursor_column as i32 + column_delta).clamp(1, max_column as i32) as u32
694 };
695 self.workspace
696 .project_mut()
697 .set_buffer_cursor(path, line, column)
698 }
699
700 fn insert_editor_text(
701 &mut self,
702 path: &str,
703 text: &str,
704 ) -> crate::development::DevelopmentResult<()> {
705 let buffer = self
706 .workspace
707 .project()
708 .buffer(path)
709 .cloned()
710 .ok_or_else(|| {
711 crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
712 })?;
713 let offset = editor_offset(&buffer.content, buffer.cursor_line, buffer.cursor_column);
714 let mut content = buffer.content.clone();
715 content.insert_str(offset, text);
716 self.workspace.project_mut().edit_buffer(
717 path,
718 content,
719 crate::development::Actor::local(),
720 )?;
721 let (line, column) = if text == "\n" {
722 (buffer.cursor_line + 1, 1)
723 } else {
724 (
725 buffer.cursor_line,
726 buffer.cursor_column + text.chars().count() as u32,
727 )
728 };
729 self.workspace
730 .project_mut()
731 .set_buffer_cursor(path, line, column)
732 }
733
734 fn backspace_editor(&mut self, path: &str) -> crate::development::DevelopmentResult<()> {
735 let buffer = self
736 .workspace
737 .project()
738 .buffer(path)
739 .cloned()
740 .ok_or_else(|| {
741 crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
742 })?;
743 let offset = editor_offset(&buffer.content, buffer.cursor_line, buffer.cursor_column);
744 if offset == 0 {
745 return Ok(());
746 }
747 let previous = buffer.content[..offset]
748 .char_indices()
749 .next_back()
750 .map(|(index, _)| index)
751 .unwrap_or(0);
752 let removed_newline = &buffer.content[previous..offset] == "\n";
753 let mut content = buffer.content.clone();
754 content.drain(previous..offset);
755 self.workspace.project_mut().edit_buffer(
756 path,
757 content.clone(),
758 crate::development::Actor::local(),
759 )?;
760 let (line, column) = if removed_newline {
761 let line = buffer.cursor_line.saturating_sub(1).max(1);
762 let column = content
763 .split('\n')
764 .nth(line.saturating_sub(1) as usize)
765 .map(|line| line.chars().count() + 1)
766 .unwrap_or(1) as u32;
767 (line, column)
768 } else {
769 (
770 buffer.cursor_line,
771 buffer.cursor_column.saturating_sub(1).max(1),
772 )
773 };
774 self.workspace
775 .project_mut()
776 .set_buffer_cursor(path, line, column)
777 }
778
779 pub fn previous_surface(&mut self) {
780 let surfaces: &[DevSurface] = if self
781 .responsive_class(self.terminal_width, self.terminal_height)
782 == ResponsiveClass::Phone
783 {
784 &DevSurface::PHONE
785 } else {
786 &DevSurface::PRIMARY
787 };
788 let index = surfaces
789 .iter()
790 .position(|surface| *surface == self.surface)
791 .unwrap_or(0);
792 self.surface = surfaces[(index + surfaces.len() - 1) % surfaces.len()];
793 }
794
795 pub fn set_terminal_size(&mut self, width: u16, height: u16) {
796 self.terminal_width = width;
797 self.terminal_height = height;
798 }
799
800 pub fn refresh(&mut self) {
801 self.files = self
802 .workspace
803 .project()
804 .list_files()
805 .map(|entries| {
806 entries
807 .into_iter()
808 .filter(|entry| matches!(entry.kind, crate::development::FileKind::File))
809 .map(|entry| entry.path)
810 .take(512)
811 .collect()
812 })
813 .unwrap_or_default();
814 if !self.files.is_empty() {
815 self.selected_file = self.selected_file.min(self.files.len() - 1);
816 }
817 self.agents = match self.workspace.agents().list() {
818 Ok(agents) if agents.is_empty() => "No agents. :agent spawn ROLE TASK".into(),
819 Ok(agents) => agents
820 .iter()
821 .map(|agent| {
822 format!(
823 "{} {:?} {} · {}\n target {} · model {} · thinking {} · events {} · dropped {}{}\n evidence {}",
824 agent.id.as_str(),
825 agent.status,
826 agent.role,
827 agent.task,
828 agent.worktree.display(),
829 agent.model.as_deref().unwrap_or("default"),
830 agent.thinking.as_deref().unwrap_or("default"),
831 agent.event_count,
832 agent.dropped_event_count,
833 agent
834 .last_error
835 .as_deref()
836 .map(|error| format!(" · {error}"))
837 .unwrap_or_default(),
838 agent
839 .evidence
840 .iter()
841 .rev()
842 .take(3)
843 .map(|evidence| evidence.to_string())
844 .collect::<Vec<_>>()
845 .join(" · ")
846 )
847 })
848 .collect::<Vec<_>>()
849 .join("\n\n"),
850 Err(error) => format!("Agent registry failed: {error}"),
851 };
852 self.agent_conversation = match self.workspace.agents().history(0) {
853 Ok(events) if events.is_empty() => {
854 "No conversation yet. Press i to compose a message.".into()
855 }
856 Ok(events) => events
857 .iter()
858 .rev()
859 .take(32)
860 .rev()
861 .map(format_agent_event)
862 .collect::<Vec<_>>()
863 .join("\n\n"),
864 Err(error) => format!("Conversation unavailable · {error}"),
865 };
866 self.tasks = match self.workspace.tasks() {
867 Ok(tasks) if tasks.is_empty() => {
868 "No tasks. :task create TITLE PROMPT creates an autonomous task".into()
869 }
870 Ok(tasks) => tasks
871 .iter()
872 .map(|task| {
873 let glyph = match task.state {
874 crate::TaskState::Succeeded
875 if task.verification == crate::VerificationRequirement::Settled => "◇",
876 crate::TaskState::Succeeded => "✓",
877 crate::TaskState::Failed | crate::TaskState::Cancelled => "×",
878 crate::TaskState::Blocked => "!",
879 crate::TaskState::Running | crate::TaskState::Verifying => "●",
880 _ => "○",
881 };
882 format!(
883 "{} {} {:?} {}\n goal {}\n agent {} · attempt {} · model {} · thinking {}\n depends {}\n verification {}{}\n evidence {}",
884 glyph,
885 task.id.as_str(),
886 task.state,
887 task.title,
888 task.goal,
889 task.assigned_agent
890 .as_ref()
891 .map(|agent| agent.as_str())
892 .unwrap_or("unassigned"),
893 task.attempt,
894 task.model.as_deref().unwrap_or("default"),
895 task.thinking.as_deref().unwrap_or("default"),
896 task.dependencies
897 .iter()
898 .map(|dependency| dependency.as_str())
899 .collect::<Vec<_>>()
900 .join(", "),
901 serde_json::to_string(&task.verification).unwrap_or_default(),
902 task.last_error
903 .as_deref()
904 .map(|error| format!(" · {error}"))
905 .unwrap_or_default(),
906 task.evidence
907 .iter()
908 .rev()
909 .take(3)
910 .map(|evidence| format!("{}={:?}", evidence.kind, evidence.passed))
911 .collect::<Vec<_>>()
912 .join(" · ")
913 )
914 })
915 .collect::<Vec<_>>()
916 .join("\n\n"),
917 Err(error) => format!("Task scheduler failed: {error}"),
918 };
919 self.processes = self
920 .workspace
921 .project_mut()
922 .processes()
923 .list_checked()
924 .map(|items| {
925 if items.is_empty() {
926 "No managed terminals. Start the detected development command from More.".into()
927 } else {
928 items
929 .into_iter()
930 .map(|item| {
931 format!(
932 "{} {:?} · health {:?} · pid {} · {}\n {}",
933 if matches!(item.health, crate::development::ProcessHealth::Healthy)
934 {
935 "●"
936 } else {
937 "○"
938 },
939 item.name,
940 item.health,
941 item.pid.map_or_else(|| "—".into(), |pid| pid.to_string()),
942 if item.pty { "PTY" } else { "pipes" },
943 item.detected_urls
944 .first()
945 .map_or(item.command.as_str(), String::as_str),
946 )
947 })
948 .collect::<Vec<_>>()
949 .join("\n\n")
950 }
951 })
952 .unwrap_or_else(|error| format!("Process state failed: {error}"));
953 let buffers = self
954 .workspace
955 .project()
956 .buffers()
957 .cloned()
958 .collect::<Vec<_>>();
959 self.editor = if buffers.is_empty() {
960 "No file open. Use :editor open PATH or select a file.".into()
961 } else {
962 buffers
963 .iter()
964 .map(|buffer| {
965 let viewport = buffer
966 .content
967 .lines()
968 .take(24)
969 .enumerate()
970 .map(|(index, line)| format!("{:>4} {}", index + 1, line))
971 .collect::<Vec<_>>()
972 .join("\n");
973 format!(
974 "{}{} · cursor {}:{} · actor {}\n{}",
975 if buffer.dirty { "● " } else { "○ " },
976 buffer.path,
977 buffer.cursor_line,
978 buffer.cursor_column,
979 buffer.actor.id,
980 viewport
981 )
982 })
983 .collect::<Vec<_>>()
984 .join("\n\n")
985 };
986 self.lsp = {
987 let language = self.workspace.language();
988 let servers = language.names().collect::<Vec<_>>();
989 let event_count = language.events(0).len();
990 if servers.is_empty() {
991 "No language server active · diagnostics unavailable".into()
992 } else {
993 format!("● {} · {} recent events", servers.join(" · "), event_count)
994 }
995 };
996 self.git = self
997 .workspace
998 .git()
999 .map(|git| match git.status() {
1000 Ok(status) => {
1001 let header = format!(
1002 "branch {} · ↑{} ↓{} · upstream {}",
1003 status.branch.as_deref().unwrap_or("detached"),
1004 status.ahead,
1005 status.behind,
1006 status.upstream.as_deref().unwrap_or("none")
1007 );
1008 let entries = status
1009 .entries
1010 .iter()
1011 .map(|entry| {
1012 format!(
1013 "{}{} {}{}",
1014 if entry.untracked { "?" } else { "●" },
1015 if status.conflicts.contains(&entry.path) {
1016 "!"
1017 } else {
1018 " "
1019 },
1020 entry.index_status,
1021 entry.path
1022 )
1023 })
1024 .collect::<Vec<_>>();
1025 if entries.is_empty() {
1026 format!("{header}\n✓ working tree clean")
1027 } else {
1028 format!("{header}\n{}", entries.join("\n"))
1029 }
1030 }
1031 Err(error) => format!("Git state failed: {error}"),
1032 })
1033 .unwrap_or_else(|| "Not a Git repository".into());
1034 let _ = self.workspace.tests_mut().poll();
1035 let test_runs = self
1036 .workspace
1037 .tests()
1038 .results()
1039 .rev()
1040 .take(32)
1041 .collect::<Vec<_>>();
1042 self.tests = if test_runs.is_empty() {
1043 "No test runs".into()
1044 } else {
1045 test_runs
1046 .iter()
1047 .map(|run| {
1048 format!(
1049 "{} {} · {:?} · {} ms · {} cases",
1050 if run.exit_code == Some(0) {
1051 "✓"
1052 } else {
1053 "×"
1054 },
1055 run.suite_id,
1056 run.state,
1057 run.duration_ms.unwrap_or_default(),
1058 run.cases.len()
1059 )
1060 })
1061 .collect::<Vec<_>>()
1062 .join("\n")
1063 };
1064 let kernels = self.workspace.kernels().snapshots().collect::<Vec<_>>();
1065 self.kernels = if kernels.is_empty() {
1066 "No persistent kernels".into()
1067 } else {
1068 kernels
1069 .iter()
1070 .map(|kernel| {
1071 format!(
1072 "{} {} · {:?} · {} executions · rev {}",
1073 if matches!(kernel.state, crate::kernels::KernelState::Ready) {
1074 "●"
1075 } else {
1076 "○"
1077 },
1078 kernel.name,
1079 kernel.kind,
1080 kernel.executions,
1081 kernel.workspace_revision
1082 )
1083 })
1084 .collect::<Vec<_>>()
1085 .join("\n")
1086 };
1087 let debugger_names = self
1088 .workspace
1089 .debugger_names()
1090 .map(str::to_string)
1091 .collect::<Vec<_>>();
1092 self.debugger = if debugger_names.is_empty() {
1093 "No debugger sessions. :debug start NAME COMMAND [ARGS...]".into()
1094 } else {
1095 let snapshots = debugger_names
1096 .iter()
1097 .map(|name| {
1098 self.workspace
1099 .debugger_mut(name)
1100 .and_then(|debugger| debugger.snapshot())
1101 .map(|snapshot| (name, snapshot))
1102 })
1103 .collect::<Result<Vec<_>, _>>();
1104 match snapshots {
1105 Ok(snapshots) => snapshots.iter().map(|(name, snapshot)| format!("● {} · {:?} · pid {} · {} breakpoints · {} watches · {} threads/processes", name, snapshot.state, snapshot.adapter_process_id, snapshot.breakpoints.values().map(Vec::len).sum::<usize>(), snapshot.watches.len(), snapshot.debuggee_processes.len())).collect::<Vec<_>>().join("\n"),
1106 Err(error) => format!("Debugger state failed: {error}"),
1107 }
1108 };
1109 self.replay = self
1110 .workspace
1111 .intelligence()
1112 .replay(0, 128)
1113 .map(|events| {
1114 if events.is_empty() {
1115 "No observable replay events".into()
1116 } else {
1117 events
1118 .iter()
1119 .rev()
1120 .take(24)
1121 .rev()
1122 .map(|event| {
1123 format!(
1124 "{} {} · {} · {} · rev {}",
1125 event.sequence,
1126 event.actor,
1127 event.subsystem,
1128 event.kind,
1129 event.workspace_revision
1130 )
1131 })
1132 .collect::<Vec<_>>()
1133 .join("\n")
1134 }
1135 })
1136 .unwrap_or_else(|error| format!("Replay failed: {error}"));
1137 self.browser = match self.workspace.browser().state() {
1138 Ok(state) => {
1139 let connected = state
1140 .get("connected")
1141 .and_then(serde_json::Value::as_bool)
1142 .unwrap_or(false);
1143 let revision = state
1144 .get("browserRevision")
1145 .and_then(serde_json::Value::as_u64);
1146 if connected {
1147 if self.browser_workspace.state().connection
1148 != BrowserConnectionPhase::Connected
1149 {
1150 self.browser_workspace.connected(true, None, revision);
1151 } else if let Some(revision) = revision {
1152 self.browser_workspace.state_mut().browser_revision = Some(revision);
1153 }
1154 } else {
1155 self.browser_workspace.state_mut().connection =
1156 BrowserConnectionPhase::Detached;
1157 }
1158 self.browser_workspace_summary()
1159 }
1160 Err(error) => format!("Browser state failed: {error}"),
1161 };
1162 self.workflow = self
1163 .workspace
1164 .browser()
1165 .list_workflows()
1166 .and_then(|state| serde_json::to_string_pretty(&state).map_err(Into::into))
1167 .unwrap_or_else(|error| format!("Workflow state failed: {error}"));
1168 let root = self.workspace.root().display().to_string();
1169 let generation = self.workspace.generation();
1170 let project_revision = self.workspace.project().revision();
1171 let trust = self.workspace.trust();
1172 let detection = self.workspace.project().detection().clone();
1173 let agent_count = self
1174 .workspace
1175 .agents()
1176 .list()
1177 .map(|items| items.len())
1178 .unwrap_or(0);
1179 let task_count = self.workspace.tasks().map(|items| items.len()).unwrap_or(0);
1180 let kernel_count = self.workspace.kernels().snapshots().count();
1181 let debugger_count = self.workspace.debugger_names().count();
1182 self.workspace_status = format!(
1183 "root {}\n{} project · {} · branch {}\ngeneration {} · project revision {} · trust {:?}\nresident: {} agents · {} tasks · {} kernels · {} debuggers\nnext actions: Agent · Code · {} · {}",
1184 root,
1185 detection.languages.join("/"),
1186 detection.build_system.as_deref().unwrap_or("unknown build"),
1187 detection.git_branch.as_deref().unwrap_or("no Git"),
1188 generation,
1189 project_revision,
1190 trust,
1191 agent_count,
1192 task_count,
1193 kernel_count,
1194 debugger_count,
1195 detection
1196 .dev_command
1197 .as_deref()
1198 .map(|command| format!("run `{command}`"))
1199 .unwrap_or_else(|| "configure a dev command".into()),
1200 detection
1201 .browser_url
1202 .as_deref()
1203 .map(|url| format!("open App {url}"))
1204 .unwrap_or_else(|| "start App after a URL is detected".into()),
1205 );
1206 if self.workspace.trust().permits_project_execution()
1207 && let Ok(experiments) = self.workspace.experiments()
1208 {
1209 let snapshots = experiments.snapshots();
1210 self.experiments = if snapshots.is_empty() {
1211 "No experiments".into()
1212 } else {
1213 snapshots
1214 .iter()
1215 .map(|experiment| {
1216 format!(
1217 "{} {} · {:?} · port {} · agent {}",
1218 if experiment.evidence.tests_failed == 0
1219 && experiment.evidence.tests_passed > 0
1220 {
1221 "✓"
1222 } else {
1223 "○"
1224 },
1225 experiment.id,
1226 experiment.state,
1227 experiment
1228 .port
1229 .map_or_else(|| "—".into(), |port| port.to_string()),
1230 experiment
1231 .agent_id
1232 .as_ref()
1233 .map(|id| id.as_str())
1234 .unwrap_or("none")
1235 )
1236 })
1237 .collect::<Vec<_>>()
1238 .join("\n")
1239 };
1240 self.experiment_comparison = Some(experiments.compare());
1241 }
1242 }
1243
1244 pub fn apply_browser_result(&mut self, tool: &str, result: &serde_json::Value) {
1245 if tool == "glass.browser.observe" {
1246 let revision = result
1247 .pointer("/accessibility/revision")
1248 .and_then(serde_json::Value::as_u64);
1249 let title = result
1250 .pointer("/page/title")
1251 .and_then(serde_json::Value::as_str)
1252 .unwrap_or("Untitled");
1253 let url = result
1254 .pointer("/page/url")
1255 .and_then(serde_json::Value::as_str)
1256 .unwrap_or_default();
1257 if let Some(revision) = revision {
1258 self.browser_workspace
1259 .update_page(title, url, false, Some(revision));
1260 let entities = result
1261 .pointer("/accessibility/interactive")
1262 .and_then(serde_json::Value::as_array)
1263 .into_iter()
1264 .flatten()
1265 .filter_map(|entity| {
1266 Some(BrowserWorkspaceEntity {
1267 reference: entity.get("reference")?.as_str()?.into(),
1268 role: entity
1269 .get("role")
1270 .and_then(serde_json::Value::as_str)
1271 .unwrap_or("unknown")
1272 .into(),
1273 name: entity
1274 .get("name")
1275 .and_then(serde_json::Value::as_str)
1276 .unwrap_or("unnamed")
1277 .into(),
1278 actionable: true,
1279 revision,
1280 })
1281 })
1282 .collect();
1283 self.browser_workspace.replace_entities(revision, entities);
1284 }
1285 } else if tool == "glass.browser.stop" {
1286 self.browser_workspace.state_mut().connection = BrowserConnectionPhase::Detached;
1287 }
1288 self.browser = self.browser_workspace_summary();
1289 }
1290
1291 pub fn browser_workspace_summary(&self) -> String {
1292 let browser = self.browser_workspace.state();
1293 let entities = if browser.entities.is_empty() {
1294 "No current semantic entities".into()
1295 } else {
1296 browser
1297 .entities
1298 .iter()
1299 .enumerate()
1300 .skip(browser.semantic_scroll)
1301 .take(24)
1302 .map(|(index, entity)| {
1303 format!(
1304 "{} {} · {} · {}",
1305 if Some(index) == browser.selected_entity {
1306 "◆"
1307 } else {
1308 "○"
1309 },
1310 entity.name,
1311 entity.role,
1312 entity.reference
1313 )
1314 })
1315 .collect::<Vec<_>>()
1316 .join("\n")
1317 };
1318 format!(
1319 "{} · rev {} · {} · owner {:?}\n{}\n{}\n\nUNDERSTANDING\n{}",
1320 browser.connection_label(),
1321 browser
1322 .browser_revision
1323 .map_or_else(|| "—".into(), |revision| revision.to_string()),
1324 browser.presentation_label(),
1325 browser.input_owner,
1326 browser.title,
1327 browser.url,
1328 entities,
1329 )
1330 }
1331
1332 pub fn highlight_app_selection(&mut self) {
1333 let Some(entity) = self.browser_workspace.state().selected().cloned() else {
1334 return;
1335 };
1336 if let Err(error) = self
1337 .workspace
1338 .browser()
1339 .highlight(entity.reference, entity.revision)
1340 {
1341 let stale = error.to_string().to_lowercase().contains("stale");
1342 self.browser_workspace.fail_action(error.to_string(), stale);
1343 self.status = format!("App highlight failed: {error}");
1344 }
1345 }
1346
1347 pub fn execute_app_intent(&mut self, intent: BrowserWorkspaceIntent) {
1348 let action = match self.browser_workspace.reduce(intent) {
1349 Ok(Some(action)) => action,
1350 Ok(None) => return,
1351 Err(error) => {
1352 self.status = format!("App action unavailable: {error}");
1353 return;
1354 }
1355 };
1356 let result = match action {
1357 BrowserWorkspaceAction::Click {
1358 target,
1359 expected_revision,
1360 } => self.workspace.browser().click(target, expected_revision),
1361 BrowserWorkspaceAction::Scroll {
1362 dx,
1363 dy,
1364 expected_revision,
1365 } => self.workspace.browser().scroll(dx, dy, expected_revision),
1366 _ => return,
1367 };
1368 match result.and_then(|_| self.workspace.browser().observe()) {
1369 Ok(observation) => {
1370 self.apply_browser_result("glass.browser.observe", &observation);
1371 self.browser_detail = serde_json::to_string_pretty(&observation)
1372 .unwrap_or_else(|_| observation.to_string());
1373 self.status = "App action complete · semantic revision refreshed".into();
1374 }
1375 Err(error) => {
1376 let stale = error.to_string().to_lowercase().contains("stale");
1377 self.browser_workspace.fail_action(error.to_string(), stale);
1378 self.status = format!("App action failed: {error}");
1379 }
1380 }
1381 }
1382
1383 pub fn refresh_agent_readiness(&mut self) -> Result<bool, String> {
1384 let readiness = crate::pi_runtime::pi_readiness().map_err(|error| error.to_string())?;
1385 let ready = readiness.ready;
1386 self.agent_readiness = format_pi_readiness(&readiness);
1387 Ok(ready)
1388 }
1389}
1390
1391fn format_pi_readiness(readiness: &crate::PiReadiness) -> String {
1392 let provider = readiness.provider.as_deref().unwrap_or("not selected");
1393 let session = readiness.session.as_deref().unwrap_or("new session");
1394 let remediation = readiness
1395 .remediation
1396 .first()
1397 .map(|item| format!(" · next: {item}"))
1398 .unwrap_or_default();
1399 format!(
1400 "{} · Node {:?} · SDK {} · auth {:?} · provider {} · {}{}",
1401 if readiness.ready {
1402 "Ready"
1403 } else {
1404 "Needs setup"
1405 },
1406 readiness.node.state,
1407 readiness.sdk.version.as_deref().unwrap_or("missing"),
1408 readiness.authentication.state,
1409 provider,
1410 session,
1411 remediation,
1412 )
1413}
1414
1415fn format_agent_event(event: &crate::AgentEvent) -> String {
1416 let actor = event.agent_id.as_str();
1417 let text = event
1418 .payload
1419 .pointer("/message/content")
1420 .or_else(|| event.payload.pointer("/result/text"))
1421 .or_else(|| event.payload.get("text"))
1422 .and_then(serde_json::Value::as_str);
1423 match text {
1424 Some(text) => format!("{actor} · {}\n{}", event.kind, text),
1425 None if event.payload.is_null() => format!("{actor} · {}", event.kind),
1426 None => format!("{actor} · {} · details available in Inspect", event.kind),
1427 }
1428}
1429
1430fn fuzzy_contains(candidate: &str, query: &str) -> bool {
1431 if query.is_empty() {
1432 return true;
1433 }
1434 let mut query = query
1435 .chars()
1436 .map(|character| character.to_ascii_lowercase());
1437 let mut expected = query.next();
1438 for character in candidate
1439 .chars()
1440 .map(|character| character.to_ascii_lowercase())
1441 {
1442 if Some(character) == expected {
1443 expected = query.next();
1444 if expected.is_none() {
1445 return true;
1446 }
1447 }
1448 }
1449 false
1450}
1451
1452fn editor_offset(content: &str, line: u32, column: u32) -> usize {
1453 let mut offset = 0;
1454 for (index, value) in content.split_inclusive('\n').enumerate() {
1455 if index + 1 == line as usize {
1456 let column_bytes = value
1457 .trim_end_matches('\n')
1458 .char_indices()
1459 .nth(column.saturating_sub(1) as usize)
1460 .map(|(offset, _)| offset)
1461 .unwrap_or_else(|| value.trim_end_matches('\n').len());
1462 return offset + column_bytes;
1463 }
1464 offset += value.len();
1465 }
1466 content.len()
1467}