alecthomas/kong

Features

• CLI and Argument Parsing - Transforms raw command-line strings into typed Go data structures with automatic validation and default assignment.
• Command-Line Argument Parsers - Provides a comprehensive system for parsing command-line flags, positional arguments, and configuration options into typed Go structs.
• CLI Struct Mapping - Maps command line flags and positional arguments directly into typed Go structures using reflection.
• Struct Mapping - Parses flags and arguments into a typed data structure to simplify configuration and input handling.
• Nested Command Structures - Supports the organization of large-scale applications into nested command structures and sub-commands.
• Declarative Argument Definitions - Allows developers to define terminal interfaces through declarative Go structures and struct tags.
• Command Execution Logic - Invokes run methods on selected command nodes and their parents to execute the requested action.
• Command Line Interface Frameworks - Provides a complete toolkit for building professional terminal applications with nested sub-commands and automated help.
• Configuration Mappers - Populates Go structures by mapping inputs from command-line arguments, environment variables, and JSON files.
• Go CLI Frameworks - Provides a Go-specific framework for mapping flags and arguments directly into typed Go structures.
• Help Text Generators - Automatically constructs and formats instructional usage documentation based on the data model.
• Application Configuration - Populates Go structures from environment variables and JSON files to supplement command-line flags.
• Dependency Injection Providers - Provides a dependency injection container to pass external services and values into command handlers.
• Struct Tags - Uses struct tags to define flag behavior, help text, and validation constraints within the data model.
• Command-Line Interface Development - Enables building terminal applications with structured command hierarchies, flags, and positional arguments using Go structs.
• Shared Configuration Embedding - Allows integrating external structures into the root interface to share flags across different commands.
• Command Line Interface Plugins - Provides a plugin architecture to extend CLI tools with dynamic command registration and shared configurations.
• Command Metadata - Provides structures for defining command names, help text, and aliases separately from the data model.
• Runtime Command Registration - Allows the application to be extended by adding new commands at runtime.
• Environment Variable Mapping - Populates configuration fields using environment variables with support for custom prefixes and aliases.
• Boolean Flag Negation - Generates a corresponding disable flag for boolean options to allow users to explicitly turn off default features.
• Configuration File Loading - Populates default values for flags and arguments from external sources like JSON files.
• JSON Parsing - Parses a JSON source to populate flag values by mapping names to JSON keys.
• Command Tree Traversers - Walks a hierarchical tree of commands and sub-commands to apply configuration and resolve active nodes.
• Configuration Fallbacks - Populates missing input values with predefined defaults before validating the final configuration.
• Custom Type Decoders - Transforms raw input strings into complex types via custom decoding interfaces implemented by the target fields.
• Dependency Injection Containers - Includes a dependency injection container to pass external services and values into command handlers.
• Parse Error Reporters - Provides detailed error objects with trigger context and suggested exit codes for parsing failures.
• Extensible Plugin Architectures - Ships an extensible architecture that supports modular extensions and custom logic injection.
• Command Lifecycle Hooks - Executes custom logic at predefined stages of the parsing process through pluggable command lifecycle hooks.
• Modular Plugin Extensions - Integrates external structures into the application via pointers to support modular plugin functionality.
• Parser Lifecycle Hooks - Executes custom logic at specific stages, such as before resolving arguments or after applying inputs.
• Allowed Value Validations - Checks that loaded settings match allowed enum values or required field constraints.
• Required Field Enforcement - Marks specific flags as required and prevents the application from running if they are missing.
• Conflicting Argument Restrictions - Restricts the user from providing conflicting flags simultaneously to prevent invalid configurations.
• Input Validation - Provides mechanisms for verifying structural and custom constraints on parsed commands to ensure data integrity.
• Terminal Input Validation - Implements custom validation interfaces on command nodes to ensure arguments meet specific criteria.
• Configuration Management - Listed in the “Configuration Management” section of the Awesome Go awesome list.
• Command Line Tools - Struct-based command-line argument parser.
• Configuration Management - Command-line and configuration parser.
• Go CLI Frameworks - Library for complex command-line structures with minimal effort.

Star history