ctate 0.0.0 → 0.1.0

package/src/main.rs

@@ -0,0 +1,1194 @@
+use std::{env, io, panic, time::Duration};
+
+use crossterm::{
+    event::{self, Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers},
+    execute,
+    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+};
+use ratatui::{
+    backend::CrosstermBackend,
+    layout::{Constraint, Direction, Layout, Rect},
+    style::{Color, Modifier, Style},
+    text::{Line, Span},
+    widgets::{Block, Borders, Cell, Paragraph, Row, Table, TableState, Wrap},
+    Frame, Terminal,
+};
+
+type AppResult<T> = Result<T, Box<dyn std::error::Error>>;
+
+const GITHUB_URL: &str = "https://github.com/ctate";
+const GITHUB_DISPLAY_URL: &str = "github.com/ctate";
+const X_URL: &str = "https://x.com/ctatedev";
+const X_DISPLAY_URL: &str = "x.com/ctatedev";
+const TAGLINE: &str = "Building for the web since 1997";
+const SHIP_LIST_TITLE: &str = "RECENT SHIPS AT \u{25b2} ";
+const HEADER_WIDTH: u16 = 78;
+const LIST_WIDTH: u16 = HEADER_WIDTH + 2;
+const SCROLLBAR_GAP_WIDTH: u16 = 1;
+const SCROLLBAR_WIDTH: u16 = 1;
+const MAX_APP_WIDTH: u16 = LIST_WIDTH + SCROLLBAR_GAP_WIDTH + SCROLLBAR_WIDTH;
+const LOGO_HEIGHT: u16 = 6;
+const LOGO_BOTTOM_SPACER_HEIGHT: u16 = 1;
+const HEADER_HEIGHT: u16 = LOGO_HEIGHT + LOGO_BOTTOM_SPACER_HEIGHT + 1;
+const VISIBLE_PROJECT_ROWS: u16 = 16;
+const PROJECT_TABLE_HEIGHT: u16 = VISIBLE_PROJECT_ROWS + 1;
+const TABLE_TOP_SPACER_HEIGHT: u16 = 1;
+const MAX_APP_HEIGHT: u16 = HEADER_HEIGHT + TABLE_TOP_SPACER_HEIGHT + PROJECT_TABLE_HEIGHT;
+const LOGO_LINES: &[&str] = &[
+    "              ██                      ██",
+    "  ██████      ██        ██████        ██        ██████",
+    "██        ██████████          ██  ██████████  ██      ██",
+    "██            ██        ████████      ██      ██████████",
+    "██            ██      ██      ██      ██      ██",
+    "  ██████        ████    ████████        ████    ████████",
+];
+
+#[derive(Clone, Copy)]
+struct Project {
+    name: &'static str,
+    kind: &'static str,
+    url: &'static str,
+}
+
+const PROJECTS: &[Project] = &[
+    Project {
+        name: "zerolang",
+        kind: "Language",
+        url: "https://zerolang.ai",
+    },
+    Project {
+        name: "Markdown Experience Guidelines",
+        kind: "Specification",
+        url: "https://mdxg.org",
+    },
+    Project {
+        name: "zero-native",
+        kind: "Framework",
+        url: "https://zero-native.dev",
+    },
+    Project {
+        name: "wterm",
+        kind: "Library",
+        url: "https://wterm.dev",
+    },
+    Project {
+        name: "emulate",
+        kind: "Library",
+        url: "https://emulate.dev",
+    },
+    Project {
+        name: "webreel",
+        kind: "Library",
+        url: "https://webreel.dev",
+    },
+    Project {
+        name: "visual-json",
+        kind: "Library",
+        url: "https://visual-json.dev",
+    },
+    Project {
+        name: "portless",
+        kind: "Library",
+        url: "https://port1355.dev",
+    },
+    Project {
+        name: "json-render",
+        kind: "Library",
+        url: "https://json-render.dev",
+    },
+    Project {
+        name: "agent-browser",
+        kind: "Library",
+        url: "https://agent-browser.dev",
+    },
+    Project {
+        name: "opensrc",
+        kind: "Library",
+        url: "https://github.com/vercel-labs/opensrc",
+    },
+    Project {
+        name: "ralph-loop-agent",
+        kind: "Library",
+        url: "https://github.com/vercel-labs/ralph-loop-agent",
+    },
+    Project {
+        name: "Workflow Builder",
+        kind: "Template",
+        url: "https://workflow-builder.dev/",
+    },
+    Project {
+        name: "Coding Agent Platform",
+        kind: "Template",
+        url: "https://coding-agent-platform.vercel.sh/",
+    },
+    Project {
+        name: "vterm",
+        kind: "Web App",
+        url: "https://vterm.dev/",
+    },
+    Project {
+        name: "Type-Z",
+        kind: "Game",
+        url: "https://type-z.ctate.dev/",
+    },
+    Project {
+        name: "v0 Platform API",
+        kind: "API",
+        url: "https://v0.app/docs/api/platform",
+    },
+    Project {
+        name: "v0 Model API",
+        kind: "API",
+        url: "https://v0.app/docs/api/model",
+    },
+    Project {
+        name: "v0 SDK",
+        kind: "Library",
+        url: "https://www.npmjs.com/package/v0-sdk",
+    },
+    Project {
+        name: "v0 SDK Playground",
+        kind: "Web App",
+        url: "https://playground.v0-sdk.dev/",
+    },
+    Project {
+        name: "v0 Clone",
+        kind: "Template",
+        url: "https://clone-demo.v0-sdk.dev/",
+    },
+    Project {
+        name: "Liquid Glass",
+        kind: "Template",
+        url: "https://v0.app/templates/liquid-glass-2Tyr62QLwAT",
+    },
+    Project {
+        name: "3D Maze",
+        kind: "Art",
+        url: "https://x.com/ctatedev/status/1853791722196615325",
+    },
+    Project {
+        name: "Tetrahedron Physics",
+        kind: "Art",
+        url: "https://tetrahedron-physics.ctate.dev/",
+    },
+    Project {
+        name: "Classic v0",
+        kind: "Template",
+        url: "https://x.com/ctatedev/status/1960785629501120779",
+    },
+    Project {
+        name: "Simple v0",
+        kind: "Template",
+        url: "https://simple-demo.v0-sdk.dev/",
+    },
+    Project {
+        name: "v0 MCP",
+        kind: "MCP",
+        url: "https://mcp.v0.dev/",
+    },
+    Project {
+        name: "@v0-sdk/ai-tools",
+        kind: "Package",
+        url: "https://www.npmjs.com/package/@v0-sdk/ai-tools",
+    },
+    Project {
+        name: "OpenUI",
+        kind: "Specification",
+        url: "https://openuispec.org/",
+    },
+    Project {
+        name: "Next.js Conf 2024",
+        kind: "Art",
+        url: "https://nextjs-conf-2024.ctate.dev/",
+    },
+    Project {
+        name: "Halftone Waves",
+        kind: "Art",
+        url: "https://halftone-waves.ctate.dev/",
+    },
+    Project {
+        name: "Neon Maze",
+        kind: "Art",
+        url: "https://neon-maze.ctate.dev/",
+    },
+    Project {
+        name: "SEV0",
+        kind: "Game",
+        url: "https://x.com/ctatedev/status/1907498490370068606",
+    },
+    Project {
+        name: "v0 CLI",
+        kind: "Concept",
+        url: "https://x.com/ctatedev/status/1962322136724373651",
+    },
+    Project {
+        name: "3D Model Generator",
+        kind: "Web App",
+        url: "https://3d-model-generator.ctate.dev/",
+    },
+    Project {
+        name: "p0",
+        kind: "Template",
+        url: "https://v0.app/chat/templates/p0-minimalist-linear-task-list-hvjn7tu440z",
+    },
+    Project {
+        name: "VS Code extension for v0",
+        kind: "Extension",
+        url: "https://x.com/ctatedev/status/1875380513869066695",
+    },
+    Project {
+        name: "Image to SVG",
+        kind: "Template",
+        url: "https://v0.app/templates/image-to-svg-v0xdBJ3LNVP",
+    },
+    Project {
+        name: "Prompting Is All You Need",
+        kind: "Template",
+        url: "https://prompting-is-all-you-need.ctate.dev/",
+    },
+    Project {
+        name: "We're Snow Back",
+        kind: "Game",
+        url: "https://snow-back.ctate.dev/",
+    },
+    Project {
+        name: "Audio Visualizer",
+        kind: "Template",
+        url: "https://v0.app/templates/audio-visualizer-eGfAJ9Uw70W",
+    },
+];
+
+struct App {
+    state: TableState,
+    theme: TerminalTheme,
+    status: String,
+    should_quit: bool,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum TerminalTheme {
+    Dark,
+    Light,
+}
+
+impl App {
+    fn new() -> Self {
+        let mut state = TableState::default();
+        state.select(Some(0));
+
+        Self {
+            state,
+            theme: detect_terminal_theme(),
+            status: "Select a ship and press Enter to open it.".to_string(),
+            should_quit: false,
+        }
+    }
+
+    fn run(&mut self, terminal: &mut Terminal<CrosstermBackend<io::Stdout>>) -> AppResult<()> {
+        while !self.should_quit {
+            terminal.draw(|frame| self.render(frame))?;
+
+            if event::poll(Duration::from_millis(200))? {
+                if let Event::Key(key) = event::read()? {
+                    if key.kind == KeyEventKind::Press {
+                        self.handle_key(key);
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn render(&mut self, frame: &mut Frame<'_>) {
+        let areas = screen_areas(frame.area());
+        let area = centered_area(areas.content, MAX_APP_WIDTH, MAX_APP_HEIGHT);
+        let app_areas = app_layout_areas(area);
+
+        let mut header_lines = LOGO_LINES
+            .iter()
+            .map(|line| Line::from(Span::styled(*line, logo_style(self.theme))))
+            .collect::<Vec<_>>();
+        header_lines.push(Line::raw(""));
+        header_lines.push(metadata_line(app_areas.header.width));
+
+        let header = Paragraph::new(header_lines).wrap(Wrap { trim: false });
+        frame.render_widget(header, app_areas.header);
+
+        let selected = self.selected();
+        let selected_style = selected_row_style(self.theme);
+        let rows = PROJECTS.iter().enumerate().map(|(index, project)| {
+            let is_selected = index == selected;
+            let name_style = if is_selected {
+                selected_style
+            } else {
+                Style::default()
+            };
+            let kind_style = if is_selected {
+                selected_style
+            } else {
+                project_kind_style()
+            };
+
+            Row::new(vec![
+                Cell::from(project.name).style(name_style),
+                Cell::from(project.kind).style(kind_style),
+            ])
+        });
+
+        let table = Table::new(rows, [Constraint::Min(18), Constraint::Length(15)])
+            .block(
+                Block::default()
+                    .borders(Borders::TOP)
+                    .border_style(Style::default().add_modifier(Modifier::DIM))
+                    .title(Line::from(Span::styled(
+                        SHIP_LIST_TITLE,
+                        Style::default().add_modifier(Modifier::DIM),
+                    ))),
+            )
+            .row_highlight_style(selected_style);
+        frame.render_stateful_widget(table, app_areas.table, &mut self.state);
+        frame.render_widget(
+            scroll_indicator(
+                PROJECTS.len(),
+                app_areas.visible_rows as usize,
+                app_areas.scroll.height,
+                self.state.offset(),
+            ),
+            app_areas.scroll,
+        );
+
+        let footer_style = status_bar_style(self.theme);
+        let footer_key_style = footer_style.add_modifier(Modifier::BOLD);
+        let shortcuts = vec![
+            Span::styled("Enter", footer_key_style),
+            Span::styled(" open  ", footer_style),
+            Span::styled("g", footer_key_style),
+            Span::styled(" github  ", footer_style),
+            Span::styled("x", footer_key_style),
+            Span::styled(" x.com  ", footer_style),
+            Span::styled("q", footer_key_style),
+            Span::styled(" quit", footer_style),
+        ];
+        let footer = Paragraph::new(status_line(
+            areas.status.width,
+            shortcuts,
+            &self.status,
+            footer_style,
+        ))
+        .style(footer_style);
+        frame.render_widget(footer, areas.status);
+    }
+
+    fn handle_key(&mut self, key: KeyEvent) {
+        match key.code {
+            KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => {
+                self.should_quit = true;
+            }
+            KeyCode::Char('q') | KeyCode::Esc => self.should_quit = true,
+            KeyCode::Down | KeyCode::Char('j') => self.next(),
+            KeyCode::Up | KeyCode::Char('k') => self.previous(),
+            KeyCode::PageDown => self.move_by(8),
+            KeyCode::PageUp => self.move_by(-8),
+            KeyCode::Home => self.select(0),
+            KeyCode::End => self.select(PROJECTS.len().saturating_sub(1)),
+            KeyCode::Enter => self.open_selected(),
+            KeyCode::Char(character) => {
+                if let Some((label, url)) = shortcut_url(character) {
+                    self.open_url(label, url);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn selected(&self) -> usize {
+        self.state.selected().unwrap_or(0)
+    }
+
+    fn select(&mut self, index: usize) {
+        self.state
+            .select(Some(index.min(PROJECTS.len().saturating_sub(1))));
+    }
+
+    fn next(&mut self) {
+        let next = (self.selected() + 1) % PROJECTS.len();
+        self.select(next);
+    }
+
+    fn previous(&mut self) {
+        let previous = self
+            .selected()
+            .checked_sub(1)
+            .unwrap_or_else(|| PROJECTS.len().saturating_sub(1));
+        self.select(previous);
+    }
+
+    fn move_by(&mut self, delta: isize) {
+        let selected = self.selected() as isize;
+        let max = PROJECTS.len().saturating_sub(1) as isize;
+        let next = (selected + delta).clamp(0, max);
+        self.select(next as usize);
+    }
+
+    fn open_selected(&mut self) {
+        let project = PROJECTS[self.selected()];
+        self.open_url(project.name, project.url);
+    }
+
+    fn open_url(&mut self, label: &str, url: &str) {
+        match webbrowser::open(url) {
+            Ok(_) => {
+                self.status = format!("Opened {label}: {url}");
+            }
+            Err(error) => {
+                self.status = format!("Could not open {label}: {error}");
+            }
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+struct ScreenAreas {
+    content: Rect,
+    status: Rect,
+}
+
+#[derive(Clone, Copy)]
+struct AppLayoutAreas {
+    header: Rect,
+    table: Rect,
+    scroll: Rect,
+    visible_rows: u16,
+}
+
+fn screen_areas(area: Rect) -> ScreenAreas {
+    let chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([Constraint::Min(0), Constraint::Length(1)])
+        .split(area);
+
+    ScreenAreas {
+        content: chunks[0],
+        status: chunks[1],
+    }
+}
+
+fn app_layout_areas(area: Rect) -> AppLayoutAreas {
+    let spacer_height = table_top_spacer_height(area.height);
+    let table_height = project_table_height(area.height, spacer_height);
+    let chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([
+            Constraint::Length(HEADER_HEIGHT),
+            Constraint::Length(spacer_height),
+            Constraint::Length(table_height),
+            Constraint::Min(0),
+        ])
+        .split(area);
+    let table_chunks = Layout::default()
+        .direction(Direction::Horizontal)
+        .constraints([
+            Constraint::Min(1),
+            Constraint::Length(SCROLLBAR_GAP_WIDTH),
+            Constraint::Length(SCROLLBAR_WIDTH),
+        ])
+        .split(chunks[2]);
+    let header_area = Rect {
+        y: chunks[0].y,
+        height: chunks[0].height,
+        ..table_chunks[0]
+    };
+
+    AppLayoutAreas {
+        header: left_aligned_width(header_area, HEADER_WIDTH),
+        table: table_chunks[0],
+        scroll: table_chunks[2],
+        visible_rows: table_height.saturating_sub(1).min(VISIBLE_PROJECT_ROWS),
+    }
+}
+
+fn table_top_spacer_height(area_height: u16) -> u16 {
+    let compact_height = HEADER_HEIGHT + PROJECT_TABLE_HEIGHT;
+
+    if area_height >= compact_height + TABLE_TOP_SPACER_HEIGHT {
+        TABLE_TOP_SPACER_HEIGHT
+    } else {
+        0
+    }
+}
+
+fn project_table_height(area_height: u16, spacer_height: u16) -> u16 {
+    area_height
+        .saturating_sub(HEADER_HEIGHT + spacer_height)
+        .min(PROJECT_TABLE_HEIGHT)
+}
+
+fn centered_area(area: Rect, max_width: u16, max_height: u16) -> Rect {
+    let width = area.width.min(max_width);
+    let height = area.height.min(max_height);
+
+    Rect {
+        x: area.x + area.width.saturating_sub(width) / 2,
+        y: area.y + area.height.saturating_sub(height) / 2,
+        width,
+        height,
+    }
+}
+
+fn left_aligned_width(area: Rect, max_width: u16) -> Rect {
+    let width = area.width.min(max_width);
+
+    Rect { width, ..area }
+}
+
+fn scroll_indicator(
+    total_rows: usize,
+    visible_rows: usize,
+    height: u16,
+    window_start: usize,
+) -> Paragraph<'static> {
+    let lines = scroll_indicator_lines(total_rows, visible_rows, height, window_start)
+        .into_iter()
+        .map(Line::from)
+        .collect::<Vec<_>>();
+
+    Paragraph::new(lines)
+}
+
+fn scroll_indicator_lines(
+    total_rows: usize,
+    visible_rows: usize,
+    height: u16,
+    window_start: usize,
+) -> Vec<Span<'static>> {
+    let height = height as usize;
+    if height == 0 {
+        return Vec::new();
+    }
+
+    let window_start = window_start.min(total_rows.saturating_sub(visible_rows));
+    let hidden_above = window_start > 0;
+    let hidden_below = window_start + visible_rows < total_rows;
+    let mut cells = vec![Span::raw(" "); height];
+    let marker_style = Style::default().add_modifier(Modifier::DIM);
+
+    if hidden_above {
+        cells[0] = Span::styled("↑", marker_style);
+    }
+
+    if hidden_below {
+        cells[height.saturating_sub(1)] = Span::styled("↓", marker_style);
+    }
+
+    if total_rows > visible_rows && height > 2 {
+        let track_height = height - 2;
+        let scrollable = total_rows - visible_rows;
+        let thumb_offset = (window_start * track_height) / scrollable;
+        let thumb_row = 1 + thumb_offset.min(track_height.saturating_sub(1));
+        cells[thumb_row] = Span::styled("|", marker_style);
+    }
+
+    cells
+}
+
+fn shortcut_url(character: char) -> Option<(&'static str, &'static str)> {
+    match character {
+        'g' => Some(("GitHub", GITHUB_URL)),
+        'x' => Some(("X", X_URL)),
+        _ => None,
+    }
+}
+
+fn logo_style(theme: TerminalTheme) -> Style {
+    match theme {
+        TerminalTheme::Dark => Style::default()
+            .fg(Color::White)
+            .add_modifier(Modifier::BOLD),
+        TerminalTheme::Light => Style::default()
+            .fg(Color::Black)
+            .add_modifier(Modifier::BOLD),
+    }
+    .remove_modifier(Modifier::DIM)
+}
+
+fn project_kind_style() -> Style {
+    Style::default().add_modifier(Modifier::DIM)
+}
+
+fn selected_row_style(theme: TerminalTheme) -> Style {
+    selected_row_style_for(theme)
+}
+
+fn selected_row_style_for(theme: TerminalTheme) -> Style {
+    match theme {
+        TerminalTheme::Dark => Style::default().fg(Color::Black).bg(Color::White),
+        TerminalTheme::Light => Style::default().fg(Color::White).bg(Color::Black),
+    }
+    .remove_modifier(Modifier::DIM)
+}
+
+fn metadata_line(width: u16) -> Line<'static> {
+    let width = width as usize;
+    let left_width = text_width(TAGLINE);
+
+    if width <= left_width + 4 {
+        return Line::from(Span::styled(
+            TAGLINE,
+            Style::default().add_modifier(Modifier::DIM),
+        ));
+    }
+
+    let max_right_width = width.saturating_sub(left_width + 1);
+    let links = truncate_to_width(
+        &format!("{GITHUB_DISPLAY_URL}  {X_DISPLAY_URL}"),
+        max_right_width,
+    );
+    let right_width = text_width(&links);
+    let gap = width.saturating_sub(left_width + right_width);
+
+    Line::from(vec![
+        Span::styled(TAGLINE, Style::default().add_modifier(Modifier::DIM)),
+        Span::raw(" ".repeat(gap)),
+        Span::styled(links, Style::default().add_modifier(Modifier::DIM)),
+    ])
+}
+
+fn status_line(
+    width: u16,
+    mut shortcuts: Vec<Span<'static>>,
+    status: &str,
+    style: Style,
+) -> Line<'static> {
+    let width = width as usize;
+    let shortcut_width = spans_width(&shortcuts);
+    let min_gap = usize::from(width > shortcut_width);
+    let available_status_width = width.saturating_sub(shortcut_width + min_gap);
+    let status = truncate_to_width(status, available_status_width);
+    let status_width = text_width(&status);
+    let gap = width.saturating_sub(shortcut_width + status_width);
+
+    if gap > 0 {
+        shortcuts.push(Span::styled(" ".repeat(gap), style));
+    }
+
+    if status_width > 0 {
+        shortcuts.push(Span::styled(status, style));
+    }
+
+    Line::from(shortcuts)
+}
+
+fn status_bar_style(theme: TerminalTheme) -> Style {
+    status_bar_style_for(theme, terminal_colors_disabled())
+}
+
+fn status_bar_style_for(theme: TerminalTheme, colors_disabled: bool) -> Style {
+    if colors_disabled {
+        return Style::default().add_modifier(Modifier::BOLD | Modifier::REVERSED);
+    }
+
+    match theme {
+        TerminalTheme::Dark => Style::default().fg(Color::Black).bg(Color::White),
+        TerminalTheme::Light => Style::default().fg(Color::White).bg(Color::Black),
+    }
+}
+
+fn terminal_colors_disabled() -> bool {
+    env::var_os("NO_COLOR").is_some() && env::var_os("CLICOLOR_FORCE").is_none()
+}
+
+fn detect_terminal_theme() -> TerminalTheme {
+    env::var("CTATE_TUI_THEME")
+        .ok()
+        .and_then(|value| parse_theme_override(&value))
+        .or_else(|| {
+            env::var("COLORFGBG")
+                .ok()
+                .and_then(|value| parse_colorfgbg_theme(&value))
+        })
+        .unwrap_or(TerminalTheme::Dark)
+}
+
+fn parse_theme_override(value: &str) -> Option<TerminalTheme> {
+    match value.trim().to_ascii_lowercase().as_str() {
+        "dark" => Some(TerminalTheme::Dark),
+        "light" => Some(TerminalTheme::Light),
+        _ => None,
+    }
+}
+
+fn parse_colorfgbg_theme(value: &str) -> Option<TerminalTheme> {
+    let background = value.rsplit(';').next()?.parse::<u8>().ok()?;
+
+    match background {
+        0..=6 | 8 => Some(TerminalTheme::Dark),
+        7 | 9..=15 => Some(TerminalTheme::Light),
+        _ => None,
+    }
+}
+
+fn truncate_to_width(value: &str, width: usize) -> String {
+    if text_width(value) <= width {
+        return value.to_string();
+    }
+
+    if width <= 3 {
+        return value.chars().take(width).collect();
+    }
+
+    let mut truncated = value.chars().take(width - 3).collect::<String>();
+    truncated.push_str("...");
+    truncated
+}
+
+fn spans_width(spans: &[Span<'_>]) -> usize {
+    spans.iter().map(|span| text_width(&span.content)).sum()
+}
+
+#[cfg(test)]
+fn line_width(line: &Line<'_>) -> usize {
+    spans_width(&line.spans)
+}
+
+fn text_width(value: &str) -> usize {
+    value.chars().count()
+}
+
+fn main() -> AppResult<()> {
+    if handle_cli_flags() {
+        return Ok(());
+    }
+
+    install_panic_hook();
+
+    let mut terminal = setup_terminal()?;
+    let app_result = App::new().run(&mut terminal);
+    let restore_result = restore_terminal(&mut terminal);
+
+    restore_result?;
+    app_result
+}
+
+fn handle_cli_flags() -> bool {
+    let args: Vec<String> = env::args().skip(1).collect();
+
+    if args.iter().any(|arg| arg == "--version" || arg == "-V") {
+        println!("ctate {}", env!("CARGO_PKG_VERSION"));
+        return true;
+    }
+
+    if args.iter().any(|arg| arg == "--help" || arg == "-h") {
+        println!("ctate");
+        println!();
+        println!("A ratatui version of ctate.dev.");
+        println!();
+        println!("Usage: ctate");
+        println!();
+        println!("Keys:");
+        println!("  Up/Down, j/k      move selection");
+        println!("  Enter             open selected link in a browser");
+        println!("  g                 open GitHub");
+        println!("  x                 open X");
+        println!("  q, Esc            quit");
+        println!("  Ctrl-C            quit");
+        return true;
+    }
+
+    false
+}
+
+fn setup_terminal() -> AppResult<Terminal<CrosstermBackend<io::Stdout>>> {
+    enable_raw_mode()?;
+    let mut stdout = io::stdout();
+    execute!(stdout, EnterAlternateScreen)?;
+    let backend = CrosstermBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+    terminal.clear()?;
+    Ok(terminal)
+}
+
+fn restore_terminal(terminal: &mut Terminal<CrosstermBackend<io::Stdout>>) -> AppResult<()> {
+    disable_raw_mode()?;
+    execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
+    terminal.show_cursor()?;
+    Ok(())
+}
+
+fn install_panic_hook() {
+    let original_hook = panic::take_hook();
+
+    panic::set_hook(Box::new(move |panic_info| {
+        let _ = disable_raw_mode();
+        let _ = execute!(io::stdout(), LeaveAlternateScreen);
+        original_hook(panic_info);
+    }));
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn project_links_are_populated() {
+        assert_eq!(PROJECTS.len(), 41);
+
+        for project in PROJECTS {
+            assert!(!project.name.is_empty());
+            assert!(!project.kind.is_empty());
+            assert!(project.url.starts_with("https://"));
+        }
+    }
+
+    #[test]
+    fn app_area_is_centered_when_terminal_is_large() {
+        let areas = screen_areas(Rect {
+            x: 0,
+            y: 0,
+            width: 120,
+            height: 50,
+        });
+        let area = centered_area(areas.content, MAX_APP_WIDTH, MAX_APP_HEIGHT);
+
+        assert_eq!(area.width, MAX_APP_WIDTH);
+        assert_eq!(area.height, MAX_APP_HEIGHT);
+        assert_eq!(area.x, 19);
+        assert_eq!(area.y, 11);
+    }
+
+    #[test]
+    fn app_area_uses_available_space_when_terminal_is_small() {
+        let areas = screen_areas(Rect {
+            x: 0,
+            y: 0,
+            width: 60,
+            height: 20,
+        });
+        let area = centered_area(areas.content, MAX_APP_WIDTH, MAX_APP_HEIGHT);
+
+        assert_eq!(area.width, 60);
+        assert_eq!(area.height, 19);
+        assert_eq!(area.x, 0);
+        assert_eq!(area.y, 0);
+    }
+
+    #[test]
+    fn status_area_sticks_to_bottom_and_fills_width() {
+        let areas = screen_areas(Rect {
+            x: 0,
+            y: 0,
+            width: 120,
+            height: 50,
+        });
+
+        assert_eq!(areas.status.x, 0);
+        assert_eq!(areas.status.y, 49);
+        assert_eq!(areas.status.width, 120);
+        assert_eq!(areas.status.height, 1);
+    }
+
+    #[test]
+    fn project_table_viewport_is_limited_to_sixteen_rows() {
+        let areas = screen_areas(Rect {
+            x: 0,
+            y: 0,
+            width: 120,
+            height: 50,
+        });
+        let centered = centered_area(areas.content, MAX_APP_WIDTH, MAX_APP_HEIGHT);
+        let app_areas = app_layout_areas(centered);
+
+        assert_eq!(app_areas.table.height, PROJECT_TABLE_HEIGHT);
+        assert_eq!(app_areas.visible_rows, VISIBLE_PROJECT_ROWS);
+        assert_eq!(PROJECT_TABLE_HEIGHT - 1, VISIBLE_PROJECT_ROWS);
+    }
+
+    #[test]
+    fn logo_has_lowercase_x_height() {
+        assert_eq!(LOGO_LINES.len(), LOGO_HEIGHT as usize);
+        assert_eq!(HEADER_HEIGHT, LOGO_HEIGHT + LOGO_BOTTOM_SPACER_HEIGHT + 1);
+
+        assert!(LOGO_LINES[0]
+            .chars()
+            .take(8)
+            .all(|character| character == ' '));
+        assert!(LOGO_LINES[1]
+            .chars()
+            .take(8)
+            .any(|character| character == '█'));
+        assert!(LOGO_LINES[2].starts_with("██"));
+    }
+
+    #[test]
+    fn logo_uses_primary_style() {
+        let dark_style = logo_style(TerminalTheme::Dark);
+        let light_style = logo_style(TerminalTheme::Light);
+
+        assert_eq!(dark_style.fg, Some(Color::White));
+        assert_eq!(light_style.fg, Some(Color::Black));
+        assert!(dark_style.sub_modifier.contains(Modifier::DIM));
+        assert!(light_style.sub_modifier.contains(Modifier::DIM));
+        assert!(!dark_style.add_modifier.contains(Modifier::DIM));
+        assert!(!light_style.add_modifier.contains(Modifier::DIM));
+        assert!(dark_style.add_modifier.contains(Modifier::BOLD));
+        assert!(light_style.add_modifier.contains(Modifier::BOLD));
+    }
+
+    #[test]
+    fn selected_row_uses_primary_text_over_dim_kind() {
+        let kind_style = project_kind_style();
+        let dark_style = selected_row_style_for(TerminalTheme::Dark);
+        let light_style = selected_row_style_for(TerminalTheme::Light);
+
+        assert!(kind_style.add_modifier.contains(Modifier::DIM));
+        assert_eq!(dark_style.fg, Some(Color::Black));
+        assert_eq!(dark_style.bg, Some(Color::White));
+        assert_eq!(light_style.fg, Some(Color::White));
+        assert_eq!(light_style.bg, Some(Color::Black));
+        assert!(dark_style.sub_modifier.contains(Modifier::DIM));
+        assert!(light_style.sub_modifier.contains(Modifier::DIM));
+        assert!(!dark_style.add_modifier.contains(Modifier::REVERSED));
+        assert!(!light_style.add_modifier.contains(Modifier::REVERSED));
+    }
+
+    #[test]
+    fn project_table_title_aligns_with_left_content() {
+        assert!(SHIP_LIST_TITLE.starts_with("RECENT SHIPS AT"));
+        assert!(!SHIP_LIST_TITLE.starts_with(' '));
+    }
+
+    #[test]
+    fn project_table_is_two_columns_wider_than_header_when_space_allows() {
+        let areas = screen_areas(Rect {
+            x: 0,
+            y: 0,
+            width: 120,
+            height: 50,
+        });
+        let centered = centered_area(areas.content, MAX_APP_WIDTH, MAX_APP_HEIGHT);
+        let app_areas = app_layout_areas(centered);
+
+        assert_eq!(app_areas.header.width, HEADER_WIDTH);
+        assert_eq!(app_areas.table.width, LIST_WIDTH);
+        assert_eq!(app_areas.table.width, app_areas.header.width + 2);
+        assert_eq!(app_areas.table.x, app_areas.header.x);
+        assert_eq!(
+            app_areas.table.x + app_areas.table.width,
+            app_areas.header.x + app_areas.header.width + 2
+        );
+        assert_eq!(
+            app_areas.scroll.x,
+            app_areas.table.x + app_areas.table.width + SCROLLBAR_GAP_WIDTH
+        );
+    }
+
+    #[test]
+    fn project_table_has_a_line_above_it_when_space_allows() {
+        let areas = screen_areas(Rect {
+            x: 0,
+            y: 0,
+            width: 120,
+            height: 50,
+        });
+        let centered = centered_area(areas.content, MAX_APP_WIDTH, MAX_APP_HEIGHT);
+        let app_areas = app_layout_areas(centered);
+
+        assert_eq!(
+            app_areas.table.y,
+            app_areas.header.y + HEADER_HEIGHT + TABLE_TOP_SPACER_HEIGHT
+        );
+    }
+
+    #[test]
+    fn project_table_viewport_fits_standard_terminal_height() {
+        let areas = screen_areas(Rect {
+            x: 0,
+            y: 0,
+            width: 80,
+            height: 24,
+        });
+        let centered = centered_area(areas.content, MAX_APP_WIDTH, MAX_APP_HEIGHT);
+        let app_areas = app_layout_areas(centered);
+
+        assert_eq!(app_areas.table.y, app_areas.header.y + HEADER_HEIGHT);
+        assert_eq!(app_areas.table.y + app_areas.table.height, areas.status.y);
+        assert!(app_areas.table.height < PROJECT_TABLE_HEIGHT);
+        assert!(app_areas.visible_rows < VISIBLE_PROJECT_ROWS);
+    }
+
+    #[test]
+    fn scroll_indicator_marks_more_rows_below_at_top() {
+        let cells = scroll_indicator_lines(
+            PROJECTS.len(),
+            VISIBLE_PROJECT_ROWS as usize,
+            PROJECT_TABLE_HEIGHT,
+            0,
+        )
+        .into_iter()
+        .map(|span| span.content.into_owned())
+        .collect::<Vec<_>>();
+
+        assert_eq!(cells[0], " ");
+        assert_eq!(cells[1], "|");
+        assert_eq!(cells[cells.len() - 1], "↓");
+    }
+
+    #[test]
+    fn scroll_indicator_marks_more_rows_above_and_below_in_middle() {
+        let cells = scroll_indicator_lines(
+            PROJECTS.len(),
+            VISIBLE_PROJECT_ROWS as usize,
+            PROJECT_TABLE_HEIGHT,
+            10,
+        )
+        .into_iter()
+        .map(|span| span.content.into_owned())
+        .collect::<Vec<_>>();
+
+        assert_eq!(cells[0], "↑");
+        assert_eq!(cells[cells.len() - 1], "↓");
+        assert!(cells.iter().any(|cell| cell == "|"));
+    }
+
+    #[test]
+    fn scroll_indicator_marks_more_rows_above_at_bottom() {
+        let max_start = PROJECTS.len() - VISIBLE_PROJECT_ROWS as usize;
+        let cells = scroll_indicator_lines(
+            PROJECTS.len(),
+            VISIBLE_PROJECT_ROWS as usize,
+            PROJECT_TABLE_HEIGHT,
+            max_start,
+        )
+        .into_iter()
+        .map(|span| span.content.into_owned())
+        .collect::<Vec<_>>();
+
+        assert_eq!(cells[0], "↑");
+        assert_eq!(cells[cells.len() - 1], " ");
+        assert!(cells.iter().any(|cell| cell == "|"));
+    }
+
+    #[test]
+    fn scroll_indicator_uses_dim_markers() {
+        let cells = scroll_indicator_lines(
+            PROJECTS.len(),
+            VISIBLE_PROJECT_ROWS as usize,
+            PROJECT_TABLE_HEIGHT,
+            10,
+        );
+
+        for marker in ["↑", "|", "↓"] {
+            let span = cells
+                .iter()
+                .find(|span| span.content.as_ref() == marker)
+                .expect("scroll marker should be present");
+
+            assert!(span.style.add_modifier.contains(Modifier::DIM));
+            assert!(!span.style.add_modifier.contains(Modifier::BOLD));
+        }
+    }
+
+    #[test]
+    fn social_shortcuts_map_to_expected_urls() {
+        assert_eq!(shortcut_url('g'), Some(("GitHub", GITHUB_URL)));
+        assert_eq!(shortcut_url('x'), Some(("X", X_URL)));
+        assert_eq!(shortcut_url('q'), None);
+    }
+
+    #[test]
+    fn metadata_line_places_links_on_same_line() {
+        let line = metadata_line(HEADER_WIDTH);
+        let text = line
+            .spans
+            .iter()
+            .map(|span| span.content.as_ref())
+            .collect::<String>();
+
+        assert_eq!(line_width(&line), HEADER_WIDTH as usize);
+        assert!(text.starts_with(TAGLINE));
+        assert!(text.ends_with(X_DISPLAY_URL));
+        assert!(text.contains(GITHUB_DISPLAY_URL));
+        assert!(!text.contains("https://"));
+        assert!(!text.contains("github "));
+    }
+
+    #[test]
+    fn status_line_keeps_shortcuts_left_and_hint_right() {
+        let style = status_bar_style_for(TerminalTheme::Dark, false);
+        let line = status_line(
+            48,
+            vec![
+                Span::styled("Enter", style.add_modifier(Modifier::BOLD)),
+                Span::styled(" open  ", style),
+                Span::styled("x", style.add_modifier(Modifier::BOLD)),
+                Span::styled(" x.com  ", style),
+                Span::styled("q", style.add_modifier(Modifier::BOLD)),
+                Span::styled(" quit", style),
+            ],
+            "Select a ship",
+            style,
+        );
+        let text = line
+            .spans
+            .iter()
+            .map(|span| span.content.as_ref())
+            .collect::<String>();
+
+        assert_eq!(line_width(&line), 48);
+        assert!(text.starts_with("Enter open  x x.com  q quit"));
+        assert!(text.ends_with("Select a ship"));
+        assert!(
+            line.spans
+                .iter()
+                .all(|span| span.style.fg == Some(Color::Black)
+                    && span.style.bg == Some(Color::White))
+        );
+    }
+
+    #[test]
+    fn status_bar_uses_explicit_black_and_white_colors() {
+        let dark_style = status_bar_style_for(TerminalTheme::Dark, false);
+        let light_style = status_bar_style_for(TerminalTheme::Light, false);
+
+        assert_eq!(dark_style.fg, Some(Color::Black));
+        assert_eq!(dark_style.bg, Some(Color::White));
+        assert_eq!(light_style.fg, Some(Color::White));
+        assert_eq!(light_style.bg, Some(Color::Black));
+    }
+
+    #[test]
+    fn status_bar_uses_reverse_video_when_colors_are_disabled() {
+        let style = status_bar_style_for(TerminalTheme::Dark, true);
+
+        assert_eq!(style.fg, None);
+        assert_eq!(style.bg, None);
+        assert!(style.add_modifier.contains(Modifier::BOLD));
+        assert!(style.add_modifier.contains(Modifier::REVERSED));
+    }
+
+    #[test]
+    fn theme_overrides_are_parsed() {
+        assert_eq!(parse_theme_override("dark"), Some(TerminalTheme::Dark));
+        assert_eq!(parse_theme_override("LIGHT"), Some(TerminalTheme::Light));
+        assert_eq!(parse_theme_override(""), None);
+    }
+
+    #[test]
+    fn colorfgbg_background_is_parsed_when_available() {
+        assert_eq!(parse_colorfgbg_theme("15;0"), Some(TerminalTheme::Dark));
+        assert_eq!(parse_colorfgbg_theme("0;15"), Some(TerminalTheme::Light));
+        assert_eq!(parse_colorfgbg_theme("bad"), None);
+    }
+
+    #[test]
+    fn navigation_does_not_replace_status_with_selection_name() {
+        let mut app = App::new();
+        let initial_status = app.status.clone();
+
+        app.next();
+        app.previous();
+        app.move_by(4);
+
+        assert_eq!(app.status, initial_status);
+    }
+}