1use super::command;
2use super::editor::{
3 self as native, EditorEngine, EditorMode, GhostText, Motion, Operator, TextObject,
4 apply_motion, compile_prove_it, complete_mention, evidence_card, expand_mentions,
5 inferred_app_path, join_app_url, line_hunks, local_fim, multi_delete, multi_insert,
6 next_edit_after_accept, pair_apply_caret, pair_apply_step, parse_inlay_hints, same_word_ranges,
7 split_ghost_word, textobject_from_key, textobject_selection,
8};
9use super::parse::IncrementalSyntax;
10use crate::development::TextSelection;
11use crate::{ExperimentComparison, SharedDevelopmentWorkspace};
12use glass_browser::browser::WorkflowRecorder;
13use glass_browser::browser::policy::PolicyPreset;
14use glass_browser::browser::session::VerificationPredicate;
15use glass_browser::browser_workspace::{
16 BrowserConnectionPhase, BrowserWorkspaceAction, BrowserWorkspaceAdapterKind,
17 BrowserWorkspaceController, BrowserWorkspaceEntity, BrowserWorkspaceIntent,
18 BrowserWorkspaceLayout, BrowserWorkspaceTarget,
19};
20use glass_browser::cli::args::TuiLayout;
21use glass_browser::terminal_graphics::AnsiCanvas;
22use glass_browser::tui::live_view::AnsiPane;
23use serde::{Deserialize, Serialize};
24use std::path::Path;
25use std::sync::atomic::{AtomicU64, Ordering};
26
27static NEXT_BROWSER_TOOL: AtomicU64 = AtomicU64::new(1);
28
29pub struct PendingConfirmation {
30 pub call: crate::development::ToolCall,
31 pub context: crate::tools::DevelopmentToolContext,
32 pub summary: String,
33}
34
35#[derive(Debug, Clone)]
36pub struct TuiWorkflowRecording {
37 pub name: String,
38 pub recorder: WorkflowRecorder,
39 step: usize,
40}
41
42impl TuiWorkflowRecording {
43 fn next_id(&mut self) -> String {
44 self.step += 1;
45 format!("step-{}", self.step)
46 }
47}
48
49enum PendingFim {
50 Thread {
51 path: String,
52 offset: usize,
53 rx: std::sync::mpsc::Receiver<Option<String>>,
54 },
55 Pi {
56 path: String,
57 offset: usize,
58 agent_id: crate::AgentId,
59 since: u64,
60 },
61}
62
63impl PendingFim {
64 fn path(&self) -> &str {
65 match self {
66 Self::Thread { path, .. } | Self::Pi { path, .. } => path,
67 }
68 }
69
70 fn offset(&self) -> usize {
71 match self {
72 Self::Thread { offset, .. } | Self::Pi { offset, .. } => *offset,
73 }
74 }
75}
76
77#[derive(Debug, Clone)]
78pub struct PendingAgentApproval {
79 pub agent_id: String,
80 pub frame_id: String,
81 pub tool_name: String,
82 pub arguments: serde_json::Value,
83}
84
85#[derive(Debug, Clone, Copy, PartialEq, Eq)]
86pub enum ChatMessageState {
87 Sending,
88 Sent,
89 Failed,
90}
91
92#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
93pub struct WorkspacePlan {
94 pub id: String,
95 pub goal: String,
96 pub body: String,
97 pub accepted: bool,
98}
99
100#[derive(Debug, Clone, PartialEq, Eq)]
101pub struct SessionPickerItem {
102 pub path: String,
103 pub label: String,
104}
105
106#[derive(Debug, Clone, PartialEq, Eq)]
107pub struct ProcessRow {
108 pub name: String,
109 pub command: String,
110 pub pid: Option<u32>,
111 pub health: crate::development::ProcessHealth,
112 pub url: Option<String>,
113}
114
115impl ProcessRow {
116 pub fn from_snapshot(item: &crate::development::ProcessSnapshot) -> Self {
117 Self {
118 name: item.name.clone(),
119 command: item.command.clone(),
120 pid: item.pid,
121 health: item.health.clone(),
122 url: item.detected_urls.first().cloned(),
123 }
124 }
125}
126
127#[derive(Debug, Clone, PartialEq, Eq)]
128pub struct DebugSessionRow {
129 pub name: String,
130 pub state: crate::debugger::DebugSessionState,
131 pub pid: u32,
132 pub breakpoints: usize,
133 pub watches: usize,
134}
135
136#[derive(Debug, Clone, PartialEq, Eq)]
137pub struct DebugScopeRow {
138 pub name: String,
139 pub variables_reference: i64,
140}
141
142#[derive(Debug, Clone, PartialEq, Eq)]
143pub struct DebugVariableRow {
144 pub name: String,
145 pub value: String,
146}
147
148#[derive(Debug, Clone, PartialEq, Eq)]
149pub struct DebugThreadRow {
150 pub id: i64,
151 pub name: String,
152}
153
154#[derive(Debug, Clone, PartialEq, Eq)]
155pub struct DebugFrameRow {
156 pub id: i64,
157 pub name: String,
158 pub path: Option<String>,
159 pub line: Option<u64>,
160}
161
162#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
163pub enum DebugPane {
164 #[default]
165 Sessions,
166 Threads,
167 Frames,
168}
169
170impl DebugPane {
171 pub fn label(self) -> &'static str {
172 match self {
173 Self::Sessions => "sessions",
174 Self::Threads => "threads",
175 Self::Frames => "frames",
176 }
177 }
178
179 fn next(self) -> Self {
180 match self {
181 Self::Sessions => Self::Threads,
182 Self::Threads => Self::Frames,
183 Self::Frames => Self::Sessions,
184 }
185 }
186
187 fn previous(self) -> Self {
188 match self {
189 Self::Sessions => Self::Frames,
190 Self::Threads => Self::Sessions,
191 Self::Frames => Self::Threads,
192 }
193 }
194}
195
196#[derive(Debug, Clone, PartialEq, Eq)]
197pub struct PendingChatMessage {
198 pub text: String,
199 pub state: ChatMessageState,
200 pub job_id: Option<u64>,
201 pub error: Option<String>,
202}
203
204#[derive(Debug, Clone, PartialEq, Eq)]
206pub struct BrowserRecoveryOffer {
207 pub reason: String,
208 pub port: u16,
209 pub compatible_endpoint: bool,
211}
212
213impl BrowserRecoveryOffer {
214 pub fn from_error(error: &str, port: u16) -> Self {
215 let lower = error.to_ascii_lowercase();
216 Self {
217 reason: error.to_string(),
218 port,
219 compatible_endpoint: ["attach", "devtools", "page target", "multiple page targets"]
220 .iter()
221 .any(|marker| lower.contains(marker)),
222 }
223 }
224
225 pub fn actions(&self) -> &'static [(&'static str, &'static str)] {
226 if self.compatible_endpoint {
227 &[
228 ("1", "attach after checking the running browser"),
229 ("2", "launch an isolated browser on an automatic free port"),
230 ("3", "retry the preferred port"),
231 ("Esc", "dismiss"),
232 ]
233 } else {
234 &[
235 ("1", "launch an isolated browser on an automatic free port"),
236 ("2", "retry the preferred port"),
237 ("Esc", "dismiss"),
238 ]
239 }
240 }
241
242 pub fn guidance(&self) -> &'static str {
243 let lower = self.reason.to_ascii_lowercase();
244 if self.compatible_endpoint {
245 "A DevTools endpoint answered. Attach only when its page is the intended browser; otherwise launch an isolated session."
246 } else if lower.contains("occup") || lower.contains("address") || lower.contains("port") {
247 "The preferred endpoint is busy or unavailable. Glass keeps the project and agent alive while you retry or move to an automatic free port."
248 } else {
249 "The browser did not become usable. Check Chrome/Chromium availability, then retry; the workspace remains intact."
250 }
251 }
252}
253
254#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
255pub enum DevSurface {
256 Trust,
257 Agent,
258 Code,
259 App,
260 Terminal,
261 Tasks,
262 Git,
263 Debug,
264 More,
265}
266
267impl DevSurface {
268 pub const ALL: [Self; 8] = [
269 Self::Agent,
270 Self::Code,
271 Self::App,
272 Self::Terminal,
273 Self::Tasks,
274 Self::Git,
275 Self::Debug,
276 Self::More,
277 ];
278
279 pub const PRIMARY: [Self; 8] = [
280 Self::Agent,
281 Self::Code,
282 Self::App,
283 Self::Terminal,
284 Self::Tasks,
285 Self::Git,
286 Self::Debug,
287 Self::More,
288 ];
289
290 pub const PHONE: [Self; 5] = [Self::Agent, Self::Code, Self::App, Self::Tasks, Self::More];
291
292 pub fn label(self) -> &'static str {
293 match self {
294 Self::Trust => "Trust",
295 Self::Agent => "Agent",
296 Self::Code => "Code",
297 Self::App => "App",
298 Self::Terminal => "Terminal",
299 Self::Tasks => "Tasks",
300 Self::Git => "Git",
301 Self::Debug => "Debug",
302 Self::More => "More",
303 }
304 }
305}
306
307#[derive(Debug, Clone, Copy, PartialEq, Eq)]
308pub enum ResponsiveClass {
309 Desktop,
310 Compact,
311 Phone,
312}
313
314#[derive(Debug, Clone, Copy, PartialEq, Eq)]
315pub enum EditorExitPrompt {
316 Clean,
317 Unsaved,
318}
319
320#[derive(Debug, Clone, Copy, PartialEq, Eq)]
321pub enum ProductMode {
322 Build,
323 Agent,
324 RunApp,
325 Debug,
326}
327
328impl ProductMode {
329 pub fn label(self) -> &'static str {
330 match self {
331 Self::Build => "build",
332 Self::Agent => "agent",
333 Self::RunApp => "run",
334 Self::Debug => "debug",
335 }
336 }
337}
338
339pub struct DevTuiState {
340 pub workspace: SharedDevelopmentWorkspace,
341 pub surface: DevSurface,
342 pub layout: TuiLayout,
343 pub yolo_mode: bool,
345 pub quit_confirmation: bool,
346 pub quit: bool,
347 pub command_mode: bool,
348 pub command_input: String,
349 pub command_cursor: usize,
350 pub command_history: Vec<String>,
351 pub command_history_index: Option<usize>,
352 pub palette_error: Option<String>,
353 pub palette_scroll: u16,
354 pub palette_selection: usize,
356 pub menu_open: bool,
357 pub menu_selection: usize,
358 pub help_open: bool,
359 pub help_scroll: u16,
360 pub composer_mode: bool,
361 pub composer_run_mode: crate::AgentTurnMode,
362 pub pending_plan: Option<WorkspacePlan>,
363 pub composer_input: String,
364 pub composer_cursor: usize,
365 pub composer_steer: bool,
366 pub last_app_comment: Option<String>,
367 pub session_todos: crate::SessionTodoList,
368 pub composer_history: Vec<String>,
369 pub composer_history_index: Option<usize>,
370 pub composer_history_draft: String,
371 pub file_picker_open: bool,
372 pub file_picker_query: String,
373 pub file_picker_cursor: usize,
374 pub file_picker_selection: usize,
375 pub transcript_selection: usize,
376 pub transcript_expanded: bool,
377 pub session_picker_open: bool,
378 pub session_picker_items: Vec<SessionPickerItem>,
379 pub session_picker_selection: usize,
380 pub conversation_items: Vec<super::projection::ConversationEntry>,
381 pub agent_model: String,
382 pub agent_thinking: String,
383 pub agent_session_name: String,
384 pub agent_token_summary: String,
385 pub git_branch: String,
386 pub git_dirty: bool,
387 pub git_ahead: u64,
388 pub git_behind: u64,
389 pub git_conflicts: Vec<String>,
390 pub github_review_requested: bool,
391 pub pending_trust: Option<crate::LocalTrustDecision>,
392 pub pending_open_file: Option<String>,
393 pub pending_chat_messages: Vec<PendingChatMessage>,
394 pub agent_send_job: Option<u64>,
395 pub selected_agent: Option<crate::AgentId>,
396 pub pending_confirmation: Option<PendingConfirmation>,
397 pub pending_browser_navigation: Option<String>,
399 pub pending_page_entity: Option<String>,
400 pub process_urls: Vec<String>,
401 pub pending_agent_approval: Option<PendingAgentApproval>,
402 pub editor_exit_prompt: Option<EditorExitPrompt>,
403 pub queued_tool_request: Option<(
404 crate::development::ToolCall,
405 crate::tools::DevelopmentToolContext,
406 )>,
407 pub running_tool_job: Option<u64>,
408 pub surface_scroll: std::collections::BTreeMap<DevSurface, usize>,
409 pub terminal_width: u16,
410 pub terminal_height: u16,
411 pub status: String,
412 pub snapshot_root: String,
413 pub snapshot_trust_label: String,
414 pub snapshot_trust_inspection: Vec<crate::customization::CustomizationInspectionItem>,
415 pub snapshot_project_revision: u64,
416 pub snapshot_generation: u64,
417 pub snapshot_skills_count: usize,
418 pub snapshot_tools_count: usize,
419 pub refresh_latency_ms: u64,
421 pub conversation_cursor: u64,
423 pub editor_buffer_index: usize,
425 pub focused_editor_path: String,
426 pub focused_editor_content: String,
428 pub focused_editor_dirty: bool,
429 pub focused_editor_line: u32,
430 pub focused_editor_column: u32,
431 pub focused_editor_selection: Option<crate::development::TextSelection>,
432 pub editor_comments: Vec<crate::development::EditorComment>,
433 pub editor_proposals: Vec<crate::development::EditorProposal>,
434 pub editor_checkpoints: Vec<crate::development::EditorCheckpoint>,
435 pub editor_diagnostics: Vec<crate::development::LanguageDiagnostic>,
436 pub editor_inlays: Vec<(u32, String)>,
437 pub last_crew_wake: Option<String>,
438 pub agents: String,
439 pub agent_readiness: String,
440 pub harnesses: String,
441 pub agent_login_requested: bool,
444 pub harness_launch_requested: Option<String>,
447 pub agent_conversation: String,
448 pub tasks: String,
449 pub editor: String,
450 pub files: Vec<String>,
451 pub selected_file: usize,
452 pub code_edit_mode: bool,
453 pub editor_soft_wrap: bool,
454 pub editor_scroll_line: usize,
455 pub editor_scroll_column: usize,
456 pub editor_engine: EditorEngine,
457 pub syntax: IncrementalSyntax,
458 pub last_verify: Option<String>,
459 pub last_proof_ok: Option<bool>,
460 pub pending_verify: Option<serde_json::Value>,
461 pub factory_split: bool,
462 pub lsp: String,
463 pub processes: String,
464 pub process_entries: Vec<ProcessRow>,
465 pub selected_process: usize,
466 pub process_logs: String,
467 pub process_logs_requested: bool,
468 pub git: String,
469 pub git_entries: Vec<crate::git::GitStatusEntry>,
470 pub github: crate::github::GitHubStatus,
471 pub github_review: String,
472 pub selected_git_file: usize,
473 pub git_diff_path: Option<String>,
474 pub git_diff: String,
475 pub git_diff_open: bool,
476 pub git_diff_requested: bool,
477 pub tests: String,
478 pub kernels: String,
479 pub debugger: String,
480 pub debug_sessions: Vec<DebugSessionRow>,
481 pub selected_debug_session: usize,
482 pub debug_threads: Vec<DebugThreadRow>,
483 pub selected_debug_thread: usize,
484 pub debug_frames: Vec<DebugFrameRow>,
485 pub selected_debug_frame: usize,
486 pub debug_pane: DebugPane,
487 pub debug_threads_requested: bool,
488 pub debug_stack_requested: bool,
489 pub debug_scopes: Vec<DebugScopeRow>,
490 pub selected_debug_scope: usize,
491 pub debug_variables: Vec<DebugVariableRow>,
492 pub debug_scopes_requested: bool,
493 pub debug_variables_requested: bool,
494 pub selected_todo: usize,
495 pub selected_more: usize,
496 pub more_result: String,
497 pub replay: String,
498 pub browser: String,
499 pub browser_detail: String,
500 pub browser_workspace: BrowserWorkspaceController,
501 pub browser_recovery: Option<BrowserRecoveryOffer>,
502 pub browser_target_picker: bool,
503 pub browser_target_picker_requested: bool,
504 pub browser_target_query: String,
505 pub browser_target_selection: usize,
506 pub browser_visual_live: bool,
507 pub browser_observe_pending: bool,
508 pub browser_ansi: AnsiCanvas,
509 pub browser_pane: Option<AnsiPane>,
510 pub workflow: String,
511 pub workspace_status: String,
512 pub experiment_comparison: Option<ExperimentComparison>,
513 pub experiments: String,
514 pub cockpit_url: String,
515 pub private_cockpit: Option<crate::development::LocalCockpit>,
516 pub workflow_recording: Option<TuiWorkflowRecording>,
517 pending_fim: Option<PendingFim>,
518}
519
520impl DevTuiState {
521 pub fn ws(&self) -> Result<std::sync::MutexGuard<'_, crate::DevelopmentWorkspace>, String> {
523 self.workspace.try_lock().map_err(|error| error.to_string())
524 }
525
526 pub fn ws_mut(&self) -> Result<std::sync::MutexGuard<'_, crate::DevelopmentWorkspace>, String> {
528 self.workspace.try_lock().map_err(|error| error.to_string())
529 }
530
531 fn locked<F, T>(&mut self, operation: F) -> Option<T>
534 where
535 F: FnOnce(&mut crate::DevelopmentWorkspace) -> T,
536 {
537 match self.workspace.try_lock() {
538 Ok(mut workspace) => Some(operation(&mut workspace)),
539 Err(error) => {
540 self.status = format!("Workspace lock failed: {error}");
541 None
542 }
543 }
544 }
545
546 pub fn product_mode(&self) -> ProductMode {
547 match self.surface {
548 DevSurface::Agent => ProductMode::Agent,
549 DevSurface::App => ProductMode::RunApp,
550 DevSurface::Debug => ProductMode::Debug,
551 _ => ProductMode::Build,
552 }
553 }
554 pub fn open(
555 root: impl AsRef<Path>,
556 layout: TuiLayout,
557 ) -> Result<Self, Box<dyn std::error::Error>> {
558 Self::open_internal(root, layout, true, false, PolicyPreset::Development)
559 }
560
561 pub fn open_for_tui(
565 root: impl AsRef<Path>,
566 layout: TuiLayout,
567 ) -> Result<Self, Box<dyn std::error::Error>> {
568 Self::open_internal(root, layout, false, false, PolicyPreset::Development)
569 }
570
571 pub fn open_for_tui_with_mode(
573 root: impl AsRef<Path>,
574 layout: TuiLayout,
575 yolo_mode: bool,
576 ) -> Result<Self, Box<dyn std::error::Error>> {
577 Self::open_for_tui_with_policy(root, layout, yolo_mode, PolicyPreset::Development)
578 }
579
580 pub fn open_for_tui_with_policy(
582 root: impl AsRef<Path>,
583 layout: TuiLayout,
584 yolo_mode: bool,
585 policy_preset: PolicyPreset,
586 ) -> Result<Self, Box<dyn std::error::Error>> {
587 Self::open_internal(root, layout, false, yolo_mode, policy_preset)
588 }
589
590 fn open_internal(
591 root: impl AsRef<Path>,
592 layout: TuiLayout,
593 initial_refresh: bool,
594 yolo_mode: bool,
595 policy_preset: PolicyPreset,
596 ) -> Result<Self, Box<dyn std::error::Error>> {
597 let workspace = SharedDevelopmentWorkspace::open_with_policy(root, policy_preset)?;
598 if yolo_mode {
599 let mut workspace = workspace.lock()?;
600 workspace.agents().set_default_unrestricted(true);
601 }
602 let locked = workspace.lock()?;
603 let trust = locked.trust();
604 let trust_inspection = locked.trust_inspection();
605 let snapshot_root = locked.root().display().to_string();
606 let snapshot_project_revision = locked.project().revision();
607 let snapshot_generation = locked.generation();
608 let snapshot_skills_count = locked.customization().skills().count();
609 let snapshot_tools_count = locked.customization().config().tools.len();
610 let trust_prompt = trust == crate::WorkspaceTrust::Untrusted
611 && trust_inspection.iter().any(|item| item.trust_required);
612 drop(locked);
613 let agent_readiness = crate::pi_runtime::pi_readiness()
614 .map(|readiness| format_pi_readiness(&readiness))
615 .unwrap_or_else(|error| format!("Agent unavailable · {error}"));
616 let initial_status = if trust_prompt {
617 "Trust required · I inspect · O untrusted · 1 once · T project".to_string()
618 } else if agent_readiness.starts_with("✓ Ready") {
619 "Ready · Enter chat · Ctrl-P files · : commands · ? help".to_string()
620 } else {
621 "Pi setup required · press :actions or Enter to continue".to_string()
622 };
623 let mut state = Self {
624 workspace,
625 surface: if trust_prompt {
626 DevSurface::Trust
627 } else {
628 DevSurface::Agent
629 },
630 layout,
631 yolo_mode,
632 quit: false,
633 quit_confirmation: false,
634 command_mode: false,
635 command_input: String::new(),
636 command_cursor: 0,
637 command_history: Vec::new(),
638 command_history_index: None,
639 palette_error: None,
640 palette_scroll: 0,
641 palette_selection: 0,
642 menu_open: false,
643 menu_selection: 0,
644 help_open: false,
645 help_scroll: 0,
646 composer_mode: false,
647 composer_run_mode: crate::AgentTurnMode::Agent,
648 pending_plan: None,
649 composer_input: String::new(),
650 composer_cursor: 0,
651 composer_steer: false,
652 last_app_comment: None,
653 session_todos: crate::SessionTodoList::default(),
654 composer_history: Vec::new(),
655 composer_history_index: None,
656 composer_history_draft: String::new(),
657 file_picker_open: false,
658 file_picker_query: String::new(),
659 file_picker_cursor: 0,
660 file_picker_selection: 0,
661 transcript_selection: 0,
662 transcript_expanded: false,
663 session_picker_open: false,
664 session_picker_items: Vec::new(),
665 session_picker_selection: 0,
666 conversation_items: Vec::new(),
667 agent_model: String::new(),
668 agent_thinking: String::new(),
669 agent_session_name: String::new(),
670 agent_token_summary: String::new(),
671 git_branch: String::new(),
672 git_dirty: false,
673 git_ahead: 0,
674 git_behind: 0,
675 git_conflicts: Vec::new(),
676 github_review_requested: false,
677 pending_trust: None,
678 pending_open_file: None,
679 pending_chat_messages: Vec::new(),
680 agent_send_job: None,
681 selected_agent: None,
682 pending_confirmation: None,
683 editor_exit_prompt: None,
684 pending_agent_approval: None,
685 pending_browser_navigation: None,
686 pending_page_entity: None,
687 process_urls: Vec::new(),
688 queued_tool_request: None,
689 running_tool_job: None,
690 surface_scroll: std::collections::BTreeMap::new(),
691 terminal_width: 80,
692 terminal_height: 24,
693 snapshot_root,
694 snapshot_trust_label: trust.label().into(),
695 snapshot_trust_inspection: trust_inspection,
696 snapshot_project_revision,
697 snapshot_generation,
698 snapshot_skills_count,
699 snapshot_tools_count,
700 refresh_latency_ms: 0,
701 conversation_cursor: 0,
702 editor_buffer_index: 0,
703 focused_editor_path: String::new(),
704 focused_editor_content: String::new(),
705 focused_editor_dirty: false,
706 focused_editor_line: 0,
707 focused_editor_column: 0,
708 focused_editor_selection: None,
709 editor_comments: Vec::new(),
710 editor_proposals: Vec::new(),
711 editor_checkpoints: Vec::new(),
712 editor_diagnostics: Vec::new(),
713 editor_inlays: Vec::new(),
714 last_crew_wake: None,
715 status: initial_status,
716 agents: String::new(),
717 agent_readiness,
718 harnesses: crate::harness::summary(),
719 agent_login_requested: false,
720 harness_launch_requested: None,
721 agent_conversation:
722 "No conversation yet. Press Enter or start typing to compose a message.".into(),
723 tasks: String::new(),
724 editor: String::new(),
725 files: Vec::new(),
726 selected_file: 0,
727 code_edit_mode: false,
728 editor_soft_wrap: false,
729 editor_scroll_line: 0,
730 editor_scroll_column: 0,
731 editor_engine: EditorEngine {
732 mode: EditorMode::Insert,
733 ..EditorEngine::default()
734 },
735 syntax: IncrementalSyntax::new(),
736 last_verify: None,
737 last_proof_ok: None,
738 pending_verify: None,
739 factory_split: true,
740 lsp: String::new(),
741 processes: String::new(),
742 process_entries: Vec::new(),
743 selected_process: 0,
744 process_logs: String::new(),
745 process_logs_requested: false,
746 git: String::new(),
747 git_entries: Vec::new(),
748 github: crate::github::GitHubStatus::default(),
749 github_review: "No GitHub review yet".into(),
750 selected_git_file: 0,
751 git_diff_path: None,
752 git_diff: String::new(),
753 git_diff_open: false,
754 git_diff_requested: false,
755 tests: String::new(),
756 kernels: String::new(),
757 debugger: String::new(),
758 debug_sessions: Vec::new(),
759 selected_debug_session: 0,
760 debug_threads: Vec::new(),
761 selected_debug_thread: 0,
762 debug_frames: Vec::new(),
763 selected_debug_frame: 0,
764 debug_pane: DebugPane::Sessions,
765 debug_threads_requested: false,
766 debug_stack_requested: false,
767 debug_scopes: Vec::new(),
768 selected_debug_scope: 0,
769 debug_variables: Vec::new(),
770 debug_scopes_requested: false,
771 debug_variables_requested: false,
772 selected_todo: 0,
773 selected_more: 0,
774 more_result: String::new(),
775 replay: String::new(),
776 browser: String::new(),
777 browser_detail: "No browser observation yet".into(),
778 browser_workspace: BrowserWorkspaceController::for_adapter(
779 match layout {
780 TuiLayout::Mobile => BrowserWorkspaceLayout::Phone,
781 TuiLayout::Compact => BrowserWorkspaceLayout::Compact,
782 TuiLayout::Auto | TuiLayout::Desktop => BrowserWorkspaceLayout::Desktop,
783 },
784 BrowserWorkspaceAdapterKind::EmbeddedDevelopment,
785 ),
786 browser_recovery: None,
787 browser_target_picker: false,
788 browser_target_picker_requested: false,
789 browser_target_query: String::new(),
790 browser_target_selection: 0,
791 browser_visual_live: false,
792 browser_observe_pending: false,
793 browser_ansi: AnsiCanvas::default(),
794 browser_pane: None,
795 workflow: "No workflow evidence yet".into(),
796 workspace_status: String::new(),
797 experiment_comparison: None,
798 experiments: "No experiments. :experiment create ID BRANCH [PORT]".into(),
799 cockpit_url: String::new(),
800 private_cockpit: None,
801 workflow_recording: None,
802 pending_fim: None,
803 };
804 if initial_refresh {
805 state.refresh();
806 }
807 Ok(state)
808 }
809
810 pub fn responsive_class(&self, width: u16, height: u16) -> ResponsiveClass {
811 match self.layout {
812 TuiLayout::Desktop => ResponsiveClass::Desktop,
813 TuiLayout::Compact => ResponsiveClass::Compact,
814 TuiLayout::Mobile => ResponsiveClass::Phone,
815 TuiLayout::Auto if width < 72 || height < 22 => ResponsiveClass::Phone,
816 TuiLayout::Auto if width < 118 || height < 32 => ResponsiveClass::Compact,
817 TuiLayout::Auto => ResponsiveClass::Desktop,
818 }
819 }
820
821 pub fn request_quit(&mut self) {
822 if self.quit {
823 return;
824 }
825 self.quit_confirmation = true;
826 self.status = "Quit confirmation · Enter exits · Esc stays".into();
827 }
828
829 pub fn confirm_quit(&mut self) {
830 self.quit_confirmation = false;
831 self.quit = true;
832 self.status = "Closing Glass Dev".into();
833 }
834
835 pub fn cancel_quit(&mut self) {
836 self.quit_confirmation = false;
837 self.status = "Quit dismissed · workspace remains open".into();
838 }
839
840 pub fn quit_menu_index(&self) -> usize {
841 self.surface_actions().len() + 1
842 }
843
844 pub fn surface_actions(&self) -> &'static [command::SurfaceAction] {
846 command::surface_actions(self.surface)
847 }
848
849 pub fn toggle_help(&mut self) {
850 self.help_open = !self.help_open;
851 self.help_scroll = 0;
852 self.status = if self.help_open {
853 "Help · j/k scroll · ? or Esc closes".into()
854 } else {
855 "Help closed".into()
856 };
857 }
858
859 pub fn scroll_help(&mut self, delta: i32) {
860 self.help_scroll = (self.help_scroll as i32 + delta).max(0) as u16;
861 }
862
863 pub fn open_menu(&mut self) {
864 self.menu_open = true;
865 self.menu_selection = 0;
866 self.status = format!("Command center · {}", self.surface.label());
867 }
868
869 pub fn close_menu(&mut self) {
870 self.menu_open = false;
871 }
872
873 pub fn start_private_cockpit(&mut self) -> Result<String, String> {
874 if let Some(cockpit) = self.private_cockpit.as_ref() {
875 return Ok(cockpit.local_url());
876 }
877 let cockpit = crate::development::LocalCockpit::start(self.workspace.clone())
878 .map_err(|error| error.to_string())?;
879 let url = cockpit.local_url();
880 self.cockpit_url = url.clone();
881 self.private_cockpit = Some(cockpit);
882 self.status = format!("Private cockpit ready · {url}");
883 Ok(url)
884 }
885
886 pub fn stop_private_cockpit(&mut self) {
887 if self.private_cockpit.take().is_some() {
888 self.cockpit_url.clear();
889 self.status = "Private cockpit stopped".into();
890 } else {
891 self.status = "Private cockpit is not running".into();
892 }
893 }
894
895 pub fn private_cockpit_status(&self) -> String {
896 self.private_cockpit
897 .as_ref()
898 .map(|cockpit| format!("running · {}", cockpit.local_url()))
899 .unwrap_or_else(|| "not running · use `cockpit start`".into())
900 }
901
902 pub fn start_workflow_recording(&mut self, name: &str) -> Result<String, String> {
903 if let Some(recording) = &self.workflow_recording {
904 return Err(format!(
905 "already recording {} · :workflow record stop first",
906 recording.name
907 ));
908 }
909 let name = workflow_slug(name);
910 self.workflow_recording = Some(TuiWorkflowRecording {
911 name: name.clone(),
912 recorder: WorkflowRecorder::new(name.clone(), "1.0.0"),
913 step: 0,
914 });
915 self.surface = DevSurface::App;
916 self.refresh_workflow_recording_status();
917 self.status = format!("Recording {name} · Enter activates and records locators");
918 Ok(self.status.clone())
919 }
920
921 pub fn workflow_recording_status(&self) -> String {
922 match &self.workflow_recording {
923 Some(recording) => format!(
924 "recording {} · {} step(s)",
925 recording.name,
926 recording.recorder.draft().steps.len()
927 ),
928 None => "not recording · :workflow record start NAME".into(),
929 }
930 }
931
932 pub fn capture_workflow_click(&mut self) -> Result<bool, String> {
933 if self.workflow_recording.is_none() {
934 return Ok(false);
935 }
936 let selected = self
937 .browser_workspace
938 .state()
939 .selected()
940 .cloned()
941 .filter(|entity| entity.actionable)
942 .ok_or("no actionable semantic entity is selected")?;
943 let Some(recording) = self.workflow_recording.as_mut() else {
944 return Ok(false);
945 };
946 let id = recording.next_id();
947 recording
948 .recorder
949 .record_click(id, selected.role, selected.name, None)
950 .map_err(|error| error.to_string())?;
951 self.refresh_workflow_recording_status();
952 Ok(true)
953 }
954
955 pub fn record_workflow_type(&mut self, input_name: &str) -> Result<String, String> {
956 let selected = self
957 .browser_workspace
958 .state()
959 .selected()
960 .cloned()
961 .ok_or("no semantic entity is selected")?;
962 let recording = self
963 .workflow_recording
964 .as_mut()
965 .ok_or("start a recording first")?;
966 let id = recording.next_id();
967 let input = workflow_slug(input_name);
968 recording
969 .recorder
970 .record_type_input(id, selected.role, selected.name, input.clone())
971 .map_err(|error| error.to_string())?;
972 let steps = recording.recorder.draft().steps.len();
973 self.refresh_workflow_recording_status();
974 self.status = format!("REC {steps} · typed ${{inputs.{input}}}");
975 Ok(self.status.clone())
976 }
977
978 pub fn record_workflow_verify(&mut self) -> Result<String, String> {
979 let value = self
980 .pending_verify
981 .clone()
982 .ok_or("no pending prove-it predicate to attach")?;
983 let expect: VerificationPredicate = serde_json::from_value(value)
984 .map_err(|error| format!("pending verify is not a workflow predicate: {error}"))?;
985 let recording = self
986 .workflow_recording
987 .as_mut()
988 .ok_or("start a recording first")?;
989 recording
990 .recorder
991 .attach_expect_to_last(expect)
992 .map_err(|error| error.to_string())?;
993 let steps = recording.recorder.draft().steps.len();
994 self.refresh_workflow_recording_status();
995 self.status = format!("REC {steps} · attached prove-it to the last step");
996 Ok(self.status.clone())
997 }
998
999 pub fn stop_workflow_recording(&mut self) -> Result<String, String> {
1000 let recording = self
1001 .workflow_recording
1002 .take()
1003 .ok_or("no click-path recording is active")?;
1004 let draft = recording.recorder.draft();
1005 if draft.steps.is_empty() {
1006 self.workflow = "No workflow evidence yet".into();
1007 return Err("recording had no steps · activate entities before stop".into());
1008 }
1009 let dir = Path::new(&self.snapshot_root)
1010 .join(".glass")
1011 .join("workflows");
1012 std::fs::create_dir_all(&dir).map_err(|error| error.to_string())?;
1013 let path = dir.join(format!("{}.draft.json", recording.name));
1014 let encoded = serde_json::to_vec_pretty(draft).map_err(|error| error.to_string())?;
1015 std::fs::write(&path, &encoded).map_err(|error| error.to_string())?;
1016 self.workflow = format!(
1017 "Draft {} · {} step(s) · {}",
1018 recording.name,
1019 draft.steps.len(),
1020 path.display()
1021 );
1022 self.status = format!(
1023 "Recorded {} step(s) · {}",
1024 draft.steps.len(),
1025 path.display()
1026 );
1027 Ok(self.status.clone())
1028 }
1029
1030 fn refresh_workflow_recording_status(&mut self) {
1031 if let Some(recording) = &self.workflow_recording {
1032 self.workflow = format!(
1033 "REC {} · {} step(s) · :workflow record stop",
1034 recording.name,
1035 recording.recorder.draft().steps.len()
1036 );
1037 }
1038 }
1039
1040 fn capture_workflow_type_from_selection(&mut self) {
1041 if self.workflow_recording.is_none() {
1042 return;
1043 }
1044 let input = self
1045 .browser_workspace
1046 .state()
1047 .selected()
1048 .map(|entity| slug_input_name(&entity.name))
1049 .unwrap_or_else(|| "value".into());
1050 let _ = self.record_workflow_type(&input);
1051 }
1052
1053 pub fn run_menu_action(&mut self) {
1057 let search_index = self.surface_actions().len();
1058 let quit_index = self.quit_menu_index();
1059 if self.menu_selection == search_index {
1060 self.menu_open = false;
1061 self.open_palette();
1062 return;
1063 }
1064 if self.menu_selection == quit_index {
1065 self.menu_open = false;
1066 self.request_quit();
1067 return;
1068 }
1069 let Some(action) = self.surface_actions().get(self.menu_selection).copied() else {
1070 return;
1071 };
1072 self.menu_open = false;
1073 let name = action.label;
1074 let hint = action.command;
1075 if hint == "browser view" {
1076 self.surface = DevSurface::App;
1077 self.browser_visual_live = !self.browser_visual_live;
1078 self.status = if self.browser_visual_live {
1079 "Live view starting · command palette can stop it".into()
1080 } else {
1081 "Live view off · semantic inspection remains available".into()
1082 };
1083 return;
1084 }
1085 if hint == "process start dev" {
1086 self.request_detected_dev();
1087 return;
1088 }
1089 if hint == "git diff" && self.surface == DevSurface::Git {
1090 self.git_diff_requested = true;
1091 self.status = "Git diff queued · loading off-thread".into();
1092 return;
1093 }
1094 if self.surface == DevSurface::Trust && matches!(hint, "I" | "O" | "1" | "T") {
1095 self.handle_printable(hint.chars().next().expect("trust action hint is non-empty"));
1096 return;
1097 }
1098 let prefix = action.key;
1099 if prefix == ":" {
1100 let prefill = hint
1104 .split_whitespace()
1105 .take_while(|token| {
1106 !token
1107 .chars()
1108 .all(|character| character.is_ascii_uppercase() || character == '_')
1109 })
1110 .collect::<Vec<_>>()
1111 .join(" ");
1112 if prefill.is_empty() || prefill == hint {
1113 self.open_palette_with(hint);
1114 } else {
1115 self.open_palette_with(&format!("{prefill} "));
1116 }
1117 } else if hint == "i" {
1118 if self.surface == DevSurface::Agent {
1119 self.open_composer();
1120 } else {
1121 self.enter_code_edit();
1122 }
1123 } else if hint == "Enter" {
1124 if self.surface == DevSurface::Code {
1125 self.open_selected_file();
1126 }
1127 } else if hint == "Ctrl-S" && self.surface == DevSurface::Code {
1128 self.edit_code_key(
1129 crossterm::event::KeyCode::Char('s'),
1130 crossterm::event::KeyModifiers::CONTROL,
1131 );
1132 } else {
1133 self.status = format!("{name} is available from this surface");
1134 }
1135 }
1136
1137 pub fn move_menu_selection(&mut self, delta: i32) {
1138 let count = self.surface_actions().len() as i32 + 2;
1139 self.menu_selection =
1140 (self.menu_selection as i32 + delta).rem_euclid(count.max(1)) as usize;
1141 }
1142
1143 pub fn open_palette(&mut self) {
1144 self.close_file_picker();
1145 self.command_mode = true;
1146 self.command_input.clear();
1147 self.command_cursor = 0;
1148 self.command_history_index = None;
1149 self.palette_error = None;
1150 self.palette_scroll = 0;
1151 self.palette_selection = 0;
1152 self.status = format!(
1153 "Command search · {} actions · ↑↓ select · Enter run · Ctrl-P files",
1154 self.surface.label()
1155 );
1156 }
1157
1158 pub fn close_palette(&mut self) {
1159 self.command_mode = false;
1160 self.command_input.clear();
1161 self.command_cursor = 0;
1162 self.command_history_index = None;
1163 self.palette_error = None;
1164 self.palette_scroll = 0;
1165 self.palette_selection = 0;
1166 self.status = "Command palette closed · press : for guided launchers".into();
1167 }
1168
1169 pub fn palette_action_indices(&self) -> Vec<usize> {
1170 let query = self.command_input.trim();
1171 self.surface_actions()
1172 .iter()
1173 .enumerate()
1174 .filter_map(|(index, action)| {
1175 let haystack =
1176 format!("{} {} {}", action.label, action.command, action.description);
1177 fuzzy_contains(&haystack, query).then_some(index)
1178 })
1179 .collect()
1180 }
1181
1182 pub fn selected_palette_action(&self) -> Option<command::SurfaceAction> {
1183 let indices = self.palette_action_indices();
1184 indices
1185 .get(self.palette_selection)
1186 .and_then(|index| self.surface_actions().get(*index))
1187 .copied()
1188 }
1189
1190 pub fn move_palette_selection(&mut self, delta: i32) {
1191 let count = self.palette_action_indices().len();
1192 if count == 0 {
1193 return;
1194 }
1195 self.palette_selection =
1196 (self.palette_selection as i32 + delta).rem_euclid(count as i32) as usize;
1197 self.palette_error = None;
1198 self.palette_scroll = 0;
1199 if let Some(action) = self.selected_palette_action() {
1200 self.status = format!("{} · Enter runs", action.label);
1201 }
1202 }
1203
1204 pub fn submit_palette(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1205 let typed = self.command_input.trim().to_string();
1206 let typed_root = typed.split_whitespace().next().unwrap_or("");
1207 let command = match (typed_root, self.selected_palette_action()) {
1208 ("a" | "actions" | "help" | "?" | "q" | "quit" | "open" | "search" | "doctor", _) => {
1209 self.command_mode = false;
1210 self.command_input.clear();
1211 self.command_cursor = 0;
1212 self.command_history_index = None;
1213 self.palette_scroll = 0;
1214 self.palette_selection = 0;
1215 Some(typed)
1216 }
1217 (_, Some(action)) => self.prepare_palette_action(action),
1218 (_, None) if typed.is_empty() => {
1219 self.status = "No matching palette action · Esc closes".into();
1220 return;
1221 }
1222 (_, None) => {
1223 self.command_mode = false;
1224 self.command_input.clear();
1225 self.command_cursor = 0;
1226 self.command_history_index = None;
1227 self.palette_scroll = 0;
1228 self.palette_selection = 0;
1229 Some(typed)
1230 }
1231 };
1232
1233 let Some(input) = command else {
1234 if !self.command_mode {
1235 self.submit_queued_tool(worker);
1236 worker.request_refresh();
1237 }
1238 return;
1239 };
1240
1241 if self.command_history.last() != Some(&input) {
1242 self.command_history.push(input.clone());
1243 if self.command_history.len() > 32 {
1244 self.command_history.remove(0);
1245 }
1246 }
1247 match command::execute(self, &input) {
1248 Ok(message) => {
1249 self.palette_error = None;
1250 self.status = message;
1251 }
1252 Err(error) => {
1253 self.palette_error = Some(error.clone());
1254 self.status = format!("Error: {error}");
1255 }
1256 }
1257 self.submit_queued_tool(worker);
1258 worker.request_refresh();
1259 }
1260
1261 fn prepare_palette_action(&mut self, action: command::SurfaceAction) -> Option<String> {
1262 self.palette_error = None;
1263 match action.command {
1264 "i" => {
1265 self.command_mode = false;
1266 if self.surface == DevSurface::Agent {
1267 self.open_composer();
1268 } else {
1269 self.enter_code_edit();
1270 }
1271 None
1272 }
1273 "Enter" => {
1274 self.command_mode = false;
1275 if self.surface == DevSurface::Code {
1276 self.open_selected_file();
1277 }
1278 None
1279 }
1280 "browser navigate URL" => {
1281 self.surface = DevSurface::App;
1282 self.open_palette_with("browser navigate ");
1283 self.status =
1284 "Navigate · type a URL or domain (https:// optional), then press Enter".into();
1285 None
1286 }
1287 "browser type TARGET TEXT" => {
1288 self.surface = DevSurface::App;
1289 self.open_palette_with("browser type ");
1290 self.status = "Type · enter the target and text, then press Enter".into();
1291 None
1292 }
1293 "browser view" => {
1294 self.command_mode = false;
1295 self.browser_visual_live = !self.browser_visual_live;
1296 self.status = if self.browser_visual_live {
1297 "Live view starting · command palette can stop it".into()
1298 } else {
1299 "Live view off · semantic inspection remains available".into()
1300 };
1301 None
1302 }
1303 "process start dev"
1304 if matches!(self.surface, DevSurface::Terminal | DevSurface::More) =>
1305 {
1306 self.command_mode = false;
1307 self.request_detected_dev();
1308 None
1309 }
1310 "debug threads SESSION" | "debug continue SESSION THREAD_ID" => {
1311 if let Some(session) = self.selected_debug_session().map(|row| row.name.clone()) {
1312 let action = action
1313 .command
1314 .split_whitespace()
1315 .nth(1)
1316 .unwrap_or("threads");
1317 if action == "continue" {
1318 if let Some(thread) = self.selected_debug_thread() {
1319 self.open_palette_with(&format!(
1320 "debug continue {session} {}",
1321 thread.id
1322 ));
1323 } else {
1324 self.open_palette_with(&format!("debug continue {session} "));
1325 }
1326 } else {
1327 self.open_palette_with(&format!("debug threads {session}"));
1328 }
1329 None
1330 } else {
1331 self.open_palette_with("debug threads ");
1332 None
1333 }
1334 }
1335 "process logs NAME" | "process stop NAME" | "process restart NAME" => {
1336 if let Some(name) = self
1337 .selected_process_entry()
1338 .map(|entry| entry.name.clone())
1339 {
1340 let action = action.command.split_whitespace().nth(1).unwrap_or("logs");
1341 self.open_palette_with(&format!("process {action} {name}"));
1342 None
1343 } else {
1344 self.open_palette_with(&format!(
1345 "{} ",
1346 action
1347 .command
1348 .split_whitespace()
1349 .take(2)
1350 .collect::<Vec<_>>()
1351 .join(" ")
1352 ));
1353 None
1354 }
1355 }
1356 "git diff" if self.surface == DevSurface::Git => {
1357 self.command_mode = false;
1358 self.git_diff_requested = true;
1359 self.status = "Git diff queued · loading off-thread".into();
1360 None
1361 }
1362 "1" | "T" | "I" | "O" => {
1363 self.command_mode = false;
1364 self.handle_printable(action.command.chars().next().unwrap());
1365 None
1366 }
1367 "Ctrl-S" if self.surface == DevSurface::Code => {
1368 self.command_mode = false;
1369 self.edit_code_key(
1370 crossterm::event::KeyCode::Char('s'),
1371 crossterm::event::KeyModifiers::CONTROL,
1372 );
1373 None
1374 }
1375 command => {
1376 let prefill = command
1377 .split_whitespace()
1378 .take_while(|token| {
1379 !token
1380 .chars()
1381 .all(|character| character.is_ascii_uppercase() || character == '_')
1382 })
1383 .collect::<Vec<_>>()
1384 .join(" ");
1385 if prefill != command {
1386 self.open_palette_with(&format!("{prefill} "));
1387 self.status = format!(
1388 "{} · enter only the required value(s), then press Enter",
1389 action.label
1390 );
1391 None
1392 } else {
1393 self.command_mode = false;
1394 self.command_input.clear();
1395 self.command_cursor = 0;
1396 self.command_history_index = None;
1397 self.palette_scroll = 0;
1398 self.palette_selection = 0;
1399 Some(command.into())
1400 }
1401 }
1402 }
1403 }
1404
1405 pub fn insert_palette_char(&mut self, character: char) {
1406 self.command_input.insert(self.command_cursor, character);
1407 self.command_cursor += character.len_utf8();
1408 self.palette_error = None;
1409 self.command_history_index = None;
1410 self.palette_scroll = 0;
1411 self.palette_selection = 0;
1412 }
1413
1414 pub fn insert_palette_text(&mut self, text: &str) {
1415 for character in text.replace(['\r', '\n'], " ").chars().take(8_192) {
1416 self.insert_palette_char(character);
1417 }
1418 }
1419
1420 pub fn palette_backspace(&mut self) {
1421 if self.command_cursor == 0 {
1422 return;
1423 }
1424 let previous = self.command_input[..self.command_cursor]
1425 .char_indices()
1426 .next_back()
1427 .map(|(index, _)| index)
1428 .unwrap_or(0);
1429 self.command_input.drain(previous..self.command_cursor);
1430 self.command_cursor = previous;
1431 self.command_history_index = None;
1432 self.palette_scroll = 0;
1433 self.palette_selection = 0;
1434 }
1435
1436 fn palette_history_indices(&self) -> Vec<usize> {
1437 let visible = command::palette_order(self.surface);
1438 self.command_history
1439 .iter()
1440 .enumerate()
1441 .filter_map(|(index, input)| {
1442 let root = input.split_whitespace().next()?;
1443 let root = match root {
1444 "?" => "help",
1445 "q" => "quit",
1446 "gh" => "github",
1447 "tasks" => "task",
1448 "tests" => "test",
1449 "experiments" => "experiment",
1450 "knowledge" => "memory",
1451 "surfaces" | "backend" => "surface",
1452 "tools" => "tool",
1453 _ => root,
1454 };
1455 visible.contains(&root).then_some(index)
1456 })
1457 .collect()
1458 }
1459
1460 pub fn navigate_palette_history(&mut self, older: bool) {
1461 let history = self.palette_history_indices();
1462 if history.is_empty() {
1463 return;
1464 }
1465 let position = self
1466 .command_history_index
1467 .and_then(|index| history.iter().position(|candidate| *candidate == index));
1468 let next_position = match (position, older) {
1469 (None, true) => history.len() - 1,
1470 (None, false) => return,
1471 (Some(position), true) => position.saturating_sub(1),
1472 (Some(position), false) if position + 1 < history.len() => position + 1,
1473 (Some(_), false) => {
1474 self.command_history_index = None;
1475 self.command_input.clear();
1476 self.command_cursor = 0;
1477 self.palette_scroll = 0;
1478 self.palette_selection = 0;
1479 return;
1480 }
1481 };
1482 let index = history[next_position];
1483 self.command_history_index = Some(index);
1484 self.command_input.clone_from(&self.command_history[index]);
1485 self.command_cursor = self.command_input.len();
1486 self.palette_scroll = 0;
1487 self.palette_selection = 0;
1488 }
1489
1490 pub fn complete_palette(&mut self) {
1491 let Some(completion) = self.palette_matches().first().copied() else {
1492 return;
1493 };
1494 let suffix = self
1495 .command_input
1496 .find(char::is_whitespace)
1497 .map(|index| self.command_input[index..].to_string())
1498 .unwrap_or_default();
1499 self.command_input = format!("{completion}{suffix}");
1500 self.command_cursor = self.command_input.len();
1501 self.command_history_index = None;
1502 self.palette_scroll = 0;
1503 self.palette_selection = 0;
1504 self.status = format!("Completed `{completion}` · Enter runs · Ctrl-P/N history");
1505 }
1506
1507 pub fn open_palette_with(&mut self, prefix: &str) {
1508 self.open_palette();
1509 self.command_input = prefix.into();
1510 self.command_cursor = self.command_input.len();
1511 }
1512
1513 pub fn move_palette_cursor(&mut self, right: bool) {
1514 if right {
1515 self.command_cursor = self.command_input[self.command_cursor..]
1516 .char_indices()
1517 .nth(1)
1518 .map(|(offset, _)| self.command_cursor + offset)
1519 .unwrap_or(self.command_input.len());
1520 } else if self.command_cursor > 0 {
1521 self.command_cursor = self.command_input[..self.command_cursor]
1522 .char_indices()
1523 .next_back()
1524 .map(|(index, _)| index)
1525 .unwrap_or(0);
1526 }
1527 }
1528
1529 pub fn scroll_palette(&mut self, delta: i32) {
1530 self.move_palette_selection(delta.saturating_mul(5));
1531 }
1532
1533 pub fn palette_matches(&self) -> Vec<&'static str> {
1534 let query = self
1535 .command_input
1536 .split_whitespace()
1537 .next()
1538 .unwrap_or_default();
1539 command::palette_order(self.surface)
1540 .into_iter()
1541 .filter(|candidate| fuzzy_contains(candidate, query))
1542 .take(6)
1543 .collect()
1544 }
1545
1546 pub fn background_action_running(&self) -> bool {
1547 self.pending_confirmation.is_some()
1548 || self.pending_agent_approval.is_some()
1549 || self.running_tool_job.is_some()
1550 || self.queued_tool_request.is_some()
1551 || self.agent_send_job.is_some()
1552 }
1553
1554 pub fn agent_browser_context(&self) -> serde_json::Value {
1555 let semantic_summary = self.browser_workspace_summary();
1556 let state = self.browser_workspace.state();
1557 let selected_entity = state.selected().map(|entity| {
1558 serde_json::json!({
1559 "reference": entity.reference,
1560 "role": entity.role,
1561 "name": entity.name,
1562 "actionable": entity.actionable,
1563 "revision": entity.revision,
1564 })
1565 });
1566 let selected_target = state
1567 .targets
1568 .iter()
1569 .find(|target| target.selected)
1570 .map(|target| {
1571 serde_json::json!({
1572 "id": target.id,
1573 "title": target.title,
1574 "url": safe_browser_url(&target.url),
1575 })
1576 });
1577 serde_json::json!({
1578 "schemaVersion": "glass.agent-context.v1",
1579 "browser": {
1580 "attached": state.connection == glass_browser::browser_workspace::BrowserConnectionPhase::Connected,
1581 "connection": serde_json::to_value(state.connection).unwrap_or(serde_json::Value::Null),
1582 "targetId": selected_target.as_ref().and_then(|target| target.get("id")).cloned(),
1583 "origin": page_origin(&state.url),
1584 "url": safe_browser_url(&state.url),
1585 "title": state.title,
1586 "browserRevision": state.browser_revision,
1587 "semanticSummary": semantic_summary,
1588 "selectedEntity": selected_entity,
1589 "workflowState": state.workflow,
1590 "inputOwner": serde_json::to_value(state.input_owner).unwrap_or(serde_json::Value::Null),
1591 "freshness": if state.semantic_invalidated { "stale" } else { "current" },
1592 "target": selected_target,
1593 "bootstrap": if state.connection == glass_browser::browser_workspace::BrowserConnectionPhase::Connected {
1594 "attached; observe before acting"
1595 } else {
1596 "detached; call glass.browser.start, then navigate and observe the requested URL"
1597 },
1598 },
1599 "authority": {
1600 "source": "Glass browser workspace",
1601 "mutationLeaseRequired": selected_entity.as_ref().is_some_and(|entity| {
1602 entity.get("actionable").and_then(serde_json::Value::as_bool).unwrap_or(false)
1603 }),
1604 },
1605 "project": {
1606 "root": self.snapshot_root,
1607 },
1608 })
1609 }
1610 pub fn agent_editor_context(&self) -> serde_json::Value {
1616 let buffer = self.focused_buffer();
1617 let focused = buffer.as_ref().map(|buffer| {
1618 let (content, truncated) = bounded_editor_content(&buffer.content);
1619 serde_json::json!({
1620 "path": buffer.path,
1621 "cursor": {
1622 "line": buffer.cursor_line,
1623 "column": buffer.cursor_column,
1624 },
1625 "selection": buffer.selection,
1626 "dirty": buffer.dirty,
1627 "actor": buffer.actor,
1628 "content": content,
1629 "contentTruncated": truncated,
1630 })
1631 });
1632 let project_revision = self
1633 .workspace
1634 .try_lock()
1635 .ok()
1636 .map(|workspace| workspace.project().revision());
1637 let comments = self
1638 .editor_comments
1639 .iter()
1640 .filter(|comment| {
1641 self.focused_editor_path.is_empty() || comment.path == self.focused_editor_path
1642 })
1643 .cloned()
1644 .collect::<Vec<_>>();
1645 let proposals = self
1646 .editor_proposals
1647 .iter()
1648 .filter(|proposal| {
1649 self.focused_editor_path.is_empty() || proposal.path == self.focused_editor_path
1650 })
1651 .cloned()
1652 .collect::<Vec<_>>();
1653 serde_json::json!({
1654 "focusedPath": self.focused_editor_path,
1655 "cursor": {
1656 "line": self.focused_editor_line,
1657 "column": self.focused_editor_column,
1658 },
1659 "dirty": self.focused_editor_dirty,
1660 "projectRevision": project_revision,
1661 "focusedBuffer": focused,
1662 "comments": comments,
1663 "proposals": proposals,
1664 })
1665 }
1666
1667 pub fn browser_chat_header(&self) -> String {
1668 let browser = self.browser_workspace.state();
1669 let page = if browser.url.is_empty() {
1670 "no page".to_string()
1671 } else {
1672 safe_browser_url(&browser.url).unwrap_or_else(|| "no page".into())
1673 };
1674 let title = browser.title.trim();
1675 let include_title = !title.is_empty() && !title.eq_ignore_ascii_case(&page);
1676 let revision = browser
1677 .browser_revision
1678 .map_or_else(|| "—".to_string(), |revision| revision.to_string());
1679 let bootstrap = if browser.connection
1680 == glass_browser::browser_workspace::BrowserConnectionPhase::Connected
1681 {
1682 "observe before acting"
1683 } else {
1684 "ask `open <url>` to attach"
1685 };
1686 let mut header = format!("APP · {}", browser.connection_label());
1687 if include_title {
1688 header.push_str(" · ");
1689 header.push_str(title);
1690 }
1691 header.push_str(&format!(" · {} · rev {} · {}", page, revision, bootstrap));
1692 if let Some(entity) = browser.selected() {
1693 header.push_str(" · selected ");
1694 header.push_str(&entity.name);
1695 }
1696 header
1697 }
1698
1699 pub fn conversation_view(&self) -> String {
1700 let mut conversation = if self.agent_conversation.starts_with("No conversation yet.")
1701 && !self.pending_chat_messages.is_empty()
1702 {
1703 String::new()
1704 } else {
1705 self.agent_conversation.clone()
1706 };
1707 let mut observed = std::collections::BTreeMap::<String, usize>::new();
1708 for message in &self.pending_chat_messages {
1709 if message.state != ChatMessageState::Failed {
1710 let marker = format!("YOU\n{}", message.text);
1711 let seen = observed.entry(message.text.clone()).or_default();
1712 if *seen < conversation.matches(&marker).count() {
1713 *seen += 1;
1714 continue;
1715 }
1716 }
1717 if !conversation.is_empty() {
1718 conversation.push_str("\n\n");
1719 }
1720 conversation.push_str("YOU\n");
1721 conversation.push_str(&message.text);
1722 conversation.push('\n');
1723 match message.state {
1724 ChatMessageState::Sending => conversation.push_str("· sending…"),
1725 ChatMessageState::Sent => {
1726 conversation.push_str("· sent · Glass Agent is thinking…")
1727 }
1728 ChatMessageState::Failed => {
1729 conversation.push_str("× send failed");
1730 if let Some(error) = message.error.as_deref() {
1731 conversation.push_str(": ");
1732 conversation.push_str(error);
1733 }
1734 conversation.push_str(" · press Enter to retry");
1735 }
1736 }
1737 }
1738 conversation
1739 }
1740
1741 pub fn conversation_entries_view(&self) -> Vec<super::projection::ConversationEntry> {
1742 let mut entries = self.conversation_items.clone();
1743 if entries.is_empty() && !self.agent_conversation.starts_with("No conversation yet.") {
1744 entries = parse_conversation_view(&self.agent_conversation);
1745 }
1746 let mut observed = std::collections::BTreeMap::<String, usize>::new();
1747 for message in &self.pending_chat_messages {
1748 if message.state != ChatMessageState::Failed {
1749 let seen = observed.entry(message.text.clone()).or_default();
1750 let existing = entries
1751 .iter()
1752 .filter(|entry| {
1753 entry.kind == super::projection::ConversationKind::User
1754 && entry.text == message.text
1755 })
1756 .count();
1757 if *seen < existing {
1758 *seen += 1;
1759 continue;
1760 }
1761 }
1762 let suffix = match message.state {
1763 ChatMessageState::Sending => "· sending…",
1764 ChatMessageState::Sent => "· sent · Glass Agent is thinking…",
1765 ChatMessageState::Failed => "× send failed · press Enter to retry",
1766 };
1767 entries.push(super::projection::ConversationEntry {
1768 kind: super::projection::ConversationKind::User,
1769 text: format!("{}\n{suffix}", message.text),
1770 streaming: false,
1771 entry_id: None,
1772 tool_name: None,
1773 });
1774 }
1775 entries
1776 }
1777
1778 pub fn composer_context_chips(&self) -> String {
1779 let mut chips = Vec::new();
1780 if !self.focused_editor_path.is_empty() {
1781 chips.push(format!("@{}", self.focused_editor_path));
1782 } else if let Some(path) = self.files.get(self.selected_file) {
1783 chips.push(format!("@{path}"));
1784 }
1785 if self.focused_editor_selection.is_some() {
1786 chips.push("selection".into());
1787 }
1788 if let Some(entity) = self.browser_workspace.state().selected() {
1789 chips.push(format!("app {}", entity.name));
1790 }
1791 if self.pending_verify.is_some() {
1792 chips.push("prove-it".into());
1793 }
1794 if self.composer_steer {
1795 chips.push("steer".into());
1796 }
1797 chips.join(" · ")
1798 }
1799
1800 pub fn agent_chrome_line(&self) -> String {
1801 let mut parts = Vec::new();
1802 if !self.agent_model.is_empty() {
1803 parts.push(self.agent_model.clone());
1804 }
1805 if !self.agent_thinking.is_empty() {
1806 parts.push(format!("think {}", self.agent_thinking));
1807 }
1808 if !self.agent_session_name.is_empty() {
1809 parts.push(self.agent_session_name.clone());
1810 }
1811 if !self.agent_token_summary.is_empty() {
1812 parts.push(self.agent_token_summary.clone());
1813 }
1814 let queued = self
1815 .pending_chat_messages
1816 .iter()
1817 .filter(|message| matches!(message.state, ChatMessageState::Sending))
1818 .count();
1819 if queued > 0 {
1820 parts.push(format!("queued {queued}"));
1821 }
1822 parts.join(" · ")
1823 }
1824
1825 pub fn move_transcript_selection(&mut self, delta: i32) {
1826 let len = self.conversation_entries_view().len();
1827 if len == 0 {
1828 self.scroll_surface(delta);
1829 return;
1830 }
1831 let next = self.transcript_selection as i32 + delta;
1832 self.transcript_selection = next.clamp(0, len as i32 - 1) as usize;
1833 self.transcript_expanded = false;
1834 self.status = format!(
1835 "Bubble {}/{} · f fork · r rewind · e edit last · o expand",
1836 self.transcript_selection + 1,
1837 len
1838 );
1839 }
1840
1841 pub fn toggle_transcript_expand(&mut self) {
1842 self.transcript_expanded = !self.transcript_expanded;
1843 self.status = if self.transcript_expanded {
1844 "Expanded tool card · o collapse".into()
1845 } else {
1846 "Collapsed · o expand".into()
1847 };
1848 }
1849
1850 pub fn fork_selected_transcript(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1851 self.branch_selected_transcript("glass.agent.fork", worker);
1852 }
1853
1854 pub fn rewind_selected_transcript(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1855 self.branch_selected_transcript("glass.agent.rewind", worker);
1856 }
1857
1858 fn branch_selected_transcript(
1859 &mut self,
1860 tool: &str,
1861 worker: &mut super::snapshot::SnapshotWorker,
1862 ) {
1863 let Some(entry) = self
1864 .conversation_entries_view()
1865 .get(self.transcript_selection)
1866 .cloned()
1867 else {
1868 self.status = "No transcript bubble to branch".into();
1869 return;
1870 };
1871 let Some(entry_id) = entry.entry_id.clone() else {
1872 self.status = "Selected bubble has no Pi entry · send a turn first".into();
1873 return;
1874 };
1875 let mut arguments = serde_json::json!({"entryId": entry_id});
1876 if let Some(agent) = self.selected_agent.as_ref() {
1877 arguments["agentId"] = serde_json::Value::String(agent.as_str().to_string());
1878 }
1879 match self.tool_request(tool, arguments, true) {
1880 Ok((call, context)) => match worker.submit_tool(call, context) {
1881 Ok(_) => {
1882 self.status = format!("{tool} · branching at {entry_id}");
1883 worker.request_conversation();
1884 }
1885 Err(error) => self.status = format!("Could not {tool}: {error}"),
1886 },
1887 Err(error) => self.status = format!("Could not {tool}: {error}"),
1888 }
1889 }
1890
1891 pub fn edit_last_user_message(&mut self) {
1892 let entries = self.conversation_entries_view();
1893 let Some(entry) = entries
1894 .iter()
1895 .rev()
1896 .find(|entry| entry.kind == super::projection::ConversationKind::User)
1897 else {
1898 self.status = "No user message to edit".into();
1899 return;
1900 };
1901 let text = entry
1902 .text
1903 .lines()
1904 .next()
1905 .unwrap_or(entry.text.as_str())
1906 .to_string();
1907 self.composer_input = text;
1908 self.composer_cursor = self.composer_input.len();
1909 self.composer_steer = false;
1910 self.open_composer();
1911 if let Some(entry_id) = entry.entry_id.clone() {
1912 self.status = format!("Editing last user message · rewind {entry_id} on send");
1913 } else {
1914 self.status = "Editing last user message · Enter resends".into();
1915 }
1916 }
1917
1918 pub fn open_session_picker(&mut self, value: &serde_json::Value) {
1919 self.session_picker_items = parse_session_picker_items(value);
1920 self.session_picker_selection = 0;
1921 self.session_picker_open = !self.session_picker_items.is_empty();
1922 self.status = if self.session_picker_open {
1923 format!(
1924 "{} Pi session(s) · Enter switch · Esc close",
1925 self.session_picker_items.len()
1926 )
1927 } else {
1928 "No persisted Pi sessions".into()
1929 };
1930 }
1931
1932 pub fn close_session_picker(&mut self) {
1933 self.session_picker_open = false;
1934 }
1935
1936 pub fn move_session_picker_selection(&mut self, delta: i32) {
1937 if self.session_picker_items.is_empty() {
1938 return;
1939 }
1940 let next = self.session_picker_selection as i32 + delta;
1941 self.session_picker_selection =
1942 next.clamp(0, self.session_picker_items.len() as i32 - 1) as usize;
1943 }
1944
1945 pub fn submit_session_picker(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1946 let Some(item) = self.session_picker_items.get(self.session_picker_selection) else {
1947 self.status = "No session selected".into();
1948 return;
1949 };
1950 let mut arguments = serde_json::json!({"path": item.path});
1951 if let Some(agent) = self.selected_agent.as_ref() {
1952 arguments["agentId"] = serde_json::Value::String(agent.as_str().to_string());
1953 }
1954 match self.tool_request("glass.agent.switch-session", arguments, true) {
1955 Ok((call, context)) => match worker.submit_tool(call, context) {
1956 Ok(_) => {
1957 self.agent_session_name = item.label.clone();
1958 self.session_picker_open = false;
1959 self.status = format!("Switching to {}", item.label);
1960 worker.request_conversation();
1961 }
1962 Err(error) => self.status = format!("Could not switch session: {error}"),
1963 },
1964 Err(error) => self.status = format!("Could not switch session: {error}"),
1965 }
1966 }
1967
1968 fn composer_send_blocked(&self) -> bool {
1969 self.pending_confirmation.is_some()
1970 || self.pending_agent_approval.is_some()
1971 || self.queued_tool_request.is_some()
1972 || (self.running_tool_job.is_some() && self.agent_send_job.is_none())
1973 }
1974
1975 fn reconcile_pending_chat(&mut self) {
1976 let conversation = self.agent_conversation.clone();
1977 let mut confirmed = std::collections::BTreeMap::<String, usize>::new();
1978 self.pending_chat_messages.retain(|message| {
1979 if message.state == ChatMessageState::Failed {
1980 return true;
1981 }
1982 let marker = format!("YOU\n{}", message.text);
1983 let observed = conversation.matches(&marker).count();
1984 let seen = confirmed.entry(message.text.clone()).or_default();
1985 if *seen < observed {
1986 *seen += 1;
1987 false
1988 } else {
1989 true
1990 }
1991 });
1992 }
1993 pub fn start_agent_interaction(&mut self) {
1995 if self.snapshot_trust_label == "untrusted" {
1996 self.surface = DevSurface::Trust;
1997 self.status = "Trust this workspace before starting the Glass Agent · T or 1".into();
1998 return;
1999 }
2000 match crate::pi_runtime::pi_readiness() {
2001 Ok(readiness) if readiness.ready => self.open_composer(),
2002 Ok(readiness)
2003 if readiness.node.state != crate::pi_runtime::PiReadinessState::Ready
2004 || readiness.sdk.state != crate::pi_runtime::PiReadinessState::Ready =>
2005 {
2006 self.request_agent_setup();
2007 }
2008 Ok(_) => {
2009 let _ = self.request_agent_login();
2010 }
2011 Err(error) => {
2012 self.status = format!("Pi readiness unavailable · use :agent setup: {error}");
2013 }
2014 }
2015 }
2016
2017 pub fn cycle_agent_selection(&mut self, delta: i32) {
2021 let agents = match self.workspace.try_lock() {
2022 Ok(mut workspace) => match workspace.agents().list() {
2023 Ok(agents) => agents,
2024 Err(error) => {
2025 self.status = format!("Agent list unavailable: {error}");
2026 return;
2027 }
2028 },
2029 Err(error) => {
2030 self.status = format!("Agent list unavailable: {error}");
2031 return;
2032 }
2033 };
2034 if agents.is_empty() {
2035 self.selected_agent = None;
2036 self.status = "No resident agents · Enter starts the Glass Agent".into();
2037 return;
2038 }
2039 let current = self
2040 .selected_agent
2041 .as_ref()
2042 .and_then(|selected| agents.iter().position(|agent| &agent.id == selected))
2043 .unwrap_or(0);
2044 let next = if delta.is_negative() {
2045 (current + agents.len() - (delta.unsigned_abs() as usize % agents.len())) % agents.len()
2046 } else {
2047 (current + (delta as usize % agents.len())) % agents.len()
2048 };
2049 let selected = agents[next].id.clone();
2050 self.selected_agent = Some(selected.clone());
2051 self.status = format!(
2052 "Selected {} · Enter chats · ]/[ switches agent",
2053 selected.as_str()
2054 );
2055 }
2056
2057 pub fn open_composer(&mut self) {
2058 self.close_file_picker();
2059 self.composer_mode = true;
2060 self.composer_cursor = self.composer_input.len();
2061 self.status = format!(
2062 "{} dock on {} · Enter sends · Tab @mention · Shift-Enter newline · Ctrl-Shift-A mode · Esc back",
2063 self.composer_run_mode.label(),
2064 self.surface.label()
2065 );
2066 }
2067
2068 pub fn focus_composer_dock(&mut self) {
2070 if self.snapshot_trust_label == "untrusted" {
2071 self.surface = DevSurface::Trust;
2072 self.status = "Trust this workspace before chatting · T or 1".into();
2073 return;
2074 }
2075 if !self.agent_readiness.starts_with("✓ Ready") {
2076 self.start_agent_interaction();
2077 return;
2078 }
2079 self.open_composer();
2080 }
2081
2082 pub fn cycle_composer_run_mode(&mut self) {
2083 self.composer_run_mode = self.composer_run_mode.next();
2084 let _ = self.ws_mut().map(|mut workspace| {
2085 workspace.set_agent_turn_mode(self.composer_run_mode);
2086 });
2087 self.status = format!(
2088 "{} mode · Ask is read-only · Plan writes a reviewable plan · Agent proposes",
2089 self.composer_run_mode.label()
2090 );
2091 if self.composer_mode {
2092 self.open_composer();
2093 }
2094 }
2095
2096 pub fn set_composer_run_mode(&mut self, mode: crate::AgentTurnMode) {
2097 self.composer_run_mode = mode;
2098 let _ = self.ws_mut().map(|mut workspace| {
2099 workspace.set_agent_turn_mode(mode);
2100 });
2101 self.status = format!("{} mode", mode.label());
2102 }
2103
2104 pub fn toggle_selected_git_stage(&mut self) {
2105 let Some(entry) = self.selected_git_entry().cloned() else {
2106 self.status = "Select a changed file · Space stages or unstages".into();
2107 return;
2108 };
2109 let staged = entry.index_status != ' ' && !entry.untracked;
2110 let tool = if staged {
2111 "glass.git.unstage"
2112 } else {
2113 "glass.git.stage"
2114 };
2115 let arguments = serde_json::json!({"paths": [entry.path]});
2116 match self.tool_request(tool, arguments, true) {
2117 Ok((call, context)) => {
2118 let summary = format!(
2119 "{} {}",
2120 if staged { "Unstage" } else { "Stage" },
2121 self.selected_git_entry()
2122 .map(|entry| entry.path.as_str())
2123 .unwrap_or("path")
2124 );
2125 let _ = self.queue_or_confirm(call, context, summary);
2126 }
2127 Err(error) => self.status = format!("Git stage unavailable: {error}"),
2128 }
2129 }
2130
2131 pub fn jump_to_app_keep_dock(&mut self) {
2132 self.surface = DevSurface::App;
2133 self.status = if self.composer_mode {
2134 "App · dock stays open · watch the agent or type a follow-up".into()
2135 } else {
2136 "App selected · Ctrl-L talks about this page".into()
2137 };
2138 }
2139
2140 pub fn watch_agent_on_app(&mut self, tool: &str, value: &serde_json::Value) {
2141 self.browser_workspace.state_mut().input_owner =
2142 glass_browser::browser_workspace::BrowserInputOwner::Agent;
2143 if !self.browser_visual_live {
2144 self.browser_visual_live = true;
2145 }
2146 let target = value
2147 .get("target")
2148 .or_else(|| value.get("name"))
2149 .and_then(serde_json::Value::as_str)
2150 .unwrap_or("page");
2151 let action = tool.rsplit('.').next().unwrap_or("act");
2152 self.status = format!("Agent {action} {target} · watching · Ctrl-L to steer");
2153 }
2154
2155 pub fn comment_selected_app_entity(&mut self) {
2156 let Some(entity) = self.browser_workspace.state().selected().cloned() else {
2157 self.status = "No App entity selected · ↑/↓ then C comments".into();
2158 return;
2159 };
2160 self.last_app_comment = Some(format!("{} ({})", entity.name, entity.role));
2161 self.composer_input = format!(
2162 "About the selected App control [{}] {}: ",
2163 entity.role, entity.name
2164 );
2165 self.composer_cursor = self.composer_input.len();
2166 self.focus_composer_dock();
2167 self.status = format!(
2168 "App comment on {} · finish the note, then Enter",
2169 entity.name
2170 );
2171 }
2172
2173 pub fn capture_plan_from_goal(&mut self, goal: &str) {
2174 self.pending_plan = Some(WorkspacePlan {
2175 id: format!(
2176 "plan-{}",
2177 std::time::SystemTime::now()
2178 .duration_since(std::time::UNIX_EPOCH)
2179 .map(|duration| duration.as_millis())
2180 .unwrap_or(0)
2181 ),
2182 goal: goal.chars().take(240).collect(),
2183 body: String::new(),
2184 accepted: false,
2185 });
2186 }
2187
2188 pub fn accept_pending_plan(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
2189 let Some(mut plan) = self.pending_plan.clone() else {
2190 self.status = "No plan to accept · switch to Plan and send a goal".into();
2191 return;
2192 };
2193 if plan.body.is_empty()
2194 && let Some(entry) = self
2195 .conversation_entries_view()
2196 .into_iter()
2197 .rev()
2198 .find(|entry| entry.kind == super::projection::ConversationKind::Assistant)
2199 {
2200 plan.body = entry.text;
2201 }
2202 plan.accepted = true;
2203 self.persist_plan(&plan);
2204 if let Ok(list) = self.ws_mut().and_then(|mut workspace| {
2205 workspace
2206 .seed_todos_from_plan(&plan.goal, &plan.body)
2207 .map_err(|error| error.to_string())
2208 }) {
2209 self.session_todos = list;
2210 }
2211 self.pending_plan = Some(plan.clone());
2212 self.set_composer_run_mode(crate::AgentTurnMode::Agent);
2213 self.composer_input = format!(
2214 "Implement this accepted plan. Stay in proposals unless I say otherwise.\n\nGoal: {}\n\n{}",
2215 plan.goal, plan.body
2216 );
2217 self.composer_cursor = self.composer_input.len();
2218 self.open_composer();
2219 self.submit_composer(worker);
2220 self.status = format!("Plan {} accepted · Agent implementing", plan.id);
2221 }
2222
2223 pub fn reject_pending_plan(&mut self) {
2224 if let Some(plan) = self.pending_plan.as_mut() {
2225 plan.accepted = false;
2226 self.status = format!("Plan {} rejected · stay in Plan and revise", plan.id);
2227 } else {
2228 self.status = "No plan to reject".into();
2229 }
2230 self.set_composer_run_mode(crate::AgentTurnMode::Plan);
2231 }
2232
2233 fn persist_plan(&self, plan: &WorkspacePlan) {
2234 let Ok(workspace) = self.ws() else {
2235 return;
2236 };
2237 let dir = workspace.root().join(".glass/plans");
2238 let _ = std::fs::create_dir_all(&dir);
2239 let _ = std::fs::write(
2240 dir.join("latest.json"),
2241 serde_json::to_vec_pretty(plan).unwrap_or_default(),
2242 );
2243 }
2244
2245 pub fn prepare_editor_agent_prompt(&mut self) {
2248 let Some(buffer) = self.focused_buffer() else {
2249 self.status = "No open buffer · open a file before asking Pi".into();
2250 return;
2251 };
2252 let line = buffer
2253 .content
2254 .lines()
2255 .nth(buffer.cursor_line.saturating_sub(1) as usize)
2256 .unwrap_or_default()
2257 .trim();
2258 let line_preview = line.chars().take(240).collect::<String>();
2259 self.composer_input = format!(
2260 "Help me with {}:{}:{}.\nInspect the attached editor buffer and explain the safest minimal change. Current line: `{line_preview}`. Do not edit files until I approve a concrete proposal.",
2261 buffer.path, buffer.cursor_line, buffer.cursor_column
2262 );
2263 self.composer_cursor = self.composer_input.len();
2264 self.composer_steer = false;
2265 self.code_edit_mode = false;
2266 self.editor_exit_prompt = None;
2267 self.open_composer();
2268 self.status = format!(
2269 "Editor context attached · stay on Code · {}:{} · Enter sends",
2270 buffer.path, buffer.cursor_line
2271 );
2272 }
2273
2274 pub fn review_object_text(&self) -> String {
2275 let proposals = self
2276 .editor_proposals
2277 .iter()
2278 .map(|item| {
2279 (
2280 item.id.clone(),
2281 item.path.clone(),
2282 format!("{:?}", item.state),
2283 )
2284 })
2285 .collect::<Vec<_>>();
2286 let checkpoint = self
2287 .editor_checkpoints
2288 .last()
2289 .map(|item| item.name.as_str());
2290 let diff = if self.git_diff.starts_with("REVIEW") {
2291 None
2292 } else {
2293 Some(self.git_diff.as_str()).filter(|diff| !diff.trim().is_empty())
2294 };
2295 let wake = self.last_crew_wake.as_deref();
2296 let packed = wake.is_some_and(|wake| wake.starts_with("WAKE"));
2297 super::editor::review_object(
2298 &self.github.summary(),
2299 &self.github_review,
2300 &proposals,
2301 super::editor::ReviewEvidence {
2302 last_verify: if packed {
2303 None
2304 } else {
2305 self.last_verify.as_deref()
2306 },
2307 git_diff: if packed { None } else { diff },
2308 tasks: if packed {
2309 None
2310 } else {
2311 Some(self.tasks.as_str()).filter(|tasks| !tasks.trim().is_empty())
2312 },
2313 checkpoint: if packed { None } else { checkpoint },
2314 wake,
2315 },
2316 )
2317 }
2318
2319 pub fn refresh_review_object(&mut self) {
2320 self.refresh_crew_wake_from_live();
2321 let text = self.review_object_text();
2322 self.editor = text.clone();
2323 self.git_diff = text;
2324 self.git_diff_path = Some("REVIEW".into());
2325 self.git_diff_open = true;
2326 self.status = "REVIEW · :review accept applies the pack · ship TITLE · ask".into();
2327 }
2328
2329 pub fn accept_review_pack(&mut self) -> Result<String, String> {
2330 self.auto_checkpoint("before-review-accept");
2331 match self.locked(|workspace| {
2332 workspace
2333 .project_mut()
2334 .accept_pending_editor_proposals(crate::development::Actor::local())
2335 }) {
2336 Some(Ok(buffers)) => {
2337 self.refresh_editor_hunks();
2338 self.refresh_editor_projection();
2339 self.refresh_review_object();
2340 Ok(format!(
2341 "Accepted {} proposal(s) from the wake pack",
2342 buffers.len()
2343 ))
2344 }
2345 Some(Err(crate::development::DevelopmentError::NotFound(_))) => {
2346 Err("No pending proposals in the wake pack".into())
2347 }
2348 Some(Err(error)) => Err(error.to_string()),
2349 None => Err("Accept failed · workspace busy".into()),
2350 }
2351 }
2352
2353 pub fn accept_review_proposal(&mut self, id: Option<&str>) -> Result<String, String> {
2354 let id = self.resolve_review_proposal_id(id)?;
2355 self.auto_checkpoint("before-review-accept");
2356 match self.locked(|workspace| {
2357 workspace
2358 .project_mut()
2359 .accept_editor_proposal(&id, crate::development::Actor::local())
2360 .map(|_| ())
2361 }) {
2362 Some(Ok(())) => {
2363 self.refresh_editor_hunks();
2364 self.refresh_editor_projection();
2365 self.refresh_review_object();
2366 Ok(format!("Accepted proposal {id}"))
2367 }
2368 Some(Err(error)) => Err(error.to_string()),
2369 None => Err("Accept failed · workspace busy".into()),
2370 }
2371 }
2372
2373 pub fn reject_review_proposal(&mut self, id: Option<&str>) -> Result<String, String> {
2374 let id = self.resolve_review_proposal_id(id)?;
2375 match self.locked(|workspace| {
2376 workspace
2377 .project_mut()
2378 .reject_editor_proposal(&id, crate::development::Actor::local())
2379 .map(|_| ())
2380 }) {
2381 Some(Ok(())) => {
2382 self.refresh_editor_hunks();
2383 self.refresh_review_object();
2384 Ok(format!("Rejected proposal {id}"))
2385 }
2386 Some(Err(error)) => Err(error.to_string()),
2387 None => Err("Reject failed · workspace busy".into()),
2388 }
2389 }
2390
2391 fn resolve_review_proposal_id(&self, id: Option<&str>) -> Result<String, String> {
2392 if let Some(id) = id {
2393 return Ok(id.to_string());
2394 }
2395 self.editor_proposals
2396 .iter()
2397 .find(|item| item.state == crate::development::EditorProposalState::Pending)
2398 .map(|item| item.id.clone())
2399 .ok_or_else(|| "No pending editor proposal".into())
2400 }
2401
2402 fn refresh_crew_wake_from_live(&mut self) {
2403 let accept = self
2404 .editor_proposals
2405 .iter()
2406 .find(|proposal| proposal.state == crate::development::EditorProposalState::Pending)
2407 .map(|proposal| proposal.id.clone());
2408 let browser = self.browser_workspace.state();
2409 let page = if browser.url.is_empty() && browser.selected().is_none() {
2410 None
2411 } else {
2412 Some(self.page_evidence())
2413 };
2414 let live = crate::CrewWakeLiveEvidence {
2415 verify: self.last_verify.clone(),
2416 page,
2417 accept,
2418 };
2419 if let Some(Ok(Some(wake))) = self.locked(|workspace| workspace.refresh_crew_wake(live)) {
2420 self.last_crew_wake = Some(wake.render());
2421 }
2422 }
2423
2424 fn page_evidence(&self) -> String {
2425 let browser = self.browser_workspace.state();
2426 let url = safe_browser_url(&browser.url).unwrap_or_else(|| "—".into());
2427 let entity = browser
2428 .selected()
2429 .map(|entity| entity.reference.as_str())
2430 .unwrap_or("—");
2431 format!(
2432 "url {url}\n entity {entity}\n revision {}",
2433 browser.browser_revision.unwrap_or(0)
2434 )
2435 }
2436
2437 pub fn prepare_review_prompt(&mut self) {
2439 self.composer_input = "Review the current workspace changes. Inspect the Git diff, changed files, diagnostics, and latest test results. Report concrete correctness, security, regression, and missing-test risks. Do not edit files until I approve a fix.".into();
2440 self.composer_cursor = self.composer_input.len();
2441 self.composer_steer = false;
2442 self.open_composer();
2443 self.status =
2444 "Review prompt ready · edit it, then press Enter to ask the Glass Agent".into();
2445 }
2446
2447 pub fn toggle_composer_steer(&mut self) {
2448 self.composer_steer = !self.composer_steer;
2449 self.status = if self.composer_steer {
2450 "Steer mode · Enter interrupts the running agent".into()
2451 } else {
2452 "Follow-up mode · Enter sends during or after the current turn".into()
2453 };
2454 }
2455
2456 pub fn request_agent_setup(&mut self) {
2459 self.request_agent_setup_mode(false);
2460 }
2461
2462 pub fn request_agent_update(&mut self) {
2464 self.request_agent_setup_mode(true);
2465 }
2466
2467 fn request_agent_setup_mode(&mut self, update: bool) {
2468 if self.background_action_running() {
2469 self.status = "Another background action is still running".into();
2470 return;
2471 }
2472 let (call, context) = match self.tool_request(
2473 "glass.agent.setup",
2474 serde_json::json!({"login": false, "update": update}),
2475 true,
2476 ) {
2477 Ok(request) => request,
2478 Err(error) => {
2479 self.status = if update {
2480 format!("Pi update unavailable: {error}")
2481 } else {
2482 format!("Pi setup unavailable: {error}")
2483 };
2484 return;
2485 }
2486 };
2487 let summary = if update {
2488 "Refresh the pinned managed Pi SDK"
2489 } else {
2490 "Install or repair the pinned managed Pi SDK"
2491 };
2492 let queued = match self.queue_or_confirm(call, context, summary.into()) {
2493 Ok(queued) => queued,
2494 Err(error) => {
2495 self.status = format!("Could not queue Pi setup: {error}");
2496 return;
2497 }
2498 };
2499 self.surface = DevSurface::Agent;
2500 if !queued {
2501 self.status = if update {
2502 "Pi update ready · Enter approves once · Esc cancels".into()
2503 } else {
2504 "Pi setup ready · Enter approves once · Esc cancels".into()
2505 };
2506 }
2507 }
2508
2509 pub fn request_agent_login(&mut self) -> Result<(), String> {
2512 if self.background_action_running() {
2513 let error = "Finish the current background action before signing in".to_string();
2514 self.status = error.clone();
2515 return Err(error);
2516 }
2517 self.agent_login_requested = true;
2518 self.surface = DevSurface::Agent;
2519 self.status = "Pi login will open in this terminal · exit Pi to return".into();
2520 Ok(())
2521 }
2522
2523 pub fn close_composer(&mut self) {
2524 self.composer_mode = false;
2525 self.composer_steer = false;
2526 self.status = "Composer closed".into();
2527 }
2528
2529 pub fn move_composer_cursor(&mut self, right: bool) {
2530 if right {
2531 self.composer_cursor = self.composer_input[self.composer_cursor..]
2532 .char_indices()
2533 .nth(1)
2534 .map(|(offset, _)| self.composer_cursor + offset)
2535 .unwrap_or(self.composer_input.len());
2536 } else if self.composer_cursor > 0 {
2537 self.composer_cursor = self.composer_input[..self.composer_cursor]
2538 .char_indices()
2539 .next_back()
2540 .map(|(index, _)| index)
2541 .unwrap_or(0);
2542 }
2543 }
2544
2545 pub fn delete_composer_word(&mut self) {
2546 let before = self.composer_input[..self.composer_cursor].trim_end();
2547 let start = before.len();
2548 let target = before[..start]
2549 .trim_end_matches(|c: char| c.is_whitespace())
2550 .char_indices()
2551 .rev()
2552 .find_map(|(index, character)| character.is_whitespace().then_some(index))
2553 .map(|index| before[..index].trim_end().len())
2554 .unwrap_or(0);
2555 self.composer_input.drain(target..self.composer_cursor);
2556 self.composer_cursor = target;
2557 }
2558
2559 pub fn abort_selected_agent(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
2560 let Some(agent) = self.selected_agent.clone() else {
2561 self.status = "No active agent to abort".into();
2562 return;
2563 };
2564 let (call, context) = match self.tool_request(
2565 "glass.agent.abort",
2566 serde_json::json!({"agentId": agent.as_str()}),
2567 true,
2568 ) {
2569 Ok(request) => request,
2570 Err(error) => {
2571 self.status = format!("Abort unavailable: {error}");
2572 return;
2573 }
2574 };
2575 match worker.submit_tool(call, context) {
2576 Ok(id) => {
2577 self.running_tool_job = Some(id);
2578 self.status = format!("Stopping {} in background…", agent.as_str());
2579 }
2580 Err(error) => self.status = format!("Abort unavailable: {error}"),
2581 }
2582 }
2583
2584 pub fn insert_composer_newline(&mut self) {
2585 self.insert_composer_text("\n");
2586 self.status = "Shift-Enter newline · Enter send · ↑ history".into();
2587 }
2588
2589 pub fn navigate_composer_history(&mut self, previous: bool) {
2590 if previous && !self.composer_on_first_line() {
2591 self.move_composer_line(-1);
2592 return;
2593 }
2594 if !previous && !self.composer_on_last_line() {
2595 self.move_composer_line(1);
2596 return;
2597 }
2598 if self.composer_history.is_empty() {
2599 return;
2600 }
2601 if previous {
2602 let index = match self.composer_history_index {
2603 None => {
2604 self.composer_history_draft = self.composer_input.clone();
2605 self.composer_history.len().saturating_sub(1)
2606 }
2607 Some(0) => 0,
2608 Some(index) => index - 1,
2609 };
2610 self.composer_history_index = Some(index);
2611 self.composer_input = self.composer_history[index].clone();
2612 self.composer_cursor = self.composer_input.len();
2613 return;
2614 }
2615 match self.composer_history_index {
2616 None => {}
2617 Some(index) if index + 1 < self.composer_history.len() => {
2618 self.composer_history_index = Some(index + 1);
2619 self.composer_input = self.composer_history[index + 1].clone();
2620 self.composer_cursor = self.composer_input.len();
2621 }
2622 Some(_) => {
2623 self.composer_history_index = None;
2624 self.composer_input = std::mem::take(&mut self.composer_history_draft);
2625 self.composer_cursor = self.composer_input.len();
2626 }
2627 }
2628 }
2629
2630 fn composer_on_first_line(&self) -> bool {
2631 !self.composer_input[..self.composer_cursor.min(self.composer_input.len())].contains('\n')
2632 }
2633
2634 fn composer_on_last_line(&self) -> bool {
2635 !self.composer_input[self.composer_cursor.min(self.composer_input.len())..].contains('\n')
2636 }
2637
2638 fn move_composer_line(&mut self, delta: i32) {
2639 let cursor = self.composer_cursor.min(self.composer_input.len());
2640 if delta < 0 {
2641 if let Some(offset) = self.composer_input[..cursor].rfind('\n') {
2642 self.composer_cursor = offset;
2643 }
2644 return;
2645 }
2646 if let Some(relative) = self.composer_input[cursor..].find('\n') {
2647 self.composer_cursor = (cursor + relative + 1).min(self.composer_input.len());
2648 }
2649 }
2650
2651 pub fn remember_composer_history(&mut self, text: &str) {
2652 let trimmed = text.trim();
2653 if trimmed.is_empty() {
2654 return;
2655 }
2656 if self.composer_history.last().map(String::as_str) != Some(trimmed) {
2657 self.composer_history.push(text.to_string());
2658 if self.composer_history.len() > 64 {
2659 self.composer_history.remove(0);
2660 }
2661 }
2662 self.composer_history_index = None;
2663 self.composer_history_draft.clear();
2664 }
2665
2666 pub fn open_file_picker(&mut self) {
2667 self.command_mode = false;
2668 self.file_picker_open = true;
2669 self.file_picker_query.clear();
2670 self.file_picker_cursor = 0;
2671 self.file_picker_selection = 0;
2672 self.status = if self.files.is_empty() {
2673 "Open file · no files yet · wait for refresh or Esc close".into()
2674 } else {
2675 format!(
2676 "Open file · {} paths · type to filter · Enter open · Esc close",
2677 self.files.len()
2678 )
2679 };
2680 }
2681
2682 pub fn close_file_picker(&mut self) {
2683 if !self.file_picker_open {
2684 return;
2685 }
2686 self.file_picker_open = false;
2687 self.file_picker_query.clear();
2688 self.file_picker_cursor = 0;
2689 self.file_picker_selection = 0;
2690 self.status = "File picker closed · Ctrl-P to reopen".into();
2691 }
2692
2693 pub fn file_picker_matches(&self) -> Vec<usize> {
2694 self.files
2695 .iter()
2696 .enumerate()
2697 .filter_map(|(index, path)| {
2698 fuzzy_contains(path, self.file_picker_query.trim()).then_some(index)
2699 })
2700 .collect()
2701 }
2702
2703 pub fn insert_file_picker_char(&mut self, character: char) {
2704 if character.is_control() {
2705 return;
2706 }
2707 self.file_picker_query
2708 .insert(self.file_picker_cursor, character);
2709 self.file_picker_cursor += character.len_utf8();
2710 self.file_picker_selection = 0;
2711 }
2712
2713 pub fn file_picker_backspace(&mut self) {
2714 if self.file_picker_cursor == 0 {
2715 return;
2716 }
2717 let previous = self.file_picker_query[..self.file_picker_cursor]
2718 .char_indices()
2719 .next_back()
2720 .map(|(index, _)| index)
2721 .unwrap_or(0);
2722 self.file_picker_query
2723 .drain(previous..self.file_picker_cursor);
2724 self.file_picker_cursor = previous;
2725 self.file_picker_selection = 0;
2726 }
2727
2728 pub fn move_file_picker_selection(&mut self, delta: i32) {
2729 let count = self.file_picker_matches().len();
2730 if count == 0 {
2731 self.file_picker_selection = 0;
2732 return;
2733 }
2734 self.file_picker_selection =
2735 (self.file_picker_selection as i32 + delta).rem_euclid(count as i32) as usize;
2736 }
2737
2738 pub fn submit_file_picker(&mut self) {
2739 let matches = self.file_picker_matches();
2740 let Some(&index) = matches.get(self.file_picker_selection) else {
2741 self.status = "No matching file".into();
2742 return;
2743 };
2744 self.selected_file = index;
2745 self.close_file_picker();
2746 self.open_selected_file_for_edit();
2747 }
2748
2749 pub fn open_path(&mut self, path: &str) -> Result<String, String> {
2750 if path.trim().is_empty() {
2751 return Err("open requires PATH".into());
2752 }
2753 if let Some(index) = self.files.iter().position(|item| {
2754 item == path || item.ends_with(path) || item.rsplit('/').next() == Some(path)
2755 }) {
2756 self.selected_file = index;
2757 } else {
2758 self.files.insert(0, path.to_string());
2759 self.selected_file = 0;
2760 }
2761 self.open_selected_file_for_edit();
2762 Ok(format!("Opened {path}"))
2763 }
2764
2765 pub fn insert_composer_text(&mut self, text: &str) {
2766 for character in text.chars().take(16_384) {
2767 self.composer_input.insert(self.composer_cursor, character);
2768 self.composer_cursor += character.len_utf8();
2769 }
2770 }
2771
2772 pub fn complete_composer_mention(&mut self) {
2773 match complete_mention(&self.composer_input, self.composer_cursor, &self.files) {
2774 Some((text, cursor)) => {
2775 self.composer_input = text;
2776 self.composer_cursor = cursor;
2777 self.status = "Mention completed · Tab cycles @file".into();
2778 }
2779 None => {
2780 self.status = "Mentions: @file @page @entity @workflow @workspace".into();
2781 }
2782 }
2783 }
2784
2785 pub fn composer_backspace(&mut self) {
2786 if self.composer_cursor == 0 {
2787 return;
2788 }
2789 let previous = self.composer_input[..self.composer_cursor]
2790 .char_indices()
2791 .next_back()
2792 .map(|(index, _)| index)
2793 .unwrap_or(0);
2794 self.composer_input.drain(previous..self.composer_cursor);
2795 self.composer_cursor = previous;
2796 }
2797
2798 pub fn submit_composer(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
2799 if self.composer_input.trim_start().starts_with('/') {
2800 self.submit_composer_slash(worker);
2801 return;
2802 }
2803 if self.composer_send_blocked() {
2804 self.status = "Background operation running · message kept in composer".into();
2805 return;
2806 }
2807 if self.snapshot_trust_label == "untrusted" {
2808 self.composer_mode = false;
2809 self.surface = DevSurface::Trust;
2810 self.status = "Trust this workspace before starting the Glass Agent · T or 1".into();
2811 return;
2812 }
2813 if !self.agent_readiness.starts_with("✓ Ready") {
2814 self.status = "Pi is not ready · use :agent setup or :agent setup login".into();
2815 return;
2816 }
2817 if self.composer_input.trim().is_empty() {
2818 self.status = "Message is empty · type a prompt, then press Enter".into();
2819 return;
2820 }
2821 let file = if !self.focused_editor_path.is_empty() {
2822 Some(self.focused_editor_path.as_str())
2823 } else {
2824 self.files.get(self.selected_file).map(String::as_str)
2825 };
2826 let display_text = expand_mentions(&self.composer_input, file);
2827 let text = expand_mentions(&std::mem::take(&mut self.composer_input), file);
2828 self.remember_composer_history(&text);
2829 if self.composer_run_mode == crate::AgentTurnMode::Plan {
2830 self.capture_plan_from_goal(&text);
2831 }
2832 let prove = compile_prove_it(&text);
2833 let steer = self.composer_steer;
2834 let queued_follow_up = self.agent_send_job.is_some();
2835 self.composer_cursor = 0;
2836 self.composer_steer = false;
2837 self.composer_mode = true;
2838 let _ = self.ws_mut().map(|mut workspace| {
2839 workspace.set_agent_turn_mode(self.composer_run_mode);
2840 });
2841 let mut context = self.agent_browser_context();
2842 context["editor"] = self.agent_editor_context();
2843 context["surface"] = serde_json::Value::String(self.surface.label().to_ascii_lowercase());
2844 context["runMode"] =
2845 serde_json::Value::String(self.composer_run_mode.label().to_ascii_lowercase());
2846 context["playbook"] =
2847 serde_json::Value::String(super::playbooks::playbook_name(self.surface).into());
2848 context["playbookText"] =
2849 serde_json::Value::String(super::playbooks::playbook(self.surface).into());
2850 context["todos"] =
2851 serde_json::to_value(&self.session_todos).unwrap_or(serde_json::json!({}));
2852 if let Some(path) = self.selected_git_entry().map(|entry| entry.path.clone()) {
2853 context["git"] = serde_json::json!({
2854 "branch": self.git_branch,
2855 "selectedPath": path,
2856 });
2857 }
2858 if let Some(process) = self.selected_process_entry() {
2859 context["process"] = serde_json::json!({
2860 "name": process.name,
2861 "health": process.health.label(),
2862 "pid": process.pid,
2863 "url": process.url,
2864 });
2865 }
2866 if let Some(session) = self.selected_debug_session() {
2867 context["debug"] = serde_json::json!({
2868 "session": session.name,
2869 "state": session.state.label(),
2870 "threadId": self.selected_debug_thread().map(|thread| thread.id),
2871 "frameId": self.selected_debug_frame().map(|frame| frame.id),
2872 "path": self.selected_debug_frame().and_then(|frame| frame.path.clone()),
2873 "line": self.selected_debug_frame().and_then(|frame| frame.line),
2874 });
2875 }
2876 if let Some(plan) = &self.pending_plan {
2877 context["plan"] = serde_json::json!({
2878 "id": plan.id,
2879 "goal": plan.goal,
2880 "accepted": plan.accepted,
2881 });
2882 }
2883 if let Some(comment) = &self.last_app_comment {
2884 context["appComment"] = serde_json::Value::String(comment.clone());
2885 }
2886 if context["browser"]["selectedEntity"].is_object() {
2887 self.browser_workspace.state_mut().input_owner =
2888 glass_browser::browser_workspace::BrowserInputOwner::Agent;
2889 }
2890 let playbook = super::playbooks::playbook(self.surface);
2891 let prefixed = match self.composer_run_mode.instruction() {
2892 "" => format!("{playbook}\n\n{text}"),
2893 instruction => format!("{instruction}\n\n{playbook}\n\n{text}"),
2894 };
2895 let mut arguments = serde_json::json!({
2896 "text": prefixed,
2897 "mode": if steer { "steer" } else { "follow-up" },
2898 "context": context,
2899 });
2900 if let Some(prove) = prove {
2901 arguments["verify"] = prove.verify.clone();
2902 arguments["intent"] = serde_json::Value::String(prove.intent);
2903 self.pending_verify = Some(prove.verify);
2904 self.last_proof_ok = None;
2905 self.last_verify = Some(evidence_card(
2906 arguments["context"]["browser"]["url"]
2907 .as_str()
2908 .unwrap_or("about:blank"),
2909 arguments["context"]["browser"]["revision"]
2910 .as_u64()
2911 .unwrap_or(0),
2912 arguments["context"]["browser"]["selectedEntity"].as_str(),
2913 "composer prove-it queued",
2914 false,
2915 ));
2916 self.auto_checkpoint("before-prove-it");
2917 }
2918 if let Some(agent) = self.selected_agent.as_ref() {
2919 arguments["agentId"] = serde_json::Value::String(agent.as_str().to_string());
2920 }
2921 let (call, context) = match self.tool_request("glass.agent.send", arguments, true) {
2922 Ok(request) => request,
2923 Err(error) => {
2924 self.composer_input = display_text;
2925 self.composer_cursor = self.composer_input.len();
2926 self.status = format!("Message unavailable · edit and retry: {error}");
2927 return;
2928 }
2929 };
2930 match worker.submit_tool(call, context) {
2931 Ok(id) => {
2932 self.agent_send_job = Some(id);
2933 self.pending_chat_messages.push(PendingChatMessage {
2934 text: display_text,
2935 state: ChatMessageState::Sending,
2936 job_id: Some(id),
2937 error: None,
2938 });
2939 self.status = if steer {
2940 "Sent · steering Glass Agent…".into()
2941 } else if self.composer_run_mode == crate::AgentTurnMode::Plan {
2942 "Plan turn · inspect only · :plan accept when ready".into()
2943 } else if queued_follow_up {
2944 "Queued follow-up · Glass Agent will continue".into()
2945 } else {
2946 format!("Sent · {} is thinking…", self.composer_run_mode.label())
2947 };
2948 worker.request_conversation();
2949 }
2950 Err(error) => {
2951 self.composer_input = display_text;
2952 self.composer_cursor = self.composer_input.len();
2953 self.status = format!("Message unavailable · edit and retry: {error}");
2954 }
2955 }
2956 }
2957
2958 fn submit_composer_slash(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
2959 let raw = self.composer_input.trim().to_string();
2960 let mut parts = raw.trim_start_matches('/').split_whitespace();
2961 let Some(command) = parts.next() else {
2962 self.status = "Empty slash command".into();
2963 return;
2964 };
2965 let rest = parts.collect::<Vec<_>>();
2966 let mut arguments = serde_json::json!({});
2967 if let Some(agent) = self.selected_agent.as_ref() {
2968 arguments["agentId"] = serde_json::Value::String(agent.as_str().to_string());
2969 }
2970 let (tool, mutating) = match command {
2971 "compact" => {
2972 if !rest.is_empty() {
2973 arguments["instructions"] = serde_json::Value::String(rest.join(" "));
2974 }
2975 ("glass.agent.compact", true)
2976 }
2977 "model" => {
2978 let provider = rest.first().copied().unwrap_or("");
2979 let model = rest.get(1).copied().unwrap_or("");
2980 if provider.is_empty() || model.is_empty() {
2981 self.status = "/model requires PROVIDER MODEL".into();
2982 return;
2983 }
2984 arguments["provider"] = serde_json::Value::String(provider.into());
2985 arguments["modelId"] = serde_json::Value::String(model.into());
2986 self.agent_model = format!("{provider}/{model}");
2987 ("glass.agent.model", true)
2988 }
2989 "think" | "thinking" => {
2990 let level = rest.first().copied().unwrap_or("");
2991 if level.is_empty() {
2992 self.status = "/think requires LEVEL".into();
2993 return;
2994 }
2995 arguments["level"] = serde_json::Value::String(level.into());
2996 self.agent_thinking = level.into();
2997 ("glass.agent.thinking", true)
2998 }
2999 "new" => ("glass.agent.new-session", true),
3000 "clone" => ("glass.agent.clone-session", true),
3001 "name" => {
3002 let name = rest.join(" ");
3003 if name.is_empty() {
3004 self.status = "/name requires TITLE".into();
3005 return;
3006 }
3007 arguments["name"] = serde_json::Value::String(name.clone());
3008 self.agent_session_name = name;
3009 ("glass.agent.name", true)
3010 }
3011 "stats" => ("glass.agent.stats", false),
3012 "sessions" => ("glass.agent.sessions", false),
3013 "tree" => ("glass.agent.tree", false),
3014 "todo" => {
3015 self.composer_input = self.session_todos.render();
3016 self.composer_cursor = 0;
3017 self.status = "Session todos · edit or Esc".into();
3018 return;
3019 }
3020 "ask" | "plan" | "agent" => {
3021 let mode = match command {
3022 "ask" => crate::AgentTurnMode::Ask,
3023 "plan" => crate::AgentTurnMode::Plan,
3024 _ => crate::AgentTurnMode::Agent,
3025 };
3026 self.set_composer_run_mode(mode);
3027 self.remember_composer_history(&raw);
3028 self.composer_input = rest.join(" ");
3029 self.composer_cursor = self.composer_input.len();
3030 if self.composer_input.trim().is_empty() {
3031 return;
3032 }
3033 self.submit_composer(worker);
3034 return;
3035 }
3036 _ => {
3037 self.status = format!("Unknown slash command /{command}");
3038 return;
3039 }
3040 };
3041 match self.tool_request(tool, arguments, mutating) {
3042 Ok((call, context)) => match worker.submit_tool(call, context) {
3043 Ok(id) => {
3044 self.running_tool_job = Some(id);
3045 self.remember_composer_history(&raw);
3046 self.composer_input.clear();
3047 self.composer_cursor = 0;
3048 self.status = format!("{tool} · queued from composer");
3049 }
3050 Err(error) => self.status = format!("{tool} failed: {error}"),
3051 },
3052 Err(error) => self.status = format!("{tool} unavailable: {error}"),
3053 }
3054 }
3055
3056 pub fn approve_confirmation_async(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
3057 let Some(pending) = self.pending_confirmation.take() else {
3058 return;
3059 };
3060 match worker.submit_tool(pending.call, pending.context) {
3061 Ok(id) => {
3062 self.running_tool_job = Some(id);
3063 self.status = format!(
3064 "Running {} · Esc keeps the workspace responsive",
3065 pending.summary
3066 );
3067 }
3068 Err(error) => self.status = format!("Could not queue mutation: {error}"),
3069 }
3070 }
3071
3072 pub fn resolve_agent_approval(
3073 &mut self,
3074 approved: bool,
3075 worker: &mut super::snapshot::SnapshotWorker,
3076 ) {
3077 let Some(pending) = self.pending_agent_approval.take() else {
3078 return;
3079 };
3080 let arguments = serde_json::json!({
3081 "agentId": pending.agent_id,
3082 "frameId": pending.frame_id,
3083 "approved": approved,
3084 });
3085 let (call, context) = match self.tool_request("glass.agent.approve", arguments, true) {
3086 Ok(request) => request,
3087 Err(error) => {
3088 self.pending_agent_approval = Some(pending);
3089 self.status = format!("Agent approval unavailable: {error}");
3090 return;
3091 }
3092 };
3093 match worker.submit_tool(call, context) {
3094 Ok(id) => {
3095 self.running_tool_job = Some(id);
3096 self.status = if approved {
3097 format!("Approved {} · Glass Agent continues…", pending.tool_name)
3098 } else {
3099 format!("Denied {} · Glass Agent continues…", pending.tool_name)
3100 };
3101 }
3102 Err(error) => {
3103 self.pending_agent_approval = Some(pending);
3104 self.status = format!("Could not queue agent approval: {error}");
3105 }
3106 }
3107 }
3108
3109 pub fn apply_visual_job_result(&mut self, result: super::snapshot::VisualJobResult) {
3110 self.apply_visual_job_result_with_fit(
3111 result,
3112 glass_browser::terminal_graphics::FrameFit::Contain,
3113 );
3114 }
3115
3116 pub fn apply_visual_job_result_with_fit(
3117 &mut self,
3118 result: super::snapshot::VisualJobResult,
3119 fit: glass_browser::terminal_graphics::FrameFit,
3120 ) {
3121 let png = match result.result {
3122 Ok(value) => {
3123 let Some(encoded) = value.get("base64").and_then(serde_json::Value::as_str) else {
3124 self.browser_visual_live = false;
3125 self.browser_workspace.state_mut().presentation_reason =
3126 Some("screenshot payload did not contain base64 PNG data".into());
3127 self.status = "Live view unavailable · screenshot payload was empty".into();
3128 return;
3129 };
3130 use base64::Engine as _;
3131 match base64::engine::general_purpose::STANDARD.decode(encoded) {
3132 Ok(png) => png,
3133 Err(error) => {
3134 self.browser_visual_live = false;
3135 self.browser_workspace.state_mut().presentation_reason =
3136 Some(format!("screenshot payload was not valid base64: {error}"));
3137 self.status = "Live view unavailable · invalid screenshot payload".into();
3138 return;
3139 }
3140 }
3141 }
3142 Err(error) => {
3143 self.browser_visual_live = false;
3144 self.browser_workspace.state_mut().presentation_reason =
3145 Some(format!("browser screenshot failed: {error}"));
3146 self.status = format!("Live view unavailable · {error}");
3147 return;
3148 }
3149 };
3150 match AnsiPane::from_png(
3151 &mut self.browser_ansi,
3152 &png,
3153 result.columns.clamp(8, 80),
3154 result.rows.clamp(4, 40),
3155 fit,
3156 ) {
3157 Ok(pane) => {
3158 self.browser_pane = Some(pane);
3159 let browser = self.browser_workspace.state_mut();
3160 browser.presentation =
3161 glass_browser::browser_workspace::BrowserPresentationPath::Ansi;
3162 browser.frame_revision = browser.browser_revision;
3163 browser.presentation_reason = Some(
3164 "bounded ANSI half-block frame · semantic controls remain authoritative".into(),
3165 );
3166 self.status = "Live view updated · ANSI half-block".into();
3167 }
3168 Err(error) => {
3169 self.browser_visual_live = false;
3170 self.browser_workspace.state_mut().presentation_reason = Some(error.to_string());
3171 self.status = format!("Live view unavailable: {error}");
3172 }
3173 }
3174 }
3175
3176 pub fn queue_tool_request(
3177 &mut self,
3178 call: crate::development::ToolCall,
3179 context: crate::tools::DevelopmentToolContext,
3180 ) -> Result<(), String> {
3181 if self.background_action_running() {
3182 return Err("another background tool is already running".into());
3183 }
3184 self.queued_tool_request = Some((call, context));
3185 Ok(())
3186 }
3187 pub(super) fn queue_or_confirm(
3188 &mut self,
3189 call: crate::development::ToolCall,
3190 context: crate::tools::DevelopmentToolContext,
3191 summary: String,
3192 ) -> Result<bool, String> {
3193 if self.yolo_mode {
3194 self.queue_tool_request(call, context)?;
3195 self.status = format!("YOLO · {summary} queued");
3196 Ok(true)
3197 } else {
3198 self.pending_confirmation = Some(PendingConfirmation {
3199 call,
3200 context,
3201 summary,
3202 });
3203 Ok(false)
3204 }
3205 }
3206
3207 pub fn submit_pending_verify(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
3208 let Some(predicate) = self.pending_verify.take() else {
3209 return;
3210 };
3211 let arguments = serde_json::json!({ "predicate": predicate, "timeoutSeconds": 8 });
3212 let (call, context) = match self.tool_request("glass.browser.verify", arguments, false) {
3213 Ok(request) => request,
3214 Err(error) => {
3215 self.last_proof_ok = Some(false);
3216 self.status = format!("Prove-it unavailable: {error}");
3217 return;
3218 }
3219 };
3220 match worker.submit_tool(call, context) {
3221 Ok(id) => {
3222 self.running_tool_job = Some(id);
3223 self.status = "Prove-it running against the live page".into();
3224 }
3225 Err(error) => {
3226 self.last_proof_ok = Some(false);
3227 self.status = format!("Prove-it failed to start: {error}");
3228 }
3229 }
3230 }
3231
3232 pub fn submit_queued_tool(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
3233 let Some((call, context)) = self.queued_tool_request.take() else {
3234 return;
3235 };
3236 match worker.submit_tool(call, context) {
3237 Ok(id) => {
3238 self.running_tool_job = Some(id);
3239 self.status.push_str(" · running in background");
3240 }
3241 Err(error) => self.status = format!("Could not queue tool: {error}"),
3242 }
3243 }
3244
3245 pub fn apply_tool_job_result(&mut self, result: super::snapshot::ToolJobResult) {
3246 if result.tool == "glass.agent.send" && self.agent_send_job == Some(result.id) {
3247 self.agent_send_job = None;
3248 match result.result {
3249 Ok(value) => {
3250 let agent = value
3251 .get("agentId")
3252 .and_then(serde_json::Value::as_str)
3253 .and_then(|value| crate::AgentId::parse(value).ok());
3254 let restarted = value
3255 .get("restarted")
3256 .and_then(serde_json::Value::as_bool)
3257 .unwrap_or(false);
3258 if let Some(agent_id) = agent {
3259 self.selected_agent = Some(agent_id.clone());
3260 self.status = if restarted {
3261 format!("Restarted {} · Glass Agent is thinking…", agent_id.as_str())
3262 } else {
3263 format!("Sent to {} · Glass Agent is thinking…", agent_id.as_str())
3264 };
3265 } else {
3266 self.status = if restarted {
3267 "Restarted Glass Agent · thinking…".into()
3268 } else {
3269 "Sent · Glass Agent is thinking…".into()
3270 };
3271 }
3272 if let Some(message) = self
3273 .pending_chat_messages
3274 .iter_mut()
3275 .find(|message| message.job_id == Some(result.id))
3276 {
3277 message.state = ChatMessageState::Sent;
3278 message.job_id = None;
3279 }
3280 }
3281 Err(error) => {
3282 let failed_text = self
3283 .pending_chat_messages
3284 .iter_mut()
3285 .find(|message| message.job_id == Some(result.id))
3286 .map(|message| {
3287 message.state = ChatMessageState::Failed;
3288 message.job_id = None;
3289 message.error = Some(error.clone());
3290 message.text.clone()
3291 });
3292 if self.composer_input.is_empty()
3293 && let Some(text) = failed_text
3294 {
3295 self.composer_input = text;
3296 self.composer_cursor = self.composer_input.len();
3297 }
3298 self.composer_mode = true;
3299 self.status = format!("Could not send message · edit and retry: {error}");
3300 }
3301 }
3302 return;
3303 }
3304
3305 if self.running_tool_job != Some(result.id) {
3306 return;
3307 }
3308 self.running_tool_job = None;
3309 match result.result {
3310 Ok(value) => {
3311 if result.tool == "glass.agent.sessions" {
3312 self.open_session_picker(&value);
3313 return;
3314 }
3315 if result.tool == "glass.agent.stats" {
3316 self.agent_token_summary = stats_summary(&value);
3317 self.status = format!("Session stats · {}", self.agent_token_summary);
3318 return;
3319 }
3320 if result.tool == "glass.browser.verify" {
3321 let ok = value.get("status").and_then(serde_json::Value::as_str)
3322 == Some("satisfied");
3323 self.last_proof_ok = Some(ok);
3324 self.last_verify = Some(evidence_card(
3325 value
3326 .pointer("/predicate/urlEquals")
3327 .and_then(serde_json::Value::as_str)
3328 .or_else(|| value.get("state").and_then(serde_json::Value::as_str))
3329 .unwrap_or("live page"),
3330 value
3331 .get("elapsedMs")
3332 .and_then(serde_json::Value::as_u64)
3333 .unwrap_or(0),
3334 None,
3335 value
3336 .get("state")
3337 .and_then(serde_json::Value::as_str)
3338 .unwrap_or("verify"),
3339 ok,
3340 ));
3341 self.status = if ok {
3342 "Prove-it passed · gutter ✓".into()
3343 } else {
3344 "Prove-it failed · inspect last verify".into()
3345 };
3346 } else if result.tool.starts_with("glass.browser") {
3347 self.apply_browser_result(&result.tool, &value);
3348 self.browser_detail = super::projection::browser_result(&result.tool, &value);
3349 if result.tool == "glass.browser.act" || result.tool == "glass.browser.navigate"
3350 {
3351 self.browser_observe_pending = true;
3352 self.watch_agent_on_app(&result.tool, &value);
3353 }
3354 } else if result.tool == "glass.process.logs" {
3355 self.process_logs = value
3356 .get("output")
3357 .and_then(serde_json::Value::as_str)
3358 .unwrap_or_default()
3359 .chars()
3360 .rev()
3361 .take(8 * 1024)
3362 .collect::<String>()
3363 .chars()
3364 .rev()
3365 .collect();
3366 self.surface = DevSurface::Terminal;
3367 self.status = format!(
3368 "Logs · {}",
3369 value
3370 .get("name")
3371 .and_then(serde_json::Value::as_str)
3372 .unwrap_or("process")
3373 );
3374 } else if result.tool == "glass.debug.threads" {
3375 self.debug_threads = parse_debug_threads(&value);
3376 self.selected_debug_thread = self
3377 .selected_debug_thread
3378 .min(self.debug_threads.len().saturating_sub(1));
3379 self.debug_frames.clear();
3380 if !self.debug_threads.is_empty() {
3381 self.debug_pane = DebugPane::Threads;
3382 self.debug_stack_requested = true;
3383 }
3384 self.status = format!(
3385 "{} thread(s) · Enter stack · Space continue",
3386 self.debug_threads.len()
3387 );
3388 } else if result.tool == "glass.debug.stack" {
3389 self.debug_frames = parse_debug_frames(&value);
3390 self.selected_debug_frame = 0;
3391 if !self.debug_frames.is_empty() {
3392 self.debug_pane = DebugPane::Frames;
3393 self.debug_scopes_requested = true;
3394 }
3395 self.status = format!(
3396 "{} frame(s) · Enter jumps to source",
3397 self.debug_frames.len()
3398 );
3399 } else if result.tool == "glass.debug.scopes" {
3400 self.debug_scopes = parse_debug_scopes(&value);
3401 self.selected_debug_scope = 0;
3402 self.debug_variables.clear();
3403 if !self.debug_scopes.is_empty() {
3404 self.debug_variables_requested = true;
3405 }
3406 self.status = format!("{} scope(s)", self.debug_scopes.len());
3407 } else if result.tool == "glass.debug.variables" {
3408 self.debug_variables = parse_debug_variables(&value);
3409 self.status = format!("{} variable(s)", self.debug_variables.len());
3410 } else if result.tool == "glass.git.diff" {
3411 let empty = value.as_str().is_none_or(|diff| diff.trim().is_empty());
3412 self.git_diff = if empty {
3413 self.git_diff_path
3414 .as_deref()
3415 .map(|path| format!("{path}\n\nNo tracked diff for this file."))
3416 .unwrap_or_else(|| "Working tree clean · no diff to show".into())
3417 } else {
3418 value.as_str().unwrap_or_default().to_string()
3419 };
3420 self.git_diff_open = true;
3421 self.status = self
3422 .git_diff_path
3423 .as_deref()
3424 .map(|path| format!("Git diff · {path} · PgUp/PgDn scroll · Esc closes"))
3425 .unwrap_or_else(|| "Git diff · PgUp/PgDn scroll · Esc closes".into());
3426 } else if result.tool == "glass.agent.setup" {
3427 match self.refresh_agent_readiness() {
3428 Ok(true) => {
3429 self.open_composer();
3430 self.status =
3431 "Pi runtime ready · type a prompt, then press Enter".into();
3432 }
3433 Ok(false) => {
3434 self.status =
3435 "Pi runtime installed · use :agent setup login, then Enter to chat"
3436 .into();
3437 }
3438 Err(error) => self.status = format!("Pi readiness check failed: {error}"),
3439 }
3440 } else if result.tool == "glass.agent.send" {
3441 if let Some(agent_id) = value
3442 .get("agentId")
3443 .and_then(serde_json::Value::as_str)
3444 .and_then(|value| crate::AgentId::parse(value).ok())
3445 {
3446 self.selected_agent = Some(agent_id.clone());
3447 self.status =
3448 format!("Sent to {} · Glass Agent is thinking…", agent_id.as_str());
3449 } else {
3450 self.status = "Sent · Glass Agent is thinking…".into();
3451 }
3452 } else if result.tool == "glass.agent.delegate" {
3453 self.surface = DevSurface::Agent;
3454 let harness = value
3455 .get("harness")
3456 .and_then(serde_json::Value::as_str)
3457 .unwrap_or("external harness");
3458 let outcome = if value.get("success").and_then(serde_json::Value::as_bool)
3459 == Some(true)
3460 {
3461 "completed"
3462 } else if value.get("timedOut").and_then(serde_json::Value::as_bool)
3463 == Some(true)
3464 {
3465 "timed out"
3466 } else {
3467 "failed"
3468 };
3469 let detail = super::projection::external_agent_output(&value);
3470 self.status = format!("Temporary {harness} {outcome} · {detail}");
3471 } else if result.tool == "glass.github.review" {
3472 match serde_json::from_value::<crate::github::GitHubReview>(value) {
3473 Ok(review) => {
3474 self.github = crate::github::GitHubStatus {
3475 repository: review.repository.clone(),
3476 availability: review.availability,
3477 };
3478 self.github_review = review.display();
3479 self.surface = DevSurface::Git;
3480 self.status = "GitHub review refreshed".into();
3481 }
3482 Err(error) => {
3483 self.status = format!("GitHub review response invalid: {error}");
3484 }
3485 }
3486 } else if result.tool == "glass.github.ship" {
3487 self.surface = DevSurface::Git;
3488 self.status = value
3489 .get("url")
3490 .and_then(serde_json::Value::as_str)
3491 .map(|url| format!("Pull request created · {url}"))
3492 .unwrap_or_else(|| "Pull request created · review GitHub status".into());
3493 } else if result.tool == "glass.task.wake" {
3494 self.last_crew_wake = serde_json::from_value::<crate::CrewWake>(value.clone())
3495 .ok()
3496 .map(|wake| wake.render());
3497 self.surface = DevSurface::Tasks;
3498 self.status = "Crew wake loaded · :review".into();
3499 } else if result.tool == "glass.task.crew" {
3500 let wake = value.get("wake").cloned().unwrap_or_else(|| value.clone());
3501 self.last_crew_wake = serde_json::from_value::<crate::CrewWake>(wake)
3502 .ok()
3503 .map(|wake| wake.render())
3504 .or_else(|| {
3505 value
3506 .get("goal")
3507 .and_then(serde_json::Value::as_str)
3508 .map(|goal| format!("WAKE\n goal {goal}"))
3509 });
3510 self.surface = DevSurface::Tasks;
3511 self.status = format!(
3512 "Crew wake {} · :review",
3513 value
3514 .pointer("/wake/id")
3515 .and_then(serde_json::Value::as_str)
3516 .unwrap_or("queued")
3517 );
3518 } else if result.tool.starts_with("glass.lsp") {
3519 if result.tool == "glass.lsp.inlay_hints" {
3520 self.editor_inlays =
3521 parse_inlay_hints(value.get("result").unwrap_or(&value));
3522 }
3523 if result.tool == "glass.lsp.diagnostics" {
3524 self.editor_diagnostics =
3525 parse_editor_diagnostics(value.get("result").unwrap_or(&value));
3526 }
3527 self.editor = if result.tool == "glass.lsp.diagnostics" {
3528 super::projection::lsp(Some(&value))
3529 } else {
3530 super::projection::first_meaningful(&value)
3531 };
3532 }
3533 if !matches!(
3534 result.tool.as_str(),
3535 "glass.agent.send"
3536 | "glass.agent.setup"
3537 | "glass.agent.delegate"
3538 | "glass.git.diff"
3539 | "glass.github.review"
3540 | "glass.github.ship"
3541 | "glass.browser.verify"
3542 | "glass.task.crew"
3543 | "glass.task.wake"
3544 | "glass.process.logs"
3545 | "glass.debug.threads"
3546 | "glass.debug.stack"
3547 | "glass.debug.scopes"
3548 | "glass.debug.variables"
3549 ) {
3550 self.status = format!("Completed {} · workspace refreshed", result.tool);
3551 }
3552 }
3553 Err(error) => {
3554 if result.tool == "glass.browser.verify" {
3555 self.last_proof_ok = Some(false);
3556 self.last_verify = Some(evidence_card("live page", 0, None, &error, false));
3557 }
3558 if result.tool.starts_with("glass.browser") {
3559 self.note_browser_failure(&result.tool, &error);
3560 }
3561 if result.tool == "glass.git.diff" {
3562 self.git_diff = format!("Git diff unavailable: {error}");
3563 self.git_diff_open = true;
3564 }
3565 self.status = format!("{} failed: {error}", result.tool);
3566 }
3567 }
3568 }
3569
3570 pub fn deny_confirmation(&mut self) {
3571 self.pending_browser_navigation = None;
3572 self.pending_page_entity = None;
3573 if let Some(pending) = self.pending_confirmation.take() {
3574 self.status = format!("Denied · {}", pending.summary);
3575 }
3576 }
3577
3578 pub fn prepare_browser_navigation(&mut self, url: &str) -> Result<String, String> {
3580 if self.background_action_running() {
3581 return Err("another browser action is already awaiting or running".into());
3582 }
3583 if self.browser_workspace.state().connection == BrowserConnectionPhase::Connected {
3584 let (call, context) =
3585 self.tool_request("glass.browser.observe", serde_json::json!({}), false)?;
3586 self.pending_browser_navigation = Some(url.to_string());
3587 self.queued_tool_request = Some((call, context));
3588 self.surface = DevSurface::App;
3589 return Ok("Browser connected · refreshing page before navigation".into());
3590 }
3591 let (call, context) =
3592 self.tool_request("glass.browser.start", serde_json::json!({}), true)?;
3593 self.pending_browser_navigation = Some(url.to_string());
3594 let queued = self.queue_or_confirm(
3595 call,
3596 context,
3597 format!("Start browser before navigating to {url}"),
3598 )?;
3599 self.surface = DevSurface::App;
3600 Ok(if queued {
3601 "Browser detached · launching; navigation continues automatically".into()
3602 } else {
3603 "Browser detached · Enter approves launch; navigation continues automatically".into()
3604 })
3605 }
3606
3607 pub fn handle_printable(&mut self, character: char) {
3608 if character == ':' {
3609 self.open_palette();
3610 return;
3611 }
3612 if character == 'a' && self.surface != DevSurface::Agent {
3613 self.open_menu();
3614 return;
3615 }
3616 if self.surface == DevSurface::Trust {
3617 let decision = match character {
3618 'i' | 'I' => {
3619 self.status = "Inspecting exact repository configuration".into();
3620 return;
3621 }
3622 'o' | 'O' => Some(crate::LocalTrustDecision::OpenUntrusted),
3623 '1' => Some(crate::LocalTrustDecision::TrustOnce),
3624 'T' => Some(crate::LocalTrustDecision::TrustProject),
3625 _ => None,
3626 };
3627 if let Some(decision) = decision {
3628 self.queue_trust(decision);
3629 return;
3630 }
3631 }
3632 if self.surface == DevSurface::Agent && self.snapshot_trust_label == "untrusted" {
3633 let decision = match character {
3634 't' => Some(crate::LocalTrustDecision::TrustOnce),
3635 'T' => Some(crate::LocalTrustDecision::TrustProject),
3636 _ => None,
3637 };
3638 if let Some(decision) = decision {
3639 self.queue_trust(decision);
3640 return;
3641 }
3642 }
3643
3644 if self.surface == DevSurface::Agent
3647 && self.snapshot_trust_label != "untrusted"
3648 && !character.is_ascii_digit()
3649 {
3650 if self.agent_readiness.starts_with("✓ Ready") {
3651 self.open_composer();
3652 } else {
3653 self.start_agent_interaction();
3654 }
3655 if self.composer_mode {
3656 self.insert_composer_text(&character.to_string());
3657 }
3658 return;
3659 }
3660
3661 if self.surface == DevSurface::Code && character == 'i' {
3662 self.enter_code_edit();
3663 return;
3664 }
3665 if self.responsive_class(self.terminal_width, self.terminal_height)
3666 == ResponsiveClass::Phone
3667 {
3668 let surface = match character {
3669 '1' => Some(DevSurface::Agent),
3670 '2' => Some(DevSurface::Code),
3671 '3' => Some(DevSurface::App),
3672 '4' => Some(DevSurface::Tasks),
3673 '5' => Some(DevSurface::More),
3674 _ => None,
3675 };
3676 if let Some(surface) = surface {
3677 self.show_surface(surface);
3678 return;
3679 }
3680 }
3681 let surface = match character {
3682 '1' => Some(DevSurface::Agent),
3683 '2' | 'c' => Some(DevSurface::Code),
3684 '3' | 'v' => Some(DevSurface::App),
3685 '4' => Some(DevSurface::Terminal),
3686 '5' | 'w' => Some(DevSurface::Tasks),
3687 '6' | 'g' => Some(DevSurface::Git),
3688 '7' | 'd' => Some(DevSurface::Debug),
3689 '8' | 'm' => Some(DevSurface::More),
3690 _ => None,
3691 };
3692 if let Some(surface) = surface {
3693 self.show_surface(surface);
3694 } else if self.surface == DevSurface::Agent && self.snapshot_trust_label != "untrusted" {
3695 self.open_composer();
3696 self.insert_composer_text(&character.to_string());
3697 }
3698 }
3699 pub fn request_detected_dev(&mut self) {
3702 if self.background_action_running() {
3703 self.status = "Another background action is still running".into();
3704 return;
3705 }
3706 let command_result = {
3707 match self.ws() {
3708 Ok(workspace) => workspace
3709 .project()
3710 .detection()
3711 .dev_command
3712 .clone()
3713 .ok_or_else(|| "no detected dev command".to_string()),
3714 Err(error) => Err(error),
3715 }
3716 };
3717 let command = match command_result {
3718 Ok(command) => command,
3719 Err(error) if error == "no detected dev command" => {
3720 self.status =
3721 "No development command detected · use :process start NAME COMMAND".into();
3722 return;
3723 }
3724 Err(error) => {
3725 self.status = if error.to_string().contains("workspace busy") {
3726 "Development suite unavailable: workspace refresh is still running · use :s again"
3727 .into()
3728 } else {
3729 format!("Development command unavailable: {error}")
3730 };
3731 return;
3732 }
3733 };
3734 let (call, context) = match self.tool_request(
3735 "glass.process.start",
3736 serde_json::json!({"name": "dev", "command": command}),
3737 true,
3738 ) {
3739 Ok(request) => request,
3740 Err(error) => {
3741 self.status = format!("Development suite unavailable: {error}");
3742 return;
3743 }
3744 };
3745 let queued = match self.queue_or_confirm(
3746 call,
3747 context,
3748 "Start the detected development suite".into(),
3749 ) {
3750 Ok(queued) => queued,
3751 Err(error) => {
3752 self.status = format!("Development suite unavailable: {error}");
3753 return;
3754 }
3755 };
3756 self.surface = DevSurface::Terminal;
3757 if !queued {
3758 self.status = "Development suite ready · Enter approves once · Esc cancels".into();
3759 }
3760 }
3761
3762 pub fn show_surface(&mut self, surface: DevSurface) {
3763 self.surface = surface;
3764 self.status = format!("{} selected", surface.label());
3765 if surface != DevSurface::Code {
3766 self.pending_open_file = None;
3767 }
3768 if surface == DevSurface::Code && !self.code_edit_mode {
3769 self.queue_selected_file_preview();
3770 }
3771 if surface == DevSurface::Git {
3772 self.request_selected_git_diff();
3773 }
3774 }
3775
3776 pub fn queue_trust(&mut self, decision: crate::LocalTrustDecision) {
3777 if self.apply_trust(decision) {
3778 return;
3779 }
3780 self.pending_trust = Some(decision);
3781 self.status = "Trust queued · applying when the workspace is free".into();
3782 }
3783
3784 fn apply_trust(&mut self, decision: crate::LocalTrustDecision) -> bool {
3785 match self
3786 .workspace
3787 .try_lock()
3788 .and_then(|mut workspace| workspace.apply_local_trust_decision(decision))
3789 {
3790 Ok(trust) => {
3791 if self.surface == DevSurface::Trust {
3792 self.surface = DevSurface::Agent;
3793 }
3794 self.snapshot_trust_label = trust.label().into();
3795 self.status = format!("Workspace opened with {} authority", trust.label());
3796 true
3797 }
3798 Err(error) if error.to_string().contains("workspace busy") => false,
3799 Err(error) => {
3800 self.status = format!("Trust decision failed: {error}");
3801 true
3802 }
3803 }
3804 }
3805
3806 pub fn flush_pending_trust(&mut self) {
3807 let Some(decision) = self.pending_trust else {
3808 return;
3809 };
3810 if self.apply_trust(decision) {
3811 self.pending_trust = None;
3812 }
3813 }
3814
3815 fn queue_selected_file_preview(&mut self) {
3816 if self.files.is_empty() {
3817 self.pending_open_file = Some(String::new());
3818 return;
3819 }
3820 self.open_selected_file();
3821 }
3822
3823 pub fn flush_pending_open_file(&mut self) {
3824 if self.pending_open_file.is_none() {
3825 return;
3826 }
3827 if self.surface != DevSurface::Code || self.code_edit_mode {
3828 return;
3829 }
3830 if self.files.is_empty() {
3831 return;
3832 }
3833 let queued = self.pending_open_file.take().unwrap_or_default();
3834 if !queued.is_empty()
3835 && let Some(index) = self.files.iter().position(|path| path == &queued)
3836 {
3837 self.selected_file = index;
3838 }
3839 self.open_selected_file();
3840 }
3841
3842 fn request_selected_git_diff(&mut self) {
3843 if self.git_entries.is_empty() {
3844 return;
3845 }
3846 self.git_diff_requested = true;
3847 if let Some(path) = self.selected_git_entry().map(|entry| entry.path.clone()) {
3848 self.git_diff_path = Some(path);
3849 }
3850 if !self.git_diff_open {
3851 self.git_diff_open = true;
3852 self.git_diff = "Loading Git diff…".into();
3853 }
3854 }
3855
3856 fn is_workspace_busy(error: &impl std::fmt::Display) -> bool {
3857 error.to_string().contains("workspace busy")
3858 }
3859
3860 pub fn next_surface(&mut self) {
3861 let surfaces: &[DevSurface] = if self
3862 .responsive_class(self.terminal_width, self.terminal_height)
3863 == ResponsiveClass::Phone
3864 {
3865 &DevSurface::PHONE
3866 } else {
3867 &DevSurface::PRIMARY
3868 };
3869 let index = surfaces
3870 .iter()
3871 .position(|surface| *surface == self.surface)
3872 .unwrap_or(0);
3873 self.show_surface(surfaces[(index + 1) % surfaces.len()]);
3874 }
3875
3876 pub fn scroll_surface(&mut self, delta: i32) {
3877 let scroll = self.surface_scroll.entry(self.surface).or_default();
3878 *scroll = (*scroll as i64 + i64::from(delta)).max(0) as usize;
3879 }
3880
3881 pub fn scroll_home(&mut self) {
3882 self.surface_scroll.insert(self.surface, 0);
3883 }
3884
3885 pub fn scroll_end(&mut self) {
3886 let end = self.surface_content_height().saturating_sub(1);
3887 self.surface_scroll.insert(self.surface, end);
3888 }
3889
3890 fn surface_content_height(&self) -> usize {
3892 if self.surface == DevSurface::Agent {
3893 return self.conversation_view().lines().count().max(1);
3894 }
3895 let content = match self.surface {
3896 DevSurface::Code => &self.editor,
3897 DevSurface::App => &self.browser,
3898 DevSurface::Terminal => &self.processes,
3899 DevSurface::Tasks => &self.tasks,
3900 DevSurface::Git => &self.git,
3901 DevSurface::Debug => &self.debugger,
3902 DevSurface::More | DevSurface::Trust => &self.workspace_status,
3903 DevSurface::Agent => unreachable!("agent content handled above"),
3904 };
3905 content.lines().count().max(1)
3906 }
3907
3908 pub fn current_scroll(&self) -> u16 {
3909 self.surface_scroll
3910 .get(&self.surface)
3911 .copied()
3912 .unwrap_or(0)
3913 .min(u16::MAX as usize) as u16
3914 }
3915
3916 pub fn move_file_selection(&mut self, delta: i32) {
3917 if self.files.is_empty() {
3918 self.selected_file = 0;
3919 return;
3920 }
3921 self.selected_file = (self.selected_file as i32 + delta)
3922 .clamp(0, self.files.len().saturating_sub(1) as i32)
3923 as usize;
3924 if !self.code_edit_mode {
3925 self.open_selected_file();
3926 }
3927 }
3928 pub fn move_git_selection(&mut self, delta: i32) {
3929 if self.git_entries.is_empty() {
3930 self.selected_git_file = 0;
3931 self.status = "No changed files selected".into();
3932 return;
3933 }
3934 self.selected_git_file = (self.selected_git_file as i32 + delta)
3935 .clamp(0, self.git_entries.len().saturating_sub(1) as i32)
3936 as usize;
3937 if let Some(entry) = self.git_entries.get(self.selected_git_file) {
3938 self.status = format!(
3939 "{} · Enter diff · Space stage · c commit · o open",
3940 entry.path
3941 );
3942 self.git_diff_requested = true;
3943 }
3944 }
3945
3946 pub fn selected_git_entry(&self) -> Option<&crate::git::GitStatusEntry> {
3947 self.git_entries.get(self.selected_git_file)
3948 }
3949
3950 pub fn open_selected_git_file(&mut self) {
3951 let Some(path) = self.selected_git_entry().map(|entry| entry.path.clone()) else {
3952 self.status = "Select a changed file · o opens it in Code".into();
3953 return;
3954 };
3955 match self.open_path(&path) {
3956 Ok(_) => self.status = format!("Opened {path} in Code"),
3957 Err(error) => self.status = format!("Could not open {path}: {error}"),
3958 }
3959 }
3960
3961 pub fn compose_git_commit(&mut self) {
3962 self.open_palette_with("git commit ");
3963 self.status = "Commit · type a message, then Enter".into();
3964 }
3965
3966 pub fn discard_selected_git_file(&mut self) {
3967 let Some(path) = self.selected_git_entry().map(|entry| entry.path.clone()) else {
3968 self.status = "Select a changed file · x discards working-tree changes".into();
3969 return;
3970 };
3971 match self.tool_request(
3972 "glass.git.discard",
3973 serde_json::json!({"paths": [path.clone()]}),
3974 true,
3975 ) {
3976 Ok((call, context)) => {
3977 let _ = self.queue_or_confirm(call, context, format!("Discard {path}"));
3978 }
3979 Err(error) => self.status = format!("Git discard unavailable: {error}"),
3980 }
3981 }
3982
3983 pub fn queue_github_review(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
3984 if self.background_action_running() {
3985 self.status = "GitHub review waits for the current background operation".into();
3986 return;
3987 }
3988 let (call, context) =
3989 match self.tool_request("glass.github.review", serde_json::json!({}), false) {
3990 Ok(request) => request,
3991 Err(error) => {
3992 self.status = format!("GitHub review unavailable: {error}");
3993 return;
3994 }
3995 };
3996 match worker.submit_tool(call, context) {
3997 Ok(id) => {
3998 self.running_tool_job = Some(id);
3999 self.status = "Loading pull-request review…".into();
4000 }
4001 Err(error) => self.status = format!("GitHub review unavailable: {error}"),
4002 }
4003 }
4004
4005 pub fn move_process_selection(&mut self, delta: i32) {
4006 if self.process_entries.is_empty() {
4007 self.selected_process = 0;
4008 self.status = "No managed process selected".into();
4009 return;
4010 }
4011 self.selected_process = (self.selected_process as i32 + delta)
4012 .clamp(0, self.process_entries.len().saturating_sub(1) as i32)
4013 as usize;
4014 if let Some(entry) = self.selected_process_entry() {
4015 self.status = format!(
4016 "{} · {} · Enter logs · Space restart · u App · x stop",
4017 entry.name,
4018 entry.health.label()
4019 );
4020 self.process_logs_requested = true;
4021 }
4022 }
4023
4024 pub fn selected_process_entry(&self) -> Option<&ProcessRow> {
4025 self.process_entries.get(self.selected_process)
4026 }
4027
4028 pub fn queue_selected_process_logs(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
4029 let Some(name) = self
4030 .selected_process_entry()
4031 .map(|entry| entry.name.clone())
4032 else {
4033 self.status = "Select a process · j/k then Enter logs".into();
4034 return;
4035 };
4036 if self.background_action_running() {
4037 self.status = "Process logs wait for the current background operation".into();
4038 return;
4039 }
4040 let (call, context) = match self.tool_request(
4041 "glass.process.logs",
4042 serde_json::json!({"name": name}),
4043 false,
4044 ) {
4045 Ok(request) => request,
4046 Err(error) => {
4047 self.status = format!("Process logs unavailable: {error}");
4048 return;
4049 }
4050 };
4051 match worker.submit_tool(call, context) {
4052 Ok(id) => {
4053 self.running_tool_job = Some(id);
4054 self.status = format!("Loading logs for {name}…");
4055 }
4056 Err(error) => self.status = format!("Process logs unavailable: {error}"),
4057 }
4058 }
4059
4060 pub fn restart_selected_process(&mut self) {
4061 let Some(name) = self
4062 .selected_process_entry()
4063 .map(|entry| entry.name.clone())
4064 else {
4065 self.status = "Select a process · j/k then Space restarts".into();
4066 return;
4067 };
4068 match self.tool_request(
4069 "glass.process.restart",
4070 serde_json::json!({"name": name}),
4071 true,
4072 ) {
4073 Ok((call, context)) => {
4074 let _ = self.queue_or_confirm(call, context, format!("Restart {name}"));
4075 }
4076 Err(error) => self.status = format!("Process restart unavailable: {error}"),
4077 }
4078 }
4079
4080 pub fn stop_selected_process(&mut self) {
4081 let Some(name) = self
4082 .selected_process_entry()
4083 .map(|entry| entry.name.clone())
4084 else {
4085 self.status = "Select a process · x stops it".into();
4086 return;
4087 };
4088 match self.tool_request(
4089 "glass.process.stop",
4090 serde_json::json!({"name": name}),
4091 true,
4092 ) {
4093 Ok((call, context)) => {
4094 let _ = self.queue_or_confirm(call, context, format!("Stop {name}"));
4095 }
4096 Err(error) => self.status = format!("Process stop unavailable: {error}"),
4097 }
4098 }
4099
4100 pub fn attach_selected_process_url(&mut self) -> Result<String, String> {
4101 let url = self
4102 .selected_process_entry()
4103 .and_then(|entry| entry.url.clone())
4104 .or_else(|| self.resolved_app_url())
4105 .ok_or_else(|| {
4106 "No URL on the selected process · start a suite that prints one".to_string()
4107 })?;
4108 self.auto_checkpoint("before-app-attach");
4109 self.prepare_browser_navigation(&url)
4110 }
4111
4112 pub fn cycle_debug_pane(&mut self, delta: i32) {
4113 self.debug_pane = if delta < 0 {
4114 self.debug_pane.previous()
4115 } else {
4116 self.debug_pane.next()
4117 };
4118 self.status = format!(
4119 "Debug {} · j/k select · Enter · Space continue",
4120 self.debug_pane.label()
4121 );
4122 }
4123
4124 pub fn move_debug_selection(&mut self, delta: i32) {
4125 match self.debug_pane {
4126 DebugPane::Sessions => {
4127 if self.debug_sessions.is_empty() {
4128 self.selected_debug_session = 0;
4129 self.status = "No debugger session · :debug start NAME COMMAND".into();
4130 return;
4131 }
4132 self.selected_debug_session = (self.selected_debug_session as i32 + delta)
4133 .clamp(0, self.debug_sessions.len().saturating_sub(1) as i32)
4134 as usize;
4135 if let Some(session) = self.selected_debug_session() {
4136 self.status = format!(
4137 "{} · {} · Enter threads",
4138 session.name,
4139 session.state.label()
4140 );
4141 }
4142 }
4143 DebugPane::Threads => {
4144 if self.debug_threads.is_empty() {
4145 self.status = "No threads · Enter on a session to refresh".into();
4146 return;
4147 }
4148 self.selected_debug_thread = (self.selected_debug_thread as i32 + delta)
4149 .clamp(0, self.debug_threads.len().saturating_sub(1) as i32)
4150 as usize;
4151 if let Some(thread) = self.selected_debug_thread() {
4152 self.status = format!("{} · Enter stack · Space continue", thread.name);
4153 }
4154 }
4155 DebugPane::Frames => {
4156 if self.debug_frames.is_empty() {
4157 self.status = "No frames · Enter on a thread to load the stack".into();
4158 return;
4159 }
4160 self.selected_debug_frame = (self.selected_debug_frame as i32 + delta)
4161 .clamp(0, self.debug_frames.len().saturating_sub(1) as i32)
4162 as usize;
4163 if let Some(frame) = self.selected_debug_frame() {
4164 self.status = format!(
4165 "{} · Enter jumps to {}",
4166 frame.name,
4167 frame.path.as_deref().unwrap_or("source")
4168 );
4169 }
4170 }
4171 }
4172 }
4173
4174 pub fn selected_debug_session(&self) -> Option<&DebugSessionRow> {
4175 self.debug_sessions.get(self.selected_debug_session)
4176 }
4177
4178 pub fn selected_debug_thread(&self) -> Option<&DebugThreadRow> {
4179 self.debug_threads.get(self.selected_debug_thread)
4180 }
4181
4182 pub fn selected_debug_frame(&self) -> Option<&DebugFrameRow> {
4183 self.debug_frames.get(self.selected_debug_frame)
4184 }
4185
4186 pub fn activate_debug_selection(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
4187 match self.debug_pane {
4188 DebugPane::Sessions => self.queue_debug_threads(worker),
4189 DebugPane::Threads => self.queue_debug_stack(worker),
4190 DebugPane::Frames => self.jump_selected_debug_frame(),
4191 }
4192 }
4193
4194 pub fn queue_debug_threads(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
4195 let Some(session) = self.selected_debug_session().map(|row| row.name.clone()) else {
4196 self.status = "Start a debugger with :debug start NAME COMMAND".into();
4197 return;
4198 };
4199 if self.background_action_running() {
4200 self.status = "Debug threads wait for the current background operation".into();
4201 return;
4202 }
4203 let (call, context) = match self.tool_request(
4204 "glass.debug.threads",
4205 serde_json::json!({"session": session}),
4206 false,
4207 ) {
4208 Ok(request) => request,
4209 Err(error) => {
4210 self.status = format!("Debug threads unavailable: {error}");
4211 return;
4212 }
4213 };
4214 match worker.submit_tool(call, context) {
4215 Ok(id) => {
4216 self.running_tool_job = Some(id);
4217 self.status = format!("Loading threads for {session}…");
4218 }
4219 Err(error) => self.status = format!("Debug threads unavailable: {error}"),
4220 }
4221 }
4222
4223 pub fn queue_debug_stack(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
4224 let Some(session) = self.selected_debug_session().map(|row| row.name.clone()) else {
4225 self.status = "Select a debugger session first".into();
4226 return;
4227 };
4228 let Some(thread_id) = self.selected_debug_thread().map(|thread| thread.id) else {
4229 self.status = "Select a thread · Enter on a session first".into();
4230 return;
4231 };
4232 if self.background_action_running() {
4233 self.status = "Debug stack waits for the current background operation".into();
4234 return;
4235 }
4236 let (call, context) = match self.tool_request(
4237 "glass.debug.stack",
4238 serde_json::json!({"session": session, "threadId": thread_id}),
4239 false,
4240 ) {
4241 Ok(request) => request,
4242 Err(error) => {
4243 self.status = format!("Debug stack unavailable: {error}");
4244 return;
4245 }
4246 };
4247 match worker.submit_tool(call, context) {
4248 Ok(id) => {
4249 self.running_tool_job = Some(id);
4250 self.status = format!("Loading stack for thread {thread_id}…");
4251 }
4252 Err(error) => self.status = format!("Debug stack unavailable: {error}"),
4253 }
4254 }
4255
4256 pub fn continue_selected_debug(&mut self) {
4257 let Some(session) = self.selected_debug_session().map(|row| row.name.clone()) else {
4258 self.status = "Select a debugger session · Space continues".into();
4259 return;
4260 };
4261 let Some(thread_id) = self.selected_debug_thread().map(|thread| thread.id) else {
4262 self.status = "Refresh threads before continue".into();
4263 return;
4264 };
4265 match self.tool_request(
4266 "glass.debug.continue",
4267 serde_json::json!({"session": session, "threadId": thread_id}),
4268 true,
4269 ) {
4270 Ok((call, context)) => {
4271 let _ = self.queue_or_confirm(
4272 call,
4273 context,
4274 format!("Continue {session} thread {thread_id}"),
4275 );
4276 }
4277 Err(error) => self.status = format!("Debug continue unavailable: {error}"),
4278 }
4279 }
4280
4281 pub fn step_selected_debug(&mut self, kind: &str) {
4282 let Some(session) = self.selected_debug_session().map(|row| row.name.clone()) else {
4283 self.status = "Select a debugger session · n over · i in · o out".into();
4284 return;
4285 };
4286 let Some(thread_id) = self.selected_debug_thread().map(|thread| thread.id) else {
4287 self.status = "Refresh threads before stepping".into();
4288 return;
4289 };
4290 match self.tool_request(
4291 "glass.debug.step",
4292 serde_json::json!({"session": session, "threadId": thread_id, "kind": kind}),
4293 true,
4294 ) {
4295 Ok((call, context)) => {
4296 let _ = self.queue_or_confirm(
4297 call,
4298 context,
4299 format!("Step {kind} {session} thread {thread_id}"),
4300 );
4301 }
4302 Err(error) => self.status = format!("Debug step unavailable: {error}"),
4303 }
4304 }
4305
4306 pub fn pause_selected_debug(&mut self) {
4307 let Some(session) = self.selected_debug_session().map(|row| row.name.clone()) else {
4308 self.status = "Select a debugger session · p pauses".into();
4309 return;
4310 };
4311 let thread_id = self
4312 .selected_debug_thread()
4313 .map(|thread| thread.id)
4314 .unwrap_or(1);
4315 match self.tool_request(
4316 "glass.debug.pause",
4317 serde_json::json!({"session": session, "threadId": thread_id}),
4318 true,
4319 ) {
4320 Ok((call, context)) => {
4321 let _ = self.queue_or_confirm(call, context, format!("Pause {session}"));
4322 }
4323 Err(error) => self.status = format!("Debug pause unavailable: {error}"),
4324 }
4325 }
4326
4327 pub fn breakpoint_focused_line(&mut self) {
4328 let Some(session) = self.selected_debug_session().map(|row| row.name.clone()) else {
4329 self.status = "Start a debugger before setting breakpoints".into();
4330 return;
4331 };
4332 if self.focused_editor_path.is_empty() {
4333 self.status = "Open a file in Code · b sets a breakpoint on the cursor line".into();
4334 return;
4335 }
4336 let line = u64::from(self.focused_editor_line.max(1));
4337 match self.tool_request(
4338 "glass.debug.breakpoint.set",
4339 serde_json::json!({
4340 "session": session,
4341 "path": self.focused_editor_path,
4342 "lines": [line],
4343 }),
4344 true,
4345 ) {
4346 Ok((call, context)) => {
4347 let _ = self.queue_or_confirm(
4348 call,
4349 context,
4350 format!("Breakpoint {}:{}", self.focused_editor_path, line),
4351 );
4352 }
4353 Err(error) => self.status = format!("Breakpoint unavailable: {error}"),
4354 }
4355 }
4356
4357 pub fn queue_debug_scopes(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
4358 let Some(session) = self.selected_debug_session().map(|row| row.name.clone()) else {
4359 return;
4360 };
4361 let Some(frame_id) = self.selected_debug_frame().map(|frame| frame.id) else {
4362 return;
4363 };
4364 if self.background_action_running() {
4365 return;
4366 }
4367 let Ok((call, context)) = self.tool_request(
4368 "glass.debug.scopes",
4369 serde_json::json!({"session": session, "frameId": frame_id}),
4370 false,
4371 ) else {
4372 return;
4373 };
4374 if let Ok(id) = worker.submit_tool(call, context) {
4375 self.running_tool_job = Some(id);
4376 self.status = "Loading scopes…".into();
4377 }
4378 }
4379
4380 pub fn queue_debug_variables(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
4381 let Some(session) = self.selected_debug_session().map(|row| row.name.clone()) else {
4382 return;
4383 };
4384 let Some(reference) = self
4385 .debug_scopes
4386 .get(self.selected_debug_scope)
4387 .map(|scope| scope.variables_reference)
4388 else {
4389 return;
4390 };
4391 if reference <= 0 || self.background_action_running() {
4392 return;
4393 }
4394 let Ok((call, context)) = self.tool_request(
4395 "glass.debug.variables",
4396 serde_json::json!({"session": session, "variablesReference": reference}),
4397 false,
4398 ) else {
4399 return;
4400 };
4401 if let Ok(id) = worker.submit_tool(call, context) {
4402 self.running_tool_job = Some(id);
4403 self.status = "Loading variables…".into();
4404 }
4405 }
4406
4407 pub fn jump_selected_debug_frame(&mut self) {
4408 let Some(frame) = self.selected_debug_frame().cloned() else {
4409 self.status = "Select a stack frame · Enter jumps to source".into();
4410 return;
4411 };
4412 let Some(path) = frame.path.clone() else {
4413 self.status = format!("{} has no source path", frame.name);
4414 return;
4415 };
4416 match self.open_path(&path) {
4417 Ok(_) => {
4418 if let Some(line) = frame.line {
4419 let _ = self.set_editor_cursor(
4420 &self.focused_editor_path.clone(),
4421 crate::development::TextPosition {
4422 line: u32::try_from(line).unwrap_or(u32::MAX).max(1),
4423 column: 1,
4424 },
4425 false,
4426 );
4427 self.refresh_editor_projection();
4428 }
4429 self.status = format!(
4430 "Debug {} · {}{}",
4431 frame.name,
4432 path,
4433 frame
4434 .line
4435 .map(|line| format!(":{line}"))
4436 .unwrap_or_default()
4437 );
4438 self.debug_scopes_requested = true;
4439 }
4440 Err(error) => self.status = format!("Could not open {path}: {error}"),
4441 }
4442 }
4443
4444 pub fn move_todo_selection(&mut self, delta: i32) {
4445 if self.session_todos.items.is_empty() {
4446 self.selected_todo = 0;
4447 self.status = "No session todos · Plan accept or glass.todo.write".into();
4448 return;
4449 }
4450 self.selected_todo = (self.selected_todo as i32 + delta)
4451 .clamp(0, self.session_todos.items.len().saturating_sub(1) as i32)
4452 as usize;
4453 if let Some(item) = self.session_todos.items.get(self.selected_todo) {
4454 self.status = format!(
4455 "{} · {} · Enter complete · Space activate",
4456 item.id,
4457 item.status.label()
4458 );
4459 }
4460 }
4461
4462 pub fn complete_selected_todo(&mut self) {
4463 let Some(id) = self
4464 .session_todos
4465 .items
4466 .get(self.selected_todo)
4467 .map(|item| item.id.clone())
4468 else {
4469 self.status = "Select a session todo · Enter marks it done".into();
4470 return;
4471 };
4472 match self.ws_mut().and_then(|mut workspace| {
4473 workspace
4474 .complete_todo(&id)
4475 .map_err(|error| error.to_string())
4476 }) {
4477 Ok(item) => {
4478 if let Ok(list) = self.ws().map(|workspace| workspace.todos()) {
4479 self.session_todos = list;
4480 self.selected_todo = self
4481 .selected_todo
4482 .min(self.session_todos.items.len().saturating_sub(1));
4483 }
4484 self.status = format!("Todo {} done · {}", item.id, item.title);
4485 }
4486 Err(error) => self.status = format!("Todo complete unavailable: {error}"),
4487 }
4488 }
4489
4490 pub fn activate_selected_todo(&mut self) {
4491 let Some(id) = self
4492 .session_todos
4493 .items
4494 .get(self.selected_todo)
4495 .map(|item| item.id.clone())
4496 else {
4497 self.status = "Select a session todo · Space makes it active".into();
4498 return;
4499 };
4500 match self.ws_mut().and_then(|mut workspace| {
4501 workspace
4502 .activate_todo(&id)
4503 .map_err(|error| error.to_string())
4504 }) {
4505 Ok(item) => {
4506 if let Ok(list) = self.ws().map(|workspace| workspace.todos()) {
4507 self.session_todos = list;
4508 }
4509 self.status = format!("Todo {} active · {}", item.id, item.title);
4510 }
4511 Err(error) => self.status = format!("Todo activate unavailable: {error}"),
4512 }
4513 }
4514
4515 pub const MORE_ROUTES: [&'static str; 5] = [
4516 "doctor",
4517 "cockpit start",
4518 "kernel start",
4519 "experiment",
4520 "harness list",
4521 ];
4522
4523 pub fn move_more_selection(&mut self, delta: i32) {
4524 let last = Self::MORE_ROUTES.len().saturating_sub(1) as i32;
4525 self.selected_more = (self.selected_more as i32 + delta).clamp(0, last) as usize;
4526 self.status = format!("{} · Enter runs", Self::MORE_ROUTES[self.selected_more]);
4527 }
4528
4529 pub fn activate_more_selection(&mut self) {
4530 let command = Self::MORE_ROUTES[self.selected_more.min(Self::MORE_ROUTES.len() - 1)];
4531 if command == "kernel start" {
4532 self.open_palette_with("kernel start ");
4533 self.status = "kernel start · NAME KIND, then Enter".into();
4534 return;
4535 }
4536 match super::command::execute(self, command) {
4537 Ok(message) => {
4538 self.surface = DevSurface::More;
4539 self.more_result = message.clone();
4540 self.status = more_route_status(command, &message);
4541 }
4542 Err(error) => {
4543 self.surface = DevSurface::More;
4544 self.open_palette_with(command);
4545 self.status = format!("{command} · {error}");
4546 }
4547 }
4548 }
4549
4550 pub fn open_selected_file(&mut self) {
4551 let Some(path) = self.files.get(self.selected_file).cloned() else {
4552 self.status = "No project file selected".into();
4553 return;
4554 };
4555 let already_open = self
4556 .workspace
4557 .try_lock()
4558 .map(|workspace| workspace.project().buffer(&path).is_some())
4559 .unwrap_or(false);
4560 let result = if already_open {
4561 Ok(())
4562 } else {
4563 self.workspace.try_lock().and_then(|mut workspace| {
4564 workspace
4565 .project_mut()
4566 .open_buffer(&path, crate::development::Actor::local())
4567 .map(|_| ())
4568 })
4569 };
4570 match result {
4571 Ok(()) => {
4572 self.pending_open_file = None;
4573 self.editor_buffer_index = self
4574 .workspace
4575 .try_lock()
4576 .ok()
4577 .and_then(|workspace| {
4578 workspace
4579 .project()
4580 .buffers()
4581 .position(|buffer| buffer.path == path)
4582 })
4583 .unwrap_or(0);
4584 self.refresh_editor_projection();
4585 self.status = if already_open {
4586 format!("Selected {path} · Enter opens the full-screen editor")
4587 } else {
4588 format!("Opened {path} · Enter opens the full-screen editor")
4589 };
4590 }
4591 Err(error) if Self::is_workspace_busy(&error) => {
4592 self.pending_open_file = Some(path.clone());
4593 self.status = format!("Opening {path} when the workspace is free");
4594 }
4595 Err(error) => self.status = format!("Open failed: {error}"),
4596 }
4597 }
4598
4599 pub fn open_selected_file_for_edit(&mut self) {
4600 let selected_path = self.files.get(self.selected_file).cloned();
4601 self.open_selected_file();
4602 if selected_path.as_deref() == Some(self.focused_editor_path.as_str()) {
4603 self.surface = DevSurface::Code;
4604 self.enter_code_edit();
4605 }
4606 }
4607
4608 pub fn queue_git_diff(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
4610 if self.background_action_running() {
4611 self.status = "Git diff waits for the current background operation".into();
4612 return;
4613 }
4614 let selected = self.selected_git_entry().map(|entry| {
4615 (
4616 entry.path.clone(),
4617 entry.untracked,
4618 entry.index_status,
4619 entry.worktree_status,
4620 )
4621 });
4622 if let Some((path, true, _, _)) = selected.as_ref() {
4623 self.git_diff_path = Some(path.clone());
4624 self.git_diff = format!(
4625 "{path}\n\nUntracked file · Git has no tracked diff yet.\nUse Enter on Code to inspect the file."
4626 );
4627 self.git_diff_open = true;
4628 self.surface_scroll.insert(DevSurface::Git, 0);
4629 self.status = format!("{path} is untracked · no Git diff to show");
4630 return;
4631 }
4632 let staged = selected
4633 .as_ref()
4634 .is_some_and(|(_, _, index, worktree)| *index != ' ' && *worktree == ' ');
4635 let mut arguments = serde_json::json!({"staged": staged});
4636 if let Some((path, _, _, _)) = selected.as_ref() {
4637 arguments["path"] = serde_json::Value::String(path.clone());
4638 }
4639 let (call, context) = match self.tool_request("glass.git.diff", arguments, false) {
4640 Ok(request) => request,
4641 Err(error) => {
4642 self.status = format!("Git diff unavailable: {error}");
4643 return;
4644 }
4645 };
4646 match worker.submit_tool(call, context) {
4647 Ok(id) => {
4648 self.running_tool_job = Some(id);
4649 self.git_diff_path = selected.map(|(path, _, _, _)| path);
4650 self.git_diff_open = true;
4651 self.surface_scroll.insert(DevSurface::Git, 0);
4652 self.git_diff = "Loading Git diff…".into();
4653 self.status = self
4654 .git_diff_path
4655 .as_deref()
4656 .map(|path| format!("Loading diff for {path} in background…"))
4657 .unwrap_or_else(|| "Loading full worktree diff in background…".into());
4658 }
4659 Err(error) => self.status = format!("Git diff unavailable: {error}"),
4660 }
4661 }
4662
4663 pub fn open_git_diff(&mut self) {
4665 let diff = self.workspace.try_lock().and_then(|workspace| {
4666 workspace
4667 .git()
4668 .ok_or_else(|| {
4669 crate::development::DevelopmentError::NotFound("not a Git repository".into())
4670 })?
4671 .diff(false, None)
4672 .map_err(|error| crate::development::DevelopmentError::Process(error.to_string()))
4673 });
4674 self.git_diff_path = None;
4675 match diff {
4676 Ok(diff) if diff.trim().is_empty() => {
4677 self.git_diff = "Working tree clean · no diff to show".into();
4678 self.git_diff_open = true;
4679 self.surface_scroll.insert(DevSurface::Git, 0);
4680 self.status = "Git diff · no changes".into();
4681 }
4682 Ok(diff) => {
4683 self.git_diff = diff;
4684 self.git_diff_open = true;
4685 self.surface_scroll.insert(DevSurface::Git, 0);
4686 self.status = "Git diff · PgUp/PgDn scroll · Esc closes".into();
4687 }
4688 Err(error) => self.status = format!("Git diff unavailable: {error}"),
4689 }
4690 }
4691
4692 pub fn close_git_diff(&mut self) {
4693 self.git_diff_open = false;
4694 self.git_diff_requested = false;
4695 self.git_diff_path = None;
4696 self.surface_scroll.insert(DevSurface::Git, 0);
4697 self.status = "Git status · select a file with ↑/↓".into();
4698 }
4699
4700 pub fn focused_buffer(&self) -> Option<crate::development::EditorBuffer> {
4701 self.workspace.try_lock().ok().and_then(|workspace| {
4702 workspace
4703 .project()
4704 .buffers()
4705 .nth(self.editor_buffer_index)
4706 .cloned()
4707 })
4708 }
4709
4710 pub fn refresh_editor_projection(&mut self) {
4711 let (buffers, comments, proposals, checkpoints, diagnostics) = self
4712 .workspace
4713 .lock()
4714 .map(|workspace| {
4715 (
4716 workspace.project().buffers().cloned().collect::<Vec<_>>(),
4717 workspace.project().editor_comments(None),
4718 workspace.project().editor_proposals(),
4719 workspace.project().editor_checkpoints(),
4720 workspace.project().diagnostics().clone(),
4721 )
4722 })
4723 .unwrap_or_default();
4724 self.editor_comments = comments;
4725 self.editor_proposals = proposals;
4726 self.editor_checkpoints = checkpoints;
4727 if let Some(buffer) = buffers.get(self.editor_buffer_index) {
4728 self.focused_editor_path = buffer.path.clone();
4729 self.focused_editor_content = buffer.content.clone();
4730 self.focused_editor_dirty = buffer.dirty;
4731 self.focused_editor_line = buffer.cursor_line;
4732 self.focused_editor_column = buffer.cursor_column;
4733 self.focused_editor_selection = buffer.selection.clone();
4734 self.editor_diagnostics = diagnostics.get(&buffer.path).cloned().unwrap_or_default();
4735 self.ensure_editor_cursor_visible();
4736 let path = self.focused_editor_path.clone();
4737 let content = self.focused_editor_content.clone();
4738 self.syntax.sync(&path, &content);
4739 if let Some(proposal) = self.editor_proposals.iter().find(|item| {
4740 item.path == path && item.state == crate::development::EditorProposalState::Pending
4741 }) {
4742 let line = native::line_hunks(&proposal.original, &proposal.proposed)
4743 .first()
4744 .map(|hunk| hunk.start_line)
4745 .unwrap_or(1);
4746 self.editor_engine.agent_caret = Some(native::Jump {
4747 path: path.clone(),
4748 line,
4749 column: 1,
4750 });
4751 } else {
4752 self.editor_engine.agent_caret = None;
4753 }
4754 self.maybe_begin_pair_apply();
4755 } else {
4756 self.focused_editor_path.clear();
4757 self.focused_editor_content.clear();
4758 self.focused_editor_dirty = false;
4759 self.focused_editor_line = 0;
4760 self.focused_editor_column = 0;
4761 self.focused_editor_selection = None;
4762 self.editor_scroll_line = 0;
4763 self.editor_scroll_column = 0;
4764 self.editor_inlays.clear();
4765 self.editor_diagnostics.clear();
4766 }
4767 self.editor = format_editor_buffers(&buffers);
4768 }
4769
4770 fn refresh_editor_inlays(&mut self) {
4771 let path = self.focused_editor_path.clone();
4772 if path.is_empty() {
4773 self.editor_inlays.clear();
4774 return;
4775 }
4776 let response = self.workspace.try_lock().ok().and_then(|mut workspace| {
4777 let name = workspace.language().names().next()?.to_string();
4778 workspace.language().inlay_hints(&name, "local", &path).ok()
4779 });
4780 self.editor_inlays = response
4781 .map(|response| parse_inlay_hints(&response.result))
4782 .unwrap_or_default();
4783 }
4784
4785 pub fn editor_collaboration_summary(&self) -> String {
4786 let open_comments = self
4787 .editor_comments
4788 .iter()
4789 .filter(|comment| comment.state == crate::development::EditorCommentState::Open)
4790 .count();
4791 let pending = self
4792 .editor_proposals
4793 .iter()
4794 .filter(|proposal| proposal.state == crate::development::EditorProposalState::Pending)
4795 .count();
4796 format!(
4797 "comments {} open · proposals {} pending · checkpoints {}",
4798 open_comments,
4799 pending,
4800 self.editor_checkpoints.len()
4801 )
4802 }
4803
4804 pub fn cycle_editor_buffer(&mut self, delta: i32) {
4805 let count = self
4806 .workspace
4807 .lock()
4808 .map(|workspace| workspace.project().buffers().count())
4809 .unwrap_or(0);
4810 if count == 0 {
4811 self.status = "No open buffers · open a file from the list".into();
4812 return;
4813 }
4814 let index = self.editor_buffer_index as i32 + delta;
4815 self.editor_buffer_index = index.rem_euclid(count as i32) as usize;
4816 let name = self
4817 .workspace
4818 .lock()
4819 .ok()
4820 .and_then(|workspace| {
4821 workspace
4822 .project()
4823 .buffers()
4824 .nth(self.editor_buffer_index)
4825 .map(|buffer| buffer.path.clone())
4826 })
4827 .unwrap_or_default();
4828 self.refresh_editor_projection();
4829 self.status = format!("Buffer {}/{} · {name}", self.editor_buffer_index + 1, count);
4830 }
4831
4832 pub fn enter_code_edit(&mut self) {
4833 let has_buffer = self.focused_buffer().is_some();
4834 if !has_buffer {
4835 self.open_selected_file();
4836 }
4837 if self.focused_buffer().is_some() || !self.focused_editor_path.is_empty() {
4838 self.surface = DevSurface::Code;
4839 self.code_edit_mode = true;
4840 self.editor_exit_prompt = None;
4841 self.ensure_editor_cursor_visible();
4842 self.editor_engine.enter_insert();
4843 self.refresh_editor_hunks();
4844 self.refresh_editor_inlays();
4845 self.status = "INSERT · Esc normal · gm/gn extra carets · dif · gd · Ctrl-S".into();
4846 }
4847 }
4848
4849 pub fn handle_editor_escape(&mut self) {
4850 if self.editor_engine.overlay.take().is_some()
4851 || !self.editor_engine.symbols.is_empty()
4852 || self.editor_engine.ghost.take().is_some()
4853 {
4854 self.editor_engine.symbols.clear();
4855 self.editor_engine.clear_pending();
4856 self.status = format!("{} · overlay closed", self.editor_engine.mode.label());
4857 return;
4858 }
4859 match self.editor_engine.mode {
4860 EditorMode::Agent => {
4861 self.editor_engine.stop_pair_apply();
4862 self.status = "NORMAL · agent yielded · hjkl · i insert · Esc exit".into();
4863 }
4864 EditorMode::Insert | EditorMode::Select => {
4865 self.editor_engine.enter_normal();
4866 self.status = self.editor_normal_status();
4867 }
4868 EditorMode::Normal => {
4869 if self.editor_engine.clear_extra_cursors() {
4870 self.status = "NORMAL · extra carets cleared".into();
4871 self.refresh_editor_projection();
4872 return;
4873 }
4874 if !self.focused_editor_dirty {
4875 self.close_code_edit();
4876 return;
4877 }
4878 self.request_editor_exit();
4879 }
4880 }
4881 }
4882
4883 fn editor_normal_status(&self) -> String {
4884 let extras = self.editor_engine.extra_caret_count();
4885 if extras > 0 {
4886 format!(
4887 "NORMAL · {} carets · gm match · gn next · d/c/i apply to all · Esc clear",
4888 extras + 1
4889 )
4890 } else {
4891 "NORMAL · hjkl · d/c/y · iw/if/ia · gm/gn extra carets · i insert · Esc exit".into()
4892 }
4893 }
4894
4895 pub fn close_code_edit(&mut self) {
4896 self.code_edit_mode = false;
4897 self.editor_exit_prompt = None;
4898 self.surface = DevSurface::Code;
4899 self.status = "Code navigation · select a file and press Enter to edit".into();
4900 }
4901
4902 pub fn request_editor_exit(&mut self) {
4903 if !self.code_edit_mode {
4904 return;
4905 }
4906 self.refresh_editor_projection();
4907 let prompt = if self.focused_editor_dirty {
4908 EditorExitPrompt::Unsaved
4909 } else {
4910 EditorExitPrompt::Clean
4911 };
4912 self.editor_exit_prompt = Some(prompt);
4913 self.status = match prompt {
4914 EditorExitPrompt::Clean => "Exit editor? Enter leaves · Esc stays".into(),
4915 EditorExitPrompt::Unsaved => {
4916 "Unsaved changes · S save · D discard · Q discard and quit · Esc stays".into()
4917 }
4918 };
4919 }
4920
4921 pub fn cancel_editor_exit(&mut self) {
4922 self.editor_exit_prompt = None;
4923 self.status = "Still editing · Esc opens exit choices".into();
4924 }
4925
4926 pub fn handle_editor_exit_key(&mut self, code: crossterm::event::KeyCode) {
4927 let Some(prompt) = self.editor_exit_prompt else {
4928 return;
4929 };
4930 match prompt {
4931 EditorExitPrompt::Clean => match code {
4932 crossterm::event::KeyCode::Enter
4933 | crossterm::event::KeyCode::Char('q' | 'Q' | 'y' | 'Y') => {
4934 self.close_code_edit();
4935 }
4936 crossterm::event::KeyCode::Esc | crossterm::event::KeyCode::Char('n' | 'N') => {
4937 self.cancel_editor_exit()
4938 }
4939 _ => {}
4940 },
4941 EditorExitPrompt::Unsaved => match code {
4942 crossterm::event::KeyCode::Char('s' | 'S') => match self.save_editor_buffer() {
4943 Ok(()) => {
4944 let path = self.focused_editor_path.clone();
4945 self.refresh_editor_projection();
4946 self.close_code_edit();
4947 self.status = format!("Saved {path} · editor closed");
4948 }
4949 Err(error) => {
4950 self.status =
4951 format!("Save failed: {error} · S retry · D discard · Q quit");
4952 }
4953 },
4954 crossterm::event::KeyCode::Char('d' | 'D') => match self.discard_editor_buffer() {
4955 Ok(()) => {
4956 let path = self.focused_editor_path.clone();
4957 self.refresh_editor_projection();
4958 self.close_code_edit();
4959 self.status = format!("Discarded changes in {path} · editor closed");
4960 }
4961 Err(error) => {
4962 self.status =
4963 format!("Discard failed: {error} · S save · D retry · Q quit");
4964 }
4965 },
4966 crossterm::event::KeyCode::Char('q' | 'Q') => match self.discard_editor_buffer() {
4967 Ok(()) => {
4968 self.code_edit_mode = false;
4969 self.editor_exit_prompt = None;
4970 self.surface = DevSurface::Code;
4971 self.quit = true;
4972 self.status = "Changes discarded · closing Glass Dev".into();
4973 }
4974 Err(error) => {
4975 self.status =
4976 format!("Discard failed: {error} · S save · D retry · Q quit");
4977 }
4978 },
4979 crossterm::event::KeyCode::Esc => self.cancel_editor_exit(),
4980 _ => {}
4981 },
4982 }
4983 }
4984
4985 fn save_editor_buffer(&mut self) -> Result<(), String> {
4986 let path = self.focused_editor_path.clone();
4987 self.workspace
4988 .try_lock()
4989 .map_err(|error| error.to_string())?
4990 .project_mut()
4991 .save_buffer(&path)
4992 .map(|_| ())
4993 .map_err(|error| error.to_string())
4994 }
4995
4996 fn discard_editor_buffer(&mut self) -> Result<(), String> {
4997 let path = self.focused_editor_path.clone();
4998 self.workspace
4999 .try_lock()
5000 .map_err(|error| error.to_string())?
5001 .project_mut()
5002 .open_buffer(&path, crate::development::Actor::local())
5003 .map(|_| ())
5004 .map_err(|error| error.to_string())
5005 }
5006
5007 fn ensure_editor_cursor_visible(&mut self) {
5008 if self.focused_editor_path.is_empty() {
5009 return;
5010 }
5011 let viewport_height = usize::from(self.terminal_height.saturating_sub(8).max(1));
5012 if self.editor_soft_wrap {
5013 let marks = self
5014 .editor_gutter_marks()
5015 .into_iter()
5016 .map(|(line, mark)| (line, mark.glyph()))
5017 .collect::<Vec<_>>();
5018 let notes = self.editor_source_notes();
5019 let decorations = super::file_view::EditorDecorations {
5020 marks: &marks,
5021 inlays: ¬es,
5022 extra_selections: &self.editor_engine.extra_selections,
5023 };
5024 let wrapped = super::file_view::render_editable_source_wrapped(
5025 &self.focused_editor_path,
5026 &self.focused_editor_content,
5027 self.focused_editor_line,
5028 self.focused_editor_column,
5029 self.focused_editor_selection.as_ref(),
5030 self.terminal_width.saturating_sub(4).max(1),
5031 &decorations,
5032 );
5033 let Some(cursor) = wrapped.cursor else {
5034 return;
5035 };
5036 self.editor_scroll_column = 0;
5037 if cursor.row < self.editor_scroll_line {
5038 self.editor_scroll_line = cursor.row;
5039 } else if cursor.row >= self.editor_scroll_line + viewport_height {
5040 self.editor_scroll_line = cursor.row + 1 - viewport_height;
5041 }
5042 return;
5043 }
5044 let lines = self.focused_editor_content.split('\n').collect::<Vec<_>>();
5045 let cursor_line = self.focused_editor_line.saturating_sub(1) as usize;
5046 if cursor_line < self.editor_scroll_line {
5047 self.editor_scroll_line = cursor_line;
5048 } else if cursor_line >= self.editor_scroll_line + viewport_height {
5049 self.editor_scroll_line = cursor_line + 1 - viewport_height;
5050 }
5051 let gutter_width = lines.len().max(1).to_string().len().max(3);
5052 let viewport_width = usize::from(
5053 self.terminal_width
5054 .saturating_sub((gutter_width + 8).min(u16::MAX as usize) as u16)
5055 .max(1),
5056 );
5057 let cursor_column = self.focused_editor_column.saturating_sub(1) as usize;
5058 if cursor_column < self.editor_scroll_column {
5059 self.editor_scroll_column = cursor_column;
5060 } else if cursor_column >= self.editor_scroll_column + viewport_width {
5061 self.editor_scroll_column = cursor_column + 1 - viewport_width;
5062 }
5063 }
5064
5065 pub fn toggle_editor_soft_wrap(&mut self) {
5066 self.editor_soft_wrap = !self.editor_soft_wrap;
5067 self.editor_scroll_line = 0;
5068 self.editor_scroll_column = 0;
5069 self.ensure_editor_cursor_visible();
5070 self.status = if self.editor_soft_wrap {
5071 "Soft wrap ON · source lines reflow to the editor width".into()
5072 } else {
5073 "Soft wrap OFF · horizontal scrolling follows source columns".into()
5074 };
5075 }
5076
5077 pub fn edit_code_key(
5078 &mut self,
5079 code: crossterm::event::KeyCode,
5080 modifiers: crossterm::event::KeyModifiers,
5081 ) {
5082 if code == crossterm::event::KeyCode::Char('w')
5083 && modifiers.contains(crossterm::event::KeyModifiers::ALT)
5084 {
5085 self.toggle_editor_soft_wrap();
5086 return;
5087 }
5088 if self.editor_engine.mode == EditorMode::Agent {
5089 self.edit_agent_key(code, modifiers);
5090 return;
5091 }
5092 if self.editor_engine.mode == EditorMode::Insert
5093 || modifiers.contains(crossterm::event::KeyModifiers::CONTROL)
5094 || modifiers.contains(crossterm::event::KeyModifiers::ALT)
5095 {
5096 self.edit_insert_or_chords(code, modifiers);
5097 return;
5098 }
5099 self.edit_normal_key(code, modifiers);
5100 }
5101
5102 fn edit_agent_key(
5103 &mut self,
5104 code: crossterm::event::KeyCode,
5105 modifiers: crossterm::event::KeyModifiers,
5106 ) {
5107 match code {
5108 crossterm::event::KeyCode::Enter => {
5109 let id = self
5110 .editor_engine
5111 .pair_apply
5112 .as_ref()
5113 .map(|apply| apply.proposal_id.clone());
5114 self.editor_engine.stop_pair_apply();
5115 if let Some(id) = id {
5116 match self.accept_review_proposal(Some(&id)) {
5117 Ok(message) => self.status = message,
5118 Err(error) => self.status = error,
5119 }
5120 }
5121 }
5122 crossterm::event::KeyCode::Char('n') => {
5123 let id = self
5124 .editor_engine
5125 .pair_apply
5126 .as_ref()
5127 .map(|apply| apply.proposal_id.clone());
5128 self.editor_engine.stop_pair_apply();
5129 if let Some(id) = id {
5130 match self.reject_review_proposal(Some(&id)) {
5131 Ok(message) => self.status = message,
5132 Err(error) => self.status = error,
5133 }
5134 }
5135 }
5136 crossterm::event::KeyCode::Esc => self.handle_editor_escape(),
5137 _ => {
5138 self.editor_engine.stop_pair_apply();
5139 self.editor_engine.enter_insert();
5140 self.edit_insert_or_chords(code, modifiers);
5141 }
5142 }
5143 self.refresh_editor_projection();
5144 }
5145
5146 fn edit_insert_or_chords(
5147 &mut self,
5148 code: crossterm::event::KeyCode,
5149 modifiers: crossterm::event::KeyModifiers,
5150 ) {
5151 let Some(buffer) = self.focused_buffer() else {
5152 self.status = "No open buffer".into();
5153 return;
5154 };
5155 let path = buffer.path.clone();
5156 if code == crossterm::event::KeyCode::Tab
5157 && let Some(ghost) = self.editor_engine.ghost.take()
5158 {
5159 self.accept_ghost_text(&path, &ghost.text);
5160 return;
5161 }
5162 if matches!(
5163 code,
5164 crossterm::event::KeyCode::Right | crossterm::event::KeyCode::Char('f')
5165 ) && modifiers.contains(crossterm::event::KeyModifiers::CONTROL)
5166 && !modifiers.contains(crossterm::event::KeyModifiers::SHIFT)
5167 && self.editor_engine.ghost.is_some()
5168 {
5169 self.accept_ghost_word(&path);
5170 return;
5171 }
5172 let result = match (code, modifiers) {
5173 (crossterm::event::KeyCode::Char('a'), value)
5174 if value.contains(crossterm::event::KeyModifiers::ALT) =>
5175 {
5176 self.prepare_editor_agent_prompt();
5177 Ok(())
5178 }
5179 (crossterm::event::KeyCode::Char('s'), value)
5180 if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
5181 {
5182 self.locked(|workspace| workspace.project_mut().save_buffer(&path).map(|_| ()))
5183 .unwrap_or_else(|| {
5184 Err(crate::development::DevelopmentError::Conflict(
5185 "workspace lock failed".into(),
5186 ))
5187 })
5188 }
5189 (crossterm::event::KeyCode::Char('z'), value)
5190 if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
5191 {
5192 self.locked(|workspace| workspace.project_mut().undo_buffer(&path).map(|_| ()))
5193 .unwrap_or_else(|| {
5194 Err(crate::development::DevelopmentError::Conflict(
5195 "workspace lock failed".into(),
5196 ))
5197 })
5198 }
5199 (crossterm::event::KeyCode::Char('y'), value)
5200 if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
5201 {
5202 self.locked(|workspace| workspace.project_mut().redo_buffer(&path).map(|_| ()))
5203 .unwrap_or_else(|| {
5204 Err(crate::development::DevelopmentError::Conflict(
5205 "workspace lock failed".into(),
5206 ))
5207 })
5208 }
5209 (crossterm::event::KeyCode::Char('o'), value)
5210 if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
5211 {
5212 self.open_symbol_picker();
5213 Ok(())
5214 }
5215 (crossterm::event::KeyCode::Left, value) => self.move_editor_cursor(
5216 &path,
5217 0,
5218 -1,
5219 value.contains(crossterm::event::KeyModifiers::SHIFT),
5220 ),
5221 (crossterm::event::KeyCode::Right, value) => self.move_editor_cursor(
5222 &path,
5223 0,
5224 1,
5225 value.contains(crossterm::event::KeyModifiers::SHIFT),
5226 ),
5227 (crossterm::event::KeyCode::Up, value) => self.move_editor_cursor(
5228 &path,
5229 -1,
5230 0,
5231 value.contains(crossterm::event::KeyModifiers::SHIFT),
5232 ),
5233 (crossterm::event::KeyCode::Down, value) => self.move_editor_cursor(
5234 &path,
5235 1,
5236 0,
5237 value.contains(crossterm::event::KeyModifiers::SHIFT),
5238 ),
5239 (crossterm::event::KeyCode::Enter, _) => self.insert_editor_text(&path, "\n"),
5240 (crossterm::event::KeyCode::Backspace, _) => self.backspace_editor(&path),
5241 (crossterm::event::KeyCode::Char(character), _)
5242 if self.editor_engine.mode == EditorMode::Insert =>
5243 {
5244 let result = self.insert_editor_text(&path, &character.to_string());
5245 self.request_ghost_from_line();
5246 result
5247 }
5248 _ => Ok(()),
5249 };
5250 if let Err(error) = result {
5251 self.status = format!("Editor action failed: {error}");
5252 }
5253 self.refresh_editor_projection();
5254 }
5255
5256 fn edit_normal_key(
5257 &mut self,
5258 code: crossterm::event::KeyCode,
5259 modifiers: crossterm::event::KeyModifiers,
5260 ) {
5261 let Some(buffer) = self.focused_buffer() else {
5262 self.status = "No open buffer".into();
5263 return;
5264 };
5265 let path = buffer.path.clone();
5266 let content = buffer.content.clone();
5267 let cursor = crate::development::TextPosition {
5268 line: buffer.cursor_line,
5269 column: buffer.cursor_column,
5270 };
5271 if let crossterm::event::KeyCode::Char(digit) = code
5272 && digit.is_ascii_digit()
5273 && !(digit == '0' && self.editor_engine.pending_count == 0)
5274 {
5275 self.editor_engine
5276 .push_digit(digit.to_digit(10).unwrap_or(0));
5277 return;
5278 }
5279 let count = self.editor_engine.count();
5280 if self.editor_engine.pending_find.is_some() {
5281 if let crossterm::event::KeyCode::Char(needle) = code {
5282 let jumping_mark = self.editor_engine.pending_find == Some('\'');
5283 self.editor_engine.pending_find = None;
5284 if jumping_mark {
5285 if let Some(mark) = self.editor_engine.marks.get(&needle).cloned() {
5286 self.editor_engine
5287 .record_jump(&path, cursor.line, cursor.column);
5288 if mark.path == path {
5289 let _ = self.set_editor_cursor(
5290 &path,
5291 crate::development::TextPosition {
5292 line: mark.line,
5293 column: mark.column,
5294 },
5295 false,
5296 );
5297 } else {
5298 self.status = format!("Mark '{needle}' is {}", mark.path);
5299 }
5300 } else {
5301 self.status = format!("Mark '{needle}' is empty");
5302 }
5303 } else {
5304 let motion = Motion::Find {
5305 needle,
5306 till: self.editor_engine.pending_find_till,
5307 reverse: self.editor_engine.pending_find_reverse,
5308 };
5309 if let Some(operator) = self.editor_engine.pending_operator.take() {
5310 let _ = self.apply_operator(&path, &content, cursor, operator, motion);
5311 } else {
5312 let next = apply_motion(&content, cursor, motion);
5313 let _ = self.set_editor_cursor(&path, next, false);
5314 }
5315 }
5316 self.refresh_editor_projection();
5317 } else {
5318 self.editor_engine.clear_pending();
5319 }
5320 return;
5321 }
5322 if self.editor_engine.pending_mark {
5323 if let crossterm::event::KeyCode::Char(name) = code {
5324 self.editor_engine.marks.insert(
5325 name,
5326 native::Jump {
5327 path: path.clone(),
5328 line: cursor.line,
5329 column: cursor.column,
5330 },
5331 );
5332 self.status = format!("Mark '{name}' set");
5333 }
5334 self.editor_engine.pending_mark = false;
5335 return;
5336 }
5337 if let crossterm::event::KeyCode::Char(character) = code
5338 && let Some(around) = self.editor_engine.pending_around
5339 {
5340 if let Some(object) = textobject_from_key(character, around) {
5341 self.apply_textobject(&path, &content, cursor, object);
5342 } else {
5343 self.editor_engine.clear_pending();
5344 self.status = format!("Unknown textobject '{character}'");
5345 }
5346 return;
5347 }
5348 if self.editor_engine.pending_operator.is_some() {
5349 match code {
5350 crossterm::event::KeyCode::Char('i') => {
5351 self.editor_engine.pending_around = Some(false);
5352 self.status =
5353 "inner textobject · w word · f fn · a arg · c comment · s string".into();
5354 return;
5355 }
5356 crossterm::event::KeyCode::Char('a') => {
5357 self.editor_engine.pending_around = Some(true);
5358 self.status =
5359 "around textobject · w word · f fn · a arg · c comment · s string".into();
5360 return;
5361 }
5362 crossterm::event::KeyCode::Char('f') => {
5363 self.apply_textobject(
5364 &path,
5365 &content,
5366 cursor,
5367 TextObject::Function { around: true },
5368 );
5369 return;
5370 }
5371 _ => {}
5372 }
5373 }
5374 let motion = match code {
5375 crossterm::event::KeyCode::Char('h') | crossterm::event::KeyCode::Left => {
5376 Some(Motion::Left)
5377 }
5378 crossterm::event::KeyCode::Char('l') | crossterm::event::KeyCode::Right => {
5379 Some(Motion::Right)
5380 }
5381 crossterm::event::KeyCode::Char('j') | crossterm::event::KeyCode::Down => {
5382 Some(Motion::Down)
5383 }
5384 crossterm::event::KeyCode::Char('k') | crossterm::event::KeyCode::Up => {
5385 Some(Motion::Up)
5386 }
5387 crossterm::event::KeyCode::Char('w') => Some(Motion::WordForward),
5388 crossterm::event::KeyCode::Char('b') => Some(Motion::WordBackward),
5389 crossterm::event::KeyCode::Char('e') => Some(Motion::WordEnd),
5390 crossterm::event::KeyCode::Char('0') => Some(Motion::LineStart),
5391 crossterm::event::KeyCode::Char('$') => Some(Motion::LineEnd),
5392 crossterm::event::KeyCode::Char('%') => Some(Motion::MatchPair),
5393 crossterm::event::KeyCode::Char('G') => Some(Motion::FileEnd),
5394 _ => None,
5395 };
5396 if code == crossterm::event::KeyCode::Char('g') {
5397 if self.editor_engine.pending_g {
5398 self.editor_engine.pending_g = false;
5399 self.apply_editor_motion(&path, &content, cursor, Motion::FileStart, false);
5400 } else {
5401 self.editor_engine.pending_g = true;
5402 }
5403 return;
5404 }
5405 if let Some(motion) = motion {
5406 if let Some(operator) = self.editor_engine.pending_operator.take() {
5407 let _ = self.apply_operator(&path, &content, cursor, operator, motion);
5408 } else {
5409 let mut position = cursor;
5410 for _ in 0..count {
5411 position = apply_motion(&content, position, motion);
5412 }
5413 self.editor_engine.clear_pending();
5414 let extend = self.editor_engine.mode == EditorMode::Select
5415 || modifiers.contains(crossterm::event::KeyModifiers::SHIFT);
5416 let _ = self.set_editor_cursor(&path, position, extend);
5417 }
5418 self.refresh_editor_projection();
5419 return;
5420 }
5421 match code {
5422 crossterm::event::KeyCode::Char('i') => self.editor_engine.enter_insert(),
5423 crossterm::event::KeyCode::Char('a') => {
5424 let next = apply_motion(&content, cursor, Motion::Right);
5425 let _ = self.set_editor_cursor(&path, next, false);
5426 self.editor_engine.enter_insert();
5427 }
5428 crossterm::event::KeyCode::Char('v') => self.editor_engine.enter_select(),
5429 crossterm::event::KeyCode::Char('W') => {
5430 self.apply_textobject(&path, &content, cursor, TextObject::Word { around: true });
5431 }
5432 crossterm::event::KeyCode::Char('d') if self.editor_engine.pending_g => {
5433 self.editor_engine.pending_g = false;
5434 self.editor_go_to_definition();
5435 }
5436 crossterm::event::KeyCode::Char('r') if self.editor_engine.pending_g => {
5437 self.editor_engine.pending_g = false;
5438 self.editor_references();
5439 }
5440 crossterm::event::KeyCode::Char('p') if self.editor_engine.pending_g => {
5441 self.editor_engine.pending_g = false;
5442 self.jump_page_from_source();
5443 }
5444 crossterm::event::KeyCode::Char('c') if self.editor_engine.pending_g => {
5445 self.editor_engine.pending_g = false;
5446 self.show_comment_thread();
5447 }
5448 crossterm::event::KeyCode::Char('m') if self.editor_engine.pending_g => {
5449 self.editor_engine.pending_g = false;
5450 self.match_same_objects(&path, &content, cursor, true);
5451 }
5452 crossterm::event::KeyCode::Char('n') if self.editor_engine.pending_g => {
5453 self.editor_engine.pending_g = false;
5454 self.match_same_objects(&path, &content, cursor, false);
5455 }
5456 crossterm::event::KeyCode::Char('d') => {
5457 self.editor_engine.pending_operator = Some(Operator::Delete);
5458 }
5459 crossterm::event::KeyCode::Char('c') => {
5460 self.editor_engine.pending_operator = Some(Operator::Change);
5461 }
5462 crossterm::event::KeyCode::Char('y')
5463 if !modifiers.contains(crossterm::event::KeyModifiers::CONTROL) =>
5464 {
5465 self.editor_engine.pending_operator = Some(Operator::Yank);
5466 }
5467 crossterm::event::KeyCode::Char('x') => {
5468 let _ =
5469 self.apply_operator(&path, &content, cursor, Operator::Delete, Motion::Right);
5470 }
5471 crossterm::event::KeyCode::Char('u') => {
5472 let _ =
5473 self.locked(|workspace| workspace.project_mut().undo_buffer(&path).map(|_| ()));
5474 }
5475 crossterm::event::KeyCode::Char('p') => {
5476 if !self.editor_engine.yank.is_empty() {
5477 let _ = self.insert_editor_text(&path, &self.editor_engine.yank.clone());
5478 }
5479 }
5480 crossterm::event::KeyCode::Char('m') => {
5481 self.editor_engine.pending_mark = true;
5482 self.status = "Mark · next character names the mark".into();
5483 }
5484 crossterm::event::KeyCode::Char('\'') => {
5485 self.status = "Jump to mark · next character".into();
5486 self.editor_engine.pending_find = Some('\'');
5487 }
5488 crossterm::event::KeyCode::Char('K') => self.editor_hover(),
5489 crossterm::event::KeyCode::Char(']') => {
5490 if let Some(hunk) = self.editor_engine.step_hunk(1).cloned() {
5491 let _ = self.set_editor_cursor(
5492 &path,
5493 crate::development::TextPosition {
5494 line: hunk.start_line,
5495 column: 1,
5496 },
5497 false,
5498 );
5499 self.status = format!(
5500 "Hunk {}/{}",
5501 self.editor_engine.hunk_index + 1,
5502 self.editor_engine.hunks.len()
5503 );
5504 }
5505 }
5506 crossterm::event::KeyCode::Char('[') => {
5507 if let Some(hunk) = self.editor_engine.step_hunk(-1).cloned() {
5508 let _ = self.set_editor_cursor(
5509 &path,
5510 crate::development::TextPosition {
5511 line: hunk.start_line,
5512 column: 1,
5513 },
5514 false,
5515 );
5516 }
5517 }
5518 crossterm::event::KeyCode::Enter => self.accept_current_hunk(),
5519 crossterm::event::KeyCode::Char('n') => self.reject_current_hunk(),
5520 crossterm::event::KeyCode::Char('o') => self.open_symbol_picker(),
5521 crossterm::event::KeyCode::Char('f') => {
5522 self.editor_engine.pending_find = Some('f');
5523 self.editor_engine.pending_find_till = false;
5524 self.editor_engine.pending_find_reverse = false;
5525 self.status = "find · next character".into();
5526 }
5527 crossterm::event::KeyCode::Char('t') => {
5528 self.editor_engine.pending_find = Some('t');
5529 self.editor_engine.pending_find_till = true;
5530 self.editor_engine.pending_find_reverse = false;
5531 self.status = "till · next character".into();
5532 }
5533 crossterm::event::KeyCode::Char('F') => {
5534 self.editor_engine.pending_find = Some('F');
5535 self.editor_engine.pending_find_till = false;
5536 self.editor_engine.pending_find_reverse = true;
5537 self.status = "find back · next character".into();
5538 }
5539 crossterm::event::KeyCode::Char('T') => {
5540 self.editor_engine.pending_find = Some('T');
5541 self.editor_engine.pending_find_till = true;
5542 self.editor_engine.pending_find_reverse = true;
5543 self.status = "till back · next character".into();
5544 }
5545 _ => {}
5546 }
5547 self.refresh_editor_projection();
5548 }
5549
5550 fn set_editor_cursor(
5551 &mut self,
5552 path: &str,
5553 position: crate::development::TextPosition,
5554 extend: bool,
5555 ) -> crate::development::DevelopmentResult<()> {
5556 let buffer = self
5557 .workspace
5558 .try_lock()?
5559 .project()
5560 .buffer(path)
5561 .cloned()
5562 .ok_or_else(|| {
5563 crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
5564 })?;
5565 let position = native::clamp_position(&buffer.content, position);
5566 let anchor = if extend {
5567 buffer
5568 .selection
5569 .map(|selection| selection.anchor)
5570 .unwrap_or(crate::development::TextPosition {
5571 line: buffer.cursor_line,
5572 column: buffer.cursor_column,
5573 })
5574 } else {
5575 position
5576 };
5577 let mut workspace = self.workspace.try_lock()?;
5578 workspace
5579 .project_mut()
5580 .set_buffer_cursor(path, position.line, position.column)?;
5581 workspace.project_mut().set_buffer_selection(
5582 path,
5583 extend.then_some(crate::development::TextSelection {
5584 anchor,
5585 active: position,
5586 }),
5587 crate::development::Actor::local(),
5588 )?;
5589 Ok(())
5590 }
5591
5592 fn apply_editor_motion(
5593 &mut self,
5594 path: &str,
5595 content: &str,
5596 cursor: crate::development::TextPosition,
5597 motion: Motion,
5598 extend: bool,
5599 ) {
5600 let next = apply_motion(content, cursor, motion);
5601 let _ = self.set_editor_cursor(path, next, extend);
5602 }
5603
5604 fn apply_textobject(
5605 &mut self,
5606 path: &str,
5607 content: &str,
5608 cursor: crate::development::TextPosition,
5609 object: TextObject,
5610 ) {
5611 let selection = self
5612 .syntax
5613 .textobject(path, content, cursor, object)
5614 .or_else(|| textobject_selection(content, cursor, object));
5615 let Some(selection) = selection else {
5616 self.editor_engine.clear_pending();
5617 self.status = "No textobject under cursor".into();
5618 return;
5619 };
5620 self.editor_engine.last_textobject = Some(object);
5621 if let Some(operator) = self.editor_engine.pending_operator.take() {
5622 let mut ranges = vec![selection];
5623 for extra in self.editor_engine.extra_selections.clone() {
5624 let origin = extra.active;
5625 if let Some(range) = self
5626 .syntax
5627 .textobject(path, content, origin, object)
5628 .or_else(|| textobject_selection(content, origin, object))
5629 {
5630 ranges.push(range);
5631 }
5632 }
5633 if let Err(error) = self.apply_operator_ranges(path, content, operator, ranges) {
5634 self.status = format!("Operator failed: {error}");
5635 }
5636 } else {
5637 self.editor_engine.enter_select();
5638 let _ = self.set_editor_cursor(path, selection.anchor, false);
5639 let _ = self.set_editor_cursor(path, selection.active, true);
5640 self.status = format!("{} · textobject selected", self.editor_engine.mode.label());
5641 }
5642 self.refresh_editor_projection();
5643 }
5644
5645 fn match_same_objects(
5646 &mut self,
5647 path: &str,
5648 content: &str,
5649 cursor: crate::development::TextPosition,
5650 all: bool,
5651 ) {
5652 let object = self
5653 .editor_engine
5654 .last_textobject
5655 .unwrap_or(TextObject::Word { around: false });
5656 let mut ranges = if matches!(object, TextObject::Word { .. }) {
5657 same_word_ranges(
5658 content,
5659 cursor,
5660 matches!(object, TextObject::Word { around: true }),
5661 )
5662 } else {
5663 let mut found = self.syntax.same_textobjects(path, content, cursor, object);
5664 if found.is_empty() {
5665 found = textobject_selection(content, cursor, object)
5666 .into_iter()
5667 .collect();
5668 }
5669 found
5670 };
5671 if ranges.is_empty() {
5672 self.status = "No matching objects under the caret".into();
5673 return;
5674 }
5675 ranges.sort_by_key(|selection| (selection.anchor.line, selection.anchor.column));
5676 let primary_index = ranges
5677 .iter()
5678 .position(|selection| selection_covers(content, selection, cursor))
5679 .unwrap_or(0);
5680 if all {
5681 let primary = ranges.remove(primary_index.min(ranges.len().saturating_sub(1)));
5682 self.editor_engine.extra_selections = ranges;
5683 let _ = self.set_editor_cursor(path, primary.anchor, false);
5684 let _ = self.set_editor_cursor(path, primary.active, true);
5685 self.editor_engine.last_textobject = Some(object);
5686 self.status = self.editor_normal_status();
5687 } else {
5688 let extras = &self.editor_engine.extra_selections;
5689 let next = ranges
5690 .iter()
5691 .cycle()
5692 .skip(primary_index + 1)
5693 .take(ranges.len().saturating_sub(1))
5694 .find(|candidate| {
5695 !extras.iter().any(|existing| {
5696 existing.anchor == candidate.anchor && existing.active == candidate.active
5697 })
5698 })
5699 .cloned();
5700 if let Some(next) = next {
5701 self.editor_engine.extra_selections.push(next);
5702 self.editor_engine.last_textobject = Some(object);
5703 self.status = self.editor_normal_status();
5704 } else {
5705 self.status = "No further matching objects".into();
5706 }
5707 }
5708 self.refresh_editor_projection();
5709 }
5710
5711 fn apply_operator(
5712 &mut self,
5713 path: &str,
5714 content: &str,
5715 cursor: crate::development::TextPosition,
5716 operator: Operator,
5717 motion: Motion,
5718 ) -> crate::development::DevelopmentResult<()> {
5719 let mut ranges = vec![TextSelection {
5720 anchor: cursor,
5721 active: apply_motion(content, cursor, motion),
5722 }];
5723 for extra in &self.editor_engine.extra_selections {
5724 let origin = extra.active;
5725 ranges.push(TextSelection {
5726 anchor: origin,
5727 active: apply_motion(content, origin, motion),
5728 });
5729 }
5730 self.apply_operator_ranges(path, content, operator, ranges)
5731 }
5732
5733 fn apply_operator_ranges(
5734 &mut self,
5735 path: &str,
5736 content: &str,
5737 operator: Operator,
5738 ranges: Vec<TextSelection>,
5739 ) -> crate::development::DevelopmentResult<()> {
5740 let mut offsets = ranges
5741 .iter()
5742 .filter_map(|selection| {
5743 crate::development::editor::selection_offsets(content, selection)
5744 })
5745 .collect::<Vec<_>>();
5746 offsets.sort_by_key(|(start, _)| *start);
5747 offsets.dedup();
5748 if offsets.is_empty() {
5749 self.editor_engine.clear_pending();
5750 return Ok(());
5751 }
5752 self.auto_checkpoint("before-operator");
5753 match operator {
5754 Operator::Yank => {
5755 self.editor_engine.yank = offsets
5756 .iter()
5757 .map(|(start, stop)| content[*start..*stop].to_string())
5758 .collect::<Vec<_>>()
5759 .join("\n");
5760 self.status = format!("Yanked {} bytes", self.editor_engine.yank.len());
5761 }
5762 Operator::Delete | Operator::Change => {
5763 let (next, carets) = multi_delete(content, &offsets);
5764 let mut extras = Vec::new();
5765 let mut primary = crate::development::TextPosition { line: 1, column: 1 };
5766 for (index, offset) in carets.into_iter().enumerate() {
5767 let position =
5768 crate::development::editor::text_position_at_offset(&next, offset)
5769 .unwrap_or(primary);
5770 if index == 0 {
5771 primary = position;
5772 } else {
5773 extras.push(TextSelection::collapsed(position));
5774 }
5775 }
5776 let actor = crate::development::Actor::local();
5777 let mut workspace = self.workspace.try_lock()?;
5778 workspace
5779 .project_mut()
5780 .edit_buffer(path, next, actor.clone())?;
5781 workspace
5782 .project_mut()
5783 .set_buffer_cursor(path, primary.line, primary.column)?;
5784 workspace
5785 .project_mut()
5786 .set_buffer_selection(path, None, actor)?;
5787 drop(workspace);
5788 self.editor_engine.extra_selections = extras;
5789 if operator == Operator::Change {
5790 self.editor_engine.enter_insert();
5791 }
5792 }
5793 }
5794 self.editor_engine.clear_pending();
5795 Ok(())
5796 }
5797
5798 fn maybe_begin_pair_apply(&mut self) {
5799 if self.editor_engine.pair_apply.is_some() {
5800 return;
5801 }
5802 let path = self.focused_editor_path.clone();
5803 if path.is_empty() {
5804 return;
5805 }
5806 let Some(proposal) = self
5807 .editor_proposals
5808 .iter()
5809 .find(|item| {
5810 item.path == path
5811 && item.state == crate::development::EditorProposalState::Pending
5812 && item.original == self.focused_editor_content
5813 && item.original != item.proposed
5814 })
5815 .cloned()
5816 else {
5817 return;
5818 };
5819 self.editor_engine.begin_pair_apply(
5820 proposal.id,
5821 proposal.actor.name.clone(),
5822 proposal.path,
5823 proposal.original,
5824 proposal.proposed,
5825 );
5826 self.status = format!(
5827 "AGENT · {} pair-apply · Enter accept · n reject · type to yield",
5828 proposal.actor.name
5829 );
5830 }
5831
5832 pub fn tick_pair_apply(&mut self) -> bool {
5833 let Some(apply) = self.editor_engine.pair_apply.clone() else {
5834 return false;
5835 };
5836 if self.focused_editor_content == apply.proposed {
5837 return false;
5838 }
5839 let (content, revealed, _done) =
5840 pair_apply_step(&apply.original, &apply.proposed, apply.revealed, 24);
5841 let path = apply.path.clone();
5842 let actor = apply.actor.clone();
5843 let _ = self.locked(|workspace| {
5844 workspace
5845 .project_mut()
5846 .edit_buffer(
5847 &path,
5848 content.clone(),
5849 crate::development::Actor::embedded(),
5850 )
5851 .map(|_| ())
5852 });
5853 if let Some(live) = self.editor_engine.pair_apply.as_mut() {
5854 live.revealed = revealed;
5855 }
5856 self.focused_editor_content = content.clone();
5857 self.focused_editor_dirty = true;
5858 let caret_offset = pair_apply_caret(&apply.original, &apply.proposed, revealed);
5859 if let Some(position) =
5860 crate::development::editor::text_position_at_offset(&content, caret_offset)
5861 {
5862 self.focused_editor_line = position.line;
5863 self.focused_editor_column = position.column;
5864 self.editor_engine.agent_caret = Some(native::Jump {
5865 path,
5866 line: position.line,
5867 column: position.column,
5868 });
5869 let _ = self.set_editor_cursor(&self.focused_editor_path.clone(), position, false);
5870 }
5871 self.editor_engine.mode = EditorMode::Agent;
5872 self.status = format!("AGENT · {actor} pair-apply · Enter accept · n reject");
5873 self.ensure_editor_cursor_visible();
5874 true
5875 }
5876
5877 pub fn editor_gutter_marks(&self) -> Vec<(u32, native::GutterMark)> {
5878 let mut marks = Vec::new();
5879 let path = &self.focused_editor_path;
5880 for diagnostic in &self.editor_diagnostics {
5881 if diagnostic_matches_path(diagnostic, path) {
5882 marks.push((
5883 diagnostic.start.line.saturating_add(1),
5884 native::GutterMark::Lsp,
5885 ));
5886 }
5887 }
5888 let page_lines = self.page_source_lines(path);
5889 match self.last_proof_ok {
5890 Some(true) => {
5891 for line in &page_lines {
5892 marks.push((*line, native::GutterMark::Proof));
5893 }
5894 }
5895 Some(false) => {
5896 for line in &page_lines {
5897 marks.push((*line, native::GutterMark::Lsp));
5898 }
5899 }
5900 None => {}
5901 }
5902 for hunk in &self.editor_engine.hunks {
5903 marks.push((hunk.start_line, native::GutterMark::Git));
5904 }
5905 if let Some(caret) = &self.editor_engine.agent_caret
5906 && caret.path == *path
5907 {
5908 marks.push((caret.line, native::GutterMark::Agent));
5909 }
5910 for line in page_lines {
5911 marks.push((line, native::GutterMark::Page));
5912 }
5913 for comment in &self.editor_comments {
5914 if comment.state == crate::development::EditorCommentState::Open
5915 && (path.is_empty() || comment.path == *path)
5916 {
5917 marks.push((comment.start_line, native::GutterMark::Comment));
5918 }
5919 }
5920 marks
5921 }
5922
5923 pub fn editor_source_notes(&self) -> Vec<(u32, String)> {
5924 let mut by_line = std::collections::BTreeMap::<u32, Vec<String>>::new();
5925 for (line, hint) in &self.editor_inlays {
5926 by_line.entry(*line).or_default().push(hint.clone());
5927 }
5928 let path = &self.focused_editor_path;
5929 for diagnostic in &self.editor_diagnostics {
5930 if diagnostic_matches_path(diagnostic, path) {
5931 by_line
5932 .entry(diagnostic.start.line.saturating_add(1))
5933 .or_default()
5934 .push(format!("! {}", truncate_note(&diagnostic.message)));
5935 }
5936 }
5937 for comment in &self.editor_comments {
5938 if comment.state == crate::development::EditorCommentState::Open
5939 && (path.is_empty() || comment.path == *path)
5940 {
5941 by_line
5942 .entry(comment.start_line)
5943 .or_default()
5944 .push(format!("# {}", truncate_note(&comment.text)));
5945 }
5946 }
5947 by_line
5948 .into_iter()
5949 .map(|(line, parts)| (line, parts.join(" ")))
5950 .collect()
5951 }
5952
5953 fn page_source_lines(&self, path: &str) -> Vec<u32> {
5954 self.workspace
5955 .try_lock()
5956 .ok()
5957 .map(|workspace| {
5958 workspace
5959 .project()
5960 .graph()
5961 .entities_for_source(path, None)
5962 .into_iter()
5963 .map(|link| link.source.start_line)
5964 .collect()
5965 })
5966 .unwrap_or_default()
5967 }
5968
5969 fn show_comment_thread(&mut self) {
5970 let path = self.focused_editor_path.clone();
5971 let line = self.focused_editor_line.max(1);
5972 let thread = self
5973 .editor_comments
5974 .iter()
5975 .filter(|comment| {
5976 comment.state == crate::development::EditorCommentState::Open
5977 && (path.is_empty() || comment.path == path)
5978 && line >= comment.start_line
5979 && line <= comment.end_line
5980 })
5981 .map(|comment| {
5982 format!(
5983 "{} · {}:{}\n {}",
5984 comment.actor.name, comment.path, comment.start_line, comment.text
5985 )
5986 })
5987 .collect::<Vec<_>>();
5988 if thread.is_empty() {
5989 self.status = "No open comment on this line · :editor comment-selection".into();
5990 return;
5991 }
5992 self.editor_engine.overlay = Some(thread.join("\n\n"));
5993 self.status = "Comment thread · Esc closes".into();
5994 }
5995
5996 fn refresh_editor_hunks(&mut self) {
5997 let path = self.focused_editor_path.clone();
5998 if path.is_empty() {
5999 return;
6000 }
6001 let proposal = self.editor_proposals.iter().find(|item| item.path == path);
6002 if let Some(proposal) = proposal {
6003 self.editor_engine
6004 .set_hunks(line_hunks(&proposal.original, &proposal.proposed));
6005 }
6006 }
6007
6008 fn auto_checkpoint(&mut self, name: &str) {
6009 let _ = self.locked(|workspace| {
6010 workspace
6011 .project_mut()
6012 .create_editor_checkpoint(name.to_string(), crate::development::Actor::local())
6013 .map(|_| ())
6014 });
6015 }
6016
6017 fn editor_hover(&mut self) {
6018 let path = self.focused_editor_path.clone();
6019 let line = self.focused_editor_line.saturating_sub(1);
6020 let character = self.focused_editor_column.saturating_sub(1);
6021 match self.locked(|workspace| {
6022 let server = workspace
6023 .language()
6024 .names()
6025 .next()
6026 .ok_or_else(|| {
6027 crate::development::DevelopmentError::NotFound("language server".into())
6028 })?
6029 .to_string();
6030 workspace
6031 .language()
6032 .hover(&server, "local", &path, line, character)
6033 }) {
6034 Some(Ok(response)) => {
6035 self.editor_engine.overlay = Some(response.result.to_string());
6036 self.status = "Hover · Esc closes".into();
6037 }
6038 Some(Err(error)) => self.status = format!("Hover unavailable: {error}"),
6039 None => self.status = "Hover unavailable · workspace busy".into(),
6040 }
6041 }
6042
6043 fn editor_references(&mut self) {
6044 let path = self.focused_editor_path.clone();
6045 let line = self.focused_editor_line.saturating_sub(1);
6046 let character = self.focused_editor_column.saturating_sub(1);
6047 match self.locked(|workspace| {
6048 let server = workspace
6049 .language()
6050 .names()
6051 .next()
6052 .ok_or_else(|| {
6053 crate::development::DevelopmentError::NotFound("language server".into())
6054 })?
6055 .to_string();
6056 workspace
6057 .language()
6058 .references(&server, "local", &path, line, character)
6059 }) {
6060 Some(Ok(response)) => {
6061 self.editor_engine.overlay = Some(format_lsp_locations(&response.result));
6062 self.status = "References · Esc closes".into();
6063 }
6064 Some(Err(error)) => self.status = format!("References unavailable: {error}"),
6065 None => self.status = "References unavailable · workspace busy".into(),
6066 }
6067 }
6068
6069 fn editor_go_to_definition(&mut self) {
6070 let path = self.focused_editor_path.clone();
6071 let line = self.focused_editor_line.saturating_sub(1);
6072 let character = self.focused_editor_column.saturating_sub(1);
6073 self.editor_engine
6074 .record_jump(&path, self.focused_editor_line, self.focused_editor_column);
6075 match self.locked(|workspace| {
6076 let server = workspace
6077 .language()
6078 .names()
6079 .next()
6080 .ok_or_else(|| {
6081 crate::development::DevelopmentError::NotFound("language server".into())
6082 })?
6083 .to_string();
6084 workspace
6085 .language()
6086 .definition(&server, "local", &path, line, character)
6087 }) {
6088 Some(Ok(response)) => {
6089 self.editor_engine.overlay = Some(format!("definition {}", response.result));
6090 if let Some(target) = parse_lsp_location(&response.result) {
6091 let _ = self.open_path(&target.path);
6092 let _ = self.set_editor_cursor(
6093 &self.focused_editor_path.clone(),
6094 crate::development::TextPosition {
6095 line: target.line.max(1),
6096 column: target.column.max(1),
6097 },
6098 false,
6099 );
6100 }
6101 self.status = "Definition · Ctrl-O symbols · Enter jump".into();
6102 }
6103 Some(Err(error)) => self.status = format!("Definition unavailable: {error}"),
6104 None => self.status = "Definition unavailable · workspace busy".into(),
6105 }
6106 }
6107
6108 fn open_symbol_picker(&mut self) {
6109 let path = self.focused_editor_path.clone();
6110 match self.locked(|workspace| {
6111 let server = workspace
6112 .language()
6113 .names()
6114 .next()
6115 .ok_or_else(|| {
6116 crate::development::DevelopmentError::NotFound("language server".into())
6117 })?
6118 .to_string();
6119 workspace
6120 .language()
6121 .document_symbols(&server, "local", &path)
6122 }) {
6123 Some(Ok(response)) => {
6124 self.editor_engine.symbols = parse_lsp_symbols(&response.result);
6125 self.editor_engine.symbol_selection = 0;
6126 self.status = format!(
6127 "Symbols · {} · Enter jumps",
6128 self.editor_engine.symbols.len()
6129 );
6130 }
6131 _ => {
6132 self.editor_engine.symbols = self
6133 .focused_editor_content
6134 .lines()
6135 .enumerate()
6136 .filter(|(_, line)| {
6137 let trimmed = line.trim_start();
6138 trimmed.starts_with("fn ")
6139 || trimmed.starts_with("struct ")
6140 || trimmed.starts_with("impl ")
6141 || trimmed.starts_with("pub ")
6142 })
6143 .map(|(index, line)| (line.trim().to_string(), index as u32 + 1))
6144 .collect();
6145 self.status = format!("Symbols (lexical) · {}", self.editor_engine.symbols.len());
6146 }
6147 }
6148 }
6149
6150 fn accept_current_hunk(&mut self) {
6151 let path = self.focused_editor_path.clone();
6152 let Some(proposal) = self
6153 .editor_proposals
6154 .iter()
6155 .find(|item| item.path == path)
6156 .cloned()
6157 else {
6158 self.status = "No proposal hunk on this buffer".into();
6159 return;
6160 };
6161 self.auto_checkpoint("before-hunk-accept");
6162 match self.locked(|workspace| {
6163 workspace
6164 .project_mut()
6165 .accept_editor_proposal(&proposal.id, crate::development::Actor::local())
6166 .map(|_| ())
6167 }) {
6168 Some(Ok(())) => {
6169 self.status = format!("Accepted proposal {}", proposal.id);
6170 self.refresh_editor_hunks();
6171 }
6172 Some(Err(error)) => self.status = format!("Accept failed: {error}"),
6173 None => self.status = "Accept failed · workspace busy".into(),
6174 }
6175 }
6176
6177 fn reject_current_hunk(&mut self) {
6178 let path = self.focused_editor_path.clone();
6179 let Some(proposal) = self
6180 .editor_proposals
6181 .iter()
6182 .find(|item| item.path == path)
6183 .cloned()
6184 else {
6185 return;
6186 };
6187 let _ = self.locked(|workspace| {
6188 workspace
6189 .project_mut()
6190 .reject_editor_proposal(&proposal.id, crate::development::Actor::local())
6191 .map(|_| ())
6192 });
6193 self.status = format!("Rejected proposal {}", proposal.id);
6194 self.refresh_editor_hunks();
6195 }
6196
6197 pub fn jump_page_from_source(&mut self) {
6198 let path = self.focused_editor_path.clone();
6199 if path.is_empty() {
6200 self.status = "Open a buffer, then gp jumps to App".into();
6201 return;
6202 }
6203 let line = self.focused_editor_line.max(1);
6204 let entity = self
6205 .locked(|workspace| {
6206 let _ = workspace.project_mut().discover_runtime_links();
6207 workspace
6208 .project()
6209 .graph()
6210 .entities_for_source(&path, Some(line))
6211 .first()
6212 .map(|link| link.entity_id.clone())
6213 })
6214 .flatten();
6215 if let Some(entity) = entity.clone() {
6216 self.pending_page_entity = Some(entity.clone());
6217 if self.select_page_entity(&entity) {
6218 self.surface = DevSurface::App;
6219 self.code_edit_mode = false;
6220 self.status = format!("Page bound · entity {entity}");
6221 }
6222 }
6223 let route = inferred_app_path(&path);
6224 let Some(base) = self.resolved_app_url() else {
6225 if entity.is_none() {
6226 self.status = "No App URL · start the detected suite, then gp".into();
6227 }
6228 return;
6229 };
6230 let url = join_app_url(&base, route.as_deref());
6231 let current = self.browser_workspace.state().url.clone();
6232 let current_origin = current.trim_end_matches('/');
6233 if entity.is_some()
6234 && !current.is_empty()
6235 && (current == url || current.starts_with(&url) || url.starts_with(current_origin))
6236 {
6237 self.surface = DevSurface::App;
6238 self.code_edit_mode = false;
6239 return;
6240 }
6241 self.auto_checkpoint("before-app-jump");
6242 match self.prepare_browser_navigation(&url) {
6243 Ok(message) => {
6244 self.status = if entity.is_some() {
6245 format!("{message} · will bind page entity")
6246 } else {
6247 message
6248 };
6249 }
6250 Err(error) => self.status = error,
6251 }
6252 }
6253
6254 pub fn jump_source_from_page(&mut self) {
6255 let Some(entity) = self.browser_workspace.state().selected().cloned() else {
6256 self.status = "Select an App entity, then g jumps to source".into();
6257 return;
6258 };
6259 let reference = entity.reference.clone();
6260 let name = entity.name.clone();
6261 let link = self
6262 .locked(|workspace| {
6263 let _ = workspace.project_mut().discover_runtime_links();
6264 let graph = workspace.project().graph();
6265 graph
6266 .best_link(&reference)
6267 .cloned()
6268 .or_else(|| graph.best_link(&name).cloned())
6269 .or_else(|| {
6270 graph
6271 .links
6272 .values()
6273 .flatten()
6274 .find(|link| {
6275 reference.ends_with(&link.entity_id)
6276 || name.contains(&link.entity_id)
6277 })
6278 .cloned()
6279 })
6280 })
6281 .flatten();
6282 let Some(link) = link else {
6283 self.status = format!("No source link for {reference} · :project graph discover");
6284 return;
6285 };
6286 self.open_source_at(&link.source.path, link.source.start_line);
6287 }
6288
6289 pub fn attach_detected_app(&mut self) -> Result<String, String> {
6290 let url = self
6291 .resolved_app_url()
6292 .ok_or_else(|| "No App URL · start the detected suite".to_string())?;
6293 self.auto_checkpoint("before-app-attach");
6294 self.prepare_browser_navigation(&url)
6295 }
6296
6297 pub fn resolved_app_url(&self) -> Option<String> {
6298 self.process_urls
6299 .iter()
6300 .find(|url| !url.is_empty())
6301 .cloned()
6302 .or_else(|| {
6303 self.workspace.try_lock().ok().and_then(|workspace| {
6304 let detection = workspace.project().detection();
6305 detection.browser_url.clone().or_else(|| {
6306 detection
6307 .local_development_urls
6308 .iter()
6309 .find(|url| !url.is_empty())
6310 .cloned()
6311 })
6312 })
6313 })
6314 .map(|url| join_app_url(&url, None))
6315 }
6316
6317 fn select_page_entity(&mut self, entity_id: &str) -> bool {
6318 let index = self
6319 .browser_workspace
6320 .state()
6321 .entities
6322 .iter()
6323 .position(|entity| {
6324 entity.reference == entity_id
6325 || entity.reference.ends_with(entity_id)
6326 || entity.name == entity_id
6327 || (!entity_id.is_empty() && entity.name.contains(entity_id))
6328 });
6329 let Some(index) = index else {
6330 return false;
6331 };
6332 self.browser_workspace.state_mut().selected_entity = Some(index);
6333 self.browser = self.browser_workspace_summary();
6334 true
6335 }
6336
6337 fn open_source_at(&mut self, path: &str, line: u32) {
6338 match self.open_path(path) {
6339 Ok(_) => {
6340 let focused = self.focused_editor_path.clone();
6341 let _ = self.set_editor_cursor(
6342 &focused,
6343 crate::development::TextPosition {
6344 line: line.max(1),
6345 column: 1,
6346 },
6347 false,
6348 );
6349 self.refresh_editor_projection();
6350 self.ensure_editor_cursor_visible();
6351 self.status = format!("Source · {path}:{line}");
6352 }
6353 Err(error) => self.status = format!("Source jump failed: {error}"),
6354 }
6355 }
6356
6357 fn accept_ghost_text(&mut self, path: &str, text: &str) {
6358 let _ = self.insert_editor_text(path, text);
6359 self.refresh_editor_projection();
6360 self.advance_next_edit();
6361 }
6362
6363 fn accept_ghost_word(&mut self, path: &str) {
6364 let Some(ghost) = self.editor_engine.ghost.take() else {
6365 return;
6366 };
6367 match split_ghost_word(&ghost.text) {
6368 Some((word, rest)) if !rest.is_empty() => {
6369 let _ = self.insert_editor_text(path, word);
6370 self.refresh_editor_projection();
6371 self.editor_engine.ghost = Some(GhostText {
6372 text: rest.to_string(),
6373 });
6374 self.status = "Ghost word accepted · Tab rest · Ctrl-Right another word".into();
6375 }
6376 Some((word, _)) => self.accept_ghost_text(path, word),
6377 None => self.accept_ghost_text(path, &ghost.text),
6378 }
6379 }
6380
6381 fn advance_next_edit(&mut self) {
6382 let content = self.focused_editor_content.clone();
6383 let caret = crate::development::editor::text_position_offset(
6384 &content,
6385 crate::development::TextPosition {
6386 line: self.focused_editor_line.max(1),
6387 column: self.focused_editor_column.max(1),
6388 },
6389 )
6390 .unwrap_or(content.len());
6391 let Some(offset) = next_edit_after_accept(&content, caret) else {
6392 self.request_ghost_from_line();
6393 self.status = if self.editor_engine.ghost.is_some() {
6394 "Ghost accepted · next edit here".into()
6395 } else {
6396 "Ghost accepted".into()
6397 };
6398 return;
6399 };
6400 let Some(position) = crate::development::editor::text_position_at_offset(&content, offset)
6401 else {
6402 self.request_ghost_from_line();
6403 self.status = "Ghost accepted".into();
6404 return;
6405 };
6406 let path = self.focused_editor_path.clone();
6407 self.editor_engine
6408 .record_jump(&path, position.line, position.column);
6409 let _ = self.set_editor_cursor(&path, position, false);
6410 self.refresh_editor_projection();
6411 self.request_ghost_from_line();
6412 self.status = format!(
6413 "Ghost accepted · next edit {}:{}",
6414 position.line, position.column
6415 );
6416 }
6417
6418 pub fn request_ghost_from_line(&mut self) {
6419 let path = self.focused_editor_path.clone();
6420 let Some(offset) = crate::development::editor::text_position_offset(
6421 &self.focused_editor_content,
6422 crate::development::TextPosition {
6423 line: self.focused_editor_line.max(1),
6424 column: self.focused_editor_column.max(1),
6425 },
6426 ) else {
6427 return;
6428 };
6429 if let Some(text) = local_fim(&self.focused_editor_content, offset) {
6430 self.editor_engine.ghost = Some(GhostText { text });
6431 return;
6432 }
6433 if self.take_ready_fim(&path, offset) {
6434 return;
6435 }
6436 self.spawn_hosted_fim(&path, offset);
6437 let line = self.focused_editor_line.saturating_sub(1);
6438 let character = self.focused_editor_column.saturating_sub(1);
6439 if let Some(text) = self.lsp_ghost_insert(&path, line, character) {
6440 self.editor_engine.ghost = Some(GhostText { text });
6441 return;
6442 }
6443 let line = self
6444 .focused_editor_content
6445 .lines()
6446 .nth(self.focused_editor_line.saturating_sub(1) as usize)
6447 .unwrap_or("")
6448 .trim()
6449 .to_string();
6450 if line.is_empty() {
6451 return;
6452 }
6453 let ghost = if line.ends_with('{') {
6454 "\n \n}"
6455 } else if line.contains("todo") || line.contains("TODO") {
6456 " // implemented"
6457 } else {
6458 return;
6459 };
6460 self.editor_engine.ghost = Some(GhostText { text: ghost.into() });
6461 }
6462
6463 pub fn tick_fim(&mut self) -> bool {
6464 let path = self.focused_editor_path.clone();
6465 let Some(offset) = crate::development::editor::text_position_offset(
6466 &self.focused_editor_content,
6467 crate::development::TextPosition {
6468 line: self.focused_editor_line.max(1),
6469 column: self.focused_editor_column.max(1),
6470 },
6471 ) else {
6472 return false;
6473 };
6474 self.take_ready_fim(&path, offset)
6475 }
6476
6477 fn take_ready_fim(&mut self, path: &str, offset: usize) -> bool {
6478 let stale = self
6479 .pending_fim
6480 .as_ref()
6481 .is_some_and(|pending| pending.path() != path || pending.offset() != offset);
6482 if stale {
6483 self.pending_fim = None;
6484 return false;
6485 }
6486 let pi = match &self.pending_fim {
6487 Some(PendingFim::Pi {
6488 agent_id, since, ..
6489 }) => Some((agent_id.clone(), *since)),
6490 _ => None,
6491 };
6492 if let Some((agent_id, since)) = pi {
6493 let text = self
6494 .locked(|workspace| {
6495 workspace
6496 .agents()
6497 .history(since)
6498 .ok()?
6499 .into_iter()
6500 .rev()
6501 .find_map(|event| {
6502 if event.agent_id != agent_id {
6503 return None;
6504 }
6505 if event
6506 .payload
6507 .get("operation")
6508 .and_then(serde_json::Value::as_str)
6509 != Some("complete")
6510 {
6511 return None;
6512 }
6513 crate::fim::parse_fim_text(&event.payload)
6514 })
6515 })
6516 .flatten();
6517 return match text {
6518 Some(text) => {
6519 self.pending_fim = None;
6520 self.editor_engine.ghost = Some(GhostText { text });
6521 true
6522 }
6523 None => false,
6524 };
6525 }
6526 let Some(PendingFim::Thread { rx, .. }) = self.pending_fim.as_mut() else {
6527 return false;
6528 };
6529 match rx.try_recv() {
6530 Ok(Some(text)) if !text.is_empty() => {
6531 self.pending_fim = None;
6532 self.editor_engine.ghost = Some(GhostText { text });
6533 true
6534 }
6535 Ok(_) | Err(std::sync::mpsc::TryRecvError::Disconnected) => {
6536 self.pending_fim = None;
6537 false
6538 }
6539 Err(std::sync::mpsc::TryRecvError::Empty) => false,
6540 }
6541 }
6542
6543 fn spawn_hosted_fim(&mut self, path: &str, offset: usize) {
6544 if self
6545 .pending_fim
6546 .as_ref()
6547 .is_some_and(|pending| pending.path() == path && pending.offset() == offset)
6548 {
6549 return;
6550 }
6551 let Some(provider) = self.workspace.try_lock().ok().and_then(|workspace| {
6552 crate::fim::FimProvider::from_editor(&workspace.customization().config().editor)
6553 }) else {
6554 return;
6555 };
6556 let prefix = self.focused_editor_content[..offset].to_string();
6557 let suffix = self.focused_editor_content[offset..].to_string();
6558 match provider.backend {
6559 crate::fim::FimBackend::Stub => {
6560 let (tx, rx) = std::sync::mpsc::channel();
6561 let _ = std::thread::Builder::new()
6562 .name("glass-fim".into())
6563 .spawn(move || {
6564 let _ = tx.send(provider.complete(&prefix, &suffix).ok());
6565 });
6566 self.pending_fim = Some(PendingFim::Thread {
6567 path: path.to_string(),
6568 offset,
6569 rx,
6570 });
6571 }
6572 crate::fim::FimBackend::Pi => {
6573 let selected = self.selected_agent.clone();
6574 let queued = self
6575 .locked(|workspace| {
6576 let since = workspace
6577 .agents()
6578 .history(0)
6579 .ok()?
6580 .last()
6581 .map(|event| event.sequence)
6582 .unwrap_or(0);
6583 let snapshots = workspace.agents().list().ok()?;
6584 let id = selected
6585 .as_ref()
6586 .filter(|id| {
6587 snapshots.iter().any(|item| {
6588 &item.id == *id && item.status == crate::AgentStatus::Idle
6589 })
6590 })
6591 .cloned()
6592 .or_else(|| {
6593 snapshots.into_iter().find_map(|item| {
6594 (item.status == crate::AgentStatus::Idle).then_some(item.id)
6595 })
6596 })?;
6597 workspace
6598 .agents()
6599 .request(
6600 &id,
6601 crate::pi_runtime::PiSessionRequest::Complete { prefix, suffix },
6602 )
6603 .ok()?;
6604 Some((id, since))
6605 })
6606 .flatten();
6607 if let Some((agent_id, since)) = queued {
6608 self.pending_fim = Some(PendingFim::Pi {
6609 path: path.to_string(),
6610 offset,
6611 agent_id,
6612 since,
6613 });
6614 }
6615 }
6616 }
6617 }
6618
6619 fn lsp_ghost_insert(&mut self, path: &str, line: u32, character: u32) -> Option<String> {
6620 let response = self.locked(|workspace| {
6621 let server = workspace
6622 .language()
6623 .names()
6624 .next()
6625 .ok_or_else(|| {
6626 crate::development::DevelopmentError::NotFound("language server".into())
6627 })?
6628 .to_string();
6629 workspace
6630 .language()
6631 .completion(&server, "local", path, line, character)
6632 })?;
6633 parse_completion_insert(&response.ok()?.result)
6634 }
6635
6636 fn move_editor_cursor(
6637 &mut self,
6638 path: &str,
6639 line_delta: i32,
6640 column_delta: i32,
6641 extend_selection: bool,
6642 ) -> crate::development::DevelopmentResult<()> {
6643 let buffer = self
6644 .workspace
6645 .try_lock()?
6646 .project()
6647 .buffer(path)
6648 .cloned()
6649 .ok_or_else(|| {
6650 crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
6651 })?;
6652 let lines = buffer.content.split('\n').collect::<Vec<_>>();
6653 let line =
6654 (buffer.cursor_line as i32 + line_delta).clamp(1, lines.len().max(1) as i32) as u32;
6655 let max_column = lines
6656 .get(line.saturating_sub(1) as usize)
6657 .map(|line| line.chars().count() + 1)
6658 .unwrap_or(1) as u32;
6659 let column = if line_delta != 0 {
6660 buffer.cursor_column.min(max_column)
6661 } else {
6662 (buffer.cursor_column as i32 + column_delta).clamp(1, max_column as i32) as u32
6663 };
6664 let anchor = if extend_selection {
6665 buffer
6666 .selection
6667 .map(|selection| selection.anchor)
6668 .unwrap_or(crate::development::TextPosition {
6669 line: buffer.cursor_line,
6670 column: buffer.cursor_column,
6671 })
6672 } else {
6673 crate::development::TextPosition { line, column }
6674 };
6675 let mut workspace = self.workspace.try_lock()?;
6676 workspace
6677 .project_mut()
6678 .set_buffer_cursor(path, line, column)?;
6679 workspace.project_mut().set_buffer_selection(
6680 path,
6681 extend_selection.then_some(crate::development::TextSelection {
6682 anchor,
6683 active: crate::development::TextPosition { line, column },
6684 }),
6685 crate::development::Actor::local(),
6686 )?;
6687 Ok(())
6688 }
6689
6690 fn insert_editor_text(
6691 &mut self,
6692 path: &str,
6693 text: &str,
6694 ) -> crate::development::DevelopmentResult<()> {
6695 let extras = self.editor_engine.extra_selections.clone();
6696 let mut workspace = self.workspace.try_lock()?;
6697 let project = workspace.project_mut();
6698 let buffer = project.buffer(path).cloned().ok_or_else(|| {
6699 crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
6700 })?;
6701 if buffer
6702 .selection
6703 .as_ref()
6704 .is_some_and(|selection| !selection.is_empty())
6705 && extras.is_empty()
6706 {
6707 project.replace_buffer_selection(
6708 path,
6709 text.to_string(),
6710 crate::development::Actor::local(),
6711 )?;
6712 return Ok(());
6713 }
6714 let primary = editor_offset(&buffer.content, buffer.cursor_line, buffer.cursor_column);
6715 if extras.is_empty() {
6716 let mut content = buffer.content;
6717 content.insert_str(primary, text);
6718 let cursor =
6719 crate::development::editor::text_position_at_offset(&content, primary + text.len())
6720 .ok_or_else(|| {
6721 crate::development::DevelopmentError::InvalidInput(
6722 "inserted text ended at an invalid UTF-8 boundary".into(),
6723 )
6724 })?;
6725 let actor = crate::development::Actor::local();
6726 project.edit_buffer(path, content, actor.clone())?;
6727 project.set_buffer_cursor(path, cursor.line, cursor.column)?;
6728 project.set_buffer_selection(path, None, actor)?;
6729 return Ok(());
6730 }
6731 let mut sites = vec![primary];
6732 for extra in &extras {
6733 if let Some(offset) =
6734 crate::development::editor::text_position_offset(&buffer.content, extra.active)
6735 {
6736 sites.push(offset);
6737 }
6738 }
6739 let (content, carets) = multi_insert(&buffer.content, &sites, text);
6740 let mut next_extras = Vec::new();
6741 let mut primary_pos = crate::development::TextPosition { line: 1, column: 1 };
6742 for (index, offset) in carets.into_iter().enumerate() {
6743 let position = crate::development::editor::text_position_at_offset(&content, offset)
6744 .ok_or_else(|| {
6745 crate::development::DevelopmentError::InvalidInput(
6746 "inserted text ended at an invalid UTF-8 boundary".into(),
6747 )
6748 })?;
6749 if index == 0 {
6750 primary_pos = position;
6751 } else {
6752 next_extras.push(TextSelection::collapsed(position));
6753 }
6754 }
6755 let actor = crate::development::Actor::local();
6756 project.edit_buffer(path, content, actor.clone())?;
6757 project.set_buffer_cursor(path, primary_pos.line, primary_pos.column)?;
6758 project.set_buffer_selection(path, None, actor)?;
6759 drop(workspace);
6760 self.editor_engine.extra_selections = next_extras;
6761 Ok(())
6762 }
6763
6764 fn backspace_editor(&mut self, path: &str) -> crate::development::DevelopmentResult<()> {
6765 let extras = self.editor_engine.extra_selections.clone();
6766 let mut workspace = self.workspace.try_lock()?;
6767 let project = workspace.project_mut();
6768 let buffer = project.buffer(path).cloned().ok_or_else(|| {
6769 crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
6770 })?;
6771 if buffer
6772 .selection
6773 .as_ref()
6774 .is_some_and(|selection| !selection.is_empty())
6775 && extras.is_empty()
6776 {
6777 project.replace_buffer_selection(
6778 path,
6779 String::new(),
6780 crate::development::Actor::local(),
6781 )?;
6782 return Ok(());
6783 }
6784 let mut sites = vec![editor_offset(
6785 &buffer.content,
6786 buffer.cursor_line,
6787 buffer.cursor_column,
6788 )];
6789 for extra in &extras {
6790 if let Some(offset) =
6791 crate::development::editor::text_position_offset(&buffer.content, extra.active)
6792 {
6793 sites.push(offset);
6794 }
6795 }
6796 let mut ranges = Vec::new();
6797 for offset in sites {
6798 if offset == 0 {
6799 continue;
6800 }
6801 let previous = buffer.content[..offset]
6802 .char_indices()
6803 .next_back()
6804 .map(|(index, _)| index)
6805 .unwrap_or(0);
6806 ranges.push((previous, offset));
6807 }
6808 if ranges.is_empty() {
6809 return Ok(());
6810 }
6811 if extras.is_empty() && ranges.len() == 1 {
6812 let (previous, offset) = ranges[0];
6813 let mut content = buffer.content;
6814 content.drain(previous..offset);
6815 let cursor = crate::development::editor::text_position_at_offset(&content, previous)
6816 .ok_or_else(|| {
6817 crate::development::DevelopmentError::InvalidInput(
6818 "backspace ended at an invalid UTF-8 boundary".into(),
6819 )
6820 })?;
6821 let actor = crate::development::Actor::local();
6822 project.edit_buffer(path, content, actor.clone())?;
6823 project.set_buffer_cursor(path, cursor.line, cursor.column)?;
6824 project.set_buffer_selection(path, None, actor)?;
6825 return Ok(());
6826 }
6827 let (content, carets) = multi_delete(&buffer.content, &ranges);
6828 let mut next_extras = Vec::new();
6829 let mut primary_pos = crate::development::TextPosition { line: 1, column: 1 };
6830 for (index, offset) in carets.into_iter().enumerate() {
6831 let position = crate::development::editor::text_position_at_offset(&content, offset)
6832 .ok_or_else(|| {
6833 crate::development::DevelopmentError::InvalidInput(
6834 "backspace ended at an invalid UTF-8 boundary".into(),
6835 )
6836 })?;
6837 if index == 0 {
6838 primary_pos = position;
6839 } else {
6840 next_extras.push(TextSelection::collapsed(position));
6841 }
6842 }
6843 let actor = crate::development::Actor::local();
6844 project.edit_buffer(path, content, actor.clone())?;
6845 project.set_buffer_cursor(path, primary_pos.line, primary_pos.column)?;
6846 project.set_buffer_selection(path, None, actor)?;
6847 drop(workspace);
6848 self.editor_engine.extra_selections = next_extras;
6849 Ok(())
6850 }
6851
6852 pub fn previous_surface(&mut self) {
6853 let surfaces: &[DevSurface] = if self
6854 .responsive_class(self.terminal_width, self.terminal_height)
6855 == ResponsiveClass::Phone
6856 {
6857 &DevSurface::PHONE
6858 } else {
6859 &DevSurface::PRIMARY
6860 };
6861 let index = surfaces
6862 .iter()
6863 .position(|surface| *surface == self.surface)
6864 .unwrap_or(0);
6865 self.show_surface(surfaces[(index + surfaces.len() - 1) % surfaces.len()]);
6866 }
6867
6868 pub fn apply_snapshot(&mut self, snapshot: &super::snapshot::DisplaySnapshot) {
6870 self.refresh_latency_ms = snapshot.duration.as_millis() as u64;
6871 let selected_agent_status = self.selected_agent.as_ref().and_then(|selected| {
6872 snapshot
6873 .agent_states
6874 .iter()
6875 .find(|(id, _)| id == selected)
6876 .map(|(_, status)| *status)
6877 });
6878 if let super::snapshot::BrowserHealth::Crashed {
6879 last_process_id,
6880 last_revision,
6881 } = &snapshot.browser_health
6882 && self.browser_recovery.is_none()
6883 {
6884 let pid_label = last_process_id
6885 .map(|pid| pid.to_string())
6886 .unwrap_or_else(|| "unknown".into());
6887 let revision_label = last_revision
6888 .map(|revision| revision.to_string())
6889 .unwrap_or_else(|| "none".into());
6890 self.surface = DevSurface::App;
6891 self.browser_recovery = Some(BrowserRecoveryOffer::from_error(
6892 &format!(
6893 "browser endpoint crashed unexpectedly (pid {pid_label}, last revision {revision_label})"
6894 ),
6895 9222,
6896 ));
6897 self.browser_workspace
6898 .disconnected("browser endpoint crashed".to_string(), true);
6899 self.status = "Browser endpoint crashed · recovery choices below".into();
6900 }
6901 self.harnesses = snapshot.harnesses.clone();
6902 if let Ok(list) = self.ws().map(|workspace| workspace.todos()) {
6903 self.session_todos = list;
6904 self.selected_todo = self
6905 .selected_todo
6906 .min(self.session_todos.items.len().saturating_sub(1));
6907 }
6908 self.agents = snapshot.agents.clone();
6909 self.agent_conversation = snapshot.agent_conversation.clone();
6910 self.conversation_items = snapshot.conversation_items.clone();
6911 if let Some(chrome) = self
6912 .selected_agent
6913 .as_ref()
6914 .and_then(|selected| {
6915 snapshot
6916 .agent_chrome
6917 .iter()
6918 .find(|item| item.id == *selected)
6919 })
6920 .or_else(|| snapshot.agent_chrome.first())
6921 {
6922 if self.selected_agent.is_none() {
6923 self.selected_agent = Some(chrome.id.clone());
6924 }
6925 self.agent_model = chrome.model.clone().unwrap_or_default();
6926 self.agent_thinking = chrome.thinking.clone().unwrap_or_default();
6927 if let Some(path) = chrome.session_file.as_deref() {
6928 self.agent_session_name = std::path::Path::new(path)
6929 .file_name()
6930 .and_then(|name| name.to_str())
6931 .unwrap_or(path)
6932 .to_string();
6933 }
6934 }
6935 let entry_count = self.conversation_entries_view().len();
6936 if entry_count == 0 {
6937 self.transcript_selection = 0;
6938 } else {
6939 self.transcript_selection = self.transcript_selection.min(entry_count - 1);
6940 }
6941 self.reconcile_pending_chat();
6942 if self.agent_send_job.is_none()
6943 && self.pending_chat_messages.is_empty()
6944 && self.status.contains("Glass Agent is thinking")
6945 {
6946 match selected_agent_status {
6947 Some(crate::AgentStatus::Idle) => {
6948 self.status = "Glass Agent ready · response received".into();
6949 }
6950 Some(crate::AgentStatus::Failed) => {
6951 self.status = "Glass Agent failed · press Enter to retry".into();
6952 }
6953 Some(crate::AgentStatus::Cancelled) => {
6954 self.status = "Glass Agent stopped · press Enter to retry".into();
6955 }
6956 Some(crate::AgentStatus::Waiting) => {
6957 self.status = "Glass Agent waiting for approval".into();
6958 }
6959 _ => {}
6960 }
6961 }
6962 self.tasks = snapshot.tasks.clone();
6963 if !snapshot.editor.is_empty() {
6964 self.editor = snapshot.editor.clone();
6965 }
6966 self.lsp = snapshot.lsp.clone();
6967 self.processes = snapshot.processes.clone();
6968 self.process_entries = snapshot.process_entries.clone();
6969 if self.process_entries.is_empty() {
6970 self.selected_process = 0;
6971 self.process_urls.clear();
6972 } else {
6973 self.selected_process = self
6974 .selected_process
6975 .min(self.process_entries.len().saturating_sub(1));
6976 self.process_urls = self
6977 .process_entries
6978 .iter()
6979 .filter_map(|entry| entry.url.clone())
6980 .collect();
6981 self.process_urls.sort();
6982 self.process_urls.dedup();
6983 }
6984 self.git = snapshot.git.clone();
6985 self.git_entries = snapshot.git_entries.clone();
6986 self.git_branch = snapshot.git_branch.clone();
6987 self.git_dirty = snapshot.git_dirty;
6988 self.git_ahead = snapshot.git_ahead;
6989 self.git_behind = snapshot.git_behind;
6990 self.git_conflicts = snapshot.git_conflicts.clone();
6991 self.github = snapshot.github.clone();
6992 self.github_review = snapshot.github_review.clone();
6993 if self.git_entries.is_empty() {
6994 self.selected_git_file = 0;
6995 } else {
6996 self.selected_git_file = self
6997 .selected_git_file
6998 .min(self.git_entries.len().saturating_sub(1));
6999 if self.surface == DevSurface::Git && !self.git_diff_requested {
7000 let selected_path = self.selected_git_entry().map(|entry| entry.path.as_str());
7001 if !self.git_diff_open || selected_path != self.git_diff_path.as_deref() {
7002 self.request_selected_git_diff();
7003 }
7004 }
7005 }
7006 self.tests = snapshot.tests.clone();
7007 self.kernels = snapshot.kernels.clone();
7008 self.debugger = snapshot.debugger.clone();
7009 let previous_debug = self
7010 .selected_debug_session()
7011 .map(|session| session.name.clone());
7012 self.debug_sessions = snapshot.debug_sessions.clone();
7013 if self.debug_sessions.is_empty() {
7014 self.selected_debug_session = 0;
7015 self.debug_threads.clear();
7016 self.debug_frames.clear();
7017 } else {
7018 self.selected_debug_session = self
7019 .selected_debug_session
7020 .min(self.debug_sessions.len().saturating_sub(1));
7021 let current = self
7022 .selected_debug_session()
7023 .map(|session| session.name.clone());
7024 if previous_debug != current {
7025 self.debug_threads.clear();
7026 self.debug_frames.clear();
7027 self.selected_debug_thread = 0;
7028 self.selected_debug_frame = 0;
7029 }
7030 }
7031 self.replay = snapshot.replay.clone();
7032 self.workflow = snapshot.workflow.clone();
7033 self.workspace_status = snapshot.workspace_status.clone();
7034 self.browser = snapshot.browser.clone();
7035 self.snapshot_root = snapshot.root.clone();
7036 self.snapshot_trust_label = snapshot.trust_label.clone();
7037 self.snapshot_trust_inspection = snapshot.trust_inspection.clone();
7038 self.snapshot_project_revision = snapshot.project_revision;
7039 self.snapshot_generation = snapshot.generation;
7040 self.snapshot_skills_count = snapshot.skills_count;
7041 self.snapshot_tools_count = snapshot.tools_count;
7042 self.experiments = snapshot.experiments.clone();
7043 if !snapshot.files.is_empty() {
7044 self.files = snapshot.files.clone();
7045 if !self.files.is_empty() {
7046 self.selected_file = self.selected_file.min(self.files.len() - 1);
7047 }
7048 }
7049 if self.surface == DevSurface::Code
7050 && !self.code_edit_mode
7051 && self.pending_open_file.is_some()
7052 && !self.files.is_empty()
7053 {
7054 self.flush_pending_open_file();
7055 }
7056 }
7057
7058 pub fn set_terminal_size(&mut self, width: u16, height: u16) {
7059 self.terminal_width = width;
7060 self.terminal_height = height;
7061 self.ensure_editor_cursor_visible();
7062 }
7063
7064 pub fn refresh(&mut self) {
7065 self.harnesses = crate::harness::summary();
7066 let Ok(mut workspace) = self.workspace.try_lock() else {
7067 self.status = "Workspace lock failed".into();
7068 return;
7069 };
7070 self.files = workspace
7071 .project()
7072 .list_files()
7073 .map(|entries| {
7074 entries
7075 .into_iter()
7076 .filter(|entry| matches!(entry.kind, crate::development::FileKind::File))
7077 .map(|entry| entry.path)
7078 .take(512)
7079 .collect()
7080 })
7081 .unwrap_or_default();
7082 if let Some(wake) = workspace.latest_crew_wake() {
7083 self.last_crew_wake = Some(wake.render());
7084 }
7085 if !self.files.is_empty() {
7086 self.selected_file = self.selected_file.min(self.files.len() - 1);
7087 }
7088 let agent_snapshots = workspace.agents().list();
7089 self.pending_agent_approval = pending_agent_approval(agent_snapshots.as_ref().ok());
7090 self.agents = match agent_snapshots {
7091 Ok(agents) if agents.is_empty() => "No agents. :agent spawn ROLE TASK".into(),
7092 Ok(agents) => agents
7093 .iter()
7094 .map(|agent| {
7095 format!(
7096 "{} {} {} · {}\n target {} · model {} · thinking {} · events {} · dropped {}{}\n evidence {}",
7097 agent.id.as_str(),
7098 agent.status.label(),
7099 agent.role,
7100 agent.task,
7101 agent.worktree.display(),
7102 agent.model.as_deref().unwrap_or("default"),
7103 agent.thinking.as_deref().unwrap_or("default"),
7104 agent.event_count,
7105 agent.dropped_event_count,
7106 agent
7107 .last_error
7108 .as_deref()
7109 .map(|error| format!(" · {error}"))
7110 .unwrap_or_default(),
7111 agent
7112 .evidence
7113 .iter()
7114 .rev()
7115 .take(3)
7116 .map(|evidence| evidence.to_string())
7117 .collect::<Vec<_>>()
7118 .join(" · ")
7119 )
7120 })
7121 .collect::<Vec<_>>()
7122 .join("\n\n"),
7123 Err(error) => format!("Agent registry failed: {error}"),
7124 };
7125 self.agent_conversation = match workspace.agents().history(0) {
7126 Ok(events) if events.is_empty() => {
7127 "No conversation yet. Press Enter or start typing to compose a message.".into()
7128 }
7129 Ok(events) => super::projection::conversation(
7130 &events
7131 .iter()
7132 .rev()
7133 .take(40)
7134 .rev()
7135 .cloned()
7136 .collect::<Vec<_>>(),
7137 ),
7138 Err(error) => format!("Conversation unavailable · {error}"),
7139 };
7140 self.tasks = match workspace.tasks() {
7141 Ok(tasks) if tasks.is_empty() => {
7142 "No tasks. :task create TITLE PROMPT creates an autonomous task".into()
7143 }
7144 Ok(tasks) => tasks
7145 .iter()
7146 .map(|task| {
7147 let glyph = match task.state {
7148 crate::TaskState::Succeeded
7149 if task.verification == crate::VerificationRequirement::Settled => "◇",
7150 crate::TaskState::Succeeded => "✓",
7151 crate::TaskState::Failed | crate::TaskState::Cancelled => "×",
7152 crate::TaskState::Blocked => "!",
7153 crate::TaskState::Running | crate::TaskState::Verifying => "●",
7154 _ => "○",
7155 };
7156 format!(
7157 "{} {} {} {}\n goal {}\n agent {} · attempt {} · model {} · thinking {}\n depends {}\n verification {}{}\n evidence {}",
7158 glyph,
7159 task.id.as_str(),
7160 task.state.label(),
7161 task.title,
7162 task.goal,
7163 task.assigned_agent
7164 .as_ref()
7165 .map(|agent| agent.as_str())
7166 .unwrap_or("unassigned"),
7167 task.attempt,
7168 task.model.as_deref().unwrap_or("default"),
7169 task.thinking.as_deref().unwrap_or("default"),
7170 task.dependencies
7171 .iter()
7172 .map(|dependency| dependency.as_str())
7173 .collect::<Vec<_>>()
7174 .join(", "),
7175 serde_json::to_string(&task.verification).unwrap_or_default(),
7176 task.last_error
7177 .as_deref()
7178 .map(|error| format!(" · {error}"))
7179 .unwrap_or_default(),
7180 task.evidence
7181 .iter()
7182 .rev()
7183 .take(3)
7184 .map(|evidence| {
7185 format!(
7186 "{}={}",
7187 evidence.kind,
7188 evidence.passed.map_or("?".into(), |passed| passed.to_string())
7189 )
7190 })
7191 .collect::<Vec<_>>()
7192 .join(" · ")
7193 )
7194 })
7195 .collect::<Vec<_>>()
7196 .join("\n\n"),
7197 Err(error) => format!("Task scheduler failed: {error}"),
7198 };
7199 match workspace.project_mut().processes().list_checked() {
7200 Ok(items) => {
7201 self.process_urls = items
7202 .iter()
7203 .flat_map(|item| item.detected_urls.iter().cloned())
7204 .collect();
7205 self.process_urls.sort();
7206 self.process_urls.dedup();
7207 self.process_entries = items.iter().map(ProcessRow::from_snapshot).collect();
7208 self.selected_process = if self.process_entries.is_empty() {
7209 0
7210 } else {
7211 self.selected_process
7212 .min(self.process_entries.len().saturating_sub(1))
7213 };
7214 self.processes = if items.is_empty() {
7215 "No managed terminals. Start the detected development command from More.".into()
7216 } else {
7217 items
7218 .into_iter()
7219 .map(|item| {
7220 format!(
7221 "{} {} · health {} · pid {} · {}\n {}",
7222 if matches!(item.health, crate::development::ProcessHealth::Healthy)
7223 {
7224 "●"
7225 } else {
7226 "○"
7227 },
7228 item.name,
7229 item.health.label(),
7230 item.pid.map_or_else(|| "—".into(), |pid| pid.to_string()),
7231 if item.pty { "PTY" } else { "pipes" },
7232 item.detected_urls
7233 .first()
7234 .map_or(item.command.as_str(), String::as_str),
7235 )
7236 })
7237 .collect::<Vec<_>>()
7238 .join("\n\n")
7239 };
7240 }
7241 Err(error) => {
7242 self.process_urls.clear();
7243 self.process_entries.clear();
7244 self.selected_process = 0;
7245 self.processes = format!("Process state failed: {error}");
7246 }
7247 }
7248 let buffers = workspace.project().buffers().cloned().collect::<Vec<_>>();
7249 self.editor = if buffers.is_empty() {
7250 "No file open. Select a file below and press Enter to open the full-screen editor."
7251 .into()
7252 } else {
7253 buffers
7254 .iter()
7255 .map(|buffer| {
7256 let lines: Vec<&str> = buffer.content.lines().collect();
7258 let cursor = buffer.cursor_line as usize;
7259 let viewport_rows = 16;
7260 let start = cursor
7261 .saturating_sub(viewport_rows / 2)
7262 .min(lines.len().saturating_sub(viewport_rows.min(lines.len())));
7263 let end = (start + viewport_rows).min(lines.len());
7264 let gutter_width = lines.len().to_string().len().max(3);
7265 let viewport = lines[start..end]
7266 .iter()
7267 .enumerate()
7268 .map(|(index, line)| {
7269 let number = start + index + 1;
7270 let marker = if number == cursor { "▶" } else { " " };
7271 format!(
7272 "{marker}{:>gutter_width$} │ {line}",
7273 number,
7274 gutter_width = gutter_width
7275 )
7276 })
7277 .collect::<Vec<_>>()
7278 .join("\n");
7279 format!(
7280 "{}{} · cursor {}:{} · actor {} · {} lines\n{}",
7281 if buffer.dirty { "● " } else { "○ " },
7282 buffer.path,
7283 buffer.cursor_line,
7284 buffer.cursor_column,
7285 buffer.actor.id,
7286 lines.len(),
7287 viewport
7288 )
7289 })
7290 .collect::<Vec<_>>()
7291 .join("\n\n")
7292 };
7293 self.editor_comments = workspace.project().editor_comments(None);
7294 self.editor_proposals = workspace.project().editor_proposals();
7295 self.editor_checkpoints = workspace.project().editor_checkpoints();
7296 if let Some(buffer) = buffers.get(self.editor_buffer_index) {
7297 self.focused_editor_path = buffer.path.clone();
7298 self.focused_editor_dirty = buffer.dirty;
7299 self.focused_editor_line = buffer.cursor_line;
7300 self.focused_editor_column = buffer.cursor_column;
7301 self.focused_editor_selection = buffer.selection.clone();
7302 }
7303 self.lsp = {
7304 let language = workspace.language();
7305 let servers = language.names().collect::<Vec<_>>();
7306 let event_count = language.events(0).len();
7307 if servers.is_empty() {
7308 "No language server active · diagnostics unavailable".into()
7309 } else {
7310 format!("● {} · {} recent events", servers.join(" · "), event_count)
7311 }
7312 };
7313 let git_status = workspace.git().map(|git| git.status());
7314 self.git = match git_status {
7315 Some(Ok(status)) => {
7316 self.git_entries = status.sorted_entries();
7317 self.git_branch = status.branch.clone().unwrap_or_else(|| "detached".into());
7318 self.git_ahead = status.ahead;
7319 self.git_behind = status.behind;
7320 self.git_conflicts = status.conflicts.clone();
7321 self.git_dirty = !status.conflicts.is_empty()
7322 || status.ahead > 0
7323 || status.behind > 0
7324 || status.entries.iter().any(|entry| {
7325 entry.untracked || entry.index_status != ' ' || entry.worktree_status != ' '
7326 });
7327 let header = format!(
7328 "branch {} · ↑{} ↓{} · upstream {}",
7329 status.branch.as_deref().unwrap_or("detached"),
7330 status.ahead,
7331 status.behind,
7332 status.upstream.as_deref().unwrap_or("none")
7333 );
7334 let entries = status
7335 .entries
7336 .iter()
7337 .map(|entry| {
7338 format!(
7339 "{}{} {}{}",
7340 if entry.untracked { "?" } else { "●" },
7341 if status.conflicts.contains(&entry.path) {
7342 "!"
7343 } else {
7344 " "
7345 },
7346 entry.index_status,
7347 entry.path
7348 )
7349 })
7350 .collect::<Vec<_>>();
7351 if entries.is_empty() {
7352 format!("{header}\n✓ working tree clean")
7353 } else {
7354 format!("{header}\n{}", entries.join("\n"))
7355 }
7356 }
7357 Some(Err(error)) => {
7358 self.git_entries.clear();
7359 self.git_branch.clear();
7360 self.git_ahead = 0;
7361 self.git_behind = 0;
7362 self.git_conflicts.clear();
7363 self.git_dirty = false;
7364 format!("Git state failed: {error}")
7365 }
7366 None => {
7367 self.git_entries.clear();
7368 self.git_branch.clear();
7369 self.git_ahead = 0;
7370 self.git_behind = 0;
7371 self.git_conflicts.clear();
7372 self.git_dirty = false;
7373 "Not a Git repository".into()
7374 }
7375 };
7376 if self.git_entries.is_empty() {
7377 self.selected_git_file = 0;
7378 } else {
7379 self.selected_git_file = self
7380 .selected_git_file
7381 .min(self.git_entries.len().saturating_sub(1));
7382 }
7383 let _ = workspace.tests_mut().poll();
7384 let test_runs = workspace
7385 .tests()
7386 .results()
7387 .rev()
7388 .take(32)
7389 .collect::<Vec<_>>();
7390 self.tests = if test_runs.is_empty() {
7391 "No test runs".into()
7392 } else {
7393 test_runs
7394 .iter()
7395 .map(|run| {
7396 format!(
7397 "{} {} · {} · {} ms · {} cases",
7398 if run.exit_code == Some(0) {
7399 "✓"
7400 } else {
7401 "×"
7402 },
7403 run.suite_id,
7404 run.state.label(),
7405 run.duration_ms.unwrap_or_default(),
7406 run.cases.len()
7407 )
7408 })
7409 .collect::<Vec<_>>()
7410 .join("\n")
7411 };
7412 let kernels = workspace.kernels().snapshots().collect::<Vec<_>>();
7413 self.kernels = if kernels.is_empty() {
7414 "No persistent kernels".into()
7415 } else {
7416 kernels
7417 .iter()
7418 .map(|kernel| {
7419 format!(
7420 "{} {} · {} · {} executions · rev {}",
7421 if matches!(kernel.state, crate::kernels::KernelState::Ready) {
7422 "●"
7423 } else {
7424 "○"
7425 },
7426 kernel.name,
7427 kernel.kind.label(),
7428 kernel.executions,
7429 kernel.workspace_revision
7430 )
7431 })
7432 .collect::<Vec<_>>()
7433 .join("\n")
7434 };
7435 let debugger_names = workspace
7436 .debugger_names()
7437 .map(str::to_string)
7438 .collect::<Vec<_>>();
7439 self.debugger = if debugger_names.is_empty() {
7440 self.debug_sessions.clear();
7441 self.selected_debug_session = 0;
7442 "No debugger sessions. :debug start NAME COMMAND [ARGS...]".into()
7443 } else {
7444 let snapshots: Result<Vec<_>, _> = debugger_names
7445 .iter()
7446 .map(|name| {
7447 workspace
7448 .debugger_mut(name)
7449 .and_then(|debugger| debugger.snapshot())
7450 .map(|snapshot| (name.to_string(), snapshot))
7451 })
7452 .collect();
7453 match snapshots {
7454 Ok(snapshots) => {
7455 self.debug_sessions = snapshots
7456 .iter()
7457 .map(|(name, snapshot)| DebugSessionRow {
7458 name: name.clone(),
7459 state: snapshot.state,
7460 pid: snapshot.adapter_process_id,
7461 breakpoints: snapshot.breakpoints.values().map(Vec::len).sum::<usize>(),
7462 watches: snapshot.watches.len(),
7463 })
7464 .collect();
7465 self.selected_debug_session = self
7466 .selected_debug_session
7467 .min(self.debug_sessions.len().saturating_sub(1));
7468 snapshots
7469 .iter()
7470 .map(|(name, snapshot)| {
7471 format!(
7472 "● {} · {} · pid {} · {} breakpoints · {} watches · {} threads/processes",
7473 name,
7474 snapshot.state.label(),
7475 snapshot.adapter_process_id,
7476 snapshot.breakpoints.values().map(Vec::len).sum::<usize>(),
7477 snapshot.watches.len(),
7478 snapshot.debuggee_processes.len()
7479 )
7480 })
7481 .collect::<Vec<_>>()
7482 .join("\n")
7483 }
7484 Err(error) => format!("Debugger state failed: {error}"),
7485 }
7486 };
7487 self.replay = workspace
7488 .intelligence()
7489 .replay(0, 128)
7490 .map(|events| {
7491 if events.is_empty() {
7492 "No observable replay events".into()
7493 } else {
7494 events
7495 .iter()
7496 .rev()
7497 .take(24)
7498 .rev()
7499 .map(|event| {
7500 format!(
7501 "{} {} · {} · {} · rev {}",
7502 event.sequence,
7503 event.actor,
7504 event.subsystem,
7505 event.kind,
7506 event.workspace_revision
7507 )
7508 })
7509 .collect::<Vec<_>>()
7510 .join("\n")
7511 }
7512 })
7513 .unwrap_or_else(|error| format!("Replay failed: {error}"));
7514 self.browser = match workspace.browser().state() {
7515 Ok(state) => {
7516 let connected = state
7517 .get("connected")
7518 .and_then(serde_json::Value::as_bool)
7519 .unwrap_or(false);
7520 let revision = state
7521 .get("browserRevision")
7522 .and_then(serde_json::Value::as_u64);
7523 if connected {
7524 if self.browser_workspace.state().connection
7525 != BrowserConnectionPhase::Connected
7526 {
7527 self.browser_workspace.connected(true, None, revision);
7528 } else if let Some(revision) = revision {
7529 self.browser_workspace.state_mut().browser_revision = Some(revision);
7530 }
7531 } else {
7532 self.browser_workspace.state_mut().connection =
7533 BrowserConnectionPhase::Detached;
7534 }
7535 self.browser_workspace_summary()
7536 }
7537 Err(error) => format!("Browser state failed: {error}"),
7538 };
7539 self.workflow = workspace
7540 .browser()
7541 .list_workflows()
7542 .map(|state| super::projection::workflow(Some(&state)))
7543 .unwrap_or_else(|error| format!("Workflow state failed: {error}"));
7544 let root = workspace.root().display().to_string();
7545 let generation = workspace.generation();
7546 let project_revision = workspace.project().revision();
7547 let agent_count = workspace
7548 .agents()
7549 .list()
7550 .map(|items| items.len())
7551 .unwrap_or(0);
7552 let task_count = workspace.tasks().map(|items| items.len()).unwrap_or(0);
7553 let kernel_count = workspace.kernels().snapshots().count();
7554 let debugger_count = workspace.debugger_names().count();
7555 let detection = workspace.project().detection().clone();
7556 let trust = workspace.trust();
7557 let trust_ready = trust.permits_project_execution();
7558 let dev_hint = detection
7559 .dev_command
7560 .as_deref()
7561 .map(|command| format!("● run `{command}`"))
7562 .unwrap_or_else(|| "○ configure a dev command".into());
7563 let app_hint = detection
7564 .browser_url
7565 .as_deref()
7566 .map(|url| format!("● open App {url}"))
7567 .unwrap_or_else(|| "○ start App after a URL is detected".into());
7568 let project_line = if detection.languages.is_empty() {
7569 "○ project type unknown".to_string()
7570 } else {
7571 format!("✓ {} project", detection.languages.join("/"))
7572 };
7573 let workspace_line = format!("✓ workspace {}", trust.label());
7574 let agent_hint = if self.agent_readiness.starts_with("✓ Ready") {
7575 ":agent ready · type a message or press Enter to chat"
7576 } else {
7577 "○ Pi onboarding · use :agent setup or :agent setup login"
7578 };
7579 self.workspace_status = format!(
7580 "WELCOME · {}\n{}\n\n{}\n{}\n\nNEXT ACTIONS\n◆ :actions guided launchers · per-surface flows\n◆ type a message or press Enter to talk to Glass Agent\n◆ :process start dev · start the detected dev suite\n◆ Enter · open the selected file\n{}\n{}\n\nSTATE\nroot {}\ngeneration {} · project revision {} · trust {}\nresident: {} agents · {} tasks · {} kernels · {} debuggers",
7581 detection.git_branch.as_deref().unwrap_or("no branch"),
7582 project_line,
7583 agent_hint,
7584 workspace_line,
7585 dev_hint,
7586 app_hint,
7587 root,
7588 generation,
7589 project_revision,
7590 trust_ready,
7591 agent_count,
7592 task_count,
7593 kernel_count,
7594 debugger_count,
7595 );
7596 if workspace.trust().permits_project_execution()
7597 && let Ok(experiments) = workspace.experiments()
7598 {
7599 let snapshots = experiments.snapshots();
7600 self.experiments = if snapshots.is_empty() {
7601 "No experiments".into()
7602 } else {
7603 snapshots
7604 .iter()
7605 .map(|experiment| {
7606 format!(
7607 "{} {} · {} · port {} · agent {}",
7608 if experiment.evidence.tests_failed == 0
7609 && experiment.evidence.tests_passed > 0
7610 {
7611 "✓"
7612 } else {
7613 "○"
7614 },
7615 experiment.id,
7616 experiment.state.label(),
7617 experiment
7618 .port
7619 .map_or_else(|| "—".into(), |port| port.to_string()),
7620 experiment
7621 .agent_id
7622 .as_ref()
7623 .map(|id| id.as_str())
7624 .unwrap_or("none")
7625 )
7626 })
7627 .collect::<Vec<_>>()
7628 .join("\n")
7629 };
7630 self.experiment_comparison = Some(experiments.compare());
7631 }
7632 drop(workspace);
7633 self.reconcile_pending_chat();
7634 }
7635
7636 pub fn apply_browser_result(&mut self, tool: &str, result: &serde_json::Value) {
7637 match tool {
7638 "glass.browser.observe" => {
7639 let revision = result
7640 .pointer("/accessibility/revision")
7641 .and_then(serde_json::Value::as_u64);
7642 let title = result
7643 .pointer("/page/title")
7644 .and_then(serde_json::Value::as_str)
7645 .unwrap_or("Untitled");
7646 let url = result
7647 .pointer("/page/url")
7648 .and_then(serde_json::Value::as_str)
7649 .unwrap_or_default();
7650 let loading = result
7651 .pointer("/page/loading")
7652 .and_then(serde_json::Value::as_bool)
7653 .unwrap_or(false);
7654 if let Some(revision) = revision {
7655 self.browser_workspace
7656 .update_page(title, url, loading, Some(revision));
7657 let entities = result
7658 .pointer("/accessibility/interactive")
7659 .and_then(serde_json::Value::as_array)
7660 .into_iter()
7661 .flatten()
7662 .filter_map(|entity| {
7663 Some(BrowserWorkspaceEntity {
7664 reference: entity.get("reference")?.as_str()?.into(),
7665 role: entity
7666 .get("role")
7667 .and_then(serde_json::Value::as_str)
7668 .unwrap_or("unknown")
7669 .into(),
7670 name: entity
7671 .get("name")
7672 .and_then(serde_json::Value::as_str)
7673 .unwrap_or("unnamed")
7674 .into(),
7675 actionable: entity
7676 .get("actionable")
7677 .and_then(serde_json::Value::as_bool)
7678 .unwrap_or(true),
7679 revision,
7680 })
7681 })
7682 .collect();
7683 self.browser_workspace.replace_entities(revision, entities);
7684 if let Some(entity) = self.pending_page_entity.clone()
7685 && self.select_page_entity(&entity)
7686 {
7687 self.pending_page_entity = None;
7688 self.status = format!("Page bound · {entity}");
7689 }
7690 }
7691 }
7692 "glass.browser.targets" => {
7693 let values = result
7694 .get("targets")
7695 .and_then(serde_json::Value::as_array)
7696 .or_else(|| result.as_array());
7697 let targets = values
7698 .into_iter()
7699 .flatten()
7700 .filter_map(|target| {
7701 Some(BrowserWorkspaceTarget {
7702 id: target.get("id")?.as_str()?.into(),
7703 title: target
7704 .get("title")
7705 .and_then(serde_json::Value::as_str)
7706 .unwrap_or("Untitled")
7707 .into(),
7708 url: target
7709 .get("url")
7710 .and_then(serde_json::Value::as_str)
7711 .unwrap_or_default()
7712 .into(),
7713 selected: target
7714 .get("active")
7715 .and_then(serde_json::Value::as_bool)
7716 .unwrap_or(false),
7717 })
7718 })
7719 .collect();
7720 self.browser_workspace.replace_targets(targets);
7721 if self.browser_target_picker_requested {
7722 self.browser_target_picker_requested = false;
7723 self.browser_target_picker = true;
7724 self.browser_target_selection = 0;
7725 self.status = if self.browser_workspace.state().targets.is_empty() {
7726 "No page targets found · Esc closes".into()
7727 } else {
7728 "Target picker · type to filter · j/k select · Enter choose · Esc close"
7729 .into()
7730 };
7731 }
7732 }
7733 "glass.browser.target.select" => {
7734 if let Some(target_id) = result
7735 .pointer("/target/id")
7736 .and_then(serde_json::Value::as_str)
7737 {
7738 let mut targets = self.browser_workspace.state().targets.clone();
7739 for target in &mut targets {
7740 target.selected = target.id == target_id;
7741 }
7742 self.browser_workspace.replace_targets(targets);
7743 }
7744 if let Some(observation) = result.get("observation") {
7745 self.apply_browser_result("glass.browser.observe", observation);
7746 }
7747 }
7748 "glass.browser.start" => {
7749 let connected = result
7750 .get("connected")
7751 .and_then(serde_json::Value::as_bool)
7752 .unwrap_or(true);
7753 let revision = result
7754 .get("browserRevision")
7755 .and_then(serde_json::Value::as_u64);
7756 if connected {
7757 self.browser_workspace.connected(true, None, revision);
7758 self.browser_recovery = None;
7759 }
7760 }
7761 "glass.browser.stop" => {
7762 self.browser_workspace.state_mut().connection = BrowserConnectionPhase::Detached;
7763 }
7764 _ => {}
7765 }
7766 self.browser = self.browser_workspace_summary();
7767 }
7768
7769 pub fn browser_workspace_summary(&self) -> String {
7770 let browser = self.browser_workspace.state();
7771 let entities = if browser.entities.is_empty() {
7772 "No current semantic entities".into()
7773 } else {
7774 browser
7775 .entities
7776 .iter()
7777 .enumerate()
7778 .skip(browser.semantic_scroll)
7779 .take(24)
7780 .map(|(index, entity)| {
7781 format!(
7782 "{} {} · {} · {}",
7783 if Some(index) == browser.selected_entity {
7784 "◆"
7785 } else {
7786 "○"
7787 },
7788 entity.name,
7789 entity.role,
7790 entity.reference
7791 )
7792 })
7793 .collect::<Vec<_>>()
7794 .join("\n")
7795 };
7796 let targets = if browser.targets.is_empty() {
7797 "No page targets loaded · use `browser targets`".into()
7798 } else {
7799 browser
7800 .targets
7801 .iter()
7802 .take(8)
7803 .map(|target| {
7804 format!(
7805 "{} {} · {}",
7806 if target.selected { "◆" } else { "○" },
7807 target.title,
7808 safe_browser_url(&target.url).unwrap_or_else(|| "no URL".into())
7809 )
7810 })
7811 .collect::<Vec<_>>()
7812 .join("\n")
7813 };
7814 format!(
7815 "{} · rev {} · {} · owner {}\n{}\n{}\n\nTARGETS\n{}\n\nUNDERSTANDING\n{}\n\nWORKFLOW\n{}",
7816 browser.connection_label(),
7817 browser
7818 .browser_revision
7819 .map_or_else(|| "—".into(), |revision| revision.to_string()),
7820 browser.presentation_label(),
7821 browser.input_owner_label(),
7822 browser.title,
7823 safe_browser_url(&browser.url).unwrap_or_else(|| "no page".into()),
7824 targets,
7825 entities,
7826 browser.workflow
7827 )
7828 }
7829
7830 pub fn queue_browser_targets(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
7831 if self.background_action_running() {
7832 self.status = "Target picker waits for the current background operation".into();
7833 return;
7834 }
7835 if let Err(error) = self.request_browser_target_picker("") {
7836 self.status = format!("Could not load browser targets: {error}");
7837 return;
7838 }
7839 let Some((call, context)) = self.queued_tool_request.take() else {
7840 return;
7841 };
7842 match worker.submit_tool(call, context) {
7843 Ok(id) => {
7844 self.running_tool_job = Some(id);
7845 self.status = "Loading browser targets…".into();
7846 }
7847 Err(error) => {
7848 self.browser_target_picker_requested = false;
7849 self.status = format!("Could not load browser targets: {error}");
7850 }
7851 }
7852 }
7853
7854 pub fn request_browser_target_picker(
7855 &mut self,
7856 query: impl Into<String>,
7857 ) -> Result<(), String> {
7858 if self.background_action_running() {
7859 return Err("Target picker waits for the current background operation".into());
7860 }
7861 self.browser_target_query = query.into();
7862 self.browser_target_selection = 0;
7863 self.browser_target_picker = false;
7864 self.browser_target_picker_requested = true;
7865 let (call, context) =
7866 match self.tool_request("glass.browser.targets", serde_json::json!({}), false) {
7867 Ok(request) => request,
7868 Err(error) => {
7869 self.browser_target_picker_requested = false;
7870 return Err(error);
7871 }
7872 };
7873 self.queued_tool_request = Some((call, context));
7874 self.status = "Loading browser targets…".into();
7875 Ok(())
7876 }
7877
7878 pub fn close_browser_target_picker(&mut self) {
7879 self.browser_target_picker = false;
7880 self.browser_target_picker_requested = false;
7881 self.status = "Target picker closed".into();
7882 }
7883
7884 pub fn browser_target_matches(&self) -> Vec<usize> {
7885 let query = self.browser_target_query.to_ascii_lowercase();
7886 let terms = query.split_whitespace().collect::<Vec<_>>();
7887 self.browser_workspace
7888 .state()
7889 .targets
7890 .iter()
7891 .enumerate()
7892 .filter(|(_, target)| {
7893 terms.iter().all(|term| {
7894 target.id.to_ascii_lowercase().contains(term)
7895 || target.title.to_ascii_lowercase().contains(term)
7896 || target.url.to_ascii_lowercase().contains(term)
7897 })
7898 })
7899 .map(|(index, _)| index)
7900 .collect()
7901 }
7902
7903 pub fn insert_browser_target_query(&mut self, character: char) {
7904 if self.browser_target_query.len() < 512 {
7905 self.browser_target_query.push(character);
7906 self.browser_target_selection = 0;
7907 }
7908 }
7909
7910 pub fn browser_target_backspace(&mut self) {
7911 self.browser_target_query.pop();
7912 self.browser_target_selection = 0;
7913 }
7914
7915 pub fn clear_browser_target_query(&mut self) {
7916 self.browser_target_query.clear();
7917 self.browser_target_selection = 0;
7918 }
7919
7920 pub fn move_browser_target_selection(&mut self, delta: i32) {
7921 let count = self.browser_target_matches().len();
7922 if count == 0 {
7923 self.browser_target_selection = 0;
7924 return;
7925 }
7926 self.browser_target_selection =
7927 (self.browser_target_selection as i32 + delta).rem_euclid(count as i32) as usize;
7928 }
7929
7930 pub fn select_browser_target(&mut self) {
7931 if self.background_action_running() {
7932 self.status = "Finish the current browser operation before selecting a target".into();
7933 return;
7934 }
7935 let matches = self.browser_target_matches();
7936 let Some(index) = matches.get(self.browser_target_selection).copied() else {
7937 self.status = "No matching browser target".into();
7938 return;
7939 };
7940 let Some(target) = self.browser_workspace.state().targets.get(index).cloned() else {
7941 self.status = "Selected browser target disappeared".into();
7942 return;
7943 };
7944 let (call, context) = match self.tool_request(
7945 "glass.browser.target.select",
7946 serde_json::json!({"targetId": target.id}),
7947 true,
7948 ) {
7949 Ok(request) => request,
7950 Err(error) => {
7951 self.status = format!("Target selection unavailable: {error}");
7952 return;
7953 }
7954 };
7955 self.browser_target_picker = false;
7956 let queued = match self.queue_or_confirm(
7957 call,
7958 context,
7959 format!("Select browser target · {}", target.title),
7960 ) {
7961 Ok(queued) => queued,
7962 Err(error) => {
7963 self.status = format!("Target selection unavailable: {error}");
7964 return;
7965 }
7966 };
7967 if !queued {
7968 self.status = "Target selection ready · Enter approves once · Esc cancels".into();
7969 }
7970 }
7971
7972 pub fn browser_target_picker_view(&self) -> String {
7973 let matches = self.browser_target_matches();
7974 let mut lines = vec![
7975 format!(
7976 "FILTER {}",
7977 if self.browser_target_query.is_empty() {
7978 "all pages"
7979 } else {
7980 self.browser_target_query.as_str()
7981 }
7982 ),
7983 String::new(),
7984 ];
7985 if matches.is_empty() {
7986 lines.push("No matching page targets.".into());
7987 } else {
7988 for (position, index) in matches.iter().take(16).enumerate() {
7989 let Some(target) = self.browser_workspace.state().targets.get(*index) else {
7990 continue;
7991 };
7992 let marker = if position == self.browser_target_selection {
7993 "›"
7994 } else {
7995 " "
7996 };
7997 let url = safe_browser_url(&target.url).unwrap_or_else(|| "no URL".into());
7998 lines.push(format!(
7999 "{marker} {} · {} · {}",
8000 target.title, url, target.id
8001 ));
8002 }
8003 }
8004 lines.push(String::new());
8005 lines.push("Type filters · Backspace edits · Ctrl-U clears".into());
8006 lines.push("j/k or ↑/↓ selects · Enter chooses · Esc closes".into());
8007 lines.join("\n")
8008 }
8009
8010 pub fn queue_browser_observe(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
8011 if !self.browser_observe_pending || self.background_action_running() {
8012 return;
8013 }
8014 self.browser_observe_pending = false;
8015 let (call, context) =
8016 match self.tool_request("glass.browser.observe", serde_json::json!({}), false) {
8017 Ok(request) => request,
8018 Err(error) => {
8019 self.status = format!("Could not refresh browser evidence: {error}");
8020 return;
8021 }
8022 };
8023 match worker.submit_tool(call, context) {
8024 Ok(id) => {
8025 self.running_tool_job = Some(id);
8026 self.status = "Refreshing semantic browser evidence…".into();
8027 }
8028 Err(error) => self.status = format!("Could not refresh browser evidence: {error}"),
8029 }
8030 }
8031
8032 pub fn continue_pending_browser_navigation(
8034 &mut self,
8035 worker: &mut super::snapshot::SnapshotWorker,
8036 ) {
8037 let Some(url) = self.pending_browser_navigation.as_deref() else {
8038 return;
8039 };
8040 let (call, context) =
8041 match self.tool_request("glass.browser.observe", serde_json::json!({}), false) {
8042 Ok(request) => request,
8043 Err(error) => {
8044 let url = self.pending_browser_navigation.take().unwrap_or_default();
8045 self.open_palette_with(&format!("browser navigate {url}"));
8046 self.status = format!("Browser ready · navigation retry required: {error}");
8047 return;
8048 }
8049 };
8050 match worker.submit_tool(call, context) {
8051 Ok(id) => {
8052 self.running_tool_job = Some(id);
8053 self.status = format!("Browser ready · preparing navigation to {url}…");
8054 }
8055 Err(error) => {
8056 let url = self.pending_browser_navigation.take().unwrap_or_default();
8057 self.open_palette_with(&format!("browser navigate {url}"));
8058 self.status = format!("Browser ready · navigation retry required: {error}");
8059 }
8060 }
8061 }
8062
8063 pub fn submit_pending_browser_navigation(
8065 &mut self,
8066 worker: &mut super::snapshot::SnapshotWorker,
8067 ) {
8068 let Some(url) = self.pending_browser_navigation.take() else {
8069 return;
8070 };
8071 let Some(revision) = self.browser_workspace.state().browser_revision else {
8072 self.open_palette_with(&format!("browser navigate {url}"));
8073 self.status = "Browser launch completed without a usable revision".into();
8074 return;
8075 };
8076 let (call, context) = match self.tool_request(
8077 "glass.browser.navigate",
8078 serde_json::json!({"url": url, "browserRevision": revision}),
8079 true,
8080 ) {
8081 Ok(request) => request,
8082 Err(error) => {
8083 self.open_palette_with(&format!("browser navigate {url}"));
8084 self.status = format!("Browser ready · navigation retry required: {error}");
8085 return;
8086 }
8087 };
8088 match worker.submit_tool(call, context) {
8089 Ok(id) => {
8090 self.running_tool_job = Some(id);
8091 self.status = format!("Browser ready · navigating to {url}…");
8092 }
8093 Err(error) => {
8094 self.open_palette_with(&format!("browser navigate {url}"));
8095 self.status = format!("Browser ready · navigation retry required: {error}");
8096 }
8097 }
8098 }
8099
8100 pub fn queue_browser_intent(&mut self, intent: BrowserWorkspaceIntent) {
8101 if self.background_action_running() {
8102 self.status = "Browser action waits for the current background operation".into();
8103 return;
8104 }
8105 let action = match self.browser_workspace.reduce(intent) {
8106 Ok(Some(action)) => action,
8107 Ok(None) => return,
8108 Err(error) => {
8109 self.status = format!("App action unavailable: {error}");
8110 return;
8111 }
8112 };
8113 let (tool, arguments) = match action {
8114 BrowserWorkspaceAction::Navigate {
8115 url,
8116 expected_revision,
8117 } => (
8118 "glass.browser.navigate",
8119 serde_json::json!({"url": url, "browserRevision": expected_revision}),
8120 ),
8121 BrowserWorkspaceAction::Back { expected_revision }
8122 | BrowserWorkspaceAction::Forward { expected_revision }
8123 | BrowserWorkspaceAction::Reload { expected_revision }
8124 | BrowserWorkspaceAction::StopLoading { expected_revision } => {
8125 let action = match action {
8126 BrowserWorkspaceAction::Back { .. } => "back",
8127 BrowserWorkspaceAction::Forward { .. } => "forward",
8128 BrowserWorkspaceAction::Reload { .. } => "reload",
8129 BrowserWorkspaceAction::StopLoading { .. } => "stopLoading",
8130 _ => unreachable!(),
8131 };
8132 (
8133 "glass.browser.act",
8134 serde_json::json!({"action": action, "browserRevision": expected_revision}),
8135 )
8136 }
8137 BrowserWorkspaceAction::Click {
8138 target,
8139 expected_revision,
8140 } => {
8141 let _ = self.capture_workflow_click();
8142 (
8143 "glass.browser.act",
8144 serde_json::json!({"action":"click", "target": target, "browserRevision": expected_revision}),
8145 )
8146 }
8147 BrowserWorkspaceAction::Type {
8148 target,
8149 text,
8150 expected_revision,
8151 } => {
8152 self.capture_workflow_type_from_selection();
8153 (
8154 "glass.browser.act",
8155 serde_json::json!({"action":"type", "target": target, "text": text, "browserRevision": expected_revision}),
8156 )
8157 }
8158 BrowserWorkspaceAction::Scroll {
8159 dx,
8160 dy,
8161 expected_revision,
8162 } => (
8163 "glass.browser.act",
8164 serde_json::json!({"action":"scroll", "dx": dx, "dy": dy, "browserRevision": expected_revision}),
8165 ),
8166 _ => return,
8167 };
8168 let (call, context) = match self.tool_request(tool, arguments, true) {
8169 Ok(request) => request,
8170 Err(error) => {
8171 self.status = format!("App action unavailable: {error}");
8172 return;
8173 }
8174 };
8175 let queued = match self.queue_or_confirm(
8176 call,
8177 context,
8178 format!("{tool} · browser revision guarded"),
8179 ) {
8180 Ok(queued) => queued,
8181 Err(error) => {
8182 self.status = format!("App action unavailable: {error}");
8183 return;
8184 }
8185 };
8186 if !queued {
8187 self.status = "Browser mutation ready · Enter approves once · Esc cancels".into();
8188 }
8189 }
8190
8191 pub(super) fn tool_request(
8192 &self,
8193 name: &str,
8194 arguments: serde_json::Value,
8195 mutating: bool,
8196 ) -> Result<
8197 (
8198 crate::development::ToolCall,
8199 crate::tools::DevelopmentToolContext,
8200 ),
8201 String,
8202 > {
8203 let expected_generation = self.snapshot_generation;
8207 let expected_project_revision = self.snapshot_project_revision;
8208 Ok((
8209 crate::development::ToolCall {
8210 id: format!(
8211 "tui-browser-{}",
8212 NEXT_BROWSER_TOOL.fetch_add(1, Ordering::Relaxed)
8213 ),
8214 name: name.into(),
8215 arguments,
8216 },
8217 crate::tools::DevelopmentToolContext {
8218 authorization: crate::development::ToolAuthorization {
8219 actor: crate::development::Actor::local(),
8220 allow_mutation: mutating,
8221 confirmed: mutating,
8222 unrestricted: self.yolo_mode,
8223 },
8224 initiator: None,
8225 expected_generation,
8226 expected_project_revision,
8227 },
8228 ))
8229 }
8230
8231 pub fn note_browser_failure(&mut self, tool: &str, error: &str) {
8234 let lower = error.to_ascii_lowercase();
8235 if tool.contains("browser")
8236 && (lower.contains("occupied")
8237 || lower.contains("attach")
8238 || lower.contains("connect")
8239 || lower.contains("launch")
8240 || lower.contains("timeout")
8241 || lower.contains("devtools"))
8242 {
8243 self.browser_target_picker = false;
8244 self.browser_target_picker_requested = false;
8245 self.surface = DevSurface::App;
8246 self.browser_recovery = Some(BrowserRecoveryOffer::from_error(
8247 error,
8248 self.browser_recovery
8249 .as_ref()
8250 .map_or(9222, |offer| offer.port),
8251 ));
8252 self.browser_workspace.disconnected(error.to_string(), true);
8253 }
8254 }
8255
8256 pub fn accept_browser_recovery(
8258 &mut self,
8259 choice: usize,
8260 worker: &mut super::snapshot::SnapshotWorker,
8261 ) {
8262 let Some(offer) = self.browser_recovery.take() else {
8263 return;
8264 };
8265 let (port, attach) = match (offer.compatible_endpoint, choice) {
8266 (true, 0) => (offer.port, true),
8267 (true, 1) | (false, 0) => (free_local_port().unwrap_or(0), false),
8268 (true, 2) | (false, 1) => (offer.port, false),
8269 _ => {
8270 self.status = "Recovery dismissed · project and agent remain available".into();
8271 return;
8272 }
8273 };
8274 if port == 0 {
8275 self.status =
8276 "No free local port was available · retry or use an existing browser".into();
8277 return;
8278 }
8279 let (call, context) = match self.tool_request(
8280 "glass.browser.start",
8281 browser_recovery_arguments(port, attach),
8282 true,
8283 ) {
8284 Ok(request) => request,
8285 Err(error) => {
8286 self.status = format!("Could not queue recovery: {error}");
8287 return;
8288 }
8289 };
8290 match worker.submit_tool(call, context) {
8291 Ok(id) => {
8292 self.running_tool_job = Some(id);
8293 self.status = if attach {
8294 format!("Attaching to browser on port {port} in background…")
8295 } else {
8296 format!("Recovering browser on port {port} in background…")
8297 };
8298 }
8299 Err(error) => self.status = format!("Could not queue recovery: {error}"),
8300 }
8301 }
8302
8303 pub fn refresh_agent_readiness(&mut self) -> Result<bool, String> {
8304 let readiness = crate::pi_runtime::pi_readiness().map_err(|error| error.to_string())?;
8305 let ready = readiness.ready;
8306 self.agent_readiness = format_pi_readiness(&readiness);
8307 Ok(ready)
8308 }
8309}
8310
8311fn diagnostic_matches_path(
8312 diagnostic: &crate::development::LanguageDiagnostic,
8313 path: &str,
8314) -> bool {
8315 path.is_empty()
8316 || diagnostic.path == path
8317 || diagnostic.path.ends_with(path)
8318 || path.ends_with(&diagnostic.path)
8319}
8320
8321fn truncate_note(text: &str) -> String {
8322 let text = text.trim().replace('\n', " ");
8323 if text.chars().count() <= 80 {
8324 text
8325 } else {
8326 format!("{}…", text.chars().take(79).collect::<String>())
8327 }
8328}
8329
8330fn parse_editor_diagnostics(
8331 value: &serde_json::Value,
8332) -> Vec<crate::development::LanguageDiagnostic> {
8333 if let Ok(list) =
8334 serde_json::from_value::<Vec<crate::development::LanguageDiagnostic>>(value.clone())
8335 {
8336 return list;
8337 }
8338 value
8339 .get("diagnostics")
8340 .and_then(|item| {
8341 serde_json::from_value::<Vec<crate::development::LanguageDiagnostic>>(item.clone()).ok()
8342 })
8343 .unwrap_or_default()
8344}
8345
8346fn more_route_status(command: &str, message: &str) -> String {
8347 match command {
8348 "doctor" if message.contains("is ready") => {
8349 "Doctor · Agent is ready · PI panel updated · 1 opens chat".into()
8350 }
8351 "doctor" => format!("Doctor · {message}"),
8352 "harness list" => "Harness catalog listed in ROUTES".into(),
8353 _ => message.to_string(),
8354 }
8355}
8356
8357fn format_editor_buffers(buffers: &[crate::development::EditorBuffer]) -> String {
8358 if buffers.is_empty() {
8359 return "No file open. Select a file below and press Enter to open the full-screen editor."
8360 .into();
8361 }
8362 buffers
8363 .iter()
8364 .map(|buffer| {
8365 let lines: Vec<&str> = buffer.content.lines().collect();
8366 let cursor = buffer.cursor_line as usize;
8367 let viewport_rows = 16;
8368 let start = cursor
8369 .saturating_sub(viewport_rows / 2)
8370 .min(lines.len().saturating_sub(viewport_rows.min(lines.len())));
8371 let end = (start + viewport_rows).min(lines.len());
8372 let gutter_width = lines.len().to_string().len().max(3);
8373 let viewport = lines[start..end]
8374 .iter()
8375 .enumerate()
8376 .map(|(index, line)| {
8377 let number = start + index + 1;
8378 let marker = if number == cursor { "▶" } else { " " };
8379 format!(
8380 "{marker}{:>gutter_width$} │ {line}",
8381 number,
8382 gutter_width = gutter_width
8383 )
8384 })
8385 .collect::<Vec<_>>()
8386 .join("\n");
8387 format!(
8388 "{}{} · cursor {}:{} · actor {} · {} lines\n{}",
8389 if buffer.dirty { "● " } else { "○ " },
8390 buffer.path,
8391 buffer.cursor_line,
8392 buffer.cursor_column,
8393 buffer.actor.id,
8394 lines.len(),
8395 viewport
8396 )
8397 })
8398 .collect::<Vec<_>>()
8399 .join("\n\n")
8400}
8401
8402fn parse_conversation_view(conversation: &str) -> Vec<super::projection::ConversationEntry> {
8403 let mut entries = Vec::new();
8404 for block in conversation.split("\n\n") {
8405 let mut lines = block.lines();
8406 let Some(first) = lines.next() else {
8407 continue;
8408 };
8409 let body = lines.collect::<Vec<_>>().join("\n");
8410 let (kind, text) = match first.trim() {
8411 "YOU" => (super::projection::ConversationKind::User, body),
8412 "GLASS AGENT" => (super::projection::ConversationKind::Assistant, body),
8413 "ALERT" => (super::projection::ConversationKind::Alert, body),
8414 "ERROR" => (super::projection::ConversationKind::Error, body),
8415 "SYSTEM" => (super::projection::ConversationKind::System, body),
8416 _ => continue,
8417 };
8418 entries.push(super::projection::ConversationEntry {
8419 kind,
8420 text,
8421 streaming: false,
8422 entry_id: None,
8423 tool_name: None,
8424 });
8425 }
8426 entries
8427}
8428
8429fn parse_debug_threads(value: &serde_json::Value) -> Vec<DebugThreadRow> {
8430 value
8431 .get("threads")
8432 .and_then(serde_json::Value::as_array)
8433 .into_iter()
8434 .flatten()
8435 .filter_map(|thread| {
8436 Some(DebugThreadRow {
8437 id: thread.get("id").and_then(serde_json::Value::as_i64)?,
8438 name: thread
8439 .get("name")
8440 .and_then(serde_json::Value::as_str)
8441 .unwrap_or("thread")
8442 .to_string(),
8443 })
8444 })
8445 .collect()
8446}
8447
8448fn parse_debug_scopes(value: &serde_json::Value) -> Vec<DebugScopeRow> {
8449 value
8450 .get("scopes")
8451 .and_then(serde_json::Value::as_array)
8452 .into_iter()
8453 .flatten()
8454 .map(|scope| DebugScopeRow {
8455 name: scope
8456 .get("name")
8457 .and_then(serde_json::Value::as_str)
8458 .unwrap_or("scope")
8459 .to_string(),
8460 variables_reference: scope
8461 .get("variablesReference")
8462 .and_then(serde_json::Value::as_i64)
8463 .unwrap_or(0),
8464 })
8465 .collect()
8466}
8467
8468fn parse_debug_variables(value: &serde_json::Value) -> Vec<DebugVariableRow> {
8469 value
8470 .get("variables")
8471 .and_then(serde_json::Value::as_array)
8472 .into_iter()
8473 .flatten()
8474 .filter_map(|variable| {
8475 Some(DebugVariableRow {
8476 name: variable
8477 .get("name")
8478 .and_then(serde_json::Value::as_str)?
8479 .to_string(),
8480 value: variable
8481 .get("value")
8482 .and_then(serde_json::Value::as_str)
8483 .unwrap_or("")
8484 .chars()
8485 .take(120)
8486 .collect(),
8487 })
8488 })
8489 .take(64)
8490 .collect()
8491}
8492
8493fn parse_debug_frames(value: &serde_json::Value) -> Vec<DebugFrameRow> {
8494 value
8495 .get("stackFrames")
8496 .and_then(serde_json::Value::as_array)
8497 .into_iter()
8498 .flatten()
8499 .filter_map(|frame| {
8500 Some(DebugFrameRow {
8501 id: frame.get("id").and_then(serde_json::Value::as_i64)?,
8502 name: frame
8503 .get("name")
8504 .and_then(serde_json::Value::as_str)
8505 .unwrap_or("frame")
8506 .to_string(),
8507 path: frame
8508 .pointer("/source/path")
8509 .and_then(serde_json::Value::as_str)
8510 .map(str::to_string),
8511 line: frame.get("line").and_then(serde_json::Value::as_u64),
8512 })
8513 })
8514 .collect()
8515}
8516
8517fn parse_session_picker_items(value: &serde_json::Value) -> Vec<SessionPickerItem> {
8518 let items = value
8519 .as_array()
8520 .or_else(|| value.get("sessions").and_then(serde_json::Value::as_array))
8521 .cloned()
8522 .unwrap_or_default();
8523 items
8524 .into_iter()
8525 .filter_map(|item| {
8526 if let Some(path) = item.as_str() {
8527 return Some(SessionPickerItem {
8528 label: std::path::Path::new(path)
8529 .file_name()
8530 .and_then(|name| name.to_str())
8531 .unwrap_or(path)
8532 .to_string(),
8533 path: path.to_string(),
8534 });
8535 }
8536 let path = item
8537 .get("path")
8538 .or_else(|| item.get("file"))
8539 .or_else(|| item.get("sessionFile"))
8540 .and_then(serde_json::Value::as_str)?;
8541 let label = item
8542 .get("name")
8543 .or_else(|| item.get("sessionName"))
8544 .and_then(serde_json::Value::as_str)
8545 .map(str::to_string)
8546 .unwrap_or_else(|| {
8547 std::path::Path::new(path)
8548 .file_name()
8549 .and_then(|name| name.to_str())
8550 .unwrap_or(path)
8551 .to_string()
8552 });
8553 Some(SessionPickerItem {
8554 path: path.to_string(),
8555 label,
8556 })
8557 })
8558 .collect()
8559}
8560
8561fn stats_summary(value: &serde_json::Value) -> String {
8562 let input = value
8563 .pointer("/inputTokens")
8564 .or_else(|| value.pointer("/tokens/input"))
8565 .or_else(|| value.get("input"))
8566 .and_then(serde_json::Value::as_u64);
8567 let output = value
8568 .pointer("/outputTokens")
8569 .or_else(|| value.pointer("/tokens/output"))
8570 .or_else(|| value.get("output"))
8571 .and_then(serde_json::Value::as_u64);
8572 match (input, output) {
8573 (Some(input), Some(output)) => format!("{input} in · {output} out"),
8574 (Some(input), None) => format!("{input} tokens"),
8575 _ => super::projection::first_meaningful(value)
8576 .lines()
8577 .next()
8578 .unwrap_or("stats")
8579 .to_string(),
8580 }
8581}
8582
8583fn format_pi_readiness(readiness: &crate::PiReadiness) -> String {
8584 let provider = readiness.provider.as_deref().unwrap_or("not selected");
8585 let session = readiness.session.as_deref().unwrap_or("new session");
8586 let remediation = readiness
8587 .remediation
8588 .first()
8589 .map(|item| format!(" · next: {item}"))
8590 .unwrap_or_default();
8591 let state_line = format!(
8592 "{} · Node {} · SDK {} · auth {}",
8593 if readiness.ready {
8594 "✓ Ready"
8595 } else {
8596 "○ Needs setup"
8597 },
8598 component_label(&readiness.node),
8599 readiness.sdk.version.as_deref().unwrap_or("missing"),
8600 component_label(&readiness.authentication),
8601 );
8602 if readiness.ready {
8603 format!("{state_line}\nprovider {provider} · {session}")
8604 } else {
8605 format!(
8606 "{state_line}\nprovider {provider} · {session}{remediation}\n\nUse `:agent setup` to repair the pinned runtime · `:agent update` to refresh it · `:agent setup login` to open Pi `/login`"
8607 )
8608 }
8609}
8610
8611fn component_label(component: &crate::pi_runtime::PiReadinessComponent) -> String {
8612 match component.state {
8613 crate::pi_runtime::PiReadinessState::Ready => "✓".into(),
8614 crate::pi_runtime::PiReadinessState::Missing => "× missing".into(),
8615 crate::pi_runtime::PiReadinessState::Incompatible => "! incompatible".into(),
8616 crate::pi_runtime::PiReadinessState::Expired => "! expired".into(),
8617 crate::pi_runtime::PiReadinessState::Unknown => "? unknown".into(),
8618 }
8619}
8620
8621fn safe_browser_url(url: &str) -> Option<String> {
8622 let url = url.trim();
8623 if url.is_empty() {
8624 return None;
8625 }
8626 let sanitized = url
8627 .split(['?', '#'])
8628 .next()
8629 .unwrap_or(url)
8630 .chars()
8631 .take(2_048)
8632 .collect::<String>();
8633 (!sanitized.is_empty()).then_some(sanitized)
8634}
8635
8636fn page_origin(url: &str) -> Option<String> {
8637 let url = safe_browser_url(url)?;
8638 let scheme_end = url.find("://")?;
8639 let authority_start = scheme_end + 3;
8640 let authority_end = url[authority_start..]
8641 .find('/')
8642 .map(|offset| authority_start + offset)
8643 .unwrap_or(url.len());
8644 Some(url[..authority_end].to_string())
8645}
8646fn bounded_editor_content(content: &str) -> (String, bool) {
8647 const MAX_CONTEXT_BYTES: usize = 64 * 1024;
8648 if content.len() <= MAX_CONTEXT_BYTES {
8649 return (content.to_string(), false);
8650 }
8651 let mut end = MAX_CONTEXT_BYTES;
8652 while end > 0 && !content.is_char_boundary(end) {
8653 end -= 1;
8654 }
8655 (content[..end].to_string(), true)
8656}
8657
8658fn pending_agent_approval(
8659 agents: Option<&Vec<crate::AgentSnapshot>>,
8660) -> Option<PendingAgentApproval> {
8661 let agents = agents?;
8662 for agent in agents {
8663 let mut pending = None;
8664 for event in &agent.evidence {
8665 match event.get("type").and_then(serde_json::Value::as_str) {
8666 Some("glass_tool_approval_request") => {
8667 let Some(frame_id) = event.get("frameId").and_then(serde_json::Value::as_str)
8668 else {
8669 continue;
8670 };
8671 pending = Some(PendingAgentApproval {
8672 agent_id: agent.id.as_str().to_string(),
8673 frame_id: frame_id.to_string(),
8674 tool_name: event
8675 .get("toolName")
8676 .and_then(serde_json::Value::as_str)
8677 .unwrap_or("unknown tool")
8678 .to_string(),
8679 arguments: event.get("arguments").cloned().unwrap_or_default(),
8680 });
8681 }
8682 Some("glass_tool_approval_resolved") => {
8683 let frame_id = event.get("frameId").and_then(serde_json::Value::as_str);
8684 if pending
8685 .as_ref()
8686 .is_some_and(|approval| Some(approval.frame_id.as_str()) == frame_id)
8687 {
8688 pending = None;
8689 }
8690 }
8691 _ => {}
8692 }
8693 }
8694 if pending.is_some() {
8695 return pending;
8696 }
8697 }
8698 None
8699}
8700
8701fn fuzzy_contains(candidate: &str, query: &str) -> bool {
8702 if query.is_empty() {
8703 return true;
8704 }
8705 let mut query = query
8706 .chars()
8707 .map(|character| character.to_ascii_lowercase());
8708 let mut expected = query.next();
8709 for character in candidate
8710 .chars()
8711 .map(|character| character.to_ascii_lowercase())
8712 {
8713 if Some(character) == expected {
8714 expected = query.next();
8715 if expected.is_none() {
8716 return true;
8717 }
8718 }
8719 }
8720 false
8721}
8722
8723fn browser_recovery_arguments(port: u16, attach: bool) -> serde_json::Value {
8724 serde_json::json!({
8725 "port": port,
8726 "attach": attach,
8727 "incognito": !attach,
8728 })
8729}
8730
8731fn free_local_port() -> Option<u16> {
8733 std::net::TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0))
8734 .ok()
8735 .and_then(|listener| listener.local_addr().ok())
8736 .map(|address| address.port())
8737}
8738
8739struct LspLocation {
8740 path: String,
8741 line: u32,
8742 column: u32,
8743}
8744
8745fn parse_completion_insert(value: &serde_json::Value) -> Option<String> {
8746 let items = value
8747 .get("items")
8748 .and_then(serde_json::Value::as_array)
8749 .or_else(|| value.as_array())?;
8750 let item = items.first()?;
8751 item.pointer("/textEdit/newText")
8752 .or_else(|| item.pointer("/textEdit/insert/newText"))
8753 .or_else(|| item.get("insertText"))
8754 .or_else(|| item.get("label"))
8755 .and_then(serde_json::Value::as_str)
8756 .map(str::to_string)
8757 .filter(|text| !text.is_empty())
8758}
8759
8760fn format_lsp_locations(value: &serde_json::Value) -> String {
8761 let items = value
8762 .as_array()
8763 .map(|items| items.as_slice())
8764 .unwrap_or_else(|| std::slice::from_ref(value));
8765 let mut lines = vec!["REFERENCES".to_string()];
8766 for item in items.iter().take(32) {
8767 if let Some(location) = parse_lsp_location(item) {
8768 lines.push(format!(
8769 " {}:{}:{}",
8770 location.path, location.line, location.column
8771 ));
8772 }
8773 }
8774 if lines.len() == 1 {
8775 lines.push(" none".into());
8776 }
8777 lines.join("\n")
8778}
8779
8780fn parse_lsp_location(value: &serde_json::Value) -> Option<LspLocation> {
8781 let target = value
8782 .as_array()
8783 .and_then(|items| items.first())
8784 .unwrap_or(value);
8785 let uri = target
8786 .get("uri")
8787 .or_else(|| target.get("targetUri"))
8788 .and_then(serde_json::Value::as_str)?;
8789 let range = target
8790 .get("range")
8791 .or_else(|| target.get("targetRange"))
8792 .or_else(|| target.get("targetSelectionRange"))?;
8793 let line = range
8794 .pointer("/start/line")
8795 .and_then(serde_json::Value::as_u64)? as u32
8796 + 1;
8797 let column = range
8798 .pointer("/start/character")
8799 .and_then(serde_json::Value::as_u64)? as u32
8800 + 1;
8801 let path = uri
8802 .rsplit("://")
8803 .next()
8804 .unwrap_or(uri)
8805 .rsplit('/')
8806 .take(3)
8807 .collect::<Vec<_>>()
8808 .into_iter()
8809 .rev()
8810 .collect::<Vec<_>>()
8811 .join("/");
8812 Some(LspLocation {
8813 path: path.trim_start_matches('/').to_string(),
8814 line,
8815 column,
8816 })
8817}
8818
8819fn parse_lsp_symbols(value: &serde_json::Value) -> Vec<(String, u32)> {
8820 let mut symbols = Vec::new();
8821 let items = value
8822 .get("result")
8823 .or(Some(value))
8824 .and_then(serde_json::Value::as_array)
8825 .cloned()
8826 .unwrap_or_default();
8827 for item in items {
8828 let name = item
8829 .get("name")
8830 .and_then(serde_json::Value::as_str)
8831 .unwrap_or("symbol")
8832 .to_string();
8833 let line = item
8834 .pointer("/range/start/line")
8835 .or_else(|| item.pointer("/location/range/start/line"))
8836 .and_then(serde_json::Value::as_u64)
8837 .unwrap_or(0) as u32
8838 + 1;
8839 symbols.push((name, line));
8840 }
8841 symbols
8842}
8843
8844fn workflow_slug(name: &str) -> String {
8845 let mut slug = String::new();
8846 for character in name.chars() {
8847 if character.is_ascii_alphanumeric() {
8848 slug.push(character.to_ascii_lowercase());
8849 } else if matches!(character, '-' | '_' | ' ' | '.')
8850 && !slug.is_empty()
8851 && !slug.ends_with('-')
8852 {
8853 slug.push('-');
8854 }
8855 }
8856 let slug = slug.trim_matches('-').to_string();
8857 if slug.is_empty() {
8858 "click-path".into()
8859 } else {
8860 slug
8861 }
8862}
8863
8864fn slug_input_name(name: &str) -> String {
8865 workflow_slug(name).replace('-', "_")
8866}
8867
8868fn selection_covers(
8869 content: &str,
8870 selection: &crate::development::TextSelection,
8871 cursor: crate::development::TextPosition,
8872) -> bool {
8873 let Some(offset) = crate::development::editor::text_position_offset(content, cursor) else {
8874 return false;
8875 };
8876 let Some((start, end)) = crate::development::editor::selection_offsets(content, selection)
8877 else {
8878 return false;
8879 };
8880 offset >= start && offset <= end
8881}
8882
8883fn editor_offset(content: &str, line: u32, column: u32) -> usize {
8884 let mut offset = 0;
8885 for (index, value) in content.split_inclusive('\n').enumerate() {
8886 if index + 1 == line as usize {
8887 let column_bytes = value
8888 .trim_end_matches('\n')
8889 .char_indices()
8890 .nth(column.saturating_sub(1) as usize)
8891 .map(|(offset, _)| offset)
8892 .unwrap_or_else(|| value.trim_end_matches('\n').len());
8893 return offset + column_bytes;
8894 }
8895 offset += value.len();
8896 }
8897 content.len()
8898}
8899
8900#[cfg(test)]
8901mod tests {
8902 use super::*;
8903
8904 #[test]
8905 fn debug_thread_and_frame_packets_parse_source_locations() {
8906 let threads = parse_debug_threads(&serde_json::json!({
8907 "threads": [{"id": 1, "name": "main"}, {"id": 2, "name": "worker"}]
8908 }));
8909 assert_eq!(threads.len(), 2);
8910 assert_eq!(threads[1].name, "worker");
8911 let frames = parse_debug_frames(&serde_json::json!({
8912 "stackFrames": [{
8913 "id": 12,
8914 "name": "checkout",
8915 "line": 40,
8916 "source": {"path": "src/main.rs"}
8917 }]
8918 }));
8919 assert_eq!(frames[0].path.as_deref(), Some("src/main.rs"));
8920 assert_eq!(frames[0].line, Some(40));
8921 let scopes = parse_debug_scopes(&serde_json::json!({
8922 "scopes": [{"name": "Locals", "variablesReference": 7}]
8923 }));
8924 assert_eq!(scopes[0].variables_reference, 7);
8925 let variables = parse_debug_variables(&serde_json::json!({
8926 "variables": [{"name": "x", "value": "1"}]
8927 }));
8928 assert_eq!(variables[0].name, "x");
8929 }
8930
8931 #[test]
8932 fn quit_confirmation_requires_explicit_follow_through() {
8933 let root = std::env::temp_dir().join(format!("glass-tui-quit-{}", std::process::id()));
8934 std::fs::create_dir_all(&root).expect("create temporary workspace");
8935 let mut state =
8936 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
8937
8938 state.request_quit();
8939 assert!(state.quit_confirmation);
8940 assert!(!state.quit);
8941 assert_eq!(state.status, "Quit confirmation · Enter exits · Esc stays");
8942
8943 state.cancel_quit();
8944 assert!(!state.quit_confirmation);
8945 assert!(!state.quit);
8946
8947 state.request_quit();
8948 state.confirm_quit();
8949 assert!(!state.quit_confirmation);
8950 assert!(state.quit);
8951 assert_eq!(state.status, "Closing Glass Dev");
8952
8953 std::fs::remove_dir_all(root).expect("remove temporary workspace");
8954 }
8955 #[test]
8956 fn trust_action_menu_dispatches_keyboard_hints() {
8957 let root = std::env::temp_dir().join(format!("glass-trust-menu-{}", std::process::id()));
8958 std::fs::create_dir_all(&root).expect("create temporary workspace");
8959 let mut state =
8960 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
8961 state.surface = DevSurface::Trust;
8962
8963 state.open_menu();
8964 state.menu_selection = 0;
8965 state.run_menu_action();
8966 assert!(!state.menu_open);
8967 assert!(
8968 state
8969 .status
8970 .contains("Inspecting exact repository configuration")
8971 );
8972
8973 state.open_menu();
8974 state.menu_selection = 1;
8975 state.run_menu_action();
8976 assert_eq!(state.surface, DevSurface::Agent);
8977 assert!(
8978 state
8979 .status
8980 .contains("Workspace opened with untrusted authority")
8981 );
8982
8983 std::fs::remove_dir_all(root).expect("remove temporary workspace");
8984 }
8985
8986 #[test]
8987 fn browser_context_url_redaction_preserves_path_only() {
8988 assert_eq!(
8989 safe_browser_url("https://example.test/orders/7?token=secret#receipt"),
8990 Some("https://example.test/orders/7".into())
8991 );
8992 assert_eq!(
8993 page_origin("https://example.test/orders/7?token=secret"),
8994 Some("https://example.test".into())
8995 );
8996 assert_eq!(safe_browser_url(""), None);
8997 }
8998
8999 #[test]
9000 fn browser_recovery_offer_explains_port_collision_choices() {
9001 let offer = BrowserRecoveryOffer::from_error("address already in use on port 9222", 9222);
9002 assert!(!offer.compatible_endpoint);
9003 assert_eq!(offer.actions().len(), 3);
9004 assert!(offer.guidance().contains("preferred endpoint"));
9005
9006 let attach =
9007 BrowserRecoveryOffer::from_error("DevTools page target is available for attach", 9222);
9008 assert!(attach.compatible_endpoint);
9009 assert_eq!(attach.actions().len(), 4);
9010 assert!(attach.guidance().contains("Attach"));
9011 }
9012
9013 #[test]
9014 fn browser_recovery_attach_disables_incognito() {
9015 assert_eq!(
9016 browser_recovery_arguments(9222, true),
9017 serde_json::json!({
9018 "port": 9222,
9019 "attach": true,
9020 "incognito": false,
9021 })
9022 );
9023 assert_eq!(
9024 browser_recovery_arguments(42123, false),
9025 serde_json::json!({
9026 "port": 42123,
9027 "attach": false,
9028 "incognito": true,
9029 })
9030 );
9031 }
9032
9033 #[test]
9034 fn browser_target_picker_filters_and_redacts_urls() {
9035 let root = std::env::temp_dir().join(format!("glass-target-picker-{}", std::process::id()));
9036 std::fs::create_dir_all(&root).expect("create temporary workspace");
9037 let mut state =
9038 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9039 state.browser_workspace.replace_targets(vec![
9040 BrowserWorkspaceTarget {
9041 id: "page-docs".into(),
9042 title: "Project docs".into(),
9043 url: "https://example.test/docs?token=secret".into(),
9044 selected: false,
9045 },
9046 BrowserWorkspaceTarget {
9047 id: "page-app".into(),
9048 title: "Application".into(),
9049 url: "http://localhost:3000".into(),
9050 selected: false,
9051 },
9052 ]);
9053 state
9054 .request_browser_target_picker("docs")
9055 .expect("queue target picker");
9056 state.queued_tool_request = None;
9057 let matches = state.browser_target_matches();
9058 assert_eq!(matches, vec![0]);
9059 let view = state.browser_target_picker_view();
9060 assert!(view.contains("Project docs"));
9061 assert!(view.contains("https://example.test/docs"));
9062 assert!(!view.contains("token=secret"));
9063 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9064 }
9065 #[test]
9066 fn agent_typing_opens_composer_before_surface_aliases() {
9067 let root = std::env::temp_dir().join(format!("glass-agent-compose-{}", std::process::id()));
9068 std::fs::create_dir_all(&root).expect("create temporary workspace");
9069 let mut state =
9070 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9071 state.surface = DevSurface::Agent;
9072 state.snapshot_trust_label = "trusted".into();
9073 state.agent_readiness = "✓ Ready · Node ✓ · SDK 0.84.3 · auth ✓".into();
9074
9075 state.handle_printable('c');
9076
9077 assert_eq!(state.surface, DevSurface::Agent);
9078 assert!(state.composer_mode);
9079 assert_eq!(state.composer_input, "c");
9080 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9081 }
9082
9083 #[test]
9084 fn leading_agent_message_characters_are_not_commands() {
9085 for character in ['a', 'q', 's', 'u', 'l', 'i', 'n'] {
9086 let root = std::env::temp_dir().join(format!(
9087 "glass-agent-leading-{character}-{}",
9088 std::process::id()
9089 ));
9090 std::fs::create_dir_all(&root).expect("create temporary workspace");
9091 let mut state = DevTuiState::open_for_tui(&root, TuiLayout::Desktop)
9092 .expect("open temporary workspace");
9093 state.surface = DevSurface::Agent;
9094 state.snapshot_trust_label = "trusted".into();
9095 state.agent_readiness = "✓ Ready · Node ✓ · SDK 0.84.3 · auth ✓".into();
9096
9097 state.handle_printable(character);
9098
9099 assert!(
9100 state.composer_mode,
9101 "character {character:?} did not open composer"
9102 );
9103 assert_eq!(state.composer_input, character.to_string());
9104 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9105 }
9106 }
9107 #[test]
9108 fn action_shortcut_opens_menu_without_stealing_ready_agent_text() {
9109 let root =
9110 std::env::temp_dir().join(format!("glass-action-shortcut-{}", std::process::id()));
9111 std::fs::create_dir_all(&root).expect("create temporary workspace");
9112 let mut state =
9113 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9114
9115 state.surface = DevSurface::Terminal;
9116 state.handle_printable('a');
9117 assert!(state.menu_open);
9118 state.close_menu();
9119
9120 state.surface = DevSurface::Agent;
9121 state.snapshot_trust_label = "trusted".into();
9122 state.agent_readiness = "✓ Ready · Node ✓ · SDK 0.84.3 · auth ✓".into();
9123 state.handle_printable('a');
9124 assert!(state.composer_mode);
9125 assert_eq!(state.composer_input, "a");
9126
9127 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9128 }
9129
9130 #[test]
9131 fn typed_open_in_palette_runs_instead_of_fuzzy_action() {
9132 let root = std::env::temp_dir().join(format!("glass-typed-open-{}", std::process::id()));
9133 std::fs::create_dir_all(&root).expect("create temporary workspace");
9134 let mut state =
9135 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9136 state.files = vec!["src/lib.rs".into(), "Cargo.toml".into()];
9137 state.open_palette();
9138 state.command_input = "open".into();
9139 state.command_cursor = 4;
9140 let mut worker = super::super::snapshot::SnapshotWorker::spawn(&state);
9141 state.submit_palette(&mut worker);
9142 drop(worker);
9143 assert!(
9144 state.file_picker_open,
9145 "typed :open must open the file picker, not a fuzzy action"
9146 );
9147 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9148 }
9149
9150 #[test]
9151 fn colon_opens_palette_from_every_surface() {
9152 for surface in DevSurface::ALL {
9153 let root = std::env::temp_dir().join(format!(
9154 "glass-palette-surface-{}-{}",
9155 surface.label(),
9156 std::process::id()
9157 ));
9158 std::fs::create_dir_all(&root).expect("create temporary workspace");
9159 let mut state = DevTuiState::open_for_tui(&root, TuiLayout::Desktop)
9160 .expect("open temporary workspace");
9161 state.surface = surface;
9162
9163 state.handle_printable(':');
9164
9165 assert!(
9166 state.command_mode,
9167 "colon did not open palette on {surface:?}"
9168 );
9169 assert!(!state.composer_mode);
9170 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9171 }
9172 }
9173
9174 #[test]
9175 fn file_picker_filters_and_opens_a_matching_path() {
9176 let root = std::env::temp_dir().join(format!("glass-file-picker-{}", std::process::id()));
9177 std::fs::create_dir_all(root.join("src")).expect("create temporary workspace");
9178 std::fs::write(root.join("src/lib.rs"), "fn lib() {}\n").unwrap();
9179 std::fs::write(root.join("src/main.rs"), "fn main() {}\n").unwrap();
9180 let mut state =
9181 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9182 state.files = vec![
9183 "src/lib.rs".into(),
9184 "src/main.rs".into(),
9185 "README.md".into(),
9186 ];
9187 state.open_file_picker();
9188 assert!(state.file_picker_open);
9189 for character in "main".chars() {
9190 state.insert_file_picker_char(character);
9191 }
9192 let matches = state.file_picker_matches();
9193 assert_eq!(matches.len(), 1);
9194 assert_eq!(state.files[matches[0]], "src/main.rs");
9195 state.submit_file_picker();
9196 assert!(!state.file_picker_open);
9197 assert_eq!(state.focused_editor_path, "src/main.rs");
9198 assert!(state.code_edit_mode);
9199 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9200 }
9201
9202 #[test]
9203 fn composer_shift_enter_and_history_are_local_edits() {
9204 let root =
9205 std::env::temp_dir().join(format!("glass-composer-history-{}", std::process::id()));
9206 std::fs::create_dir_all(&root).expect("create temporary workspace");
9207 let mut state =
9208 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9209 state.open_composer();
9210 state.insert_composer_text("first");
9211 state.remember_composer_history("first");
9212 state.composer_input.clear();
9213 state.composer_cursor = 0;
9214 state.insert_composer_text("second");
9215 state.navigate_composer_history(true);
9216 assert_eq!(state.composer_input, "first");
9217 state.navigate_composer_history(false);
9218 assert_eq!(state.composer_input, "second");
9219 state.insert_composer_newline();
9220 assert_eq!(state.composer_input, "second\n");
9221 state.navigate_composer_history(true);
9222 assert!(
9223 state.composer_cursor < state.composer_input.len(),
9224 "Up on a wrapped draft should move to the previous line before history"
9225 );
9226 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9227 }
9228
9229 #[test]
9230 fn external_delegate_result_is_visible_in_tui_status() {
9231 let root =
9232 std::env::temp_dir().join(format!("glass-delegate-status-{}", std::process::id()));
9233 std::fs::create_dir_all(&root).expect("create temporary workspace");
9234 let mut state =
9235 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9236 state.running_tool_job = Some(7);
9237 state.apply_tool_job_result(super::super::snapshot::ToolJobResult {
9238 id: 7,
9239 tool: "glass.agent.delegate".into(),
9240 result: Ok(serde_json::json!({
9241 "harness": "codex",
9242 "success": true,
9243 "timedOut": false,
9244 "output": "REAL_RESULT\nsecond line\n",
9245 "stderr": "",
9246 })),
9247 });
9248 assert!(state.status.contains("Temporary codex completed"));
9249 assert!(state.status.contains("REAL_RESULT"));
9250 assert_eq!(state.surface, DevSurface::Agent);
9251 assert!(state.running_tool_job.is_none());
9252 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9253 }
9254
9255 #[test]
9256 fn composer_tab_completes_file_mentions_and_submit_pins_the_path() {
9257 let root =
9258 std::env::temp_dir().join(format!("glass-composer-mention-{}", std::process::id()));
9259 std::fs::create_dir_all(&root).expect("create temporary workspace");
9260 let mut state =
9261 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9262 state.files = vec!["src/main.rs".into(), "src/lib.rs".into()];
9263 state.focused_editor_path = "src/main.rs".into();
9264 state.open_composer();
9265 state.insert_composer_text("inspect @fi");
9266 state.complete_composer_mention();
9267 assert_eq!(state.composer_input, "inspect @file");
9268 state.complete_composer_mention();
9269 assert_eq!(state.composer_input, "inspect @file:src/main.rs");
9270 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9271 }
9272
9273 #[test]
9274 fn editor_gutter_marks_open_comments_on_the_focused_buffer() {
9275 let root = std::env::temp_dir().join(format!(
9276 "glass-editor-comment-gutter-{}",
9277 std::process::id()
9278 ));
9279 std::fs::create_dir_all(&root).expect("create temporary workspace");
9280 let mut state =
9281 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9282 state.focused_editor_path = "src/main.rs".into();
9283 state
9284 .editor_comments
9285 .push(crate::development::EditorComment {
9286 id: "comment-1".into(),
9287 path: "src/main.rs".into(),
9288 start_line: 4,
9289 end_line: 4,
9290 text: "simplify this".into(),
9291 actor: crate::development::Actor::local(),
9292 state: crate::development::EditorCommentState::Open,
9293 created_revision: 1,
9294 updated_revision: 1,
9295 });
9296 let marks = state.editor_gutter_marks();
9297 assert!(marks.contains(&(4, native::GutterMark::Comment)));
9298 let notes = state.editor_source_notes();
9299 assert!(
9300 notes
9301 .iter()
9302 .any(|(line, note)| *line == 4 && note.contains("simplify this"))
9303 );
9304 state.focused_editor_line = 4;
9305 state.show_comment_thread();
9306 assert!(
9307 state
9308 .editor_engine
9309 .overlay
9310 .as_deref()
9311 .is_some_and(|overlay| overlay.contains("simplify this"))
9312 );
9313 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9314 }
9315
9316 #[test]
9317 fn gutter_marks_diagnostics_and_proof_on_source_lines() {
9318 let root = std::env::temp_dir().join(format!("glass-gutter-proof-{}", std::process::id()));
9319 std::fs::create_dir_all(root.join("src")).expect("create source directory");
9320 std::fs::write(root.join("src/main.rs"), "fn main() {}\nfn extra() {}\n")
9321 .expect("write source");
9322 let mut state =
9323 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9324 state.focused_editor_path = "src/main.rs".into();
9325 state.focused_editor_line = 2;
9326 state
9327 .editor_diagnostics
9328 .push(crate::development::LanguageDiagnostic {
9329 path: "src/main.rs".into(),
9330 start: crate::development::DiagnosticPosition {
9331 line: 0,
9332 character: 3,
9333 },
9334 end: crate::development::DiagnosticPosition {
9335 line: 0,
9336 character: 7,
9337 },
9338 severity: Some(1),
9339 code: None,
9340 source: Some("rustc".into()),
9341 message: "unused variable".into(),
9342 });
9343 state
9344 .ws_mut()
9345 .expect("workspace lock")
9346 .project_mut()
9347 .link_runtime_source(
9348 "action.main",
9349 "src/main.rs",
9350 1,
9351 1,
9352 crate::development::LinkProvenance::ExplicitMarker,
9353 "handler",
9354 1.0,
9355 crate::development::Actor::local(),
9356 )
9357 .expect("link");
9358 state.last_proof_ok = Some(true);
9359 let marks = state.editor_gutter_marks();
9360 assert!(
9361 marks.contains(&(1, native::GutterMark::Lsp)),
9362 "diagnostic is on LSP line 0 → editor line 1: {marks:?}"
9363 );
9364 assert!(
9365 marks.contains(&(1, native::GutterMark::Proof)),
9366 "proof sits on the handler, not the cursor: {marks:?}"
9367 );
9368 assert!(!marks.contains(&(2, native::GutterMark::Proof)));
9369 let notes = state.editor_source_notes();
9370 assert!(
9371 notes
9372 .iter()
9373 .any(|(line, note)| *line == 1 && note.contains("unused variable"))
9374 );
9375 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9376 }
9377
9378 #[test]
9379 fn page_gutter_marks_graph_linked_handlers() {
9380 let root = std::env::temp_dir().join(format!("glass-page-gutter-{}", std::process::id()));
9381 std::fs::create_dir_all(root.join("src")).expect("create source directory");
9382 std::fs::write(root.join("src/button.tsx"), "export function Pay() {}\n")
9383 .expect("write source");
9384 let mut state =
9385 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9386 state
9387 .ws_mut()
9388 .expect("workspace lock")
9389 .project_mut()
9390 .link_runtime_source(
9391 "action.checkout.submit",
9392 "src/button.tsx",
9393 1,
9394 1,
9395 crate::development::LinkProvenance::ExplicitMarker,
9396 "test link",
9397 1.0,
9398 crate::development::Actor::local(),
9399 )
9400 .expect("link source");
9401 state.focused_editor_path = "src/button.tsx".into();
9402 let marks = state.editor_gutter_marks();
9403 assert!(marks.contains(&(1, native::GutterMark::Page)));
9404 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9405 }
9406
9407 #[test]
9408 fn gp_navigates_to_the_inferred_app_route() {
9409 let root = std::env::temp_dir().join(format!("glass-gp-app-{}", std::process::id()));
9410 std::fs::create_dir_all(&root).expect("create temporary workspace");
9411 let mut state =
9412 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9413 state.focused_editor_path = "app/settings/page.tsx".into();
9414 state.focused_editor_line = 1;
9415 state.process_urls = vec!["http://localhost:3000/".into()];
9416 state.jump_page_from_source();
9417 assert_eq!(
9418 state.pending_browser_navigation.as_deref(),
9419 Some("http://localhost:3000/settings")
9420 );
9421 assert_eq!(state.surface, DevSurface::App);
9422 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9423 }
9424
9425 #[test]
9426 fn g_on_app_opens_the_linked_source() {
9427 let root = std::env::temp_dir().join(format!("glass-app-source-{}", std::process::id()));
9428 std::fs::create_dir_all(root.join("src")).expect("create source directory");
9429 std::fs::write(
9430 root.join("src/button.tsx"),
9431 "<button data-glass-entity=\"action.checkout.submit\">Pay</button>\n",
9432 )
9433 .expect("write source");
9434 let mut state =
9435 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9436 state.files = vec!["src/button.tsx".into()];
9437 state.browser_workspace.replace_entities(
9438 1,
9439 vec![BrowserWorkspaceEntity {
9440 reference: "action.checkout.submit".into(),
9441 role: "button".into(),
9442 name: "Pay".into(),
9443 actionable: true,
9444 revision: 1,
9445 }],
9446 );
9447 state.browser_workspace.state_mut().selected_entity = Some(0);
9448 state.jump_source_from_page();
9449 assert_eq!(state.focused_editor_path, "src/button.tsx");
9450 assert_eq!(state.focused_editor_line, 1);
9451 assert!(state.code_edit_mode);
9452 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9453 }
9454
9455 #[test]
9456 fn hosted_fim_stub_fills_an_empty_block() {
9457 let root = std::env::temp_dir().join(format!("glass-fim-stub-{}", std::process::id()));
9458 std::fs::create_dir_all(root.join("src")).expect("create source directory");
9459 std::fs::write(
9460 root.join("glass.toml"),
9461 "[editor.fim]\nendpoint = \"stub://test\"\nmodel = \"stub\"\n",
9462 )
9463 .expect("write fim config");
9464 std::fs::write(root.join("src/main.rs"), "fn main() {\n \n}\n").expect("write source");
9465 let mut state =
9466 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9467 state
9468 .ws_mut()
9469 .expect("lock")
9470 .project_mut()
9471 .open_buffer("src/main.rs", crate::development::Actor::local())
9472 .expect("open");
9473 state.refresh_editor_projection();
9474 state
9475 .ws_mut()
9476 .expect("lock")
9477 .project_mut()
9478 .set_buffer_cursor("src/main.rs", 2, 5)
9479 .expect("cursor");
9480 state.refresh_editor_projection();
9481 state.request_ghost_from_line();
9482 let mut attempts = 0;
9483 while state.editor_engine.ghost.is_none() && attempts < 50 {
9484 let _ = state.tick_fim();
9485 std::thread::sleep(std::time::Duration::from_millis(5));
9486 attempts += 1;
9487 }
9488 assert_eq!(
9489 state
9490 .editor_engine
9491 .ghost
9492 .as_ref()
9493 .map(|ghost| ghost.text.as_str()),
9494 Some("todo!()"),
9495 "configured stub FIM should fill the empty block"
9496 );
9497 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9498 }
9499
9500 #[test]
9501 fn ghost_tab_jumps_to_the_next_incomplete_ident() {
9502 let root = std::env::temp_dir().join(format!("glass-ghost-next-{}", std::process::id()));
9503 std::fs::create_dir_all(root.join("src")).expect("create source directory");
9504 let source = "fn hello_world() {}\nfn hello_\nfn greet_user() {}\nfn greet_\n";
9505 std::fs::write(root.join("src/main.rs"), source).expect("write source");
9506 let mut state =
9507 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9508 state
9509 .ws_mut()
9510 .expect("workspace lock")
9511 .project_mut()
9512 .open_buffer("src/main.rs", crate::development::Actor::local())
9513 .expect("open buffer");
9514 state.refresh_editor_projection();
9515 state.enter_code_edit();
9516 let _ = state.set_editor_cursor(
9517 "src/main.rs",
9518 crate::development::TextPosition {
9519 line: 2,
9520 column: 10,
9521 },
9522 false,
9523 );
9524 state.refresh_editor_projection();
9525 state.editor_engine.ghost = Some(GhostText {
9526 text: "world".into(),
9527 });
9528 state.edit_code_key(
9529 crossterm::event::KeyCode::Tab,
9530 crossterm::event::KeyModifiers::NONE,
9531 );
9532 assert!(
9533 state.focused_editor_content.contains("fn hello_world\n"),
9534 "tab should apply the ghost: {}",
9535 state.focused_editor_content
9536 );
9537 assert_eq!(state.focused_editor_line, 4);
9538 assert_eq!(
9539 state
9540 .editor_engine
9541 .ghost
9542 .as_ref()
9543 .map(|ghost| ghost.text.as_str()),
9544 Some("user")
9545 );
9546 assert!(state.status.contains("next edit"));
9547 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9548 }
9549
9550 #[test]
9551 fn crew_tool_result_stores_the_wake_artifact() {
9552 let root = std::env::temp_dir().join(format!("glass-crew-wake-tui-{}", std::process::id()));
9553 std::fs::create_dir_all(&root).expect("create temporary workspace");
9554 let mut state =
9555 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9556 state.running_tool_job = Some(3);
9557 state.apply_tool_job_result(super::super::snapshot::ToolJobResult {
9558 id: 3,
9559 tool: "glass.task.crew".into(),
9560 result: Ok(serde_json::json!({
9561 "goal": "add settings toggle",
9562 "wake": {
9563 "id": "add-settings-toggle",
9564 "goal": "add settings toggle",
9565 "worktree": "/tmp/worktree",
9566 "checkpoint": "before-crew:add settings toggle",
9567 "createdAtMs": 1,
9568 "tasks": [{"id":"task-0001","role":"architect","title":"architect: add settings toggle","state":"queued"}]
9569 }
9570 })),
9571 });
9572 let wake = state.last_crew_wake.expect("wake");
9573 assert!(wake.contains("WAKE add-settings-toggle"));
9574 assert!(wake.contains("architect task-0001 queued"));
9575 assert_eq!(state.surface, DevSurface::Tasks);
9576 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9577 }
9578
9579 #[test]
9580 fn review_accept_applies_the_wake_proposal_pack() {
9581 let root = std::env::temp_dir().join(format!("glass-review-pack-{}", std::process::id()));
9582 std::fs::create_dir_all(root.join("src")).expect("create source directory");
9583 std::fs::write(root.join("src/main.rs"), "fn main() {}\n").expect("write source");
9584 let mut state =
9585 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9586 state
9587 .ws_mut()
9588 .expect("workspace lock")
9589 .project_mut()
9590 .open_buffer("src/main.rs", crate::development::Actor::local())
9591 .expect("open buffer");
9592 state
9593 .ws_mut()
9594 .expect("workspace lock")
9595 .project_mut()
9596 .propose_editor_change(
9597 "src/main.rs",
9598 "fn main() {}\n".into(),
9599 "fn main() { 1 }\n".into(),
9600 "add one".into(),
9601 crate::development::Actor::local(),
9602 )
9603 .expect("propose");
9604 state.refresh_editor_projection();
9605 let accepted = state.accept_review_pack().expect("accept pack");
9606 assert!(accepted.contains("1 proposal"));
9607 assert_eq!(
9608 state.focused_editor_content, "fn main() { 1 }\n",
9609 "pack accept must write the proposed buffer"
9610 );
9611 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9612 }
9613
9614 #[test]
9615 fn gm_adds_structural_carets_and_inserts_at_each() {
9616 let root = std::env::temp_dir().join(format!("glass-multi-cursor-{}", std::process::id()));
9617 std::fs::create_dir_all(root.join("src")).expect("create source directory");
9618 std::fs::write(root.join("src/main.rs"), "fn foo() { foo(); foo }\n").expect("write");
9619 let mut state =
9620 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9621 state
9622 .ws_mut()
9623 .expect("lock")
9624 .project_mut()
9625 .open_buffer("src/main.rs", crate::development::Actor::local())
9626 .expect("open");
9627 state.refresh_editor_projection();
9628 state.enter_code_edit();
9629 state.handle_editor_escape();
9630 state
9631 .ws_mut()
9632 .expect("lock")
9633 .project_mut()
9634 .set_buffer_cursor("src/main.rs", 1, 4)
9635 .expect("cursor");
9636 state.refresh_editor_projection();
9637 state.edit_code_key(
9638 crossterm::event::KeyCode::Char('g'),
9639 crossterm::event::KeyModifiers::empty(),
9640 );
9641 state.edit_code_key(
9642 crossterm::event::KeyCode::Char('m'),
9643 crossterm::event::KeyModifiers::empty(),
9644 );
9645 assert_eq!(
9646 state.editor_engine.extra_selections.len(),
9647 2,
9648 "gm should add a caret on every other foo"
9649 );
9650 state.edit_code_key(
9651 crossterm::event::KeyCode::Char('i'),
9652 crossterm::event::KeyModifiers::empty(),
9653 );
9654 state.edit_code_key(
9655 crossterm::event::KeyCode::Char('X'),
9656 crossterm::event::KeyModifiers::empty(),
9657 );
9658 let content = state.focused_editor_content.clone();
9659 assert_eq!(
9660 content.matches('X').count(),
9661 3,
9662 "insert should hit every caret: {content}"
9663 );
9664 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9665 }
9666
9667 #[test]
9668 fn app_enter_records_role_name_locators_into_a_workflow_draft() {
9669 let root =
9670 std::env::temp_dir().join(format!("glass-workflow-record-{}", std::process::id()));
9671 std::fs::create_dir_all(&root).expect("create temporary workspace");
9672 let mut state =
9673 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9674 state.browser_workspace.replace_entities(
9675 7,
9676 vec![BrowserWorkspaceEntity {
9677 reference: "r7:save".into(),
9678 role: "button".into(),
9679 name: "Save settings".into(),
9680 actionable: true,
9681 revision: 7,
9682 }],
9683 );
9684 state
9685 .start_workflow_recording("Save Settings")
9686 .expect("start recording");
9687 state.queue_browser_intent(BrowserWorkspaceIntent::ActivateSelected);
9688 let draft = serde_json::to_string(
9689 state
9690 .workflow_recording
9691 .as_ref()
9692 .expect("recording")
9693 .recorder
9694 .draft(),
9695 )
9696 .expect("serialize draft");
9697 assert!(draft.contains("role=button;name=Save settings"));
9698 let stopped = state.stop_workflow_recording().expect("stop recording");
9699 assert!(stopped.contains("1 step"));
9700 let path = root.join(".glass/workflows/save-settings.draft.json");
9701 let persisted = std::fs::read_to_string(&path).expect("read draft");
9702 assert!(persisted.contains("role=button;name=Save settings"));
9703 assert!(persisted.contains("\"reviewRequired\": true"));
9704 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9705 }
9706
9707 #[test]
9708 fn agent_editor_context_attaches_unsaved_buffer_and_inline_prompt() {
9709 let root =
9710 std::env::temp_dir().join(format!("glass-editor-agent-context-{}", std::process::id()));
9711 std::fs::create_dir_all(root.join("src")).expect("create source directory");
9712 std::fs::write(root.join("src/main.rs"), "fn main() {}\n").expect("write source");
9713 let mut state =
9714 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9715 state
9716 .ws_mut()
9717 .expect("workspace lock")
9718 .project_mut()
9719 .open_buffer("src/main.rs", crate::development::Actor::local())
9720 .expect("open editor buffer");
9721 state
9722 .ws_mut()
9723 .expect("workspace lock")
9724 .project_mut()
9725 .edit_buffer(
9726 "src/main.rs",
9727 "fn main() {\n println!(\"unsaved\");\n}\n".into(),
9728 crate::development::Actor::local(),
9729 )
9730 .expect("edit buffer");
9731 state.refresh_editor_projection();
9732
9733 let context = state.agent_editor_context();
9734 assert_eq!(context["focusedPath"], "src/main.rs");
9735 assert_eq!(
9736 context["focusedBuffer"]["content"],
9737 "fn main() {\n println!(\"unsaved\");\n}\n"
9738 );
9739 assert_eq!(context["focusedBuffer"]["dirty"], true);
9740
9741 state.enter_code_edit();
9742 state.edit_code_key(
9743 crossterm::event::KeyCode::Char('a'),
9744 crossterm::event::KeyModifiers::ALT,
9745 );
9746 assert_eq!(state.surface, DevSurface::Code);
9747 assert!(state.composer_mode);
9748 assert!(!state.code_edit_mode);
9749 assert!(state.composer_input.contains("src/main.rs:1:1"));
9750 assert!(state.composer_input.contains("Do not edit files"));
9751
9752 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9753 }
9754
9755 #[test]
9756 fn editor_soft_wrap_toggle_scrolls_visual_rows_and_resets_horizontal_scroll() {
9757 let root =
9758 std::env::temp_dir().join(format!("glass-editor-soft-wrap-{}", std::process::id()));
9759 std::fs::create_dir_all(root.join("src")).expect("create source directory");
9760 let content = format!("{}\n", "word ".repeat(80));
9761 std::fs::write(root.join("src/main.rs"), content).expect("write source");
9762 let mut state =
9763 DevTuiState::open_for_tui(&root, TuiLayout::Mobile).expect("open temporary workspace");
9764 state
9765 .ws_mut()
9766 .expect("workspace lock")
9767 .project_mut()
9768 .open_buffer("src/main.rs", crate::development::Actor::local())
9769 .expect("open editor buffer");
9770 state
9771 .ws_mut()
9772 .expect("workspace lock")
9773 .project_mut()
9774 .set_buffer_cursor("src/main.rs", 1, 180)
9775 .expect("set editor cursor");
9776 state.refresh_editor_projection();
9777 state.set_terminal_size(32, 16);
9778 state.enter_code_edit();
9779 state.edit_code_key(
9780 crossterm::event::KeyCode::Char('w'),
9781 crossterm::event::KeyModifiers::ALT,
9782 );
9783
9784 assert!(state.editor_soft_wrap);
9785 assert!(state.editor_scroll_line > 0);
9786 assert_eq!(state.editor_scroll_column, 0);
9787 assert!(state.status.contains("Soft wrap ON"));
9788
9789 state.edit_code_key(
9790 crossterm::event::KeyCode::Char('w'),
9791 crossterm::event::KeyModifiers::ALT,
9792 );
9793 assert!(!state.editor_soft_wrap);
9794 assert!(state.editor_scroll_column > 0);
9795 assert!(state.status.contains("Soft wrap OFF"));
9796 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9797 }
9798
9799 #[test]
9800 fn editor_cursor_scroll_matches_fullscreen_source_height() {
9801 let root =
9802 std::env::temp_dir().join(format!("glass-editor-viewport-{}", std::process::id()));
9803 std::fs::create_dir_all(root.join("src")).expect("create source directory");
9804 let content = (1..=30)
9805 .map(|line| format!("line {line}\n"))
9806 .collect::<String>();
9807 std::fs::write(root.join("src/main.rs"), content).expect("write source");
9808 let mut state =
9809 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9810 state
9811 .ws_mut()
9812 .expect("workspace lock")
9813 .project_mut()
9814 .open_buffer("src/main.rs", crate::development::Actor::local())
9815 .expect("open editor buffer");
9816 state
9817 .ws_mut()
9818 .expect("workspace lock")
9819 .project_mut()
9820 .set_buffer_cursor("src/main.rs", 23, 1)
9821 .expect("set editor cursor");
9822 state.refresh_editor_projection();
9823 state.editor_scroll_line = 0;
9824 state.set_terminal_size(100, 30);
9825
9826 assert_eq!(state.focused_editor_line, 23);
9827 assert_eq!(
9828 state.editor_scroll_line, 1,
9829 "line 23 must scroll into the 22-row source viewport"
9830 );
9831 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9832 }
9833
9834 #[test]
9835 fn editor_shift_selection_replaces_text_and_clears_anchor() {
9836 let root =
9837 std::env::temp_dir().join(format!("glass-editor-selection-{}", std::process::id()));
9838 std::fs::create_dir_all(root.join("src")).expect("create source directory");
9839 std::fs::write(root.join("src/main.rs"), "alpha\nbeta\n").expect("write source");
9840 let mut state =
9841 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9842 state
9843 .ws_mut()
9844 .expect("workspace lock")
9845 .project_mut()
9846 .open_buffer("src/main.rs", crate::development::Actor::local())
9847 .expect("open editor buffer");
9848 state.refresh_editor_projection();
9849 state.enter_code_edit();
9850 for _ in 0..5 {
9851 state.edit_code_key(
9852 crossterm::event::KeyCode::Right,
9853 crossterm::event::KeyModifiers::SHIFT,
9854 );
9855 }
9856 assert!(
9857 state
9858 .focused_editor_selection
9859 .as_ref()
9860 .is_some_and(|selection| !selection.is_empty())
9861 );
9862 state.edit_code_key(
9863 crossterm::event::KeyCode::Char('X'),
9864 crossterm::event::KeyModifiers::empty(),
9865 );
9866 let buffer = state.focused_buffer().expect("focused editor buffer");
9867 assert_eq!(buffer.content, "X\nbeta\n");
9868 assert_eq!((buffer.cursor_line, buffer.cursor_column), (1, 2));
9869 assert!(buffer.selection.is_none());
9870 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9871 }
9872
9873 #[test]
9874 fn editor_exit_prompts_save_discard_and_discard_quit() {
9875 let root = std::env::temp_dir().join(format!("glass-editor-exit-{}", std::process::id()));
9876 std::fs::create_dir_all(root.join("src")).expect("create source directory");
9877 let original = "fn main() {}\n";
9878 std::fs::write(root.join("src/main.rs"), original).expect("write source");
9879 let mut state =
9880 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9881 state
9882 .ws_mut()
9883 .expect("workspace lock")
9884 .project_mut()
9885 .open_buffer("src/main.rs", crate::development::Actor::local())
9886 .expect("open editor buffer");
9887 state.refresh_editor_projection();
9888 state.enter_code_edit();
9889 state.edit_code_key(
9890 crossterm::event::KeyCode::Char('#'),
9891 crossterm::event::KeyModifiers::NONE,
9892 );
9893 state.request_editor_exit();
9894 assert_eq!(state.editor_exit_prompt, Some(EditorExitPrompt::Unsaved));
9895 state.handle_editor_exit_key(crossterm::event::KeyCode::Char('d'));
9896 assert!(!state.code_edit_mode);
9897 assert_eq!(
9898 std::fs::read_to_string(root.join("src/main.rs")).expect("read source"),
9899 original
9900 );
9901
9902 state.enter_code_edit();
9903 state.edit_code_key(
9904 crossterm::event::KeyCode::Char('#'),
9905 crossterm::event::KeyModifiers::NONE,
9906 );
9907 state.request_editor_exit();
9908 state.handle_editor_exit_key(crossterm::event::KeyCode::Char('s'));
9909 assert!(!state.code_edit_mode);
9910 assert!(
9911 std::fs::read_to_string(root.join("src/main.rs"))
9912 .expect("read saved source")
9913 .starts_with('#')
9914 );
9915 let saved = std::fs::read_to_string(root.join("src/main.rs")).expect("read saved source");
9916
9917 state.enter_code_edit();
9918 state.edit_code_key(
9919 crossterm::event::KeyCode::Char('!'),
9920 crossterm::event::KeyModifiers::NONE,
9921 );
9922 state.request_editor_exit();
9923 state.handle_editor_exit_key(crossterm::event::KeyCode::Char('q'));
9924 assert!(state.quit);
9925 assert_eq!(
9926 std::fs::read_to_string(root.join("src/main.rs")).expect("read discarded source"),
9927 saved
9928 );
9929 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9930 }
9931
9932 #[test]
9933 fn conversation_view_does_not_echo_pending_message_after_snapshot() {
9934 let root = std::env::temp_dir().join(format!("glass-chat-merge-{}", std::process::id()));
9935 std::fs::create_dir_all(&root).expect("create temporary workspace");
9936 let mut state =
9937 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9938 state.agent_conversation = "YOU\ninspect the failing test\n\nGLASS AGENT\nworking".into();
9939 state.pending_chat_messages.push(PendingChatMessage {
9940 text: "inspect the failing test".into(),
9941 state: ChatMessageState::Sent,
9942 job_id: None,
9943 error: None,
9944 });
9945
9946 let view = state.conversation_view();
9947 assert_eq!(view.matches("YOU\ninspect the failing test").count(), 1);
9948 assert!(!view.contains("Glass Agent is thinking"));
9949
9950 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9951 }
9952
9953 #[test]
9954 fn palette_filters_actions_and_prefills_selected_arguments() {
9955 let root =
9956 std::env::temp_dir().join(format!("glass-palette-actions-{}", std::process::id()));
9957 std::fs::create_dir_all(&root).expect("create temporary workspace");
9958 let mut state =
9959 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9960 state.surface = DevSurface::Agent;
9961 state.open_palette();
9962 state.insert_palette_text("agent setup");
9963 assert_eq!(
9964 state.selected_palette_action().map(|action| action.label),
9965 Some("Setup Pi runtime")
9966 );
9967 state.move_palette_selection(1);
9968 assert_eq!(
9969 state.selected_palette_action().map(|action| action.label),
9970 Some("Authenticate")
9971 );
9972
9973 state.open_palette_with("agent rewind ENTRY_ID");
9974 let action = state.selected_palette_action().expect("rewind action");
9975 assert_eq!(action.label, "Rewind Pi session");
9976 assert!(state.prepare_palette_action(action).is_none());
9977 assert!(state.command_mode);
9978 assert_eq!(state.command_input, "agent rewind ");
9979 assert!(state.status.contains("required value"));
9980
9981 std::fs::remove_dir_all(root).expect("remove temporary workspace");
9982 }
9983
9984 #[test]
9985 fn arrow_surface_cycle_matches_layout_order() {
9986 let root =
9987 std::env::temp_dir().join(format!("glass-surface-arrows-{}", std::process::id()));
9988 std::fs::create_dir_all(&root).expect("create temporary workspace");
9989 let mut desktop =
9990 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open desktop workspace");
9991 desktop.surface = DevSurface::Agent;
9992 desktop.next_surface();
9993 assert_eq!(desktop.surface, DevSurface::Code);
9994 assert_eq!(desktop.status, "Code selected");
9995 desktop.previous_surface();
9996 assert_eq!(desktop.surface, DevSurface::Agent);
9997 desktop.surface = DevSurface::Debug;
9998 desktop.next_surface();
9999 assert_eq!(desktop.surface, DevSurface::More);
10000 desktop.next_surface();
10001 assert_eq!(desktop.surface, DevSurface::Agent);
10002
10003 let mut phone =
10004 DevTuiState::open_for_tui(&root, TuiLayout::Mobile).expect("open phone workspace");
10005 phone.surface = DevSurface::Agent;
10006 phone.previous_surface();
10007 assert_eq!(phone.surface, DevSurface::More);
10008 assert_eq!(phone.status, "More selected");
10009 phone.next_surface();
10010 assert_eq!(phone.surface, DevSurface::Agent);
10011
10012 std::fs::remove_dir_all(root).expect("remove temporary workspace");
10013 }
10014
10015 #[test]
10016 fn composer_queues_follow_up_while_a_send_is_in_flight() {
10017 let root = std::env::temp_dir().join(format!("glass-follow-up-{}", std::process::id()));
10018 std::fs::create_dir_all(&root).expect("create temporary workspace");
10019 let mut state =
10020 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
10021 state.surface = DevSurface::Agent;
10022 state.snapshot_trust_label = "trusted".into();
10023 state.agent_readiness = "✓ Ready · Node ✓ · SDK 0.84.3 · auth ✓".into();
10024 state.agent_send_job = Some(9);
10025 state.open_composer();
10026 state.composer_input = "keep going".into();
10027 state.composer_cursor = state.composer_input.len();
10028 let mut worker = super::super::snapshot::SnapshotWorker::spawn(&state);
10029 state.submit_composer(&mut worker);
10030 assert_ne!(
10031 state.status,
10032 "Background operation running · message kept in composer"
10033 );
10034 assert!(
10035 state.status.contains("Queued follow-up")
10036 || state.status.contains("thinking")
10037 || state.status.contains("retry")
10038 || state.status.contains("Sent")
10039 );
10040 drop(worker);
10041 std::fs::remove_dir_all(root).expect("remove temporary workspace");
10042 }
10043
10044 #[test]
10045 fn composer_slash_compact_routes_to_pi_compact() {
10046 let root = std::env::temp_dir().join(format!("glass-slash-{}", std::process::id()));
10047 std::fs::create_dir_all(&root).expect("create temporary workspace");
10048 let mut state =
10049 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
10050 state.surface = DevSurface::Agent;
10051 state.snapshot_trust_label = "trusted".into();
10052 state.agent_readiness = "✓ Ready · Node ✓ · SDK 0.84.3 · auth ✓".into();
10053 state.open_composer();
10054 state.composer_input = "/compact keep the review".into();
10055 state.composer_cursor = state.composer_input.len();
10056 let mut worker = super::super::snapshot::SnapshotWorker::spawn(&state);
10057 state.submit_composer(&mut worker);
10058 assert!(
10059 state.status.contains("glass.agent.compact")
10060 || state.status.contains("unavailable")
10061 || state.status.contains("failed")
10062 );
10063 drop(worker);
10064 std::fs::remove_dir_all(root).expect("remove temporary workspace");
10065 }
10066
10067 #[test]
10068 fn transcript_fork_uses_selected_entry_id() {
10069 let root = std::env::temp_dir().join(format!("glass-fork-{}", std::process::id()));
10070 std::fs::create_dir_all(&root).expect("create temporary workspace");
10071 let mut state =
10072 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
10073 state.conversation_items = vec![super::super::projection::ConversationEntry {
10074 kind: super::super::projection::ConversationKind::User,
10075 text: "ship the review".into(),
10076 streaming: false,
10077 entry_id: Some("entry-7".into()),
10078 tool_name: None,
10079 }];
10080 state.transcript_selection = 0;
10081 let mut worker = super::super::snapshot::SnapshotWorker::spawn(&state);
10082 state.fork_selected_transcript(&mut worker);
10083 assert!(
10084 state.status.contains("entry-7")
10085 || state.status.contains("glass.agent.fork")
10086 || state.status.contains("branch")
10087 );
10088 drop(worker);
10089 std::fs::remove_dir_all(root).expect("remove temporary workspace");
10090 }
10091
10092 #[test]
10093 fn agent_chrome_and_session_picker_and_context_chips() {
10094 let root = std::env::temp_dir().join(format!("glass-chrome-{}", std::process::id()));
10095 std::fs::create_dir_all(&root).expect("create temporary workspace");
10096 let mut state =
10097 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
10098 state.agent_model = "xai/grok".into();
10099 state.agent_thinking = "medium".into();
10100 state.agent_session_name = "review".into();
10101 state.agent_token_summary = "12 in · 40 out".into();
10102 state.focused_editor_path = "src/lib.rs".into();
10103 state.composer_steer = true;
10104 let chrome = state.agent_chrome_line();
10105 assert!(chrome.contains("xai/grok"));
10106 assert!(chrome.contains("think medium"));
10107 assert!(chrome.contains("review"));
10108 assert!(chrome.contains("12 in"));
10109 assert!(state.composer_context_chips().contains("@src/lib.rs"));
10110 assert!(state.composer_context_chips().contains("steer"));
10111 state.open_session_picker(&serde_json::json!([
10112 {"path": "/tmp/alpha.jsonl", "name": "alpha"},
10113 {"path": "/tmp/beta.jsonl"}
10114 ]));
10115 assert!(state.session_picker_open);
10116 assert_eq!(state.session_picker_items[0].label, "alpha");
10117 assert_eq!(state.session_picker_items[1].label, "beta.jsonl");
10118 state.edit_last_user_message();
10119 state.conversation_items = vec![super::super::projection::ConversationEntry {
10120 kind: super::super::projection::ConversationKind::User,
10121 text: "previous prompt\n· sending…".into(),
10122 streaming: false,
10123 entry_id: Some("entry-1".into()),
10124 tool_name: None,
10125 }];
10126 state.edit_last_user_message();
10127 assert!(state.composer_mode);
10128 assert_eq!(state.composer_input, "previous prompt");
10129 std::fs::remove_dir_all(root).expect("remove temporary workspace");
10130 }
10131
10132 #[test]
10133 fn chat_dock_stays_on_code_and_app() {
10134 let root = std::env::temp_dir().join(format!("glass-dock-{}", std::process::id()));
10135 std::fs::create_dir_all(&root).expect("create temporary workspace");
10136 let mut state =
10137 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
10138 state.snapshot_trust_label = "trusted".into();
10139 state.agent_readiness = "✓ Ready · Node ✓ · SDK 0.84.3 · auth ✓".into();
10140 state.surface = DevSurface::Code;
10141 std::fs::create_dir_all(root.join("src")).expect("src");
10142 std::fs::write(root.join("src/lib.rs"), "fn main() {}\n").expect("write");
10143 state
10144 .ws_mut()
10145 .expect("lock")
10146 .project_mut()
10147 .open_buffer("src/lib.rs", crate::development::Actor::local())
10148 .expect("open buffer");
10149 state.refresh_editor_projection();
10150 state.prepare_editor_agent_prompt();
10151 assert_eq!(state.surface, DevSurface::Code);
10152 assert!(state.composer_mode);
10153 state.close_composer();
10154 state.surface = DevSurface::App;
10155 state.focus_composer_dock();
10156 assert_eq!(state.surface, DevSurface::App);
10157 assert!(state.composer_mode);
10158 state.cycle_composer_run_mode();
10159 assert_eq!(state.composer_run_mode, crate::AgentTurnMode::Ask);
10160 state.cycle_composer_run_mode();
10161 assert_eq!(state.composer_run_mode, crate::AgentTurnMode::Plan);
10162 state.capture_plan_from_goal("ship the checkout");
10163 state.pending_plan.as_mut().unwrap().body = "1. open App\n2. click Sign in".into();
10164 assert!(!state.pending_plan.as_ref().unwrap().accepted);
10165 std::fs::remove_dir_all(root).expect("remove temporary workspace");
10166 }
10167
10168 #[test]
10169 fn watching_agent_browser_act_enables_live_view() {
10170 let root = std::env::temp_dir().join(format!("glass-watch-{}", std::process::id()));
10171 std::fs::create_dir_all(&root).expect("create temporary workspace");
10172 let mut state =
10173 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
10174 state.watch_agent_on_app(
10175 "glass.browser.act",
10176 &serde_json::json!({"target": "Sign in"}),
10177 );
10178 assert!(state.browser_visual_live);
10179 assert!(state.status.contains("Sign in"));
10180 assert!(state.status.contains("watching"));
10181 std::fs::remove_dir_all(root).expect("remove temporary workspace");
10182 }
10183
10184 #[test]
10185 fn code_preview_queues_when_workspace_is_busy() {
10186 let root = std::env::temp_dir().join(format!("glass-open-busy-{}", std::process::id()));
10187 std::fs::create_dir_all(&root).expect("create temporary workspace");
10188 std::fs::write(root.join("notes.txt"), "hello\n").expect("write preview file");
10189 let mut state =
10190 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
10191 state.files = vec!["notes.txt".into()];
10192 let workspace = state.workspace.clone();
10193 let _guard = workspace.lock().expect("hold workspace lock");
10194
10195 state.show_surface(DevSurface::Code);
10196 assert_eq!(state.pending_open_file.as_deref(), Some("notes.txt"));
10197 assert!(state.status.contains("when the workspace is free"));
10198 assert!(
10199 !state.status.contains("Open failed"),
10200 "busy preview must queue instead of failing: {}",
10201 state.status
10202 );
10203
10204 drop(_guard);
10205 state.flush_pending_open_file();
10206 assert!(state.pending_open_file.is_none());
10207 assert_eq!(state.focused_editor_path, "notes.txt");
10208 std::fs::remove_dir_all(root).expect("remove temporary workspace");
10209 }
10210
10211 #[test]
10212 fn more_doctor_stays_on_more_and_git_loads_the_selected_diff() {
10213 let root = std::env::temp_dir().join(format!("glass-more-git-{}", std::process::id()));
10214 std::fs::create_dir_all(&root).expect("create temporary workspace");
10215 let mut state =
10216 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
10217 state
10218 .ws_mut()
10219 .expect("workspace lock")
10220 .apply_local_trust_decision(crate::LocalTrustDecision::TrustProject)
10221 .expect("trust project");
10222 state.snapshot_trust_label = "trusted-project".into();
10223
10224 state.show_surface(DevSurface::More);
10225 state.selected_more = 0;
10226 state.activate_more_selection();
10227 assert_eq!(state.surface, DevSurface::More);
10228 assert!(
10229 state.status.to_ascii_lowercase().contains("doctor")
10230 || state.status.contains("PI panel"),
10231 "doctor should stay on More: {}",
10232 state.status
10233 );
10234
10235 state.git_entries = vec![crate::git::GitStatusEntry {
10236 path: "notes.txt".into(),
10237 original_path: None,
10238 index_status: ' ',
10239 worktree_status: 'M',
10240 untracked: false,
10241 }];
10242 state.show_surface(DevSurface::Git);
10243 assert!(state.git_diff_requested);
10244 assert!(state.git_diff_open);
10245 assert!(state.git_diff.contains("Loading"));
10246 assert_eq!(state.git_diff_path.as_deref(), Some("notes.txt"));
10247 std::fs::remove_dir_all(root).expect("remove temporary workspace");
10248 }
10249}