glass-dev 0.3.5

Glass terminal-native development and browser workspace
Documentation
use super::state::{DevSurface, DevTuiState, ResponsiveClass};
use ratatui::Frame;
use ratatui::layout::{Constraint, Direction, Layout, Rect};
use ratatui::style::{Color, Modifier, Style};
use ratatui::text::{Line, Span};
use ratatui::widgets::{Block, Borders, List, ListItem, Paragraph, Wrap};

pub fn render(frame: &mut Frame<'_>, state: &DevTuiState) {
    let area = frame.area();
    match state.responsive_class(area.width, area.height) {
        ResponsiveClass::Desktop => render_desktop(frame, state, area),
        ResponsiveClass::Compact => render_compact(frame, state, area),
        ResponsiveClass::Phone => render_phone(frame, state, area),
    }
}

fn render_desktop(frame: &mut Frame<'_>, state: &DevTuiState, area: Rect) {
    let rows = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Length(2),
            Constraint::Min(8),
            Constraint::Length(2),
        ])
        .split(area);
    render_header(frame, state, rows[0], "desktop");
    let columns = Layout::default()
        .direction(Direction::Horizontal)
        .constraints([
            Constraint::Length(22),
            Constraint::Percentage(52),
            Constraint::Min(28),
        ])
        .split(rows[1]);
    render_navigation(frame, state, columns[0]);
    render_surface(frame, state, columns[1]);
    render_context(frame, state, columns[2]);
    render_status(frame, state, rows[2]);
}

fn render_compact(frame: &mut Frame<'_>, state: &DevTuiState, area: Rect) {
    let rows = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Length(2),
            Constraint::Min(8),
            Constraint::Length(2),
        ])
        .split(area);
    render_header(frame, state, rows[0], "compact");
    let columns = Layout::default()
        .direction(Direction::Horizontal)
        .constraints([Constraint::Length(20), Constraint::Min(36)])
        .split(rows[1]);
    render_navigation(frame, state, columns[0]);
    render_surface(frame, state, columns[1]);
    render_status(frame, state, rows[2]);
}

fn render_phone(frame: &mut Frame<'_>, state: &DevTuiState, area: Rect) {
    let rows = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Length(2),
            Constraint::Min(5),
            Constraint::Length(3),
        ])
        .split(area);
    render_header(frame, state, rows[0], "phone cockpit");
    render_surface(frame, state, rows[1]);
    let help = if state.command_mode {
        format!(":{}", state.command_input)
    } else {
        format!("{} · : actions · j/k views · q quit", state.surface.label())
    };
    frame.render_widget(
        Paragraph::new(help)
            .block(Block::default().borders(Borders::TOP))
            .wrap(Wrap { trim: true }),
        rows[2],
    );
}

fn render_header(frame: &mut Frame<'_>, state: &DevTuiState, area: Rect, mode: &str) {
    frame.render_widget(
        Paragraph::new(Line::from(vec![
            Span::styled(
                " GLASS DEV ",
                Style::default()
                    .fg(Color::Black)
                    .bg(Color::Cyan)
                    .add_modifier(Modifier::BOLD),
            ),
            Span::raw(format!(
                " {} · {} · {}",
                state.workspace.root().display(),
                state.surface.label(),
                mode
            )),
        ])),
        area,
    );
}

fn render_navigation(frame: &mut Frame<'_>, state: &DevTuiState, area: Rect) {
    let items = DevSurface::ALL.into_iter().map(|surface| {
        let marker = if surface == state.surface {
            "â—†"
        } else {
            "â—‹"
        };
        let style = if surface == state.surface {
            Style::default()
                .fg(Color::Cyan)
                .add_modifier(Modifier::BOLD)
        } else {
            Style::default()
        };
        ListItem::new(format!("{marker} {}", surface.label())).style(style)
    });
    frame.render_widget(
        List::new(items).block(Block::default().title(" Workspace ").borders(Borders::ALL)),
        area,
    );
}

fn render_surface(frame: &mut Frame<'_>, state: &DevTuiState, area: Rect) {
    let content = match state.surface {
        DevSurface::Trust => {
            let inspection = serde_json::to_string_pretty(&state.workspace.trust_inspection())
                .unwrap_or_else(|error| format!("inspection failed: {error}"));
            format!(
                "WORKSPACE TRUST\n\nThis repository contains executable Glass settings.\nCurrent state: {:?}\n\n[I] Inspect configuration\n[O] Open untrusted\n[1] Trust once\n[T] Trust this project\n\nCONFIGURATION BY AUTHORITY / RISK\n{}",
                state.workspace.trust(),
                inspection
            )
        }
        DevSurface::Dashboard => format!(
            "WORKSPACE STATUS\n{}\n\nTASK STATE\n{}\n\nAGENT ACTIVITY\n{}\n\nSEMANTIC / BROWSER STATE\n{}\n\nPROCESS / TEST HEALTH\n{}\n{}\n\nRECOVERY / TRUST DECISIONS\n{}\nOpen Trust or Daemon/Workspace for decisions and durable recovery.",
            state.workspace_status,
            state.tasks,
            state.agents,
            state.browser,
            state.processes,
            state.tests,
            state.status,
        ),
        DevSurface::Editor => format!(
            "SHARED BUFFERS\n{}\n\nActions: :editor open PATH · :editor replace PATH OLD NEW · :editor save PATH",
            state.editor
        ),
        DevSurface::Lsp => format!(
            "LANGUAGE SERVICES\n{}\n\nActions: :lsp start|stop|list|events|diagnostics|hover|complete|definition|references|symbols|rename",
            state.lsp
        ),
        DevSurface::Agent | DevSurface::Agents => state.agents.clone(),
        DevSurface::Tasks => format!(
            "TASK DAG\n\n{}\n\nActions: :task create|pause|resume|cancel|retry|reassign|override|evidence",
            state.tasks
        ),
        DevSurface::Processes => state.processes.clone(),
        DevSurface::Debugger => state.debugger.clone(),
        DevSurface::Git => state.git.clone(),
        DevSurface::Tests => state.tests.clone(),
        DevSurface::Experiments => state
            .experiment_comparison
            .as_ref()
            .and_then(|comparison| serde_json::to_string_pretty(comparison).ok())
            .map(|comparison| {
                format!(
                    "EXPERIMENTS\n{}\n\nEVIDENCE RANKING\n{}",
                    state.experiments, comparison
                )
            })
            .unwrap_or_else(|| state.experiments.clone()),
        DevSurface::Graph => format!(
            "CAUSAL DEVELOPMENT GRAPH\n\n{} replay events recorded\nUse governed tools to create source/runtime/test/debug/browser evidence paths.",
            state
                .workspace
                .intelligence()
                .replay(0, 4096)
                .map(|events| events.len())
                .unwrap_or(0)
        ),
        DevSurface::Replay => state.replay.clone(),
        DevSurface::Browser => format!(
            "AUTHORITATIVE BROWSER\n{}\n\nLATEST EVIDENCE\n{}\n\nActions: :browser start|stop|observe|targets|navigate|click|type",
            state.browser, state.browser_detail
        ),
        DevSurface::Workflow => format!(
            "BROWSER WORKFLOWS\n{}\n\nActions: :workflow run|pause|resume",
            state.workflow
        ),
        DevSurface::Kernels => format!(
            "PERSISTENT KERNELS\n{}\n\nActions: :kernel start|execute|cancel|reset|stop",
            state.kernels
        ),
        DevSurface::DaemonWorkspace => format!(
            "DURABLE WORKSPACE / RECOVERY\n{}\n\nRecovery: inspect task failures, process/test health, trust decisions, and reconnect to this stable workspace identity.",
            state.workspace_status
        ),
    };
    frame.render_widget(
        Paragraph::new(content)
            .block(
                Block::default()
                    .title(format!(" {} ", state.surface.label()))
                    .borders(Borders::ALL),
            )
            .wrap(Wrap { trim: false }),
        area,
    );
}

fn render_context(frame: &mut Frame<'_>, state: &DevTuiState, area: Rect) {
    let content = format!(
        "KERNELS\n{}\n\nDEBUGGERS\n{}\n\nCUSTOMIZATION\n{} skills · {} custom tools · config {}\n\nAUTHORITY\ntrust {:?}\ngeneration {}\nproject revision {}\nmutations require actor + revision + confirmation",
        state.kernels,
        state.debugger,
        state.workspace.customization().skills().count(),
        state.workspace.customization().config().tools.len(),
        state
            .workspace
            .customization()
            .config_path()
            .map(|path| path.display().to_string())
            .unwrap_or_else(|| "auto-detected".into()),
        state.workspace.trust(),
        state.workspace.generation(),
        state.workspace.project().revision()
    );
    frame.render_widget(
        Paragraph::new(content)
            .block(
                Block::default()
                    .title(" Live context ")
                    .borders(Borders::ALL),
            )
            .wrap(Wrap { trim: false }),
        area,
    );
}

fn render_status(frame: &mut Frame<'_>, state: &DevTuiState, area: Rect) {
    let content = if state.command_mode {
        format!(":{}", state.command_input)
    } else {
        state.status.clone()
    };
    frame.render_widget(
        Paragraph::new(content).style(Style::default().fg(Color::Yellow)),
        area,
    );
}

#[cfg(test)]
mod tests {
    use super::*;
    use glass_browser::cli::args::TuiLayout;
    use ratatui::Terminal;
    use ratatui::backend::TestBackend;
    use std::sync::atomic::{AtomicU64, Ordering};

    static NEXT_ROOT: AtomicU64 = AtomicU64::new(0);

    fn state(layout: TuiLayout) -> DevTuiState {
        let sequence = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
        let root =
            std::env::temp_dir().join(format!("glass-dev-tui-{}-{sequence}", std::process::id()));
        std::fs::create_dir_all(&root).unwrap();
        std::fs::write(
            root.join("Cargo.toml"),
            "[package]\nname='x'\nversion='0.1.0'\n",
        )
        .unwrap();
        DevTuiState::open(root, layout).unwrap()
    }

    fn rendered(state: &DevTuiState, width: u16, height: u16) -> String {
        let backend = TestBackend::new(width, height);
        let mut terminal = Terminal::new(backend).unwrap();
        terminal.draw(|frame| render(frame, state)).unwrap();
        terminal
            .backend()
            .buffer()
            .content()
            .iter()
            .map(|cell| cell.symbol())
            .collect::<String>()
    }

    #[test]
    fn desktop_and_phone_prioritize_resident_workspace_state() {
        for (width, height, layout) in [(140, 40, TuiLayout::Desktop), (48, 18, TuiLayout::Mobile)]
        {
            let state = state(layout);
            let rendered = rendered(&state, width, height);
            assert!(rendered.contains("GLASS DEV"));
            assert!(rendered.contains("Dashboard"));
            assert!(rendered.contains("WORKSPACE STATUS"));
            assert!(rendered.contains("generation"));
        }
    }

    #[test]
    fn desktop_compact_and_phone_can_drill_into_every_required_surface() {
        for (width, height, layout) in [
            (140, 40, TuiLayout::Desktop),
            (90, 28, TuiLayout::Compact),
            (64, 24, TuiLayout::Mobile),
        ] {
            let mut state = state(layout);
            for surface in DevSurface::ALL {
                state.surface = surface;
                let output = rendered(&state, width, height);
                assert!(
                    output.contains(surface.label()),
                    "{} layout did not expose {}",
                    match layout {
                        TuiLayout::Desktop => "desktop",
                        TuiLayout::Compact => "compact",
                        TuiLayout::Mobile => "phone",
                        TuiLayout::Auto => "auto",
                    },
                    surface.label()
                );
            }
        }
    }

    #[test]
    fn executable_project_configuration_prompts_on_phone_before_activation() {
        let sequence = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
        let root = std::env::temp_dir().join(format!(
            "glass-dev-tui-trust-{}-{sequence}",
            std::process::id()
        ));
        std::fs::create_dir_all(&root).unwrap();
        std::fs::write(
            root.join("glass.toml"),
            "[tools.probe]\ndescription='probe'\ncommand='echo unsafe'\n",
        )
        .unwrap();
        let mut state = DevTuiState::open(&root, TuiLayout::Mobile).unwrap();
        assert_eq!(state.surface, DevSurface::Trust);
        let rendered = rendered(&state, 64, 24);
        assert!(rendered.contains("WORKSPACE TRUST"));
        assert!(rendered.contains("Open untrusted"));
        state.handle_printable('O');
        assert_eq!(state.workspace.trust(), crate::WorkspaceTrust::Untrusted);
        assert_eq!(state.surface, DevSurface::Dashboard);
        std::fs::remove_dir_all(root).unwrap();
    }
}