Lefthook

https://lefthook.dev
Admin
Lefthook is a Git hooks manager that allows users to configure and automate tasks like running...
Tokens:20,875
Snippets:358
Trust Score:6.9
Update:1 month ago
Show doc for...
Tokens:
Raw
### Configure setup instructions in lefthook.yml

Source: https://lefthook.dev/configuration/setup

Example of using the setup key to ensure a dependency like golangci-lint is installed before running the pre-commit job.

```yaml
# lefthook.yml

pre-commit:
  setup:
    - run: |
        if ! command -v golangci-lint >/dev/null 2>&1; then
          go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.10.1
        fi
  jobs:
    - run: golangci-lint -- {staged_files}
      glob: "*.go"
```

--------------------------------

### Run lefthook install

Source: https://lefthook.dev/usage/commands/install

Executes the installation command to create a lefthook.yml file and install hooks.

```bash
lefthook install
```

--------------------------------

### Install Lefthook with npm

Source: https://lefthook.dev/installation/node

Standard installation command for npm users.

```bash
npm install --save-dev lefthook
```

--------------------------------

### Install Lefthook with yarn

Source: https://lefthook.dev/installation/node

Standard installation command for yarn users.

```bash
yarn add --dev lefthook
```

--------------------------------

### Install Lefthook via yay

Source: https://lefthook.dev/installation/arch

Use yay to install Lefthook from the AUR. Choose between compiling from source or installing the pre-compiled binary.

```bash
# To compile from sources
yay -S lefthook

# To install only executable
yay -S lefthook-bin
```

--------------------------------

### Install Lefthook on Alpine Linux

Source: https://lefthook.dev/installation/alpine

Install required dependencies, run the setup script, and install the lefthook package.

```bash
sudo apk add --no-cache bash curl
curl -1sLf 'https://dl.cloudsmith.io/public/evilmartians/lefthook/setup.alpine.sh' | sudo -E bash
sudo apk add lefthook
```

--------------------------------

### lefthook.yml configuration example

Source: https://lefthook.dev/usage/commands/run

Example configuration defining jobs for pre-commit and test hooks.

```yaml
# lefthook.yml

pre-commit:
  jobs:
    - name: lint
      run: yarn lint --fix {staged_files}

test:
  jobs:
    - name: test
      run: yarn test
```

--------------------------------

### Install Commitlint and Commitzen dependencies

Source: https://lefthook.dev/examples/commitlint

Install the necessary CLI tools and conventional configuration packages using yarn.

```bash
yarn add -D @commitlint/cli @commitlint/config-conventional

# For commitzen
yarn add -D commitizen cz-conventional-changelog
```

--------------------------------

### Install specific hooks

Source: https://lefthook.dev/usage/commands/install

Installs only the specified hooks by passing their names as arguments.

```bash
lefthook install <hook-1> <hook-2> ...
```

--------------------------------

### Folder structure example

Source: https://lefthook.dev/configuration/root

A representation of a project directory containing client and server subdirectories.

```text
# Folders structure

$ tree .
.
├── client/
│   ├── package.json
│   ├── node_modules/
|   ├── ...
├── server/
|   ...
```

--------------------------------

### Install Lefthook with mise use

Source: https://lefthook.dev/installation/mise

Use this command to install the latest version of Lefthook using the mise version manager.

```bash
mise use lefthook@latest
```

--------------------------------

### Example lefthook.yml configuration

Source: https://lefthook.dev/configuration/rc

A sample configuration for a pre-commit hook running eslint.

```yaml
# lefthook.yml

pre-commit:
  commands:
    lint:
      run: npm run eslint {staged_files}
```

--------------------------------

### Force install hooks

Source: https://lefthook.dev/usage/commands/install

Forces the installation of hooks, useful when core.hooksPath is already set.

```bash
lefthook install --force
```

--------------------------------

### Install Lefthook via Snap

Source: https://lefthook.dev/installation/snap

Use this command to install the Lefthook package on Linux systems with classic confinement.

```bash
snap install --classic lefthook
```

--------------------------------

### Test commit workflow

Source: https://lefthook.dev/examples/commitlint

Verify the setup by committing with commitzen or providing a manual commit message for linting.

```bash
# You can type it without message, if you are using commitzen
git commit

# Or provide a commit message is using only commitlint
git commit -am 'fix: typo'
```

--------------------------------

### Install Lefthook globally

Source: https://lefthook.dev/installation/go

Use this command to install the Lefthook binary as a global package on your system.

```bash
go install github.com/evilmartians/lefthook/v2@v2.1.12
```

--------------------------------

### Install Lefthook via APT

Source: https://lefthook.dev/installation/deb

Run these commands to configure the repository and install the lefthook package on Debian or Ubuntu systems.

```bash
curl -1sLf 'https://dl.cloudsmith.io/public/evilmartians/lefthook/setup.deb.sh' | sudo -E bash
sudo apt install lefthook
```

--------------------------------

### Install legacy @evilmartians/lefthook-installer package

Source: https://lefthook.dev/installation/node

Legacy distribution that fetches the right executable on installation.

```bash
npm install --save-dev @evilmartians/lefthook-installer
```

--------------------------------

### Install Lefthook with Homebrew

Source: https://lefthook.dev/installation/homebrew

Use this command to install the Lefthook package on macOS or Linux systems with Homebrew installed.

```bash
brew install lefthook
```

--------------------------------

### Install Lefthook globally

Source: https://lefthook.dev/installation/ruby

Install the Lefthook gem globally using the gem command.

```bash
gem install lefthook
```

--------------------------------

### Install Lefthook with pipx

Source: https://lefthook.dev/installation/python

Installs Lefthook in an isolated environment using pipx.

```bash
pipx install lefthook
```

--------------------------------

### Install Lefthook via Scoop

Source: https://lefthook.dev/installation/scoop

Run this command in your terminal to install the Lefthook CLI tool using Scoop.

```bash
scoop install lefthook
```

--------------------------------

### Install Lefthook with pnpm

Source: https://lefthook.dev/installation/node

Standard installation command for pnpm users. Note that you must update pnpm-workspace.yaml and package.json to include lefthook in onlyBuiltDependencies for the postinstall script to run.

```bash
pnpm add -D lefthook
```

--------------------------------

### Install Lefthook via Winget

Source: https://lefthook.dev/installation/winget

Use this command in your terminal to install the Lefthook package on Windows.

```bash
winget install evilmartians.lefthook
```

--------------------------------

### Define commands with multiple tags

Source: https://lefthook.dev/configuration/exclude_tags

Example configuration for pre-push hooks with multiple tags assigned to commands.

```yaml
# lefthook.yml

pre-push:
  commands:
    packages-audit:
      tags:
        - frontend
        - security
      run: yarn audit
    gems-audit:
      tags:
        - backend
        - security
      run: bundle audit
```

--------------------------------

### Example main lefthook.yml configuration

Source: https://lefthook.dev/examples/lefthook-local

A standard lefthook.yml configuration defining pre-commit hooks for linting and link checking.

```yaml
# lefthook.yml

pre-commit:
  commands:
    lint:
      run: bundle exec rubocop -- {staged_files}
      glob: "*.rb"
    check-links:
      run: lychee -- {staged_files}
```

--------------------------------

### Run hooks and jobs manually

Source: https://lefthook.dev/usage/commands/run

Examples of running specific hooks or jobs manually via the CLI.

```bash
$ lefthook run test # will run 'yarn test'
$ git commit # will run pre-commit hook ('yarn lint --fix')
$ lefthook run pre-commit # will run pre-commit hook (`yarn lint --fix`)
```

--------------------------------

### Install Lefthook with uv

Source: https://lefthook.dev/installation/python

Adds Lefthook as a development dependency to the current project using uv.

```bash
uv add --dev lefthook
```

--------------------------------

### Install legacy @evilmartians/lefthook package

Source: https://lefthook.dev/installation/node

Legacy distribution that installs executables for all OS.

```bash
npm install --save-dev @evilmartians/lefthook
```

--------------------------------

### Install git hooks

Source: https://lefthook.dev/configuration/rc

Command to update git hooks after configuration.

```bash
# Make sure you updated git hooks. This is important.
$ lefthook install -f
```

--------------------------------

### Install Lefthook via RPM

Source: https://lefthook.dev/installation/rpm

Execute these commands to configure the Cloudsmith repository and install the Lefthook package using yum.

```bash
curl -1sLf 'https://dl.cloudsmith.io/public/evilmartians/lefthook/setup.rpm.sh' | sudo -E bash
sudo yum install lefthook
```

--------------------------------

### Install Lefthook with pip

Source: https://lefthook.dev/installation/python

Installs Lefthook for the current user using the standard pip package manager.

```bash
python -m pip install --user lefthook
```

--------------------------------

### Example ~/.lefthookrc content

Source: https://lefthook.dev/configuration/rc

A sample rc file content to export environment variables or modify PATH.

```bash
# ~/.lefthookrc

# An nvm way
export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"

# An fnm way
export FNM_DIR="$HOME/.fnm"
[ -s "$FNM_DIR/fnm.sh" ] && \. "$FNM_DIR/fnm.sh"

# Or maybe just
PATH=$PATH:$HOME/.nvm/versions/node/v15.14.0/bin
```

--------------------------------

### Directory structure for source_dir

Source: https://lefthook.dev/configuration/source_dir

This example illustrates the expected directory structure within the source_dir, where subfolders correspond to git hooks and contain the relevant script files.

```text
.lefthook/
├── pre-commit/
│   ├── lint.sh
│   └── test.py
└── pre-push/
    └── check-files.rb
```

--------------------------------

### Prevent hook installation in CI

Source: https://lefthook.dev/usage/envs/CI

Set CI=true when running package manager install commands to prevent Lefthook from installing hooks in the postinstall script.

```bash
CI=true npm install
CI=true yarn install
CI=true pnpm install
```

--------------------------------

### Install Lefthook as a project tool

Source: https://lefthook.dev/installation/go

Use this command to add Lefthook as a tool dependency within your Go project.

```bash
go get -tool github.com/evilmartians/lefthook/v2
```

--------------------------------

### Example staged files list

Source: https://lefthook.dev/examples/filters

A list of files staged for the commit, used to demonstrate the filtering logic.

```text
backend/asset.js
frontend/src/index.ts
frontend/bin/cli.js # <- executable
frontend/eslint.config.js
frontend/README.md
```

--------------------------------

### Configure lefthook.yml for Git Arguments

Source: https://lefthook.dev/usage/features/git-args

Example configuration showing how to reference Git arguments using placeholders like {1}, {2}, and {3} in a job.

```yaml
# lefthook.yml

prepare-commit-msg:
  jobs:
    - script: "message.sh"
      runner: bash
    - run: echo "Git args: {1} {2} {3}"
```

--------------------------------

### Install a Git hook with lefthook add

Source: https://lefthook.dev/usage/commands/add

Use the --dirs flag to create the .git/hooks/<hook name>/ directory if it does not exist, which is required before adding a script to the configuration.

```bash
$ lefthook add pre-push  --dirs
```

--------------------------------

### Configure skip_lfs in lefthook.yml

Source: https://lefthook.dev/configuration/skip_lfs

Example showing how to set skip_lfs to true within the lefthook.yml configuration file.

```yaml
# lefthook.yml

skip_lfs: true

pre-push:
  commands:
    test:
      run: yarn test
```

--------------------------------

### Run yarn lint on pre-commit

Source: https://lefthook.dev/configuration/run

A basic example of running a lint command during the pre-commit hook.

```yaml
# lefthook.yml

pre-commit:
  commands:
    lint:
      run: yarn lint
```

--------------------------------

### Override CI hook installation behavior

Source: https://lefthook.dev/usage/envs/CI

Set LEFTHOOK=1 or LEFTHOOK=true to force hook installation in the postinstall script even when CI=true is set.

```bash
LEFTHOOK=1
LEFTHOOK=true
```

--------------------------------

### Specify a command to run lefthook

Source: https://lefthook.dev/configuration/lefthook

Example of using a shell command to navigate to a project directory before running lefthook.

```yaml
# lefthook.yml

lefthook: |
  cd project-with-lefthook
  pnpm lefthook

pre-commit:
  jobs:
    - run: yarn lint
      root: project-with-lefthook
```

--------------------------------

### Configure runner in lefthook.yml

Source: https://lefthook.dev/configuration/runner

Example showing how to define runners for JavaScript and Go scripts within the lefthook.yml configuration file.

```yaml
# lefthook.yml

pre-commit:
  scripts:
    "lint.js":
      runner: node
    "check.go":
      runner: go run
```

--------------------------------

### Check npm executable path

Source: https://lefthook.dev/configuration/rc

Example of locating an npm executable managed by nvm.

```bash
# An npm executable which is managed by nvm
$ which npm
/home/user/.nvm/versions/node/v15.14.0/bin/npm
```

--------------------------------

### Configure Git and Custom Hooks in lefthook.yml

Source: https://lefthook.dev/configuration/Hook

Example configuration showing a pre-commit Git hook with staged file linting and a custom check-docs hook.

```yaml
# lefthook.yml

# Git hook
pre-commit:
  jobs:
    - run: yarn lint {staged_files} --fix
      stage_fixed: true

# Custom hook
check-docs:
  jobs:
    - run: yarn check-docs
    - run: typos
```

--------------------------------

### Run Lefthook with summary output

Source: https://lefthook.dev/usage/envs/LEFTHOOK_OUTPUT

Example of executing a pre-commit hook while setting LEFTHOOK_OUTPUT to summary to display only the summary results.

```bash
$ LEFTHOOK_OUTPUT=summary lefthook run pre-commit
summary: (done in 0.52 seconds)
✔️  lint
```

--------------------------------

### Generated .cursor/hooks.json

Source: https://lefthook.dev/configuration/ai

The configuration file generated for Cursor after running lefthook install.

```json
{
  "version": 1,
  "hooks": {
    "stop": [
      { "command": "lefthook run validate" }
    ],
    "preToolUse": [
      { "command": "lefthook run security-check" }
    ]
  }
}
```

--------------------------------

### Basic Lefthook CLI commands

Source: https://lefthook.dev/usage

Common commands for installing hooks, running specific hook groups, validating configuration, and dumping the final configuration.

```bash
# Create/update Git hooks based on lefthook.yml, or create an empty lefthook.yml
lefthook install

# Run pre-commit hook commands and scripts (requires lefthook.yml)
lefthook run pre-commit

# Validate the configuration
lefthook validate

# Dump the configuration (useful when you have remotes, extends that overwrite the configuration)
lefthook dump
```

--------------------------------

### Provide a list of globs

Source: https://lefthook.dev/configuration/glob

Starting from version 1.10.10, you can provide a list of multiple glob patterns.

```yaml
# lefthook.yml

pre-commit:
  jobs:
    - run: yarn lint {staged_files}
      glob:
        - "*.ts"
        - "*.js"
```

--------------------------------

### Define AI hooks in lefthook.yml

Source: https://lefthook.dev/configuration/ai

Example configuration showing how to map provider events to lefthook jobs.

```yaml
# lefthook.yml

ai:
  claude:
    Stop: validate
    PreToolUse: security-check
  codex:
    Stop: validate
  cursor:
    stop: validate
    preToolUse: security-check
  copilot:
    postToolUse: validate

validate:
  jobs:
    - run: go test ./...

security-check:
  jobs:
    - run: ./scripts/security.sh
```

--------------------------------

### Generated .claude/settings.json

Source: https://lefthook.dev/configuration/ai

The configuration file generated for Claude after running lefthook install.

```json
{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          { "type": "command", "command": "lefthook run validate" }
        ]
      }
    ],
    "PreToolUse": [
      {
        "hooks": [
          { "type": "command", "command": "lefthook run security-check" }
        ]
      }
    ]
  }
}
```

--------------------------------

### Configure git_url with SSH

Source: https://lefthook.dev/configuration/git_url

Example of using an SSH URL for the git_url configuration in lefthook.yml.

```yaml
# lefthook.yml

remotes:
  - git_url: git@github.com:evilmartians/lefthook
```

--------------------------------

### Bash script reading from stdin

Source: https://lefthook.dev/configuration/use_stdin

A script example for .lefthook/pre-push/do-the-magic.sh that processes input using a while read loop.

```bash
# .lefthook/pre-push/do-the-magic.sh

remote="$1"
url="$2"

while read local_ref local_oid remote_ref remote_oid; do
  # ...
done
```

--------------------------------

### lefthook.yml root configuration

Source: https://lefthook.dev/configuration/root

Example configuration for a pre-commit hook that sets the root to the client directory and runs linting commands.

```yaml
# lefthook.yml

pre-commit:
  commands:
    lint:
      root: "client/"
      glob: "*.{js,ts}"
      run: yarn eslint --fix {staged_files} && git add {staged_files}
```

--------------------------------

### Configure git_url with HTTPS

Source: https://lefthook.dev/configuration/git_url

Example of using an HTTPS URL for the git_url configuration in lefthook.yml.

```yaml
# lefthook.yml

remotes:
  - git_url: https://github.com/evilmartians/lefthook
```

--------------------------------

### Configure refetch_frequency in lefthook.yml

Source: https://lefthook.dev/configuration/refetch_frequency

Example showing how to set the refetch_frequency to 24 hours for a remote configuration in the lefthook.yml file.

```yaml
# lefthook.yml

remotes:
  - git_url: https://github.com/evilmartians/lefthook
    refetch_frequency: 24h # Refetches once every 24 hours
```

--------------------------------

### Reset hooks path

Source: https://lefthook.dev/usage/commands/install

Resets the hooks path during installation to resolve conflicts.

```bash
lefthook install --reset-hooks-path
```

--------------------------------

### Configure args in lefthook.yml

Source: https://lefthook.dev/configuration/args

Example showing how to use the args option to pass staged files to bash scripts and yarn lint commands.

```yaml
# lefthook.yml

pre-commit:
  jobs:
    - script: check-python-files.sh
      runner: bash
      args: "{staged_files}"
      glob: "*.py"

    - run: yarn lint
      args: "{staged_files}"
      glob:
        - "*.ts"
        - "*.js"
```

--------------------------------

### Enable debug logs

Source: https://lefthook.dev/configuration/lefthook

Example of setting the LEFTHOOK_VERBOSE environment variable in lefthook-local.yml to enable debug logging.

```yaml
# lefthook-local.yml

lefthook: LEFTHOOK_VERBOSE=1 lefthook
```

--------------------------------

### Configure script in lefthook.yml

Source: https://lefthook.dev/configuration/script

Example of defining a pre-commit job that executes linter.sh using bash and passes staged files as arguments.

```yaml
# lefthook.yml

pre-commit:
  jobs:
    - script: linter.sh
      runner: bash
      args: "{staged_files}"
```

--------------------------------

### Generated .github/hooks/lefthook.json

Source: https://lefthook.dev/configuration/ai

The configuration file generated for GitHub Copilot after running lefthook install.

```json
{
  "version": 1,
  "hooks": {
    "postToolUse": [
      { "command": "lefthook run validate" }
    ]
  }
}
```

--------------------------------

### Generated .codex/hooks.json

Source: https://lefthook.dev/configuration/ai

The configuration file generated for Codex after running lefthook install.

```json
{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          { "type": "command", "command": "lefthook run validate" }
        ]
      }
    ]
  }
}
```

--------------------------------

### Configure remotes in lefthook.yml

Source: https://lefthook.dev/configuration/remotes

Example of defining a remote repository, specific reference, and configuration file path within the remotes section of lefthook.yml.

```yaml
# lefthook.yml

remotes:
  - git_url: git@github.com:evilmartians/lefthook
    ref: v1.0.0
    configs:
      - examples/ruby-linter.yml
```

--------------------------------

### Specify lefthook executable path

Source: https://lefthook.dev/configuration/lefthook

Example of setting a direct path to the lefthook executable in the lefthook.yml file.

```yaml
# lefthook.yml

lefthook: /usr/bin/lefthook

pre-commit:
  jobs:
    - run: yarn lint
```

--------------------------------

### Example lefthook-local.yml override configuration

Source: https://lefthook.dev/examples/lefthook-local

A local configuration file that modifies the pre-commit behavior and adds a new post-merge hook.

```yaml
# lefthook-local.yml

pre-commit:
  parallel: true # run all commands concurrently
  commands:
    lint:
      run: docker-compose run backend {cmd} # wrap the original command with docker-compose
    check-links:
      skip: true # skip checking links

# Add another hook
post-merge:
  files: "git diff-tree -r --name-only --no-commit-id ORIG_HEAD HEAD"
  commands:
    dependencies:
      glob: "Gemfile*"
      run: docker-compose run backend bundle install
```

--------------------------------

### Configure priority in lefthook.yml

Source: https://lefthook.dev/configuration/priority

This example demonstrates setting priority values for commands and scripts within a post-checkout hook. It requires piped: true to be effective.

```yaml
# lefthook.yml

post-checkout:
  piped: true
  commands:
    db-create:
      priority: 1
      run: rails db:create
    db-migrate:
      priority: 2
      run: rails db:migrate
    db-seed:
      priority: 3
      run: rails db:seed

  scripts:
    "check-spelling.sh":
      runner: bash
      priority: 1
    "check-grammar.rb":
      runner: ruby
      priority: 2
```

--------------------------------

### Configure ref in lefthook.yml

Source: https://lefthook.dev/configuration/ref

Example of specifying a git tag for a remote repository within the lefthook.yml configuration file.

```yaml
# lefthook.yml

remotes:
  - git_url: git@github.com:evilmartians/lefthook
    ref: v1.0.0
```

--------------------------------

### Configure piped and parallel jobs in lefthook.yml

Source: https://lefthook.dev/configuration/jobs

A configuration example showing a piped group of jobs running in parallel with other individual jobs. Note that only root, glob, and exclude options are currently applied to group jobs.

```yaml
# lefthook.yml

pre-commit:
  parallel: true
  jobs:
    - name: migrate
      root: backend/
      glob: "db/migrations/*"
      group:
        piped: true
        jobs:
          - run: bundle install
          - run: rails db:migrate
    - run: yarn lint --fix {staged_files}
      root: frontend/
      stage_fixed: true
    - run: bundle exec rubocop
      root: backend/
    - run: golangci-lint
      root: proxy/
    - script: verify.sh
      runner: bash
```

--------------------------------

### Configure pre-commit hooks in lefthook.yml

Source: https://lefthook.dev/

Example configuration for running stylelint and eslint on staged files during the pre-commit hook. Uses parallel execution and glob patterns to target specific file types.

```yaml
# lefthook.yml

pre-commit:
  parallel: true
  jobs:
    - run: yarn run stylelint --fix '{staged_files}'
      glob: "*.css"
      stage_fixed: true

    - run: yarn run eslint --fix '{staged_files}'
      glob:
        - "*.ts"
        - "*.js"
        - "*.tsx"
        - "*.jsx"
      stage_fixed: true
```

--------------------------------

### Use {cmd} template

Source: https://lefthook.dev/configuration/run

Demonstrates the use of the {cmd} shorthand for commands defined in the configuration.

```yaml
# lefthook.yml

pre-commit:
  commands:
    lint:
      run: yarn lint
  scripts:
    "good_job.js":
      runner: node
```

--------------------------------

### Force using a version from Rubygems

Source: https://lefthook.dev/configuration/lefthook

Example of using bundle exec to ensure the project uses the lefthook version defined in the Gemfile.

```yaml
# lefthook.yml

lefthook: bundle exec lefthook

pre-commit:
  jobs:
    - run: bundle exec rubocop -- {staged_files}
```

--------------------------------

### Configure fail_on_changes in lefthook.yml

Source: https://lefthook.dev/configuration/fail_on_changes

An example configuration for a pre-commit hook set to always fail if files are modified.

```yaml
# lefthook.yml
pre-commit:
  parallel: true
  fail_on_changes: "always"
  commands:
    lint:
      run: yarn lint
    test:
      run: yarn test
```

--------------------------------

### Configure no_auto_install in lefthook.yml

Source: https://lefthook.dev/configuration/no_auto_install

Set no_auto_install to true in your lefthook.yml file to prevent automatic hook installation and synchronization.

```yaml
# lefthook.yml

no_auto_install: true

pre-commit:
  commands:
    lint:
      run: npm run lint
```

--------------------------------

### Configure fail_on_changes_diff in lefthook.yml

Source: https://lefthook.dev/configuration/fail_on_changes_diff

Example configuration showing fail_on_changes_diff set to true within a pre-commit hook definition.

```yaml
# lefthook.yml
pre-commit:
  parallel: true
  fail_on_changes: "always"
  fail_on_changes_diff: true
  commands:
    lint:
      run: yarn lint
    test:
      run: yarn test
```

--------------------------------

### Skip hook on dev branches

Source: https://lefthook.dev/configuration/skip

Uses a glob pattern to skip the hook for all branches starting with dev/.

```yaml
# lefthook.yml

pre-commit:
  skip:
    - ref: dev/*
  commands:
    lint:
      run: yarn lint
    test:
      run: yarn test
```

--------------------------------

### Local configuration override example

Source: https://lefthook.dev/usage/features/local

The lefthook-local.yml file, which should be ignored by git, used to skip specific jobs or modify run commands for local development.

```yaml
# lefthook-local.yml (ignored by git)

pre-commit:
  jobs:
    - name: tests
      skip: true # don't want to run tests on every commit
    - name: linter
      run: yarn lint {staged_files} # lint only staged files
```

--------------------------------

### Access Git Arguments in message.sh

Source: https://lefthook.dev/usage/features/git-args

Example script showing how to capture Git arguments passed to a shell script using positional parameters.

```bash
# .lefthook/prepare-commit-msg/message.sh

# Arguments get passed from Git

COMMIT_MSG_FILE=$1
COMMIT_SOURCE=$2
SHA1=$3

# ...
```

--------------------------------

### Exclude tags in lefthook.yml

Source: https://lefthook.dev/configuration/exclude_tags

Example showing how to define exclude_tags in a pre-commit hook to skip commands tagged with 'frontend'.

```yaml
# lefthook.yml

pre-commit:
  exclude_tags: frontend
  commands:
    lint:
      tags: frontend
      ...
    test:
      tags: frontend
      ...
    check-syntax:
      tags: documentation
```

--------------------------------

### Configure stage_fixed in lefthook.yml

Source: https://lefthook.dev/configuration/stage_fixed

Example of enabling stage_fixed within a pre-commit command to automatically stage files after running a lint fix.

```yaml
# lefthook.yml

pre-commit:
  commands:
    lint:
      run: npm run lint --fix {staged_files}
      stage_fixed: true
```

--------------------------------

### Configure piped in lefthook.yml

Source: https://lefthook.dev/configuration/piped

Example of setting piped to true in a command group to ensure subsequent commands do not run if a previous one fails.

```yaml
# lefthook.yml

database:
  piped: true # Stop if one of the steps fail
  commands:
    1_create:
      run: rake db:create
    2_migrate:
      run: rake db:migrate
    3_seed:
      run: rake db:seed
```

--------------------------------

### Configure conditional hooks in lefthook.yml

Source: https://lefthook.dev/examples/skip

This configuration demonstrates using 'only' to restrict pre-commit hooks to branches starting with 'dev/' and using 'skip' and 'only' in pre-push hooks to conditionally run tests and linting.

```yaml
# lefthook.yml

pre-commit:
  only:
    - ref: dev/*
  commands:
    lint:
      run: yarn lint {staged_files} --fix
      glob: "*.{ts,js}"
    test:
      run: yarn test

pre-push:
  commands:
    test:
      run: yarn test
      skip:
        - run: test "$NO_TEST" -eq 1
    lint:
      run: yarn lint
      only:
        - ref: main
```

--------------------------------

### Skip commands by tags in lefthook-local.yml

Source: https://lefthook.dev/configuration/exclude_tags

Example of using exclude_tags in a local configuration file to skip specific tags without modifying the shared configuration.

```yaml
# lefthook-local.yml

pre-push:
  exclude_tags:
    - frontend
```

--------------------------------

### Exclude tags via LEFTHOOK_EXCLUDE

Source: https://lefthook.dev/usage/envs/LEFTHOOK_EXCLUDE

Example of using the LEFTHOOK_EXCLUDE environment variable to skip commands associated with specific tags during a git commit.

```bash
LEFTHOOK_EXCLUDE=ruby,security,lint git commit -am "Skip some tag checks"
```

--------------------------------

### Merge multiple configurations from multiple remotes

Source: https://lefthook.dev/configuration/configs

Demonstrates how to aggregate multiple configuration files from several different remote repositories.

```yaml
# lefthook.yml

remotes:
  - git_url: git@github.com:org/lefthook-configs
    ref: v1.0.0
    configs:
      - examples/ruby-linter.yml
      - examples/test.yml
  - git_url: https://github.com/org2/lefthook-configs
    configs:
      - lefthooks/pre_commit.yml
      - lefthooks/post_merge.yml
  - git_url: https://github.com/org3/lefthook-configs
    ref: feature/new
    configs:
      - configs/pre-push.yml
```

--------------------------------

### Run go vet with {files} template

Source: https://lefthook.dev/configuration/run

Uses the {files} template to run go vet on specific files identified by git ls-files.

```yaml
# lefthook.yml

pre-commit:
  commands:
    govet:
      files: git ls-files -m
      glob: "*.go"
      run: go vet -- {files}
```

--------------------------------

### Configure commitlint.config.js

Source: https://lefthook.dev/examples/commitlint

Create the commitlint configuration file to extend the conventional changelog rules.

```javascript
// commitlint.config.js

module.exports = {extends: ['@commitlint/config-conventional']};
```

--------------------------------

### Execute multi-line scripts

Source: https://lefthook.dev/configuration/run

Shows how to define a multi-line script directly within the run option.

```yaml
# lefthook.yml

pre-commit:
  jobs:
    - name: a whole script in a run
      run: |
        for file in $(ls .); do
          yarn lint $file
        done
```

--------------------------------

### Run eslint with {push_files} template

Source: https://lefthook.dev/configuration/run

Executes linting on files before they are pushed to the remote repository.

```yaml
# lefthook.yml

pre-push:
  commands:
    eslint:
      glob: "*.{js,ts,jsx,tsx}"
      run: yarn eslint {push_files}
```

--------------------------------

### Configure lefthook.yml

Source: https://lefthook.dev/examples/commitlint

Define the prepare-commit-msg and commit-msg hooks in lefthook.yml to integrate commitzen and commitlint.

```yaml
# lefthook.yml

# Build commit messages
prepare-commit-msg:
  commands:
    commitzen:
      interactive: true
      run: yarn run cz --hook # Or npx cz --hook
      env:
        LEFTHOOK: "0"

# Validate commit messages
commit-msg:
  commands:
    "lint commit message":
      run: yarn run commitlint --edit {1}
```

--------------------------------

### Run Lefthook with Mint

Source: https://lefthook.dev/installation/swift

Execute the Lefthook plugin directly using the Mint package manager.

```bash
mint run csjones/lefthook-plugin
```

--------------------------------

### Define remote configurations in lefthook.yml

Source: https://lefthook.dev/configuration/configs

Shows how to specify an array of configuration paths from a single remote repository.

```yaml
# lefthook.yml

remotes:
  - git_url: git@github.com:evilmartians/lefthook
    ref: v1.0.0
    configs:
      - examples/ruby-linter.yml
      - examples/test.yml
```

--------------------------------

### Configure files with git diff

Source: https://lefthook.dev/configuration/files

Uses a git command to list files for the stylelint hook in lefthook.yml.

```yaml
# lefthook.yml

pre-push:
  commands:
    stylelint:
      tags:
        - frontend
        - style
      files: git diff --name-only master
      glob: "*.js"
      run: yarn stylelint {files}
```

--------------------------------

### Quote file templates

Source: https://lefthook.dev/configuration/run

Demonstrates how to apply double or single quotes to file templates for handling filenames with spaces.

```yaml
# lefthook.yml

pre-commit:
  commands:
    lint:
      glob: "*.js"
      # Quoting with double quotes `"` might be helpful for Windows users
      run: yarn eslint "{staged_files}" # will run `yarn eslint "file1.js" "file2.js" "[strange name].js"`
    test:
      glob: "*.{spec.js}"
      run: yarn test '{staged_files}' # will run `yarn eslint 'file1.spec.js' 'file2.spec.js' '[strange name].spec.js'`
    format:
      glob: "*.js"
      # Will quote where needed with single quotes
      run: yarn test {staged_files} # will run `yarn eslint file1.js file2.js '[strange name].spec.js'`
```

--------------------------------

### Enable follow in lefthook.yml

Source: https://lefthook.dev/configuration/follow

Configures the pre-push hook to stream output from backend and frontend tests by setting follow to true.

```yaml
# lefthook.yml

pre-push:
  follow: true
  commands:
    backend-tests:
      run: bundle exec rspec
    frontend-tests:
      run: yarn test
```

--------------------------------

### Compare glob_matcher behavior

Source: https://lefthook.dev/configuration/glob_matcher

Shows the difference in matching behavior between the default gobwas engine and the doublestar engine.

```text
# gobwas (default): **/*.js matches src/app.js but NOT app.js
# doublestar:       **/*.js matches app.js, src/app.js, a/b/c/app.js
```

--------------------------------

### Apply linters on text and binary files in lefthook.yml

Source: https://lefthook.dev/configuration/file_types

Demonstrates configuring separate commands for text and binary file types within a pre-commit hook.

```yaml
# lefthook.yml

pre-commit:
  commands:
    lint-code:
      run: yarn lint {staged_files}
      file_types: text
    check-hex-codes:
      run: yarn check-hex {staged_files}
      file_types: binary
```

--------------------------------

### Wrap {cmd} in docker runner

Source: https://lefthook.dev/configuration/run

Shows how to wrap commands in a docker runner within a local configuration file.

```yaml
# lefthook-local.yml

pre-commit:
  commands:
    lint:
      run: docker run -it --rm <container_id_or_name> {cmd}
  scripts:
    "good_job.js":
      runner: docker run -it --rm <container_id_or_name> {cmd}
```

--------------------------------

### Configure output in lefthook.yml

Source: https://lefthook.dev/configuration/output

Specify which output types to display by listing them under the output key in the lefthook.yml configuration file.

```yaml
# lefthook.yml

output:
  - meta           # Print lefthook version
  - summary        # Print summary block (successful and failed steps)
  - empty_summary  # Print summary heading when there are no steps to run
  - success        # Print successful steps
  - failure        # Print failed steps printing
  - execution      # Print any execution logs
  - execution_out  # Print execution output
  - execution_info # Print `EXECUTE > ...` logging
  - skips          # Print "skip" (i.e. no files matched)
```

--------------------------------

### Execute quick linter on rebase

Source: https://lefthook.dev/configuration/only

Configures commands to skip standard linting and testing during a rebase, while executing a specific 'lint-quickly' command only during a rebase.

```yaml
# lefthook.yml

pre-commit:
  commands:
    lint:
      skip: rebase
      run: yarn lint
    test:
      skip: rebase
      run: yarn test
    lint-on-rebase:
      only: rebase
      run: yarn lint-quickly
```

--------------------------------

### Configure files in lefthook.yml

Source: https://lefthook.dev/configuration/files-global

Use the files key to specify a shell command that filters files for pre-commit hooks.

```yaml
# lefthook.yml

pre-commit:
  files: git diff --name-only master # custom list of files
  commands:
    ...
```

--------------------------------

### Run specific jobs and tags

Source: https://lefthook.dev/usage/commands/run

Execute specific jobs or tags using the --job and --tag flags.

```bash
$ lefthook run pre-commit --job lints --job pretty --tag checks
```

--------------------------------

### Configure pre-push hook in lefthook.yml

Source: https://lefthook.dev/usage/commands/add

Define the pre-push hook jobs in the lefthook.yml configuration file to specify the script and runner.

```yaml
pre-push:
  jobs:
    - script: "audit.sh"
      runner: bash
```

--------------------------------

### Run rubocop with {all_files} template

Source: https://lefthook.dev/configuration/run

Runs rubocop on all ruby files while excluding specific configuration files.

```yaml
# lefthook.yml

pre-commit:
  commands:
    rubocop:
      tags:
        - backend
        - style
      glob: "*.rb"
      exclude:
        - config/application.rb
        - config/routes.rb
      run: bundle exec rubocop --force-exclusion -- {all_files}
```

--------------------------------

### Configure script arguments with {0} template

Source: https://lefthook.dev/configuration/Scripts

Use the {0} template in the args field to preserve Git-provided arguments when executing a script.

```yaml
commit-msg:
  scripts:
    "template_checker":
      runner: bash
      args: "{0}"
```

--------------------------------

### Lefthook configuration with use_stdin

Source: https://lefthook.dev/configuration/use_stdin

Configuration in lefthook.yml to enable stdin for the specified script.

```yaml
# lefthook.yml
pre-push:
  scripts:
    "do-the-magic.sh":
      runner: bash
      use_stdin: true
```

--------------------------------

### Specify files for hook execution

Source: https://lefthook.dev/usage/commands/run

Force file templates to use all files or a specific list of files.

```bash
$ lefthook run pre-commit --all-files
$ lefthook run pre-commit --file file1.js --file file2.js
```

--------------------------------

### Configure rc path with spaces in lefthook-local.yml

Source: https://lefthook.dev/configuration/rc

Setting the path to the rc file in lefthook-local.yml when the path contains spaces.

```yaml
# lefthook-local.yml

# If the path contains spaces, you need to quote it.
rc: '"${XDG_CONFIG_HOME:-$HOME/.config}/lefthookrc"'
```

--------------------------------

### Configure source_dir_local in lefthook-local.yml

Source: https://lefthook.dev/configuration/source_dir_local

Sets the directory for local scripts to .lefthook-local/ within the lefthook-local.yml configuration file.

```yaml
# lefthook-local.yml

source_dir_local: .lefthook-local/
```

--------------------------------

### Project Directory Structure

Source: https://lefthook.dev/usage/features/git-args

The expected directory structure for a Lefthook project using a custom script for the prepare-commit-msg hook.

```text
├── .lefthook
│   └── prepare-commit-msg
│       └── message.sh
└── lefthook.yml
```

--------------------------------

### Configure assert_lefthook_installed in lefthook.yml

Source: https://lefthook.dev/configuration/assert_lefthook_installed

Set assert_lefthook_installed to true to force a failure if the Lefthook executable cannot be located.

```yaml
# lefthook.yml

assert_lefthook_installed: true
```

--------------------------------

### Configure pre-commit script in lefthook.yml

Source: https://lefthook.dev/configuration/Scripts

Add a custom script entry to the pre-commit hook configuration in lefthook.yml.

```yaml
# lefthook.yml

pre-commit:
  scripts:
    "my-script.sh":
      runner: bash
```

--------------------------------

### Configure rc path in lefthook-local.yml

Source: https://lefthook.dev/configuration/rc

Setting the path to the rc file in lefthook-local.yml using an absolute path.

```yaml
# lefthook-local.yml

# You can choose whatever name you want.
# You can share it between projects where you use lefthook.
# Make sure the path is absolute.
rc: ~/.lefthookrc
```

--------------------------------

### Reduce redundancy with templates

Source: https://lefthook.dev/configuration/templates

Define a common command wrapper in the templates section to reuse across multiple jobs in lefthook.yml.

```yaml
# lefthook.yml

templates:
  wrapper: docker-compose run --rm -v $(pwd):/app service

pre-commit:
  jobs:
    - run: "{wrapper} yarn format"
    - run: "{wrapper} yarn lint"
    - run: "{wrapper} yarn test"
```

--------------------------------

### Enable refetch in lefthook.yml

Source: https://lefthook.dev/configuration/refetch

Configures a remote to be refetched on every run by setting refetch to true.

```yaml
# lefthook.yml

remotes:
  - git_url: https://github.com/evilmartians/lefthook
    refetch: true
```

--------------------------------

### Run command with excluded tags

Source: https://lefthook.dev/configuration/exclude_tags

CLI command demonstrating that only commands not matching the excluded tags will run.

```bash
lefthook run pre-commit # will only run check-syntax command
```

--------------------------------

### Configure files with a custom script

Source: https://lefthook.dev/configuration/files

Calls a custom JavaScript script to list files for the rubocop hook in lefthook.yml.

```yaml
# lefthook.yml

pre-push:
  commands:
    rubocop:
      tags: backend
      glob: "**/*.rb"
      files: node ./lefthook-scripts/ls-files.js # you can call your own scripts
      run: bundle exec rubocop --force-exclusion --parallel -- {files}
```

--------------------------------

### Extend lefthook.yml with external configuration files

Source: https://lefthook.dev/configuration/extends

Use the extends key in lefthook.yml to merge multiple configuration files, including support for glob patterns.

```yaml
# lefthook.yml

extends:
  - /home/user/work/lefthook-extend.yml
  - /home/user/work/lefthook-extend-2.yml
  - lefthook-extends/file.yml
  - ../extend.yml
  - projects/*/specific-lefthook-config.yml
```

--------------------------------

### Enable parallel execution in lefthook.yml

Source: https://lefthook.dev/configuration/parallel

Configures the pre-commit hook to run lint and test commands concurrently by setting parallel to true.

```yaml
# lefthook.yml

pre-commit:
  parallel: true
  commands:
    lint:
      run: yarn lint
    test:
      run: yarn test
```

--------------------------------

### Configure glob filter in lefthook.yml

Source: https://lefthook.dev/configuration/glob

Use the glob key to restrict the lint job to specific file extensions.

```yaml
# lefthook.yml

pre-commit:
  jobs:
    - name: lint
      run: yarn eslint {staged_files}
      glob: "*.{js,ts,jsx,tsx}"
```

--------------------------------

### Define main command in lefthook.yml

Source: https://lefthook.dev/examples/wrap-commands

The base configuration for the rubocop job in the main lefthook.yml file.

```yaml
# lefthook.yml

pre-commit:
  jobs:
    - name: rubocop
      run: bundle exec rubocop -A -- {staged_files}
```

--------------------------------

### Extend PATH via lefthook-local.yml

Source: https://lefthook.dev/configuration/env

Extend the system PATH for hooks by defining it in lefthook-local.yml, which helps resolve executable not found errors in GUI-run hooks.

```yaml
# lefthook.yml

pre-commit:
  commands:
    test:
      run: yarn test
```

```yaml
# lefthook-local.yml

pre-commit:
  commands:
    test:
      env:
        PATH: $PATH:/home/me/path/to/yarn
```

--------------------------------

### Check lefthook version with commit hash

Source: https://lefthook.dev/usage/commands/version

Use the --full flag to display both the version number and the commit hash.

```bash
$ lefthook version --full

1.1.3 bb099d13c24114d2859815d9d23671a32932ffe2
```

--------------------------------

### Behavior of the ** pattern

Source: https://lefthook.dev/configuration/glob

The ** pattern matches one or more directories deep. To match files at the top level, use a separate pattern.

```yaml
glob: "src/**/*.js"  # does NOT match src/file.js
glob: "src/*.js"     # matches src/file.js only
```

--------------------------------

### Override skip in local configuration

Source: https://lefthook.dev/configuration/skip

Demonstrates using lefthook-local.yml to override global settings and disable a command locally.

```yaml
# lefthook.yml

pre-commit:
  commands:
    lint:
      run: yarn lint
```

```yaml
# lefthook-local.yml

pre-commit:
  commands:
    lint:
      skip: true
```

--------------------------------

### Configure hook filters in lefthook.yml

Source: https://lefthook.dev/examples/filters

Defines a lint command with glob, root, exclude, and file_types filters applied to staged files.

```yaml
# lefthook.yml

pre-commit:
  commands:
    lint:
      run: yarn lint {staged_files} --fix
      glob: "*.{js,ts}"
      root: frontend
      exclude:
        - *.config.js
        - *.config.ts
      file_types:
        - not executable
```

--------------------------------

### Always skip a command

Source: https://lefthook.dev/configuration/skip

Sets the skip option to true to unconditionally disable a specific command.

```yaml
# lefthook.yml

pre-commit:
  commands:
    lint:
      skip: true
      run: yarn lint
```

--------------------------------

### Configure glob_matcher in lefthook.yml

Source: https://lefthook.dev/configuration/glob_matcher

Sets the glob_matcher to doublestar to enable standard Bash-like glob behavior for file matching.

```yaml
# lefthook.yml

glob_matcher: doublestar

pre-commit:
  jobs:
    - name: lint
      run: yarn eslint {staged_files}
      glob: "**/*.{js,ts}"
```

--------------------------------

### Override template with lefthook-local.yml

Source: https://lefthook.dev/configuration/templates

Define an empty template in lefthook.yml and provide the actual command in lefthook-local.yml to allow local overrides.

```yaml
# lefthook.yml

templates:
  dip: # empty

pre-commit:
  jobs:
    # Will run: `bundle exec rubocop -- file1 file2 file3 ...`
    - run: "{dip} bundle exec rubocop -- {staged_files}"
```

```yaml
# lefthook-local.yml

templates:
  dip: dip # Will run: `dip bundle exec rubocop -- file1 file2 file3 ...`
```

--------------------------------

### Configure tags in lefthook.yml

Source: https://lefthook.dev/configuration/tags

Assign tags to commands within the lefthook.yml file to categorize them, such as by environment or language.

```yaml
# lefthook.yml

pre-commit:
  commands:
    lint:
      tags:
        - frontend
        - js
      run: yarn lint
    test:
      tags:
        - backend
        - ruby
      run: bundle exec rspec
```

--------------------------------

### Inherit group settings in lefthook.yml

Source: https://lefthook.dev/configuration/group

Demonstrates how env, glob, exclude, and root settings are inherited by underlying jobs, with individual jobs able to override env variables.

```yaml
# lefthook.yml

pre-commit:
  jobs:
    - env:
        E1: hello
      glob:
        - "*.md"
      exclude:
        - "README.md"
      root: "subdir/"
      group:
        parallel: true
        jobs:
          - run: echo $E1
          - run: echo $E1
            env:
              E1: bonjour
```

--------------------------------

### Edit the hook script

Source: https://lefthook.dev/usage/commands/add

Open the newly created script file in your editor to define the hook logic.

```bash
$ vim .lefthook/pre-push/audit.sh
...
```
Tokens:
Raw