Skip to main content

glass_dev/tui/
state.rs

1use super::command;
2use crate::{DevelopmentWorkspace, ExperimentComparison};
3use glass_browser::cli::args::TuiLayout;
4use serde::{Deserialize, Serialize};
5use std::path::Path;
6
7#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
8pub enum DevSurface {
9    Trust,
10    Dashboard,
11    Editor,
12    Lsp,
13    Agent,
14    Agents,
15    Tasks,
16    Processes,
17    Debugger,
18    Git,
19    Tests,
20    Experiments,
21    Graph,
22    Replay,
23    Browser,
24    Workflow,
25    Kernels,
26    DaemonWorkspace,
27}
28
29impl DevSurface {
30    pub const ALL: [Self; 18] = [
31        Self::Trust,
32        Self::Dashboard,
33        Self::Editor,
34        Self::Lsp,
35        Self::Agent,
36        Self::Agents,
37        Self::Tasks,
38        Self::Processes,
39        Self::Debugger,
40        Self::Git,
41        Self::Tests,
42        Self::Experiments,
43        Self::Graph,
44        Self::Replay,
45        Self::Browser,
46        Self::Workflow,
47        Self::Kernels,
48        Self::DaemonWorkspace,
49    ];
50
51    pub fn label(self) -> &'static str {
52        match self {
53            Self::Trust => "Trust",
54            Self::Dashboard => "Dashboard",
55            Self::Editor => "Editor",
56            Self::Lsp => "LSP",
57            Self::Agent => "Glass Agent",
58            Self::Agents => "Agents",
59            Self::Tasks => "Tasks",
60            Self::Processes => "Processes",
61            Self::Debugger => "Debugger",
62            Self::Git => "Git",
63            Self::Tests => "Tests",
64            Self::Experiments => "Experiments",
65            Self::Graph => "Graph",
66            Self::Replay => "Replay",
67            Self::Browser => "Browser",
68            Self::Workflow => "Workflow",
69            Self::Kernels => "Kernels",
70            Self::DaemonWorkspace => "Daemon/Workspace",
71        }
72    }
73}
74
75#[derive(Debug, Clone, Copy, PartialEq, Eq)]
76pub enum ResponsiveClass {
77    Desktop,
78    Compact,
79    Phone,
80}
81
82pub struct DevTuiState {
83    pub workspace: DevelopmentWorkspace,
84    pub surface: DevSurface,
85    pub layout: TuiLayout,
86    pub quit: bool,
87    pub command_mode: bool,
88    pub command_input: String,
89    pub status: String,
90    pub agents: String,
91    pub tasks: String,
92    pub editor: String,
93    pub lsp: String,
94    pub processes: String,
95    pub git: String,
96    pub tests: String,
97    pub kernels: String,
98    pub debugger: String,
99    pub replay: String,
100    pub browser: String,
101    pub browser_detail: String,
102    pub workflow: String,
103    pub workspace_status: String,
104    pub experiment_comparison: Option<ExperimentComparison>,
105    pub experiments: String,
106}
107
108impl DevTuiState {
109    pub fn open(
110        root: impl AsRef<Path>,
111        layout: TuiLayout,
112    ) -> Result<Self, Box<dyn std::error::Error>> {
113        let workspace = DevelopmentWorkspace::open(root)?;
114        let trust_prompt = workspace.trust() == crate::WorkspaceTrust::Untrusted
115            && workspace
116                .trust_inspection()
117                .iter()
118                .any(|item| item.trust_required);
119        let mut state = Self {
120            workspace,
121            surface: if trust_prompt {
122                DevSurface::Trust
123            } else {
124                DevSurface::Dashboard
125            },
126            layout,
127            quit: false,
128            command_mode: false,
129            command_input: String::new(),
130            status: if trust_prompt {
131                "Workspace trust required · I inspect · O untrusted · 1 trust once · T trust project".into()
132            } else {
133                "Ready · : opens the command palette · q quits".into()
134            },
135            agents: String::new(),
136            tasks: String::new(),
137            editor: String::new(),
138            lsp: String::new(),
139            processes: String::new(),
140            git: String::new(),
141            tests: String::new(),
142            kernels: String::new(),
143            debugger: String::new(),
144            replay: String::new(),
145            browser: String::new(),
146            browser_detail: "No browser observation yet".into(),
147            workflow: "No workflow evidence yet".into(),
148            workspace_status: String::new(),
149            experiment_comparison: None,
150            experiments: "No experiments. :experiment create ID BRANCH [PORT]".into(),
151        };
152        state.refresh();
153        Ok(state)
154    }
155
156    pub fn responsive_class(&self, width: u16, height: u16) -> ResponsiveClass {
157        match self.layout {
158            TuiLayout::Desktop => ResponsiveClass::Desktop,
159            TuiLayout::Compact => ResponsiveClass::Compact,
160            TuiLayout::Mobile => ResponsiveClass::Phone,
161            TuiLayout::Auto if width < 72 || height < 22 => ResponsiveClass::Phone,
162            TuiLayout::Auto if width < 118 || height < 32 => ResponsiveClass::Compact,
163            TuiLayout::Auto => ResponsiveClass::Desktop,
164        }
165    }
166
167    pub fn open_palette(&mut self) {
168        self.command_mode = true;
169        self.command_input.clear();
170        self.status = "Command palette · type help for routes".into();
171    }
172
173    pub fn close_palette(&mut self) {
174        self.command_mode = false;
175        self.command_input.clear();
176        self.status = "Command cancelled".into();
177    }
178
179    pub fn submit_palette(&mut self) {
180        let input = std::mem::take(&mut self.command_input);
181        self.command_mode = false;
182        match command::execute(self, &input) {
183            Ok(message) => self.status = message,
184            Err(error) => self.status = format!("Error: {error}"),
185        }
186        self.refresh();
187    }
188
189    pub fn handle_printable(&mut self, character: char) {
190        if self.surface == DevSurface::Trust {
191            let decision = match character {
192                'i' | 'I' => {
193                    self.status = "Inspecting exact repository configuration".into();
194                    return;
195                }
196                'o' | 'O' => Some(crate::LocalTrustDecision::OpenUntrusted),
197                '1' => Some(crate::LocalTrustDecision::TrustOnce),
198                'T' => Some(crate::LocalTrustDecision::TrustProject),
199                _ => None,
200            };
201            if let Some(decision) = decision {
202                match self.workspace.apply_local_trust_decision(decision) {
203                    Ok(trust) => {
204                        self.surface = DevSurface::Dashboard;
205                        self.status = format!("Workspace opened with {trust:?} authority");
206                    }
207                    Err(error) => self.status = format!("Trust decision failed: {error}"),
208                }
209                return;
210            }
211        }
212        let surface = match character {
213            'u' => Some(DevSurface::Trust),
214            'h' => Some(DevSurface::Dashboard),
215            'e' => Some(DevSurface::Editor),
216            'l' => Some(DevSurface::Lsp),
217            'a' => Some(DevSurface::Agent),
218            'm' => Some(DevSurface::Agents),
219            'w' => Some(DevSurface::Tasks),
220            'p' => Some(DevSurface::Processes),
221            'd' => Some(DevSurface::Debugger),
222            'g' => Some(DevSurface::Git),
223            't' => Some(DevSurface::Tests),
224            'x' => Some(DevSurface::Experiments),
225            'n' => Some(DevSurface::Graph),
226            'r' => Some(DevSurface::Replay),
227            'b' => Some(DevSurface::Browser),
228            'f' => Some(DevSurface::Workflow),
229            'k' => Some(DevSurface::Kernels),
230            'z' => Some(DevSurface::DaemonWorkspace),
231            _ => None,
232        };
233        if let Some(surface) = surface {
234            self.surface = surface;
235            self.status = format!("{} · : for actions", surface.label());
236        }
237    }
238
239    pub fn next_surface(&mut self) {
240        let index = DevSurface::ALL
241            .iter()
242            .position(|surface| *surface == self.surface)
243            .unwrap_or(0);
244        self.surface = DevSurface::ALL[(index + 1) % DevSurface::ALL.len()];
245    }
246
247    pub fn previous_surface(&mut self) {
248        let index = DevSurface::ALL
249            .iter()
250            .position(|surface| *surface == self.surface)
251            .unwrap_or(0);
252        self.surface = DevSurface::ALL[(index + DevSurface::ALL.len() - 1) % DevSurface::ALL.len()];
253    }
254
255    pub fn refresh(&mut self) {
256        self.agents = match self.workspace.agents().list() {
257            Ok(agents) if agents.is_empty() => "No agents. :agent spawn ROLE TASK".into(),
258            Ok(agents) => agents
259                .iter()
260                .map(|agent| {
261                    format!(
262                        "{}  {:?}  {} · {}\n  target {} · model {} · thinking {} · events {} · dropped {}{}\n  evidence {}",
263                        agent.id.as_str(),
264                        agent.status,
265                        agent.role,
266                        agent.task,
267                        agent.worktree.display(),
268                        agent.model.as_deref().unwrap_or("default"),
269                        agent.thinking.as_deref().unwrap_or("default"),
270                        agent.event_count,
271                        agent.dropped_event_count,
272                        agent
273                            .last_error
274                            .as_deref()
275                            .map(|error| format!(" · {error}"))
276                            .unwrap_or_default(),
277                        agent
278                            .evidence
279                            .iter()
280                            .rev()
281                            .take(3)
282                            .map(|evidence| evidence.to_string())
283                            .collect::<Vec<_>>()
284                            .join(" · ")
285                    )
286                })
287                .collect::<Vec<_>>()
288                .join("\n\n"),
289            Err(error) => format!("Agent registry failed: {error}"),
290        };
291        self.tasks = match self.workspace.tasks() {
292            Ok(tasks) if tasks.is_empty() => {
293                "No tasks. :task create TITLE PROMPT creates an autonomous task".into()
294            }
295            Ok(tasks) => tasks
296                .iter()
297                .map(|task| {
298                    format!(
299                        "{}  {:?}  {}\n  goal {}\n  agent {} · attempt {} · model {} · thinking {}\n  depends {}\n  verification {}{}\n  evidence {}",
300                        task.id.as_str(),
301                        task.state,
302                        task.title,
303                        task.goal,
304                        task.assigned_agent
305                            .as_ref()
306                            .map(|agent| agent.as_str())
307                            .unwrap_or("unassigned"),
308                        task.attempt,
309                        task.model.as_deref().unwrap_or("default"),
310                        task.thinking.as_deref().unwrap_or("default"),
311                        task.dependencies
312                            .iter()
313                            .map(|dependency| dependency.as_str())
314                            .collect::<Vec<_>>()
315                            .join(", "),
316                        serde_json::to_string(&task.verification).unwrap_or_default(),
317                        task.last_error
318                            .as_deref()
319                            .map(|error| format!(" · {error}"))
320                            .unwrap_or_default(),
321                        task.evidence
322                            .iter()
323                            .rev()
324                            .take(3)
325                            .map(|evidence| format!("{}={:?}", evidence.kind, evidence.passed))
326                            .collect::<Vec<_>>()
327                            .join(" · ")
328                    )
329                })
330                .collect::<Vec<_>>()
331                .join("\n\n"),
332            Err(error) => format!("Task scheduler failed: {error}"),
333        };
334        self.processes = self
335            .workspace
336            .project_mut()
337            .processes()
338            .list_checked()
339            .and_then(|items| serde_json::to_string_pretty(&items).map_err(Into::into))
340            .unwrap_or_else(|error| format!("Process state failed: {error}"));
341        self.editor = serde_json::to_string_pretty(
342            &self
343                .workspace
344                .project()
345                .buffers()
346                .cloned()
347                .collect::<Vec<_>>(),
348        )
349        .unwrap_or_else(|error| format!("Editor state failed: {error}"));
350        self.lsp = {
351            let language = self.workspace.language();
352            serde_json::to_string_pretty(&serde_json::json!({
353                "servers": language.names().collect::<Vec<_>>(),
354                "events": language.events(0).into_iter().rev().take(32).collect::<Vec<_>>()
355            }))
356            .unwrap_or_else(|error| format!("LSP state failed: {error}"))
357        };
358        self.git = self
359            .workspace
360            .git()
361            .map(|git| match git.status() {
362                Ok(status) => serde_json::to_string_pretty(&status)
363                    .unwrap_or_else(|error| format!("Git serialization failed: {error}")),
364                Err(error) => format!("Git state failed: {error}"),
365            })
366            .unwrap_or_else(|| "Not a Git repository".into());
367        let _ = self.workspace.tests_mut().poll();
368        self.tests = serde_json::to_string_pretty(
369            &self
370                .workspace
371                .tests()
372                .results()
373                .rev()
374                .take(32)
375                .collect::<Vec<_>>(),
376        )
377        .unwrap_or_else(|error| error.to_string());
378        self.kernels =
379            serde_json::to_string_pretty(&self.workspace.kernels().snapshots().collect::<Vec<_>>())
380                .unwrap_or_else(|error| error.to_string());
381        let debugger_names = self
382            .workspace
383            .debugger_names()
384            .map(str::to_string)
385            .collect::<Vec<_>>();
386        self.debugger = if debugger_names.is_empty() {
387            "No debugger sessions. :debug start NAME COMMAND [ARGS...]".into()
388        } else {
389            let snapshots = debugger_names
390                .iter()
391                .map(|name| {
392                    self.workspace
393                        .debugger_mut(name)
394                        .and_then(|debugger| debugger.snapshot())
395                        .map(|snapshot| (name, snapshot))
396                })
397                .collect::<Result<Vec<_>, _>>();
398            match snapshots {
399                Ok(snapshots) => serde_json::to_string_pretty(&snapshots)
400                    .unwrap_or_else(|error| format!("Debugger serialization failed: {error}")),
401                Err(error) => format!("Debugger state failed: {error}"),
402            }
403        };
404        self.replay = self
405            .workspace
406            .intelligence()
407            .replay(0, 128)
408            .and_then(|events| serde_json::to_string_pretty(&events).map_err(Into::into))
409            .unwrap_or_else(|error| format!("Replay failed: {error}"));
410        self.browser = self
411            .workspace
412            .browser()
413            .state()
414            .and_then(|state| serde_json::to_string_pretty(&state).map_err(Into::into))
415            .unwrap_or_else(|error| format!("Browser state failed: {error}"));
416        self.workflow = self
417            .workspace
418            .browser()
419            .list_workflows()
420            .and_then(|state| serde_json::to_string_pretty(&state).map_err(Into::into))
421            .unwrap_or_else(|error| format!("Workflow state failed: {error}"));
422        let root = self.workspace.root().display().to_string();
423        let generation = self.workspace.generation();
424        let project_revision = self.workspace.project().revision();
425        let trust = self.workspace.trust();
426        let agent_count = self
427            .workspace
428            .agents()
429            .list()
430            .map(|items| items.len())
431            .unwrap_or(0);
432        let task_count = self.workspace.tasks().map(|items| items.len()).unwrap_or(0);
433        let kernel_count = self.workspace.kernels().snapshots().count();
434        let debugger_count = self.workspace.debugger_names().count();
435        self.workspace_status = format!(
436            "root {}\ngeneration {}\nproject revision {}\ntrust {:?}\nresident resources: {} agents · {} tasks · {} kernels · {} debuggers",
437            root,
438            generation,
439            project_revision,
440            trust,
441            agent_count,
442            task_count,
443            kernel_count,
444            debugger_count,
445        );
446        if self.workspace.trust().permits_project_execution()
447            && let Ok(experiments) = self.workspace.experiments()
448        {
449            self.experiments = serde_json::to_string_pretty(&experiments.snapshots())
450                .unwrap_or_else(|error| format!("Experiment state failed: {error}"));
451            self.experiment_comparison = Some(experiments.compare());
452        }
453    }
454}