Husky.Net Documentation

Husky.Net brings the dev-dependency concept to the .NET ecosystem, allowing you to manage Git hooks and automate development workflows.

Key features include:

• Git hooks support: Works with all Git and Git-flow hooks using modern Git features.
• Task Runner: A powerful engine to manage and execute linters, tests, scripts, and other development tasks.
• Automation: Can be configured to run tasks automatically when contributors interact with the repository.
• Multiple File States: Supports filtering tasks based on file states such as staged, last-commit, git-files, and custom user-defined states.
• C# Scripting: Allows for complex task logic using C# scripting.

Husky.Net uses standard .NET FileSystemGlobbing patterns for the include and exclude properties.

Common Patterns:

• *.txt: All files with a .txt extension.
• *.*: All files with any extension.
• *: All files in the top-level directory.
• *word*: All files containing 'word' in the filename.
• styles/*.css: All .css files in the styles/ directory.
• **/*: All files in any subdirectory (arbitrary depth).
• dir/**/*: All files in any subdirectory under dir/.
• ../shared/*: Relative paths to match files in a sibling directory.

Husky manages Git submodules using two distinct behaviors depending on your configuration:

1. Default Mode: Husky installs hooks directly into the submodule's Git directory (e.g., .git/modules/mySubmodule). In this mode, hooks are only executed when you issue Git commands from inside the submodule folder.
2. Ignored Mode: Husky completely ignores project hooks and Husky steps when the project is identified as a Git submodule. This is achieved by using the --ignore-submodule flag during installation.

When running the default installation in a submodule, Husky will output a notification indicating where the hooks are being attached: Submodule detected, attaching .../Repository/Project/mySubmodule/.husky hooks to .../Repository/Project/.git/modules/mySubmodule

Husky.Net provides several advanced capabilities for managing Git workflows:

• Task Runner: Includes an internal task runner to execute various checks.
• Git Hook Support: Supports all Git and gitflow hooks.
• File State Awareness: Can target specific file states such as staged, last-commit, or general git-files.
• Scripting: Supports CSharp scripts (.csx) for complex logic.
• Cross-Platform: Works on macOS, Linux, and Windows.
• Modern Git Integration: Powered by the core.hooksPath Git feature.
• Extensibility: Supports user-defined variables and custom directories.
• Tool Compatibility: Works seamlessly with dotnet-format, CSharpier, ReSharper command line tools, and other formatting tools.
• Advanced Workflows: Supports Monorepos and Git GUIs.

You can add a new git hook by using the dotnet husky add command. You must specify the hook name (e.g., pre-commit) and the command to execute using the -c flag.

After adding a hook, ensure the newly created hook file in the .husky/ directory is staged in git.

dotnet husky add pre-commit -c "echo 'Husky.Net is awesome!'"
git add .husky/pre-commit

The Husky.Net documentation is powered by VuePress, with markdown source files located in the docs directory. You can run the documentation site locally using either yarn or npm to preview changes to the documentation.

# Using yarn
yarn install
yarn dev

# Using npm
npm install
npm run dev

If your project uses npm, you can automate the installation of Husky by adding a prepare script to your package.json. This ensures that dotnet tool restore and dotnet husky install are executed automatically after npm install.

 "scripts": {
      "prepare": "dotnet tool restore && dotnet husky install"
 }

You can automate the attachment of Husky to your project so that other contributors use your pre-configured tasks automatically without adding extra dependencies. Use the dotnet husky attach command followed by the path to your project file.

dotnet husky attach <path-to-project-file>

After installation, you must initialize Husky in your project directory to create the necessary git hooks configuration. Run the dotnet husky install command from your project root.

Note: If you installed Husky globally, you can omit the dotnet prefix from commands.

cd <Your project root directory>
dotnet husky install