spf13/cobra
Cobra
Cobra is a development framework for building command-line applications in Go. It organizes application logic into a hierarchical tree structure where each node represents a command, complete with its own flags and execution logic. This structure allows developers to build complex, nested command interfaces that mirror business domains while maintaining a clean separation between command orchestration and underlying business logic.
The framework distinguishes itself through its declarative approach to metadata and configuration. It automatically derives help documentation, usage instructions, and shell completion scripts directly from the defined command and flag structures. Furthermore, it provides a robust configuration management layer that merges settings from default values, configuration files, environment variables, and command-line flags based on defined precedence rules, ensuring consistent behavior across different environments.
Beyond core command and configuration management, the project includes a middleware hook system for injecting cross-cutting concerns like authentication, telemetry, or validation into the command execution lifecycle. It also supports advanced interface patterns such as persistent flag propagation, command aliasing, and a plugin architecture for extending functionality without recompilation. The framework includes built-in utilities for project scaffolding, programmatic command testing, and error propagation to support the development of professional-grade terminal tools.
Features
- CLI Frameworks - Provides the core structure for building professional command-line tools with nested subcommands and flags.
- Command Line Frameworks - Organizes command-line applications into hierarchical trees of nested subcommands and flags.
- Command Hierarchies - Organizes application logic into a nested tree structure where each node represents a command with its own flags and execution logic.
- Flag Definitions - Supports creating persistent and local flags with custom types, validation, mutual exclusivity, and hidden options.
- Configuration Management - Merges settings from defaults, files, environment variables, and flags using defined precedence rules.
- Configuration Managers - Orchestrates settings across multiple sources using a unified hierarchy and precedence rules.
- Subcommand Registration - Allows attaching child commands to a parent structure during initialization to build complex, hierarchical command interfaces.
- Testing Frameworks - Verifies command logic in isolation or as complete flows using programmatic execution.
- Command Line Interfaces - Modern CLI interaction and command framework.
- Command Line Tools - Standard library for creating powerful CLI apps.
- Console Interfaces - Listed in the “Console Interfaces” section of the Awesome Go awesome list.
- Core Language Tools - A library for creating powerful modern CLI applications.
- Developer Tools and CLIs - Commander for modern CLI interactions.
- Go CLI Frameworks - Standard library for building modern CLI applications.
- Utility Libraries - Library for creating powerful CLI applications in Go.
- Command Orchestration - Organizes applications into nested command trees that mirror business domains for clean separation of concerns.
- Configuration Layers - Resolves application settings by merging multiple sources into a unified hierarchy.
- Configuration Resolution - Loads settings from files, environment variables, and defaults using hierarchical resolution to ensure consistent behavior.
- Execution Middleware - Implements cross-cutting concerns like authentication and telemetry through reusable command hooks.
- Middleware Systems - Provides a hook system to execute cross-cutting logic at pre-run and post-run stages.
- Documentation Generators - Creates synchronized help text and markdown documentation directly from command definitions.
- Flag Propagation - Allows parent-level configuration flags to be inherited by all descendant subcommands for consistent global settings.
- Help Generators - Generates synchronized help documentation directly from command structures with support for custom formatting.
- Plugin Systems - Supports extending application functionality without recompilation by discovering and integrating external binaries.
- Shell Environment Integrations - Handles standard input and output piping, exit codes, and environment variable binding.
- Error Propagation Systems - Enables predictable error propagation through command hierarchies without forced process termination.
- Execution Hooks - Provides pre-run and post-run extension points for injecting cross-cutting concerns like authentication or telemetry.
- Flag Validation Utilities - Enforces mandatory flag requirements and provides automated error feedback for missing inputs.
- Modular Architecture - Enables separating command logic into distinct packages with constructor functions to maintain clean dependencies.
- Shell Autocompletion Providers - Improves user productivity by providing dynamic, context-aware command and flag suggestions.
- Shell Completion Generators - Produces dynamic, context-aware auto-completion scripts for various terminal environments.
- Shell Completion Integrations - Generates and installs completion scripts to enable command-line argument auto-completion.
