Husky: Simplifying Git Hooks

02/11/2025

1 View 0

SaveSavedRemoved 0

Automate Your Code Quality: A Developer’s Guide to Husky and Git Hooks

In modern software development, maintaining a clean, consistent, and error-free codebase is paramount. We rely on linters, formatters, and test suites to uphold quality standards. But what happens when a team member forgets to run these checks before pushing their code? The result is often a broken build, wasted time, and frustrating code reviews.

The solution isn’t to rely on manual checks and memory. It’s to automate the process. This is where Git hooks, supercharged by a tool called Husky, transform your development workflow from a game of chance into a system of guaranteed quality.

The Problem with Manual Checks

Let’s be honest: developers are human. We forget things. In the rush to meet a deadline, it’s easy to commit code that doesn’t adhere to the project’s style guide or that fails a crucial test. Relying on your CI/CD pipeline to catch these issues is a viable but slow feedback loop. You’ve already pushed the code, and now you have to wait for the build to fail before you can fix it.

There has to be a better, faster way to catch these problems—a way to enforce standards before the code ever leaves your local machine.

What Are Git Hooks?

Git has a powerful, built-in feature to solve this exact problem: Git hooks. These are simply scripts that Git automatically executes before or after key events like committing and pushing.

Some of the most common and useful hooks include:

pre-commit: Runs before a commit is created. This is the perfect place to run linters, formatters, and quick tests. If the script fails, the commit is aborted.
pre-push: Runs before you push code to a remote repository. This is an excellent final checkpoint to run your full test suite and ensure you’re not pushing broken code.
commit-msg: Runs after you’ve written a commit message. It can be used to check if your message conforms to a specific format (e.g., Conventional Commits).

The biggest challenge with native Git hooks is that they live inside the .git/hooks directory. This directory is not tracked by Git, which means you can’t version control your hooks or easily share them with your team. This is the critical problem that Husky solves.

Introducing Husky: Your Git Hooks Manager

Husky is a popular tool that makes using Git hooks simple, manageable, and team-friendly. It bridges the gap between your project’s dependencies and your Git workflow, allowing you to define your hooks in a way that can be checked into version control and shared across the entire team.

When you use Husky, everyone who clones the project and installs the dependencies gets the exact same hooks automatically. No more manual setup or “it works on my machine” excuses.

Getting Started: How to Set Up Husky in Your Project

Setting up Husky is incredibly straightforward. Here’s a step-by-step guide for a typical Node.js project.

Step 1: Install Husky

First, add Husky as a development dependency to your project.

npm install husky --save-dev

Step 2: Enable Git Hooks

Next, you need to activate Husky’s hooks. The husky install command creates a .husky/ directory in your project root where your hook scripts will live.

npx husky install

To ensure this runs automatically for anyone who sets up the project, add a prepare script to your package.json:

{
  "scripts": {
    "prepare": "husky install"
  }
}

The prepare script is an npm lifecycle script that runs automatically after npm install.

Step 3: Create Your First Hook

Now you can add a hook. Let’s create a pre-commit hook that runs your tests. Use the husky add command to generate the hook file.

npx husky add .husky/pre-commit "npm test"

This command creates a new file at .husky/pre-commit containing the command npm test. Now, every time you try to make a commit, npm test will run first. If the tests fail, Git will block the commit, forcing you to fix the issues before proceeding.

Supercharge Your Hooks with lint-staged

Running tests on every commit is great, but what about linting and formatting? Running a linter on your entire codebase every single time can be slow. A much more efficient approach is to only run checks on the files you’ve changed and staged for commit.

This is where lint-staged comes in. It’s a tool designed to work perfectly with Husky.

Install lint-staged:
```
npm install lint-staged --save-dev
```
Configure lint-staged in package.json:
Add a lint-staged key to your package.json to define which commands to run on which files. For example, to run ESLint and Prettier on staged JavaScript files:
```
"lint-staged": {
  "*.{js,jsx,ts,tsx}": [
    "eslint --fix",
    "prettier --write"
  ]
}
```
Update Your pre-commit Hook:
Modify your .husky/pre-commit hook to run lint-staged instead of a broader command.
bash npx husky set .husky/pre-commit "npx lint-staged"

With this setup, when you run git commit, Husky will trigger the pre-commit hook, which in turn runs lint-staged. lint-staged will then execute your defined ESLint and Prettier commands only on the relevant staged files, making the process incredibly fast and efficient.

Why Every Development Team Needs Automated Hooks

Integrating Husky into your workflow isn’t just about adding another tool—it’s about fundamentally improving how your team builds software.

Enforces Consistency: Automated hooks ensure every team member adheres to the same coding standards, formatting rules, and commit message conventions.
Improves Code Quality: By catching linting errors and failed tests before they are even committed, you keep your main branch cleaner and more stable.
Increases Efficiency: It provides an immediate feedback loop, allowing developers to fix issues instantly rather than waiting for a CI build to fail. This saves significant time and reduces context switching.
Streamlines Code Reviews: Pull requests become cleaner and more focused on logic and architecture, as reviewers don’t have to waste time pointing out simple style violations or formatting issues.

By automating your quality gates with Husky, you empower your team to focus on what truly matters: writing great code. Stop relying on memory and start building a more robust, efficient, and consistent development process today.

Source: https://www.linuxlinks.com/husky-git-hooks/