agentjido/term_ui

TermUI is an Elixir/BEAM terminal UI framework that provides a component-based architecture for building rich, interactive text-based interfaces. It features a comprehensive widget library for dashboards, forms, and data visualization, supported by a robust layout engine and multi-backend input handling for both raw and constrained terminal environments. The system includes advanced rendering capabilities like double-buffering and color degradation, along with development tools for debugging and performance monitoring.

An example application demonstrating the ClusterDashboard widget has been added to the examples/cluster\_dashboard directory. This example allows users to visualize distributed cluster states, including connected nodes, health metrics, global registered names, PG process groups, and network partition detection. It provides interactive controls for navigating views (nodes, globals, PG, events) and testing cluster behaviors like spawning global processes or joining PG groups.

_examples/cluster\dashboard · high confidence

An example application has been added to the \examples/command\_palette\ directory that demonstrates a command palette widget similar to VS Code's command discovery. The example allows users to type a slash command (e.g., \/help\, \/clear\) to filter and execute actions, with keyboard navigation for selection and execution.

_examples/command\palette · high confidence

The examples/context\_menu directory now includes a complete demonstration of the TermUI ContextMenu widget. This example application shows how to display floating menus at specific cursor positions, handle right-click mouse events, and navigate menu items using keyboard controls (Up/Down arrows, Enter/Space, Escape). It also demonstrates styling for selected and disabled items, as well as managing menu state and capturing user selection results.

_examples/context\menu · high confidence

The examples/form\_builder directory now includes a demonstration of the FormBuilder widget, showcasing how to create structured forms with various field types including text, password, checkbox, radio buttons, select dropdowns, and multi-select fields. The example illustrates key features such as field validation (with custom validators for password and email), conditional field visibility, and form submission handling.

_examples/form\builder · high confidence

A new example application has been added to demonstrate the TermUI LogViewer widget. This example showcases features such as virtual scrolling for large datasets, tail mode for live monitoring, regex-based search, syntax highlighting for log levels, filtering, line bookmarking, and selection. It includes a simulated log generator and keyboard controls for navigation, searching, and managing log entries.

_examples/log\viewer · high confidence

The examples/process\_monitor directory now includes a working example application that demonstrates the ProcessMonitor widget. This example allows users to live-monitor BEAM processes, view details such as PID, name, reductions, memory, and queue status, and perform actions like killing, suspending, or resuming processes. It also supports sorting, filtering, and viewing stack traces or links/monitors for selected processes.

_examples/process\monitor · high confidence

The examples/split\_pane directory now includes a demonstration application for the TermUI.SplitPane widget, showcasing how to build resizable, multi-pane interfaces similar to IDEs. This example illustrates key capabilities including horizontal and vertical split orientations, nested split layouts, keyboard-controlled divider resizing, pane collapse/expand functionality, and min/max size constraints. It also demonstrates layout persistence features, allowing users to save and restore their custom pane configurations.

_examples/split\pane · high confidence

The examples/stream\_widget location now includes a complete demonstration application for the StreamWidget. This example introduces a GenStage-based producer that generates timed data events and a consumer that feeds them into the widget, enabling users to observe backpressure handling in action. Users can interact with the stream via keyboard controls to pause/resume data flow, clear the internal buffer, toggle statistics display, switch between overflow strategies (drop oldest, drop newest, block, sliding), and adjust the event generation rate. The example also demonstrates how to integrate the widget within a TermUI Elm-based application structure, including proper supervision and message forwarding.

_examples/stream\widget · high confidence

The examples/supervision\_tree\_viewer directory now includes a complete, runnable example application that demonstrates the SupervisionTreeViewer widget. This example provides a sample OTP supervision hierarchy (including supervisors and workers) and allows users to interactively visualize the tree, view process status, and perform actions like restarting or terminating processes via keyboard controls.

_examples/supervision\_tree\viewer · high confidence

The examples/text\_input directory now includes a new example application that demonstrates the TermUI.TextInput widget. This example showcases single-line text input, multi-line text input with auto-growing height and scrolling, placeholder text, focus states, and specific behaviors like using Ctrl+Enter for newlines in multi-line mode or Enter to submit in chat-style inputs. It also illustrates how to handle keyboard events for cursor movement, deletion, and switching between multiple input fields using the Tab key.

_examples/text\input · high confidence

A new \TextInput.Line\ widget has been added to the TermUI library, providing a line-based text input component that delegates editing to the shell (supporting features like backspace, cursor movement, and command history via \IO.gets/1\). This widget is designed for simple, sequential input flows where blocking I/O is acceptable, contrasting with the existing character-by-character, event-driven \TextInput\ widget. It supports configuration for prompts, labels, placeholders, and custom validation functions.

_lib/term\_ui/widgets/text\input · high confidence

A new example application has been added to demonstrate the TermUI TreeView widget, showcasing features such as hierarchical navigation, expand/collapse functionality, single and multi-selection modes, custom node icons, search filtering, and simulated lazy loading of child nodes.

_examples/tree\view · high confidence

The examples/canvas directory now includes a new application that demonstrates the TermUI.Widgets.Canvas widget. This example showcases how to create a canvas, draw text, lines, rectangles, and use Braille characters for sub-character resolution, and provides interactive controls to switch between different drawing demos (basic shapes, box drawing, and Braille drawing).

examples/canvas · high confidence

Introduces a new set of core UI components in the \lib/term\_ui/widget\ directory, including \Block\ (a bordered layout container), \Button\ (interactive with keyboard and mouse support), \Label\ (text display with alignment and truncation), \List\ (scrollable selection with single/multi-select modes), \PickList\ (modal selection with type-ahead filtering), \Progress\ (bar and spinner indicators), and \TextInput\ (single-line input with cursor navigation). These widgets provide the foundational building blocks for constructing terminal-based user interfaces.

_lib/term\ui/widget · high confidence

This change introduces two new modules to the TermUI focus subsystem: \TermUI.Focus.Indicator\ and \TermUI.Focus.Traversal\. The indicator module provides visual feedback for focused components, offering a default cyan border style, support for multiple predefined themes (default, subtle, bold, minimal), and the ability to apply custom styles per component. The traversal module handles keyboard navigation logic, calculating the correct tab order based on explicit \tab\_index\ values and screen position, while correctly skipping components that are disabled, non-focusable, or have negative tab indices.

_lib/term\ui/focus · high confidence

A new example application demonstrating the TermUI Gauge widget has been added to the examples/gauge directory. The app showcases various gauge configurations, including simple percentage displays, gauges with color-coded zones (green, yellow, red), and gauges using custom characters. It supports interactive controls to adjust values, toggle between bar and arc styles, and quit the application, serving as a reference for integrating the Gauge widget into TermUI-based terminal interfaces.

examples/gauge, examples/menu, examples/toast · high confidence

A new dashboard example application has been added to the examples directory, demonstrating TermUI capabilities such as multiple widget types (gauges, charts, tables), nested layout constraints, real-time updates, keyboard navigation, and theme switching. The application provides entry points for interactive running via \Dashboard.run/0\ or \Dashboard.start/0\, and for programmatic embedding via \Dashboard.start\_link/0\.

examples/dashboard/lib · high confidence

Introduces a new \TermUI.Color.Converter\ module that enables graceful degradation of 24-bit true-color RGB values to lower-fidelity terminal palettes. This allows the UI to maintain visual fidelity on terminals that do not support full true color by converting colors to the xterm 256-color palette (using a 6x6x6 color cube and grayscale ramp) or the standard 16-color ANSI palette (using perceptually-weighted Euclidean distance for foreground and background codes).

_lib/term\ui/color · high confidence

A new example application has been added at \examples/dashboard\ that displays simulated system metrics (CPU, memory, network, and processes) in a terminal interface. The dashboard uses TermUI widgets to render gauges, sparklines, and tables, and supports interactive controls such as quitting with 'q', refreshing data with 'r', toggling between dark and light themes with 't', and navigating the process list with arrow keys.

examples/dashboard/lib/dashboard · high confidence

Introduces a new module to manage text selection state, tracking start and end positions to support selection expansion via Shift+arrow keys and clearing on navigation. This component provides the underlying logic for identifying and extracting selected text ranges, which is a prerequisite for the clipboard integration feature.

_lib/term\ui/clipboard · high confidence

A new example application demonstrating the TermUI.Widget.PickList widget has been added to the examples/pick\_list directory. This application showcases modal selection dialogs with filtering support, including features like scrollable list navigation, type-ahead filtering, and selection/cancel callbacks. It provides three distinct pickers (fruits, colors, and countries) accessible via keys 1, 2, and 3, allowing users to test navigation (Up/Down, Page Up/Down, Home/End), filtering by typing, and selection confirmation (Enter) or cancellation (Escape).

_examples/pick\list · high confidence

A new assets directory has been created, initialized with a .gitkeep file to ensure the folder is tracked by version control. This establishes a location for future screenshots and demo materials.

assets · high confidence

A new local CI script (scripts/ci.sh) has been added to allow developers to run the same checks as the GitHub Actions pipeline locally before submitting pull requests. This script verifies the Elixir/OTP environment, installs dependencies, checks code formatting, compiles the project with warnings treated as errors, and runs the test suite, providing immediate feedback on code quality and stability.

scripts · high confidence

Introduced a comprehensive agent orchestration system within the .claude directory, including AGENTS.md for implementation lead rules, AGENT-SYSTEM-GUIDE.md for model and tool specifications, and HOOKS-GUIDE.md for Claude Code hook configuration. Added detailed definitions for specialized agents (such as elixir-expert, architecture-agent, and various reviewers) in agent-definitions/ to enforce role separation, cost optimization through model selection (Opus/Sonnet/Haiku), and standardized tool permissions.

.claude · high confidence

This change establishes the foundational structure for the TermUI Elixir/BEAM terminal UI framework. It introduces essential configuration files including \.formatter.exs\ for code formatting, \.gitignore\ to exclude build artifacts, and \.tool-versions\ specifying Erlang 28.1.1 and Elixir 1.19.3. The repository is populated with comprehensive documentation, including a detailed \README.md\ outlining features like the Elm Architecture, rich widget library, and IEx compatibility, alongside user and developer guides. A \CHANGELOG.md\ tracks versions 0.1.0 and 0.2.0, listing added widgets (e.g., PickList, FormBuilder, CommandPalette) and backend abstractions. Additionally, a \release-1.0.0.md\ runbook and \CLAUDE.md\ AI assistant guidelines are added to support the release process and development workflow.

(repo-wide) · high confidence

Adds the TermUI library, a direct-mode terminal UI framework for Elixir/BEAM applications. The new \TermUI\ module provides a high-level API for initializing raw mode, managing terminal state, and detecting whether the application is running inside IEx (supporting interactive debugging and admin tools without code changes). The framework features a multi-backend architecture (\TermUI.Backend\) that automatically selects between raw mode (for full terminal control on modern terminals) and TTY mode (for constrained environments), along with terminal capability detection (\TermUI.Capabilities\) for colors, mouse, and Unicode support. It includes a component-based UI model (\TermUI.Component\), an ANSI escape sequence generator (\TermUI.ANSI\), clipboard integration via OSC 52, and a command system for handling side effects like timers and file reads.

_lib/term\ui · high confidence

TermUI now features a structured backend system that automatically selects between a high-fidelity Raw mode (for direct terminal control) and a fallback TTY mode (for constrained environments like Nerves or SSH). This change introduces dedicated modules for configuration (\TermUI.Backend.Config\), backend selection logic (\TermUI.Backend.Selector\), and shared state management (\TermUI.Backend.State\), alongside a new \TermUI.Backend.SSH\ backend for remote sessions. Users benefit from robust automatic detection of terminal capabilities, secure input buffer handling to prevent memory exhaustion, and graceful degradation of features like color and character sets when raw mode is unavailable.

_lib/term\ui/backend · high confidence

The terminal subsystem now includes an EscapeParser that converts raw byte streams into structured keyboard events (arrows, function keys, modifiers, UTF-8) and an InputReader GenServer that reads stdin, handles escape-sequence timeouts, and dispatches these events. A new SizeDetector provides reliable terminal dimension detection via Erlang's :io module, environment variables, or a safely wrapped stty command, with bounds checking to prevent resource exhaustion. Terminal state is now tracked explicitly in a State struct to manage raw mode, mouse tracking, bracketed paste, and other features.

_lib/term\ui/terminal · high confidence

Added \TermUI.Runtime.NodeRenderer\ to convert component render trees into terminal buffer cells, supporting struct-based nodes, tuple-based nodes, viewports, and overlays with background fills. Added \TermUI.Runtime.State\ to define the runtime GenServer state, including a bounded event queue to prevent denial-of-service conditions, backend selection, and input handler configuration.

_lib/term\ui/runtime · high confidence

The examples/alert\_dialog directory now contains a complete, runnable example application demonstrating the TermUI AlertDialog widget. This example showcases six distinct dialog types (Info, Success, Warning, Error, Confirm, and OK/Cancel) and illustrates how to handle keyboard interactions, including navigation, selection, and closing via Escape. It also demonstrates the widget's overlay rendering capabilities, allowing the dialog to appear absolutely positioned over the main application content.

_examples/alert\dialog · high confidence

This change introduces the core building blocks for the TermUI component system. It adds \RenderNode\ to define the structure of the terminal render tree (text, boxes, stacks, and cells) and \Helpers\ to provide convenient functions for constructing these nodes and validating component props. It also includes \StatePersistence\ for crash recovery using ETS tables, \Introspection\ for debugging and monitoring component trees and metrics, and establishes the foundational module structure for the component library.

_lib/term\ui/component · high confidence

This release adds a comprehensive suite of standalone example applications for the TermUI library, covering widgets such as Gauge, Sparkline, BarChart, LineChart, Table, Menu, Tabs, Dialog, Viewport, Canvas, AlertDialog, ContextMenu, CommandPalette, FormBuilder, LogViewer, and a ClusterDashboard for distributed systems. Each example is a self-contained Mix project with a consistent structure (mix.exs, run.exs, lib/, README.md) and supports both raw TUI mode (via \mix termui.run\) and IEx-compatible TTY mode. The examples demonstrate the Elm Architecture pattern, keyboard/mouse interaction, theme switching, and specific widget features like Braille graphics, virtual scrolling, and conditional form validation. A central examples/README.md provides an overview, learning path, and running instructions.

examples · high confidence

Added a new command executor module that runs commands asynchronously under a Task Supervisor, ensuring that command failures do not crash the runtime. This introduces a public API for starting the executor, executing commands with automatic ID assignment, and cancelling individual or all commands for a specific component. The system enforces a configurable limit on concurrent commands (defaulting to 100) and sends results back to the originating component via messages.

_lib/term\ui/command · high confidence

A new development mode has been added to TermUI, providing a suite of debugging tools accessible via keyboard shortcuts (Ctrl+Shift+I/S/P). This includes a UI Inspector that overlays component boundaries and render times, a State Inspector that displays a tree view of component state, and a Performance Monitor that tracks FPS, memory, and process counts. The mode also features a Hot Reload mechanism that watches for file changes and reloads modules without restarting the application, preserving state where possible.

_lib/term\ui/dev · high confidence

Added \TermUI.Event.Propagation\ and \TermUI.Event.Transformation\ modules to handle event routing within the component tree. The propagation module manages bubbling and capturing phases, allowing events to travel from target to root or vice versa, while the transformation module provides utilities for converting mouse coordinates between screen and component-local spaces, enriching events with metadata, and filtering events by type or attributes.

_lib/term\ui/event · high confidence

The terminal UI now includes a new layout engine in \lib/term\_ui/layout\ that supports flexbox-style alignment, constraint-based sizing, and performance caching. Users can define layouts using declarative constraints such as fixed lengths, percentages, ratios, and fill behavior, which are resolved by a greedy multi-pass solver. The system provides alignment options for both main and cross axes (justify and align) and supports margins and padding. To improve performance, solved layouts are cached using an LRU strategy, reducing redundant calculations for unchanged constraints and dimensions.

_lib/term\ui/layout · high confidence

Users can now access context menus in keyboard-only (TTY) environments via a new inline widget that renders items with numbered prefixes for direct selection. A factory module automatically selects between the standard positioned menu and the new inline variant based on terminal capabilities and provided options, while a shared behavior module ensures consistent cursor navigation and item selection logic across both menu types.

_lib/term\_ui/widgets/context\menu · high confidence

Added standalone example applications for the BarChart, LineChart, Sparkline, Table, Tabs, and Viewport widgets. Each example demonstrates the widget's features using the TermUI.Elm architecture, providing interactive demos for visualization (charts, sparklines), data presentation (tables), and UI organization (tabs, viewports).

(repo-wide) · high confidence

A new \mix termui.run\ task has been added, allowing users to start TermUI applications directly from the command line. The task automatically detects the application module (handling acronym preservation in module names) and compiles the project before execution. It supports explicit module and function specification via \--module\ and \--function\ flags, and includes a new \--iex\ flag to enable IEx-compatible running mode, which sets the \TERM\_UI\_IEX\_MODE\ environment variable for better interactive debugging.

mix · high confidence

The terminal UI now features a dedicated input abstraction layer in \lib/term\_ui/input\ that separates input handling into distinct backends. \TermUI.Input.Raw\ provides non-blocking, timeout-supported character polling for raw mode terminals, while \TermUI.Input.TTY\ offers IEx-compatible character input using Erlang's \:io.get\_chars/2\ to bypass IEx's input interception. A \TermUI.Input.Selector\ bridges backend selection to the appropriate input handler, and \TermUI.Input.LineReader\ provides a standalone utility for line-based input with shell editing features for the \TextInput.Line\ widget. This structure allows applications to choose between immediate character response (Raw/TTY) and line-based submission (LineReader) based on their interaction needs.

_lib/term\ui/input · high confidence

The \lib/term\_ui/widgets\ directory now contains a comprehensive suite of new terminal UI components. This includes interactive widgets such as AlertDialog, Dialog, FormBuilder, CommandPalette, ContextMenu, SplitPane, and TextInput for user input and layout management. It also introduces visualization widgets like BarChart, LineChart, Gauge, Sparkline, and Canvas for rendering data, as well as monitoring widgets including ClusterDashboard, LogViewer, ProcessMonitor, and SupervisionTreeViewer for system observability. These widgets are built on the new Theme API and CharacterSet integration, providing consistent styling and monochrome compatibility across the application.

_lib/term\ui/widgets · high confidence

The Dialog widget example has been rewritten to adopt the TermUI.Elm architecture, replacing the previous implementation with a new \Dialog.App\ module that utilizes \use TermUI.Elm\ and \TermUI.Runtime.run\. This change introduces a proper Elm-style event-to-message and update loop for handling dialog states (info, confirm, warning) and button interactions, ensuring the example aligns with the current framework standards.

examples/dialog · high confidence

The terminal UI renderer now uses an ETS-backed double-buffering system to significantly improve rendering performance and reduce terminal output overhead. This change introduces a new \Buffer\ module for efficient cell storage, a \BufferManager\ GenServer to coordinate the current and previous frame buffers, and a \Diff\ algorithm that calculates minimal render operations by comparing buffers. To optimize output, the renderer includes a \CursorOptimizer\ for efficient cursor movement, a \SequenceBuffer\ that batches and combines escape sequences, and a \FramerateLimiter\ to cap rendering frequency and coalesce dirty regions. Additionally, new \Cell\ and \Style\ modules provide immutable data structures for terminal content, and a \DisplayWidth\ module ensures correct handling of Unicode and double-width characters.

_lib/term\ui/renderer · high confidence

Added comprehensive integration tests for TermUI; Added comprehensive integration tests for TermUI core subsystems; Added comprehensive test coverage for TermUI backend modules; Added comprehensive test coverage for TermUI widgets; Added comprehensive test suite for TermUI core modules; Added test coverage for ContextMenu behavior, factory, and inline widget; Added test coverage for NodeRenderer, resize handling, and graceful shutdown; Added test coverage for TermUI development mode tools; Added test coverage for TermUI layout subsystem; Added test coverage for backend configuration and state management; Added test suite for TermUI testing utilities; Added test support helpers and fixtures; Added tests for TermUI input modules; Added tests for terminal UI initialization and IEx mode detection; Added unit tests for core terminal UI widgets; Added unit tests for terminal input parsing and state management; Added unit tests for the TextInput.Line widget; Added unit tests for the terminal UI renderer subsystem; New testing utilities for TermUI components.

New example applications have been added for various widgets, including AlertDialog, BarChart, Canvas, ClusterDashboard, CommandPalette, ContextMenu, Dashboard, Dialog, FormBuilder, Gauge, IExCounter, LineChart, LogViewer, MarkdownViewer, and Menu. Each example is configured as a standalone Mix project depending on the local \term\_ui\ library, with corresponding \mix.lock\ files pinning specific versions of dependencies such as \makeup\, \mdex\, \lumis\, and \rustler\_precompiled\ to ensure reproducible builds.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 79.

• Code Health 96
• Architecture 99
• Maturity 84
• Readiness 66
• Security 95

• 300 commits — 233 feature/other, 67 fixes

• lib/term_ui — 156 commits
• (repo) — 51 commits
• notes/features — 29 commits
• (root) — 12 commits
• test/term_ui — 11 commits
• examples/alert_dialog — 4 commits
• guides/user — 4 commits
• examples/dashboard — 3 commits
• notes/summaries — 3 commits
• examples/canvas — 2 commits
• examples/markdown_viewer — 2 commits
• examples/pick_list — 2 commits
• examples/text_input — 2 commits
• notes/feature — 2 commits
• test/manual — 2 commits
• docs/phase-05 — 1 commit
• docs/widget-compatibility.md — 1 commit
• examples/bar_chart — 1 commit
• examples/context_menu — 1 commit
• examples/dialog — 1 commit

• fix: Add regression tests for wide terminal scroll corruption bug
• fix: Address Section 3.7 review findings: security fix and quality improvements
• fix: Address Section 4.3/4.4 review findings: bug fixes and documentation
• fix: Complete Phase 4 dialyzer cleanup and fix Credo issues
• fix: Fix AlertDialog example overlay rendering and ESC handling
• fix: Fix AlertDialog overlay background rendering
• fix: Fix ContextMenu mouse support and add hover highlighting
• fix: Fix Credo code quality issues
• fix: Fix Credo refactoring and readability issues
• fix: Fix Dialog widget rendering and event handling
• fix: Fix EscapeParser to populate char field for printable characters
• fix: Fix IEx echo restoration after TTY mode apps quit
• fix: Fix IEx terminal restoration after TTY mode apps quit
• fix: Fix IO options restoration - explicitly pass as keyword arguments
• fix: Fix Phase 3 review issues: extract shared modules, improve security
• fix: Fix PickList example selection handling
• fix: Fix SplitPane resizing to work before first render
• fix: Fix StreamWidget example and add Runtime handle_info forwarding
• fix: Fix Theme.get_theme to handle non-existent ETS tables
• fix: Fix Theme.style_from_theme/4 calling undefined Style.from/1
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

agentjido/term_ui was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.