Write code, not commands. MasterCommander provides a simple, consistent interface for common development tasks.
 |
MasterCommander is a versatile command-line utility designed to streamline the workflow for developers working with multiple technology stacks. By integrating common operations for Git, .NET, Docker, and npm into a single application, MasterCommander enhances productivity and simplifies project setup and management tasks. |
|---|
- MasterCommander
Use your favorite CLI tools without leaving your code editor:
This example demonstrates how to use MasterCommander to create a new .NET solution and project, initialize a Git repository, and build and run the project. In addition, this code adds a .gitignore file, an .editorconfig file, and a global.json file to the project.
private const string SdkVersion = "8.0.*";
private const string SolutionName = "AppDemo";
private const string ConsoleProjectName = $"{SolutionName}.Console";
private const string ConsoleProjectDirectory = $"src/{ConsoleProjectName}";
private const string ConsoleCsproj = $"{ConsoleProjectDirectory}/{ConsoleProjectName}.csproj";
await git.InitAsync();
await git.StatusAsync();
await dotnet.NewAsync(new DotnetNewGitignoreOptions());
await dotnet.NewAsync(new DotnetNewEditorConfigOptions());
await dotnet.NewAsync(new DotnetNewNuGetConfigOptions());
await dotnet.NewAsync(new DotnetNewGlobalJsonOptions { SdkVersion = SdkVersion });
await dotnet.NewAsync(new DotnetNewSolutionOptions { OutputName = SolutionName });
await dotnet.NewAsync(new DotnetNewConsoleOptions { OutputName = ConsoleProjectName, OutputDirectory = ConsoleProjectDirectory });
await dotnet.SlnAddAsync(ConsoleCsproj);
await git.AddAsync("*");
await dotnet.BuildAsync();
await dotnet.BuildAsync(new DotnetBuildOptions { Configuration = "Release" });
await dotnet.RunAsync(new DotnetRunOptions { Project = ConsoleCsproj, Configuration = "Release" });You can standardize your development workflow by using MasterCommander to perform common tasks across multiple projects and technology stacks.
Output from MasterCommander commands is displayed in a clean, readable format:
Explore the extensive documentation to get started with MasterCommander, understand its capabilities, and integrate it into your projects effectively. Our documentation is split into two main sections to cater to different needs:
For an overview of MasterCommander, including features, installation guides, and how to get started with using the library in your projects, visit our User Documentation. This section is designed to help both beginners and experienced users to quickly leverage the library's full potential.
For developers looking for in-depth technical details, our Technical Documentation provides comprehensive insights into the library's internal workings, API references, and code examples. This section is ideal for those who want to extend the library, contribute to its development, or simply understand its mechanisms at a deeper level.
Our documentation is written in English to reach a broad audience. We welcome contributions from the community to expand our documentation, including translations into other languages. If you're interested in helping us make MasterCommander more accessible by translating the documentation or improving the existing content, please open an issue on our GitHub repository to discuss your ideas.
Note: The documentation for MasterCommander is generated automatically using the Doraku/DefaultDocumentation tool whenever the project is built. This ensures that the documentation is always up-to-date with the latest codebase.
- Unified Interface: MasterCommander provides a single interface for interacting with multiple development tools.
- Simple Commands: Execute common development tasks with simple, intuitive commands.
- Cross-Platform: MasterCommander is designed to work on Windows, macOS, and Linux.
- Customizable: Add new commands and features to MasterCommander to suit your workflow.
- WIP => .NET Projects: Easily create new .NET solutions and projects.
- WIP => Git Integration: Initialize new repositories, check status, and more with built-in Git commands.
- WIP => Docker Support: Manage Docker containers and images through simple commands.
- WIP => npm Packages: Handle npm packages and run npm scripts within your projects.
- Comprehensive API documentation that is easy to understand
- High-Level API for common use cases
- More tests
- More examples
- More features
To use MasterCommander, ensure you have the following installed on your system:
- Git
- .NET 8.0 (supported versions: 8.0.101 or later)
- A C# IDE (Visual Studio, JetBrains Rider, etc.)
- A C# compiler (dotnet CLI, etc.)
- Docker (optional)
- Node.js and npm (optional)
This library targets .NET 8.0 and uses the latest C# features. It is written in C# 12.0 and uses the new init
properties, record types, switch expressions, using declarations and more.
I invite you to read the C# 12.0 documentation to learn more about these features.
You can also build MasterCommander from source. Follow these steps to get started:
- Clone the repository to your local machine.
- Navigate to the cloned directory and build the project using the .NET CLI:
dotnet build. - Run the application with
dotnet runfrom within the source directory. - Or... open the project in Visual Studio (or JetBrains Rider) and run the application from the IDE.
To install MasterCommander, you can use the NuGet package manager. Run the following command in your terminal:
dotnet add package MasterCommander| Package Name | NuGet Version Badge | NuGet Downloads Badge | Package Explorer |
|---|---|---|---|
| MasterCommander |  |
 |
Explore |
This table is automatically updated regularly the latest developments and releases.
We strive for the highest code quality in MasterCommander. To ensure this, we use the following tools:
- StyleCop
- .editorconfig
We use xUnit and FluentAssertions to write and run tests for MasterCommander. This ensures that the library is reliable and performs as expected.
Contributions to MasterCommander are welcome! Whether it's reporting bugs, discussing improvements, or submitting pull requests, all contributions help make MasterCommander a better tool for developers.
Before submitting pull requests, please ensure you have discussed the proposed changes with the project maintainers.
A great way to contribute to MasterCommander is to add new commands. If you have a command you'd like to see added to MasterCommander, please open an issue to discuss it.
For reporting bugs or suggesting new features, kindly submit these as an issue to the MasterCommander Repository. We value your contributions, but before submitting an issue, please ensure it is not a duplicate of an existing one.
You can contact us by opening an issue on this repository.
GNU General Public License v3.0 or later.