use super::command;
use crate::{DevelopmentWorkspace, ExperimentComparison};
use glass_browser::cli::args::TuiLayout;
use serde::{Deserialize, Serialize};
use std::path::Path;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum DevSurface {
Trust,
Dashboard,
Editor,
Lsp,
Agent,
Agents,
Tasks,
Processes,
Debugger,
Git,
Tests,
Experiments,
Graph,
Replay,
Browser,
Workflow,
Kernels,
DaemonWorkspace,
}
impl DevSurface {
pub const ALL: [Self; 18] = [
Self::Trust,
Self::Dashboard,
Self::Editor,
Self::Lsp,
Self::Agent,
Self::Agents,
Self::Tasks,
Self::Processes,
Self::Debugger,
Self::Git,
Self::Tests,
Self::Experiments,
Self::Graph,
Self::Replay,
Self::Browser,
Self::Workflow,
Self::Kernels,
Self::DaemonWorkspace,
];
pub fn label(self) -> &'static str {
match self {
Self::Trust => "Trust",
Self::Dashboard => "Dashboard",
Self::Editor => "Editor",
Self::Lsp => "LSP",
Self::Agent => "Glass Agent",
Self::Agents => "Agents",
Self::Tasks => "Tasks",
Self::Processes => "Processes",
Self::Debugger => "Debugger",
Self::Git => "Git",
Self::Tests => "Tests",
Self::Experiments => "Experiments",
Self::Graph => "Graph",
Self::Replay => "Replay",
Self::Browser => "Browser",
Self::Workflow => "Workflow",
Self::Kernels => "Kernels",
Self::DaemonWorkspace => "Daemon/Workspace",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ResponsiveClass {
Desktop,
Compact,
Phone,
}
pub struct DevTuiState {
pub workspace: DevelopmentWorkspace,
pub surface: DevSurface,
pub layout: TuiLayout,
pub quit: bool,
pub command_mode: bool,
pub command_input: String,
pub status: String,
pub agents: String,
pub tasks: String,
pub editor: String,
pub lsp: String,
pub processes: String,
pub git: String,
pub tests: String,
pub kernels: String,
pub debugger: String,
pub replay: String,
pub browser: String,
pub browser_detail: String,
pub workflow: String,
pub workspace_status: String,
pub experiment_comparison: Option<ExperimentComparison>,
pub experiments: String,
}
impl DevTuiState {
pub fn open(
root: impl AsRef<Path>,
layout: TuiLayout,
) -> Result<Self, Box<dyn std::error::Error>> {
let workspace = DevelopmentWorkspace::open(root)?;
let trust_prompt = workspace.trust() == crate::WorkspaceTrust::Untrusted
&& workspace
.trust_inspection()
.iter()
.any(|item| item.trust_required);
let mut state = Self {
workspace,
surface: if trust_prompt {
DevSurface::Trust
} else {
DevSurface::Dashboard
},
layout,
quit: false,
command_mode: false,
command_input: String::new(),
status: if trust_prompt {
"Workspace trust required · I inspect · O untrusted · 1 trust once · T trust project".into()
} else {
"Ready · : opens the command palette · q quits".into()
},
agents: String::new(),
tasks: String::new(),
editor: String::new(),
lsp: String::new(),
processes: String::new(),
git: String::new(),
tests: String::new(),
kernels: String::new(),
debugger: String::new(),
replay: String::new(),
browser: String::new(),
browser_detail: "No browser observation yet".into(),
workflow: "No workflow evidence yet".into(),
workspace_status: String::new(),
experiment_comparison: None,
experiments: "No experiments. :experiment create ID BRANCH [PORT]".into(),
};
state.refresh();
Ok(state)
}
pub fn responsive_class(&self, width: u16, height: u16) -> ResponsiveClass {
match self.layout {
TuiLayout::Desktop => ResponsiveClass::Desktop,
TuiLayout::Compact => ResponsiveClass::Compact,
TuiLayout::Mobile => ResponsiveClass::Phone,
TuiLayout::Auto if width < 72 || height < 22 => ResponsiveClass::Phone,
TuiLayout::Auto if width < 118 || height < 32 => ResponsiveClass::Compact,
TuiLayout::Auto => ResponsiveClass::Desktop,
}
}
pub fn open_palette(&mut self) {
self.command_mode = true;
self.command_input.clear();
self.status = "Command palette · type help for routes".into();
}
pub fn close_palette(&mut self) {
self.command_mode = false;
self.command_input.clear();
self.status = "Command cancelled".into();
}
pub fn submit_palette(&mut self) {
let input = std::mem::take(&mut self.command_input);
self.command_mode = false;
match command::execute(self, &input) {
Ok(message) => self.status = message,
Err(error) => self.status = format!("Error: {error}"),
}
self.refresh();
}
pub fn handle_printable(&mut self, character: char) {
if self.surface == DevSurface::Trust {
let decision = match character {
'i' | 'I' => {
self.status = "Inspecting exact repository configuration".into();
return;
}
'o' | 'O' => Some(crate::LocalTrustDecision::OpenUntrusted),
'1' => Some(crate::LocalTrustDecision::TrustOnce),
'T' => Some(crate::LocalTrustDecision::TrustProject),
_ => None,
};
if let Some(decision) = decision {
match self.workspace.apply_local_trust_decision(decision) {
Ok(trust) => {
self.surface = DevSurface::Dashboard;
self.status = format!("Workspace opened with {trust:?} authority");
}
Err(error) => self.status = format!("Trust decision failed: {error}"),
}
return;
}
}
let surface = match character {
'u' => Some(DevSurface::Trust),
'h' => Some(DevSurface::Dashboard),
'e' => Some(DevSurface::Editor),
'l' => Some(DevSurface::Lsp),
'a' => Some(DevSurface::Agent),
'm' => Some(DevSurface::Agents),
'w' => Some(DevSurface::Tasks),
'p' => Some(DevSurface::Processes),
'd' => Some(DevSurface::Debugger),
'g' => Some(DevSurface::Git),
't' => Some(DevSurface::Tests),
'x' => Some(DevSurface::Experiments),
'n' => Some(DevSurface::Graph),
'r' => Some(DevSurface::Replay),
'b' => Some(DevSurface::Browser),
'f' => Some(DevSurface::Workflow),
'k' => Some(DevSurface::Kernels),
'z' => Some(DevSurface::DaemonWorkspace),
_ => None,
};
if let Some(surface) = surface {
self.surface = surface;
self.status = format!("{} · : for actions", surface.label());
}
}
pub fn next_surface(&mut self) {
let index = DevSurface::ALL
.iter()
.position(|surface| *surface == self.surface)
.unwrap_or(0);
self.surface = DevSurface::ALL[(index + 1) % DevSurface::ALL.len()];
}
pub fn previous_surface(&mut self) {
let index = DevSurface::ALL
.iter()
.position(|surface| *surface == self.surface)
.unwrap_or(0);
self.surface = DevSurface::ALL[(index + DevSurface::ALL.len() - 1) % DevSurface::ALL.len()];
}
pub fn refresh(&mut self) {
self.agents = match self.workspace.agents().list() {
Ok(agents) if agents.is_empty() => "No agents. :agent spawn ROLE TASK".into(),
Ok(agents) => agents
.iter()
.map(|agent| {
format!(
"{} {:?} {} · {}\n target {} · model {} · thinking {} · events {} · dropped {}{}\n evidence {}",
agent.id.as_str(),
agent.status,
agent.role,
agent.task,
agent.worktree.display(),
agent.model.as_deref().unwrap_or("default"),
agent.thinking.as_deref().unwrap_or("default"),
agent.event_count,
agent.dropped_event_count,
agent
.last_error
.as_deref()
.map(|error| format!(" · {error}"))
.unwrap_or_default(),
agent
.evidence
.iter()
.rev()
.take(3)
.map(|evidence| evidence.to_string())
.collect::<Vec<_>>()
.join(" · ")
)
})
.collect::<Vec<_>>()
.join("\n\n"),
Err(error) => format!("Agent registry failed: {error}"),
};
self.tasks = match self.workspace.tasks() {
Ok(tasks) if tasks.is_empty() => {
"No tasks. :task create TITLE PROMPT creates an autonomous task".into()
}
Ok(tasks) => tasks
.iter()
.map(|task| {
format!(
"{} {:?} {}\n goal {}\n agent {} · attempt {} · model {} · thinking {}\n depends {}\n verification {}{}\n evidence {}",
task.id.as_str(),
task.state,
task.title,
task.goal,
task.assigned_agent
.as_ref()
.map(|agent| agent.as_str())
.unwrap_or("unassigned"),
task.attempt,
task.model.as_deref().unwrap_or("default"),
task.thinking.as_deref().unwrap_or("default"),
task.dependencies
.iter()
.map(|dependency| dependency.as_str())
.collect::<Vec<_>>()
.join(", "),
serde_json::to_string(&task.verification).unwrap_or_default(),
task.last_error
.as_deref()
.map(|error| format!(" · {error}"))
.unwrap_or_default(),
task.evidence
.iter()
.rev()
.take(3)
.map(|evidence| format!("{}={:?}", evidence.kind, evidence.passed))
.collect::<Vec<_>>()
.join(" · ")
)
})
.collect::<Vec<_>>()
.join("\n\n"),
Err(error) => format!("Task scheduler failed: {error}"),
};
self.processes = self
.workspace
.project_mut()
.processes()
.list_checked()
.and_then(|items| serde_json::to_string_pretty(&items).map_err(Into::into))
.unwrap_or_else(|error| format!("Process state failed: {error}"));
self.editor = serde_json::to_string_pretty(
&self
.workspace
.project()
.buffers()
.cloned()
.collect::<Vec<_>>(),
)
.unwrap_or_else(|error| format!("Editor state failed: {error}"));
self.lsp = {
let language = self.workspace.language();
serde_json::to_string_pretty(&serde_json::json!({
"servers": language.names().collect::<Vec<_>>(),
"events": language.events(0).into_iter().rev().take(32).collect::<Vec<_>>()
}))
.unwrap_or_else(|error| format!("LSP state failed: {error}"))
};
self.git = self
.workspace
.git()
.map(|git| match git.status() {
Ok(status) => serde_json::to_string_pretty(&status)
.unwrap_or_else(|error| format!("Git serialization failed: {error}")),
Err(error) => format!("Git state failed: {error}"),
})
.unwrap_or_else(|| "Not a Git repository".into());
let _ = self.workspace.tests_mut().poll();
self.tests = serde_json::to_string_pretty(
&self
.workspace
.tests()
.results()
.rev()
.take(32)
.collect::<Vec<_>>(),
)
.unwrap_or_else(|error| error.to_string());
self.kernels =
serde_json::to_string_pretty(&self.workspace.kernels().snapshots().collect::<Vec<_>>())
.unwrap_or_else(|error| error.to_string());
let debugger_names = self
.workspace
.debugger_names()
.map(str::to_string)
.collect::<Vec<_>>();
self.debugger = if debugger_names.is_empty() {
"No debugger sessions. :debug start NAME COMMAND [ARGS...]".into()
} else {
let snapshots = debugger_names
.iter()
.map(|name| {
self.workspace
.debugger_mut(name)
.and_then(|debugger| debugger.snapshot())
.map(|snapshot| (name, snapshot))
})
.collect::<Result<Vec<_>, _>>();
match snapshots {
Ok(snapshots) => serde_json::to_string_pretty(&snapshots)
.unwrap_or_else(|error| format!("Debugger serialization failed: {error}")),
Err(error) => format!("Debugger state failed: {error}"),
}
};
self.replay = self
.workspace
.intelligence()
.replay(0, 128)
.and_then(|events| serde_json::to_string_pretty(&events).map_err(Into::into))
.unwrap_or_else(|error| format!("Replay failed: {error}"));
self.browser = self
.workspace
.browser()
.state()
.and_then(|state| serde_json::to_string_pretty(&state).map_err(Into::into))
.unwrap_or_else(|error| format!("Browser state failed: {error}"));
self.workflow = self
.workspace
.browser()
.list_workflows()
.and_then(|state| serde_json::to_string_pretty(&state).map_err(Into::into))
.unwrap_or_else(|error| format!("Workflow state failed: {error}"));
let root = self.workspace.root().display().to_string();
let generation = self.workspace.generation();
let project_revision = self.workspace.project().revision();
let trust = self.workspace.trust();
let agent_count = self
.workspace
.agents()
.list()
.map(|items| items.len())
.unwrap_or(0);
let task_count = self.workspace.tasks().map(|items| items.len()).unwrap_or(0);
let kernel_count = self.workspace.kernels().snapshots().count();
let debugger_count = self.workspace.debugger_names().count();
self.workspace_status = format!(
"root {}\ngeneration {}\nproject revision {}\ntrust {:?}\nresident resources: {} agents · {} tasks · {} kernels · {} debuggers",
root,
generation,
project_revision,
trust,
agent_count,
task_count,
kernel_count,
debugger_count,
);
if self.workspace.trust().permits_project_execution()
&& let Ok(experiments) = self.workspace.experiments()
{
self.experiments = serde_json::to_string_pretty(&experiments.snapshots())
.unwrap_or_else(|error| format!("Experiment state failed: {error}"));
self.experiment_comparison = Some(experiments.compare());
}
}
}