magefile/mage
Mage
Mage is a build automation tool and workflow orchestrator that uses Go functions to define executable build targets instead of a custom domain-specific language. It functions as a compiled build system and task runner, mapping exported Go functions to command-line targets.
The tool distinguishes itself by compiling build definitions into static binaries for distribution to dependency-free machines. It utilizes hashed binary caching to avoid redundant compilations and supports the packaging of the runtime and defined tasks into a single standalone executable.
The platform covers dependency management through task dependency trees and file timestamp comparisons to ensure targets are updated in the correct order. It provides a command-line interface featuring target namespacing, shell autocompletion, and automatic help generation derived from function comments via reflection. Execution control includes support for both parallel and serial task processing, as well as timeout-aware cancellation.
The system integrates with Go modules and allows the inclusion of external libraries to extend build target capabilities.
Features
- Build and Task Automation - Functions as a build and task automation tool that uses Go functions to orchestrate development workflows.
- Build Automation - Implements build automation specifically for Go by using Go functions to define and execute targets.
- Function-to-Target Mappings - Maps exported Go functions to executable build targets to allow standard language features to define automation logic.
- Dependency Graph Step Executions - Resolves a graph of prerequisite functions to ensure each dependency runs exactly once before the primary target executes.
- Command Line Task Runners - Acts as a command line task runner for managing dependencies and executing targets in a manner similar to Make.
- Compiled Build Systems - Functions as a compiled build system that transforms Go-based build definitions into static binaries.
- Build Target Definitions - Provides a system for defining executable build targets using standard Go functions.
- Standalone Binary Packaging - Packages the runtime and all defined build tasks into a single standalone executable.
- Project Workflow Tools - Ships a CLI that integrates task execution, namespaces, and help documentation to streamline project workflows.
- Static Binary Compilers - Compiles build definition files into a temporary or static binary to execute tasks with native performance and type safety.
- Task Dependency Management - Executes a tree of prerequisite functions before a main task runs to ensure each dependency executes only once.
- Build Automation Tools - Provides a tool for automating the build lifecycle using Go functions as the definition language.
- Workflow Orchestrators - Organizes complex development pipelines and task dependencies using Go's standard library and package management.
- Task Prerequisites - Enables declaring dependencies between build functions to ensure all prerequisites are satisfied before a task executes.
- Command Namespacing - Organizes related build commands into hierarchical namespaces to prevent naming collisions.
- Build Cache Hashing - Stores compiled versions of build files based on content hashes to skip redundant compilation when source code is unchanged.
- Build Script Library Integration - Enables the use of standard and third-party Go packages directly within build targets.
- Standalone Binary Compilation - Compiles build definitions into a single standalone executable binary for use on machines without a Go installation.
- CLI Target Autocompletion - Offers shell tab completion for build targets and flags to improve command-line discoverability.
- Compiler Caches - Utilizes hashed binary caching of compiled build files to avoid redundant compilation overhead.
- Build Constraints - Uses standard Go build tags to filter automation targets based on the host operating system or architecture.
- Host-Based Target Constraints - Uses Go build constraints to include or exclude specific targets based on the host OS or architecture.
- External Target Reuse - Enables the import of build functions from external Go packages to be used as runnable targets.
- Help Generators - Extracts function comments and signatures via reflection to automatically generate command-line documentation and usage guides.
- Help Text Generators - Converts function comments into brief summaries and detailed help text for targets and flags.
- Task Execution Sequencing - Runs a sequence of tasks serially in a specified order and halts if any task fails.
- Parallel Task Execution - Allows running dependent tasks concurrently for speed or sequentially to maintain a strict execution order.
- Build Environment Configurations - Allows customization of binary paths, cache locations, and rebuild triggers via environment variables.
- Shell Command Execution - Runs system commands with an interface that handles environment variable expansion and simplifies execution.
- Timestamp-Based Build Optimization - Compares source and destination timestamps to determine if a build target requires an update.
- Automation Engine Argument Passing - Accepts positional and optional flag parameters from the command line and converts them into specific types.
- CI/CD Pipeline Orchestration - Provides the ability to define and execute sequential build, test, and deployment targets for automated delivery pipelines.
- Go Module Organization - Integrates with Go modules to manage dependencies and workspace configurations during target execution.
- Build System Extensibility - Extends build target capabilities by integrating existing Go packages without requiring a formal plugin system.
- Installation-Free Execution - Allows running automation targets directly using the runtime to avoid installing a dedicated binary in the environment.
- Documentation Comment Generators - Converts function comments into summaries and help text to provide guidance on available targets and flags.
- Asynchronous Task Cancellation - Passes a timeout-aware context to tasks and dependencies to cancel execution when a time limit expires.
- Context-Aware Cancellation - Passes timeout-aware contexts through the execution chain to allow graceful termination of long-running build processes.
- Build and Compilation Tools - Makefile-like build tool for projects.
- Build Automation - Make-like build tool using Go code.
