Git Hooks Generator

Build executable hooks for linting, commit validation, and tests before changes leave your machine.

Secure (SSL)

Client-Side Processing

100% Free

Go to tool

Instructions

1

Enter data
Enter content, paste text or load a file from disk.
2

Click the button
The tool will immediately process your data in the browser.
3

Get the result
Copy the finished text or save the file to your device.

                                                function runTool() {

                                                  return "Result ready in 0.1s";

                                                }

Hooks

pre-commit (lint before commit)

commit-msg (message validation)

pre-push (tests before push)

Tool

Lint command

Test command

Commit message pattern

Hooks: 3

#!/usr/bin/env sh
set -eu

# Git hooks installer — run it in the repository root.
target_dir="$(git rev-parse --git-path hooks)"
mkdir -p "$target_dir"

# Installing the pre-commit hook
{
  printf '%s\n' '#!/usr/bin/env sh'
  printf '%s\n' 'set -eu'
  printf '%s\n' 'npm run lint'
} > "$target_dir/pre-commit"
chmod +x "$target_dir/pre-commit"

# Installing the commit-msg hook
{
  printf '%s\n' '#!/usr/bin/env sh'
  printf '%s\n' 'set -eu'
  printf '%s\n' 'if [ "$#" -lt 1 ]; then'
  printf '%s\n' '  echo '"'"'Git did not provide a commit message file.'"'"' >&2'
  printf '%s\n' '  exit 2'
  printf '%s\n' 'fi'
  printf '%s\n' 'if ! grep -Eq -- '"'"'^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?: .+'"'"' "$1"; then'
  printf '%s\n' '  echo '"'"'Invalid commit message. Use Conventional Commits.'"'"' >&2'
  printf '%s\n' '  exit 1'
  printf '%s\n' 'fi'
} > "$target_dir/commit-msg"
chmod +x "$target_dir/commit-msg"

# Installing the pre-push hook
{
  printf '%s\n' '#!/usr/bin/env sh'
  printf '%s\n' 'set -eu'
  printf '%s\n' 'npm test'
} > "$target_dir/pre-push"
chmod +x "$target_dir/pre-push"

printf '%s\n' 'Git hooks were installed and made executable.'

Run the copied installer in the repository root with sh install-hooks.sh. It writes hooks to .git/hooks/ or .husky/ and runs chmod +x. Husky must already be installed in the project.

Rate this tool:

Related tools

Other tools you may find useful

Git hooks generator for automated checks before commit and push

Git Hooks Generator creates a portable POSIX shell installer that writes selected pre-commit, commit-msg, and pre-push scripts to the correct directory and makes them executable. Choose native Git hooks or Husky, enter your lint and test commands, and run the result once from the repository root.

What the generator actually creates

The result is not an ambiguous collection of file fragments. It is a complete installer beginning with #!/usr/bin/env sh and set -eu. Native mode obtains the hooks directory through git rev-parse --git-path hooks, so it also respects a customized Git path. Husky mode targets .husky/. Every installed hook receives its own shebang, fail-fast behavior, and an explicit chmod +x.

Hook	When it runs	Generated behavior
`pre-commit`	Before a commit is created	Runs the selected linter, such as ESLint, Ruff, or PHP_CodeSniffer
`commit-msg`	After the message is saved	Checks Git's first argument with an extended regular expression
`pre-push`	Before references are sent	Runs tests and blocks the push when the command fails
Installer	Once per repository clone	Creates the target directory, writes files, and sets executable bits

How to install the generated hooks

Select the Node, PHP, Python, or Husky preset. A preset supplies practical starting commands that remain fully editable.
Enable only the stages your team needs. Empty or multiline commands are rejected so an accidental line break cannot change the installer structure.
Copy the output to a file such as install-hooks.sh in the repository root.
Run sh install-hooks.sh. It writes each hook and performs chmod +x, with no manual permission step.
Try a sample commit and push. You may remove the installer afterward or keep it versioned as documentation of the policy.

Document the same repository conventions alongside the Dockerignore Generator. Repeat important local checks in a workflow from the GitHub Actions Generator or GitLab CI Generator, because developers can bypass local hooks.

Portable shell and safe quoting

The installer uses POSIX sh syntax only. It writes every hook line through printf with shell-safe quoting, so an apostrophe in a regular expression cannot terminate the installer's literal early. Lint and test commands stay as single lines and execute later inside their hooks, never while the browser generates the text.

The commit-msg hook first verifies that Git supplied a message file. It then calls grep -Eq --; the -- separator prevents a pattern beginning with a dash from becoming an option. The default expression accepts common Conventional Commit types, an optional scope in parentheses, a colon, one space, and a meaningful description.

Native hooks compared with Husky

Files under .git/hooks belong to one clone and are not normally versioned. They are lightweight and have no Node dependency, but every contributor must run the installer. Husky stores scripts under .husky, allowing the team to commit them and activate them during dependency setup. The output intentionally avoids the obsolete _/husky.sh bootstrap; each hook is a standalone executable script.

Husky must still be installed and enabled in the project. This tool does not modify package.json, download packages, or run a package manager. Use the Gitignore Generator to keep local lint caches and test artifacts out of version control.

Limits and team policy

A hook is a fast feedback mechanism, not a server-side security boundary. Git supports --no-verify, so mandatory checks must run again in CI. You provide the commands and should only use trusted project scripts. The generator never executes them, checks whether their binaries exist, or installs dependencies.

Keep local hooks quick. Linting changed files is usually suitable for pre-commit, the main test suite can run in pre-push, and expensive security scans belong in CI. When a hook takes several minutes, contributors are more likely to bypass it. A failure should explain both the cause and the exact command that fixes the problem.

Frequently asked questions

Why does a copied hook not run?

Unix-like systems require the executable bit. The generated installer performs chmod +x automatically. If you moved the hook another way, inspect it with ls -l and restore that permission.

Do these hooks work on Windows?

They work in Git Bash, WSL, or another environment providing POSIX sh. Hook files should use LF line endings. Native PowerShell requires a separate wrapper, which this generator does not create.

Can a command contain arguments?

Yes. A value such as npm test -- --runInBand remains one line and runs inside the hook. Multiline snippets are rejected intentionally; place complex logic in a versioned project script instead.

How do I customize the commit message format?

Enter an extended regular expression supported by grep -E. The installer safely quotes apostrophes but does not alter operators. Test representative valid and invalid messages in a local shell first.

Do hooks replace a CI pipeline?

No. A hook provides quick feedback before commit or push, but it can be bypassed and exists only in configured clones. Server-side CI remains the repeatable merge requirement.