zig-cli

A type-safe, compile-time validated CLI library for Zig. Define your CLI with structs, get full type safety and zero runtime overhead.

No string-based lookups. No runtime parsing. Just pure, type-safe Zig.

// Define options as a struct
const MyOptions = struct {
    name: []const u8,
    port: u16 = 8080,
};

// Type-safe action
fn run(ctx: *cli.Context(MyOptions)) !void {
    const name = ctx.get(.name);  // Compile-time validated!
    const port = ctx.get(.port);
}

Inspired by modern CLI frameworks, built for Zig's strengths.

Features

CLI Framework (Type-Safe)

• Compile-Time Validation: All field access validated at compile time
• Struct-Based Options: Define CLI options as structs - auto-generate everything
• Zero Runtime Overhead: All type checking happens at compile time
• IDE Autocomplete: Full IntelliSense/LSP support for field names
• Command Routing: Support for nested subcommands with aliases
• Auto-Generated Help: Beautiful help text from struct definitions
• Type Safety: Enums, optionals, nested structs all supported
• Middleware System: Type-safe pre/post command hooks

Interactive Prompts

• State Machine: Clean 5-state state machine (initial → active ↔ error → submit/cancel)
• Event-driven: Fine-grained event system for prompt interactions
• Terminal Detection: Automatic Unicode/ASCII and color support detection
• Multiple Prompt Types:
  • Text input with validation and placeholders
  • Confirmation prompts
  • Select (single choice)
  • MultiSelect (multiple choices)
  • Password input with masking
  • Number input with range validation (integer/float)
  • Path selection with Tab autocomplete
  • Group prompts for multi-step workflows
  • Spinner for loading/activity indicators
  • Progress bars with multiple styles
  • Messages (intro, outro, note, log, cancel)
  • Box/panel rendering for organized output

Terminal Features

• ANSI Colors: Full color support with automatic detection
• Style Chaining: Composable styling API (.red().bold().underline())
• Raw Mode: Cross-platform terminal raw mode handling
• Cursor Control: Hide/show, save/restore cursor position
• Unicode Support: Graceful fallback to ASCII when needed
• Keyboard Input: Full keyboard event handling (arrows, enter, backspace, etc.)
• Dimension Detection: Automatic terminal width/height detection
• Box Rendering: Multiple box styles (single, double, rounded, ASCII)
• Table Rendering: Column alignment, auto-width, multiple border styles

Configuration

• Multiple Formats: TOML, JSONC (JSON with Comments), JSON5
• Auto-discovery: Automatically find config files in standard locations
• Type-safe Access: Typed getters for strings, integers, floats, booleans
• Nested Values: Support for tables/objects and arrays
• Flexible Syntax: Comments, trailing commas, unquoted keys (format-dependent)

Installation

Add zig-cli to your build.zig:

const zig_cli = b.dependency("zig-cli", .{
    .target = target,
    .optimize = optimize,
});

exe.root_module.addImport("zig-cli", zig_cli.module("zig-cli"));

Quick Start

Basic CLI Application

const std = @import("std");
const cli = @import("zig-cli");

// 1. Define options as a struct - that's it!
const GreetOptions = struct {
    name: []const u8 = "World",  // With default value
    enthusiastic: bool = false,   // Boolean flag
};

// 2. Type-safe action function
fn greet(ctx: *cli.Context(GreetOptions)) !void {
    const stdout = std.io.getStdOut().writer();

    // Compile-time validated field access - no strings!
    const name = ctx.get(.name);
    const punct: []const u8 = if (ctx.get(.enthusiastic)) "!" else ".";

    try stdout.print("Hello, {s}{s}\n", .{name, punct});
}

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    // 3. Create command - options auto-generated!
    var cmd = try cli.command(GreetOptions).init(allocator, "greet", "Greet someone");
    defer cmd.deinit();

    _ = cmd.setAction(greet);

    // 4. Parse and execute
    const args = try std.process.argsAlloc(allocator);
    defer std.process.argsFree(allocator, args);
    try cli.Parser.init(allocator).parse(cmd.getCommand(), args[1..]);
}

That's it! Run with: myapp greet --name Alice --enthusiastic

Benefits:

• ✅ Options auto-generated from struct fields
• ✅ Compile-time validation - typos caught by compiler
• ✅ Full IDE autocomplete support
• ✅ No string-based lookups
• ✅ Zero runtime overhead

Interactive Prompts

const std = @import("std");
const prompt = @import("zig-cli").prompt;

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    // Text prompt
    var text_prompt = prompt.TextPrompt.init(allocator, "What is your name?");
    defer text_prompt.deinit();
    const name = try text_prompt.prompt();
    defer allocator.free(name);

    // Confirm prompt
    var confirm_prompt = prompt.ConfirmPrompt.init(allocator, "Continue?");
    defer confirm_prompt.deinit();
    const confirmed = try confirm_prompt.prompt();

    // Select prompt
    const choices = [_]prompt.SelectPrompt.Choice{
        .{ .label = "Option 1", .value = "opt1" },
        .{ .label = "Option 2", .value = "opt2" },
    };
    var select_prompt = prompt.SelectPrompt.init(allocator, "Choose:", &choices);
    defer select_prompt.deinit();
    const selected = try select_prompt.prompt();
    defer allocator.free(selected);
}

API Reference

CLI Framework

Creating a CLI Application

var app = try cli.CLI.init(allocator, "app-name", "1.0.0", "Description");
defer app.deinit();

Adding Options

const option = cli.Option.init("name", "long-name", "Description", .string)
    .withShort('n')              // Short flag (-n)
    .withRequired(true)          // Make it required
    .withDefault("value");       // Set default value

_ = try app.option(option);

Option types:

• .string - String value
• .int - Integer value
• .float - Float value
• .bool - Boolean flag

Adding Arguments

const arg = cli.Argument.init("name", "Description", .string)
    .withRequired(true)          // Required argument
    .withVariadic(false);        // Accept multiple values

_ = try app.argument(arg);

Creating Subcommands

const subcmd = try cli.Command.init(allocator, "subcmd", "Subcommand description");

// Add aliases for the command
_ = try subcmd.addAlias("sub");
_ = try subcmd.addAlias("s");

const opt = cli.Option.init("opt", "option", "Option description", .string);
_ = try subcmd.addOption(opt);

_ = subcmd.setAction(myAction);
_ = try app.command(subcmd);

Now you can call the subcommand with: myapp subcmd, myapp sub, or myapp s

Middleware

Add pre/post command hooks to your CLI:

var chain = cli.Middleware.MiddlewareChain.init(allocator);
defer chain.deinit();

// Add built-in middleware
try chain.use(cli.Middleware.Middleware.init("logging", cli.Middleware.loggingMiddleware));
try chain.use(cli.Middleware.Middleware.init("timing", cli.Middleware.timingMiddleware));
try chain.use(cli.Middleware.Middleware.init("validation", cli.Middleware.validationMiddleware));

// Custom middleware
fn authMiddleware(ctx: *cli.Middleware.MiddlewareContext) !bool {
    const is_authenticated = checkAuth();
    if (!is_authenticated) {
        try ctx.set("error", "Unauthorized");
        return false; // Stop chain
    }
    try ctx.set("user", "[email protected]");
    return true; // Continue
}

// Add with priority (lower runs first)
try chain.use(cli.Middleware.Middleware.init("auth", authMiddleware).withOrder(-10));

// Execute middleware chain before command
var middleware_ctx = cli.Middleware.MiddlewareContext.init(allocator, parse_context, command);
defer middleware_ctx.deinit();

if (try chain.execute(&middleware_ctx)) {
    // All middleware passed, execute command
    try command.executeAction(parse_context);
}

Built-in middleware:

• loggingMiddleware - Logs command execution
• timingMiddleware - Records start time
• validationMiddleware - Validates required options
• environmentCheckMiddleware - Checks environment variables

Command Actions

fn myAction(ctx: *cli.Command.ParseContext) !void {
    // Get option value
    const value = ctx.getOption("name") orelse "default";

    // Check if option was provided
    if (ctx.hasOption("verbose")) {
        // Do something
    }

    // Get positional argument
    const arg = ctx.getArgument(0) orelse return error.MissingArgument;

    // Get argument count
    const count = ctx.getArgumentCount();
}

Type-Safe API (Compile-Time Validated)

zig-cli provides a fully typed API layer that leverages Zig's comptime features for maximum type safety and zero runtime overhead.

Type-Safe Commands

Define your command options as a struct and get compile-time validation:

const GreetOptions = struct {
    name: []const u8,              // Required string
    age: ?u16 = null,              // Optional integer
    times: u8 = 1,                 // With default value
    verbose: bool = false,         // Boolean flag
    format: enum { text, json } = .text, // Enum support
};

fn greetAction(ctx: *cli.TypedContext(GreetOptions)) !void {
    // Compile-time validated field access - no string lookups!
    const name = ctx.get(.name);      // Returns []const u8
    const age = ctx.get(.age);        // Returns ?u16
    const times = ctx.get(.times);    // Returns u8

    // Or parse entire struct at once
    const opts = try ctx.parse();

    std.debug.print("Hello, {s}!\n", .{opts.name});
}

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    // Auto-generates CLI options from struct fields!
    var cmd = try cli.TypedCommand(GreetOptions).init(
        allocator,
        "greet",
        "Greet a user",
    );
    defer cmd.deinit();

    _ = cmd.setAction(greetAction);

    const args = try std.process.argsAlloc(allocator);
    defer std.process.argsFree(allocator, args);

    // Get underlying command for parsing
    try cli.Parser.init(allocator).parse(cmd.getCommand(), args[1..]);
}

Benefits:

• ✅ Compile-time validation - field names validated at compile time
• ✅ IDE autocomplete - full IntelliSense support
• ✅ Type safety - no runtime string parsing or optionals
• ✅ Auto-generation - options automatically created from struct
• ✅ Zero overhead - comptime code generates efficient runtime

Type-Safe Config

Load config files with compile-time schema validation:

const AppConfig = struct {
    database: struct {
        host: []const u8,
        port: u16,
        max_connections: u32 = 100,
    },
    log_level: enum { debug, info, warn, @"error" } = .info,
    debug: bool = false,
};

// Load with full type checking
var config = try cli.config.loadTyped(AppConfig, allocator, "config.toml");
defer config.deinit();

// Direct field access - no optionals, no string parsing!
std.debug.print("DB: {s}:{d}\n", .{
    config.value.database.host,
    config.value.database.port,
});
std.debug.print("Log Level: {s}\n", .{@tagName(config.value.log_level)});

// Auto-discovery also works
var discovered = try cli.config.discoverTyped(AppConfig, allocator, "myapp");
defer discovered.deinit();

Supported types:

• Primitives: bool, i8-i64, u8-u64, f32, f64
• Strings: []const u8
• Enums: Any Zig enum
• Optionals: ?T for optional fields
• Nested structs: Arbitrary depth
• Arrays: Fixed-size arrays

Type-Safe Middleware

Create middleware with typed context instead of string HashMap:

const AuthData = struct {
    user_id: []const u8 = "",
    username: []const u8 = "",
    role: enum { admin, user, guest } = .guest,
    authenticated: bool = false,
};

fn authMiddleware(ctx: *cli.TypedMiddleware(AuthData)) !bool {
    // Type-safe field access with compile-time validation
    ctx.set(.user_id, "12345");
    ctx.set(.username, "john_doe");
    ctx.set(.role, .admin);           // Enum - compile-time checked!
    ctx.set(.authenticated, true);

    // Access with type safety
    if (ctx.get(.role) == .admin) {
        std.debug.print("Admin access granted\n", .{});
    }

    return true;
}

// Use in middleware chain
var chain = cli.TypedMiddlewareChain(AuthData).init(allocator);
defer chain.deinit();

try chain.useTyped(authMiddleware, "auth");

Runtime vs Typed API Comparison

// Runtime API (string-based)
const value = ctx.getOption("name");  // Returns ?[]const u8
if (value) |v| {
    const age_str = ctx.getOption("age") orelse "0";
    const age = try std.fmt.parseInt(u16, age_str, 10);
}

// Typed API (compile-time validated)
const name = ctx.get(.name);  // Returns []const u8 directly
const age = ctx.get(.age);    // Returns u16, already parsed
//              ^^^^^ Compile-time validated enum field!

See examples/typed.zig for a complete working example.

Prompts

Text Prompt

var text = prompt.TextPrompt.init(allocator, "Enter value:");
defer text.deinit();

_ = text.withPlaceholder("placeholder text");
_ = text.withDefault("default value");
_ = text.withValidation(myValidator);

const value = try text.prompt();
defer allocator.free(value);

Custom validator:

fn myValidator(value: []const u8) ?[]const u8 {
    if (value.len < 3) {
        return "Value must be at least 3 characters";
    }
    return null;  // Valid
}

Confirm Prompt

var confirm = prompt.ConfirmPrompt.init(allocator, "Continue?");
defer confirm.deinit();

_ = confirm.withDefault(true);

const result = try confirm.prompt();  // Returns bool

Select Prompt

const choices = [_]prompt.SelectPrompt.Choice{
    .{ .label = "TypeScript", .value = "ts", .description = "JavaScript with types" },
    .{ .label = "Zig", .value = "zig", .description = "Systems programming" },
};

var select = prompt.SelectPrompt.init(allocator, "Choose a language:", &choices);
defer select.deinit();

const selected = try select.prompt();
defer allocator.free(selected);

MultiSelect Prompt

const choices = [_]prompt.SelectPrompt.Choice{
    .{ .label = "Option 1", .value = "opt1" },
    .{ .label = "Option 2", .value = "opt2" },
};

var multi = try prompt.MultiSelectPrompt.init(allocator, "Select options:", &choices);
defer multi.deinit();

const selected = try multi.prompt();  // Returns [][]const u8
defer {
    for (selected) |item| allocator.free(item);
    allocator.free(selected);
}

Password Prompt

var password = prompt.PasswordPrompt.init(allocator, "Enter password:");
defer password.deinit();

_ = password.withMaskChar('*');
_ = password.withValidation(validatePassword);

const pwd = try password.prompt();
defer allocator.free(pwd);

Spinner Prompt

var spinner = prompt.SpinnerPrompt.init(allocator, "Loading data...");
try spinner.start();

// Do some work
std.time.sleep(2 * std.time.ns_per_s);

try spinner.stop("Data loaded successfully!");

Message Prompts

// Intro/Outro for CLI flows
try prompt.intro(allocator, "My CLI Application");
// ... your application logic ...
try prompt.outro(allocator, "All done! Thanks for using our CLI.");

// Notes and logs
try prompt.note(allocator, "Important", "This is additional information");
try prompt.log(allocator, .info, "Starting process...");
try prompt.log(allocator, .success, "Process completed!");
try prompt.log(allocator, .warning, "This is a warning");
try prompt.log(allocator, .error_level, "An error occurred");

// Cancel message
try prompt.cancel(allocator, "Operation was canceled");

Box Rendering

// Simple box
try prompt.box(allocator, "Title", "This is the content");

// Custom box with styling
var box = prompt.Box.init(allocator);
box = box.withStyle(.rounded);  // .single, .double, .rounded, .ascii
box = box.withPadding(2);
try box.render("My Box",
    \\Line 1 of content
    \\Line 2 of content
    \\Line 3 of content
);

Number Prompt

var num_prompt = prompt.NumberPrompt.init(allocator, "Enter port:", .integer);
defer num_prompt.deinit();

_ = num_prompt.withRange(1, 65535);  // Set min/max
_ = num_prompt.withDefault(8080);

const port = try num_prompt.prompt();  // Returns f64
const port_int = @as(u16, @intFromFloat(port));

Number types:

• .integer - Integer values
• .float - Floating-point values

Path Prompt

var path_prompt = prompt.PathPrompt.init(allocator, "Select file:", .file);
defer path_prompt.deinit();

_ = path_prompt.withMustExist(true);  // Must exist
_ = path_prompt.withDefault("./config.toml");

const path = try path_prompt.prompt();
defer allocator.free(path);

// Press Tab to autocomplete based on filesystem

Path types:

• .file - File selection
• .directory - Directory selection
• .any - File or directory

Group Prompts

const prompts = [_]prompt.GroupPrompt.PromptDef{
    .{ .text = .{ .key = "name", .message = "Your name?" } },
    .{ .number = .{ .key = "age", .message = "Your age?", .number_type = .integer } },
    .{ .confirm = .{ .key = "agree", .message = "Do you agree?" } },
    .{ .select = .{
        .key = "lang",
        .message = "Choose language:",
        .choices = &[_]prompt.SelectPrompt.Choice{
            .{ .label = "Zig", .value = "zig" },
            .{ .label = "TypeScript", .value = "ts" },
        },
    }},
};

var group = prompt.GroupPrompt.init(allocator, &prompts);
defer group.deinit();

try group.run();

// Access results by key
const name = group.getText("name");
const age = group.getNumber("age");
const agreed = group.getBool("agree");
const lang = group.getText("lang");

Progress Bar

var progress = prompt.ProgressBar.init(allocator, 100, "Processing files");
defer progress.deinit();

try progress.start();

for (0..100) |i| {
    // Do some work
    std.time.sleep(50 * std.time.ns_per_ms);
    try progress.update(i + 1);
}

try progress.finish();

Progress bar styles:

• .bar - Classic progress bar (█████░░░░░)
• .blocks - Block characters (▓▓▓▓▓░░░░░)
• .dots - Dots (⣿⣿⣿⣿⣿⡀⡀⡀⡀⡀)
• .ascii - ASCII fallback ([====------])

Table Rendering

const columns = [_]prompt.Table.Column{
    .{ .header = "Name", .alignment = .left },
    .{ .header = "Age", .alignment = .right },
    .{ .header = "Status", .alignment = .center },
};

var table = prompt.Table.init(allocator, &columns);
defer table.deinit();

table = table.withStyle(.rounded);  // .simple, .rounded, .double, .minimal

try table.addRow(&[_][]const u8{ "Alice", "30", "Active" });
try table.addRow(&[_][]const u8{ "Bob", "25", "Inactive" });
try table.addRow(&[_][]const u8{ "Charlie", "35", "Active" });

try table.render();

Style Chaining

// Create styled text with chainable API
const styled = try prompt.style(allocator, "Error occurred")
    .red()
    .bold()
    .underline()
    .render();
defer allocator.free(styled);

try prompt.Terminal.init().write(styled);

// Available colors: black, red, green, yellow, blue, magenta, cyan, white
// Available styles: bold(), dim(), italic(), underline()
// Available backgrounds: bgRed(), bgGreen(), bgBlue(), etc.

Configuration Files

zig-cli supports type-safe configuration loading from TOML, JSONC (JSON with Comments), and JSON5 files.

Loading Config

// 1. Define your config schema as a struct
const AppConfig = struct {
    database: struct {
        host: []const u8,
        port: u16,
    },
    log_level: enum { debug, info, warn, @"error" } = .info,
    debug: bool = false,
};

// 2. Load with full type checking
var config = try cli.config.load(AppConfig, allocator, "config.toml");
defer config.deinit();

// 3. Direct field access - type-safe!
std.debug.print("DB: {s}:{d}\n", .{
    config.value.database.host,
    config.value.database.port,
});

// Load from string
var config2 = try cli.config.loadFromString(AppConfig, allocator, toml_content, .toml);
defer config2.deinit();

// Auto-discover config file
var config3 = try cli.config.discover(AppConfig, allocator, "myapp");
defer config3.deinit();
// Searches for: myapp.toml, myapp.json5, myapp.jsonc
// In: ., ./.config, ~/.config/myapp

Reading Values

// Get typed values
if (config.getString("name")) |name| {
    std.debug.print("Name: {s}\n", .{name});
}

if (config.getInt("port")) |port| {
    std.debug.print("Port: {d}\n", .{port});
}

if (config.getBool("debug")) |debug| {
    std.debug.print("Debug: {}\n", .{debug});
}

if (config.getFloat("timeout")) |timeout| {
    std.debug.print("Timeout: {d}s\n", .{timeout});
}

// Get raw value for complex types
if (config.get("database")) |db_value| {
    // Handle nested tables, arrays, etc.
}

Supported Formats

TOML:

# config.toml
name = "myapp"
port = 8080

[database]
host = "localhost"

JSONC (JSON with Comments):

{
  // Comments are allowed
  "name": "myapp",
  "port": 8080,
  "database": {
    "host": "localhost"
  },  // trailing commas allowed
}

JSON5:

{
  // Unquoted keys
  name: 'myapp',  // single quotes
  port: 8080,
  permissions: 0x755,  // hex numbers
  ratio: .5,  // leading decimal
  maxValue: Infinity,  // special values
}

Terminal & ANSI

Colors

const ansi = @import("zig-cli").prompt.Ansi;

const colored = try ansi.colorize(allocator, "text", .green);
defer allocator.free(colored);

// Convenience functions
const bold = try ansi.bold(allocator, "text");
const red = try ansi.red(allocator, "error");
const green = try ansi.green(allocator, "success");

Symbols

const symbols = ansi.Symbols.forTerminal(supports_unicode);

std.debug.print("{s} Success!\n", .{symbols.checkmark});
std.debug.print("{s} Error!\n", .{symbols.cross});
std.debug.print("{s} Loading...\n", .{symbols.spinner[0]});

Examples

Check out the examples/ directory for complete examples:

• basic.zig - Basic CLI with options and subcommands
• prompts.zig - All prompt types with validation
• advanced.zig - Complex CLI with multiple commands and arguments
• showcase.zig - Comprehensive feature demonstration including all new prompts
• config.zig - Configuration file examples (TOML, JSONC, JSON5)
• typed.zig - Type-safe API examples (compile-time validated) (NEW!)

Example config files are in examples/configs/:

• example.toml - TOML format example
• example.jsonc - JSONC format example
• example.json5 - JSON5 format example

Run examples with your own Zig project by importing zig-cli.

Architecture

CLI Framework

CLI
├── Command (root)
│   ├── Options (parsed from --flags)
│   ├── Arguments (positional)
│   └── Subcommands (nested)
└── Parser (validation pipeline)

Prompt System

PromptCore (state machine)
├── Terminal I/O
│   ├── Raw mode handling
│   ├── Keyboard input
│   └── ANSI output
├── State: initial → active ↔ error → submit/cancel
└── Events: value, cursor, key, submit, cancel

Design Principles

1. Type Safety: Leverage Zig's type system for compile-time safety
2. Memory Ownership: Clear allocation/deallocation patterns
3. Error Handling: Explicit error handling with Zig's error unions
4. Cross-platform: Works on macOS, Linux, and Windows
5. Zero Dependencies: Only uses Zig standard library
6. Composable: Mix and match CLI and prompt features

Comparison with clapp

zig-cli is inspired by the TypeScript library clapp, bringing similar developer experience to Zig:

Feature	clapp	zig-cli
Builder Pattern	✅	✅
Subcommands	✅	✅
Command Aliases	✅	✅
Interactive Prompts	✅	✅
State Machine	✅	✅
Type Validation	✅	✅
ANSI Colors	✅	✅
Style Chaining	✅	✅
Spinner/Loading	✅	✅
Progress Bars	✅	✅
Box Rendering	✅	✅
Table Rendering	✅	✅
Message Prompts	✅	✅
Number Prompts	✅	✅
Path Prompts	✅	✅
Group Prompts	✅	✅
Terminal Detection	✅	✅
Dimension Detection	✅	✅
Config Files (TOML/JSONC/JSON5)	✅	✅
Middleware System	✅	✅
Language	TypeScript	Zig
Binary Size	~50MB (with Node.js)	~500KB
Startup Time	~50-100ms	<1ms

Testing

zig build test

License

MIT

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Roadmap

Completed Features ✅

Spinner/loading indicators
Box/panel rendering
Message prompts (intro, outro, note, log, cancel)
Terminal dimension detection
Command aliases
Config file support (TOML, JSONC, JSON5)
Auto-discovery of config files
Progress bars with multiple styles
Table rendering with column alignment
Style chaining (.red().bold().underline())
Group prompts with result access
Number prompt with range validation
Path prompt with autocomplete
Middleware system for commands
Type-safe API with compile-time validation (NEW!)
TypedCommand with auto-generated options from structs
TypedConfig with schema validation
TypedMiddleware with compile-time field checking

Future Enhancements

Tree rendering for hierarchical data
Date/time prompts
Shell completion generation (bash, zsh, fish)
Better Windows terminal support
Task prompts with status indicators
Streaming output prompts
Vim keybindings for prompts
Multi-column layout support