Skip to main content

glass_dev/tui/
state.rs

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}