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}