1GITHOOKS(5) Git Manual GITHOOKS(5)
2
6 githooks - Hooks used by Git
7
9 $GIT_DIR/hooks/* (or `git config core.hooksPath`/*)
10
12 Hooks are programs you can place in a hooks directory to trigger
13 actions at certain points in git’s execution. Hooks that don’t have the
14 executable bit set are ignored.
15 By default the hooks directory is $GIT_DIR/hooks, but that can be
17 changed via the core.hooksPath configuration variable (see git-
18 config(1)).
19 Before Git invokes a hook, it changes its working directory to either
21 $GIT_DIR in a bare repository or the root of the working tree in a
22 non-bare repository. An exception are hooks triggered during a push
23 (pre-receive, update, post-receive, post-update, push-to-checkout)
24 which are always executed in $GIT_DIR.
25 Hooks can get their arguments via the environment, command-line
27 arguments, and stdin. See the documentation for each hook below for
28 details.
29 git init may copy hooks to the new repository, depending on its
31 configuration. See the "TEMPLATE DIRECTORY" section in git-init(1) for
32 details. When the rest of this document refers to "default hooks" it’s
33 talking about the default template shipped with Git.
34 The currently supported hooks are described below.
36
38 applypatch-msg
39 This hook is invoked by git-am(1). It takes a single parameter, the
40 name of the file that holds the proposed commit log message. Exiting
41 with a non-zero status causes git am to abort before applying the
42 patch.
43 The hook is allowed to edit the message file in place, and can be used
45 to normalize the message into some project standard format. It can also
46 be used to refuse the commit after inspecting the message file.
47 The default applypatch-msg hook, when enabled, runs the commit-msg
49 hook, if the latter is enabled.
50 pre-applypatch
52 This hook is invoked by git-am(1). It takes no parameter, and is
53 invoked after the patch is applied, but before a commit is made.
54 If it exits with non-zero status, then the working tree will not be
56 committed after applying the patch.
57 It can be used to inspect the current working tree and refuse to make a
59 commit if it does not pass certain test.
60 The default pre-applypatch hook, when enabled, runs the pre-commit
62 hook, if the latter is enabled.
63 post-applypatch
65 This hook is invoked by git-am(1). It takes no parameter, and is
66 invoked after the patch is applied and a commit is made.
67 This hook is meant primarily for notification, and cannot affect the
69 outcome of git am.
70 pre-commit
72 This hook is invoked by git-commit(1), and can be bypassed with the
73 --no-verify option. It takes no parameters, and is invoked before
74 obtaining the proposed commit log message and making a commit. Exiting
75 with a non-zero status from this script causes the git commit command
76 to abort before creating a commit.
77 The default pre-commit hook, when enabled, catches introduction of
79 lines with trailing whitespaces and aborts the commit when such a line
80 is found.
81 All the git commit hooks are invoked with the environment variable
83 GIT_EDITOR=: if the command will not bring up an editor to modify the
84 commit message.
85 The default pre-commit hook, when enabled—and with the
87 hooks.allownonascii config option unset or set to false—prevents the
88 use of non-ASCII filenames.
89 pre-merge-commit
91 This hook is invoked by git-merge(1), and can be bypassed with the
92 --no-verify option. It takes no parameters, and is invoked after the
93 merge has been carried out successfully and before obtaining the
94 proposed commit log message to make a commit. Exiting with a non-zero
95 status from this script causes the git merge command to abort before
96 creating a commit.
97 The default pre-merge-commit hook, when enabled, runs the pre-commit
99 hook, if the latter is enabled.
100 This hook is invoked with the environment variable GIT_EDITOR=: if the
102 command will not bring up an editor to modify the commit message.
103 If the merge cannot be carried out automatically, the conflicts need to
105 be resolved and the result committed separately (see git-merge(1)). At
106 that point, this hook will not be executed, but the pre-commit hook
107 will, if it is enabled.
108 prepare-commit-msg
110 This hook is invoked by git-commit(1) right after preparing the default
111 log message, and before the editor is started.
112 It takes one to three parameters. The first is the name of the file
114 that contains the commit log message. The second is the source of the
115 commit message, and can be: message (if a -m or -F option was given);
116 template (if a -t option was given or the configuration option
117 commit.template is set); merge (if the commit is a merge or a
118 .git/MERGE_MSG file exists); squash (if a .git/SQUASH_MSG file exists);
119 or commit, followed by a commit SHA-1 (if a -c, -C or --amend option
120 was given).
121 If the exit status is non-zero, git commit will abort.
123 The purpose of the hook is to edit the message file in place, and it is
125 not suppressed by the --no-verify option. A non-zero exit means a
126 failure of the hook and aborts the commit. It should not be used as
127 replacement for pre-commit hook.
128 The sample prepare-commit-msg hook that comes with Git removes the help
130 message found in the commented portion of the commit template.
131 commit-msg
133 This hook is invoked by git-commit(1) and git-merge(1), and can be
134 bypassed with the --no-verify option. It takes a single parameter, the
135 name of the file that holds the proposed commit log message. Exiting
136 with a non-zero status causes the command to abort.
137 The hook is allowed to edit the message file in place, and can be used
139 to normalize the message into some project standard format. It can also
140 be used to refuse the commit after inspecting the message file.
141 The default commit-msg hook, when enabled, detects duplicate
143 Signed-off-by trailers, and aborts the commit if one is found.
144 post-commit
146 This hook is invoked by git-commit(1). It takes no parameters, and is
147 invoked after a commit is made.
148 This hook is meant primarily for notification, and cannot affect the
150 outcome of git commit.
151 pre-rebase
153 This hook is called by git-rebase(1) and can be used to prevent a
154 branch from getting rebased. The hook may be called with one or two
155 parameters. The first parameter is the upstream from which the series
156 was forked. The second parameter is the branch being rebased, and is
157 not set when rebasing the current branch.
158 post-checkout
160 This hook is invoked when a git-checkout(1) or git-switch(1) is run
161 after having updated the worktree. The hook is given three parameters:
162 the ref of the previous HEAD, the ref of the new HEAD (which may or may
163 not have changed), and a flag indicating whether the checkout was a
164 branch checkout (changing branches, flag=1) or a file checkout
165 (retrieving a file from the index, flag=0). This hook cannot affect the
166 outcome of git switch or git checkout, other than that the hook’s exit
167 status becomes the exit status of these two commands.
168 It is also run after git-clone(1), unless the --no-checkout (-n) option
170 is used. The first parameter given to the hook is the null-ref, the
171 second the ref of the new HEAD and the flag is always 1. Likewise for
172 git worktree add unless --no-checkout is used.
173 This hook can be used to perform repository validity checks,
175 auto-display differences from the previous HEAD if different, or set
176 working dir metadata properties.
177 post-merge
179 This hook is invoked by git-merge(1), which happens when a git pull is
180 done on a local repository. The hook takes a single parameter, a status
181 flag specifying whether or not the merge being done was a squash merge.
182 This hook cannot affect the outcome of git merge and is not executed,
183 if the merge failed due to conflicts.
184 This hook can be used in conjunction with a corresponding pre-commit
186 hook to save and restore any form of metadata associated with the
187 working tree (e.g.: permissions/ownership, ACLS, etc). See
188 contrib/hooks/setgitperms.perl for an example of how to do this.
189 pre-push
191 This hook is called by git-push(1) and can be used to prevent a push
192 from taking place. The hook is called with two parameters which provide
193 the name and location of the destination remote, if a named remote is
194 not being used both values will be the same.
195 Information about what is to be pushed is provided on the hook’s
197 standard input with lines of the form:
198 <local ref> SP <local sha1> SP <remote ref> SP <remote sha1> LF
200 For instance, if the command git push origin master:foreign were run
202 the hook would receive a line like the following:
203 refs/heads/master 67890 refs/heads/foreign 12345
205 although the full, 40-character SHA-1s would be supplied. If the
207 foreign ref does not yet exist the <remote SHA-1> will be 40 0. If a
208 ref is to be deleted, the <local ref> will be supplied as (delete) and
209 the <local SHA-1> will be 40 0. If the local commit was specified by
210 something other than a name which could be expanded (such as HEAD~, or
211 a SHA-1) it will be supplied as it was originally given.
212 If this hook exits with a non-zero status, git push will abort without
214 pushing anything. Information about why the push is rejected may be
215 sent to the user by writing to standard error.
216 pre-receive
218 This hook is invoked by git-receive-pack(1) when it reacts to git push
219 and updates reference(s) in its repository. Just before starting to
220 update refs on the remote repository, the pre-receive hook is invoked.
221 Its exit status determines the success or failure of the update.
222 This hook executes once for the receive operation. It takes no
224 arguments, but for each ref to be updated it receives on standard input
225 a line of the format:
226 <old-value> SP <new-value> SP <ref-name> LF
228 where <old-value> is the old object name stored in the ref, <new-value>
230 is the new object name to be stored in the ref and <ref-name> is the
231 full name of the ref. When creating a new ref, <old-value> is 40 0.
232 If the hook exits with non-zero status, none of the refs will be
234 updated. If the hook exits with zero, updating of individual refs can
235 still be prevented by the update hook.
236 Both standard output and standard error output are forwarded to git
238 send-pack on the other end, so you can simply echo messages for the
239 user.
240 The number of push options given on the command line of git push
242 --push-option=... can be read from the environment variable
243 GIT_PUSH_OPTION_COUNT, and the options themselves are found in
244 GIT_PUSH_OPTION_0, GIT_PUSH_OPTION_1,... If it is negotiated to not use
245 the push options phase, the environment variables will not be set. If
246 the client selects to use push options, but doesn’t transmit any, the
247 count variable will be set to zero, GIT_PUSH_OPTION_COUNT=0.
248 See the section on "Quarantine Environment" in git-receive-pack(1) for
250 some caveats.
251 update
253 This hook is invoked by git-receive-pack(1) when it reacts to git push
254 and updates reference(s) in its repository. Just before updating the
255 ref on the remote repository, the update hook is invoked. Its exit
256 status determines the success or failure of the ref update.
257 The hook executes once for each ref to be updated, and takes three
259 parameters:
260 • the name of the ref being updated,
262 • the old object name stored in the ref,
264 • and the new object name to be stored in the ref.
266 A zero exit from the update hook allows the ref to be updated. Exiting
268 with a non-zero status prevents git receive-pack from updating that
269 ref.
270 This hook can be used to prevent forced update on certain refs by
272 making sure that the object name is a commit object that is a
273 descendant of the commit object named by the old object name. That is,
274 to enforce a "fast-forward only" policy.
275 It could also be used to log the old..new status. However, it does not
277 know the entire set of branches, so it would end up firing one e-mail
278 per ref when used naively, though. The post-receive hook is more suited
279 to that.
280 In an environment that restricts the users' access only to git commands
282 over the wire, this hook can be used to implement access control
283 without relying on filesystem ownership and group membership. See git-
284 shell(1) for how you might use the login shell to restrict the user’s
285 access to only git commands.
286 Both standard output and standard error output are forwarded to git
288 send-pack on the other end, so you can simply echo messages for the
289 user.
290 The default update hook, when enabled—and with hooks.allowunannotated
292 config option unset or set to false—prevents unannotated tags to be
293 pushed.
294 proc-receive
296 This hook is invoked by git-receive-pack(1). If the server has set the
297 multi-valued config variable receive.procReceiveRefs, and the commands
298 sent to receive-pack have matching reference names, these commands will
299 be executed by this hook, instead of by the internal execute_commands()
300 function. This hook is responsible for updating the relevant references
301 and reporting the results back to receive-pack.
302 This hook executes once for the receive operation. It takes no
304 arguments, but uses a pkt-line format protocol to communicate with
305 receive-pack to read commands, push-options and send results. In the
306 following example for the protocol, the letter S stands for
307 receive-pack and the letter H stands for this hook.
308 # Version and features negotiation.
310 S: PKT-LINE(version=1\0push-options atomic...)
311 S: flush-pkt
312 H: PKT-LINE(version=1\0push-options...)
313 H: flush-pkt
314 # Send commands from server to the hook.
316 S: PKT-LINE(<old-oid> <new-oid> <ref>)
317 S: ... ...
318 S: flush-pkt
319 # Send push-options only if the 'push-options' feature is enabled.
320 S: PKT-LINE(push-option)
321 S: ... ...
322 S: flush-pkt
323 # Receive result from the hook.
325 # OK, run this command successfully.
326 H: PKT-LINE(ok <ref>)
327 # NO, I reject it.
328 H: PKT-LINE(ng <ref> <reason>)
329 # Fall through, let 'receive-pack' to execute it.
330 H: PKT-LINE(ok <ref>)
331 H: PKT-LINE(option fall-through)
332 # OK, but has an alternate reference. The alternate reference name
333 # and other status can be given in option directives.
334 H: PKT-LINE(ok <ref>)
335 H: PKT-LINE(option refname <refname>)
336 H: PKT-LINE(option old-oid <old-oid>)
337 H: PKT-LINE(option new-oid <new-oid>)
338 H: PKT-LINE(option forced-update)
339 H: ... ...
340 H: flush-pkt
341 Each command for the proc-receive hook may point to a pseudo-reference
343 and always has a zero-old as its old-oid, while the proc-receive hook
344 may update an alternate reference and the alternate reference may exist
345 already with a non-zero old-oid. For this case, this hook will use
346 "option" directives to report extended attributes for the reference
347 given by the leading "ok" directive.
348 The report of the commands of this hook should have the same order as
350 the input. The exit status of the proc-receive hook only determines the
351 success or failure of the group of commands sent to it, unless atomic
352 push is in use.
353 post-receive
355 This hook is invoked by git-receive-pack(1) when it reacts to git push
356 and updates reference(s) in its repository. It executes on the remote
357 repository once after all the refs have been updated.
358 This hook executes once for the receive operation. It takes no
360 arguments, but gets the same information as the pre-receive hook does
361 on its standard input.
362 This hook does not affect the outcome of git receive-pack, as it is
364 called after the real work is done.
365 This supersedes the post-update hook in that it gets both old and new
367 values of all the refs in addition to their names.
368 Both standard output and standard error output are forwarded to git
370 send-pack on the other end, so you can simply echo messages for the
371 user.
372 The default post-receive hook is empty, but there is a sample script
374 post-receive-email provided in the contrib/hooks directory in Git
375 distribution, which implements sending commit emails.
376 The number of push options given on the command line of git push
378 --push-option=... can be read from the environment variable
379 GIT_PUSH_OPTION_COUNT, and the options themselves are found in
380 GIT_PUSH_OPTION_0, GIT_PUSH_OPTION_1,... If it is negotiated to not use
381 the push options phase, the environment variables will not be set. If
382 the client selects to use push options, but doesn’t transmit any, the
383 count variable will be set to zero, GIT_PUSH_OPTION_COUNT=0.
384 post-update
386 This hook is invoked by git-receive-pack(1) when it reacts to git push
387 and updates reference(s) in its repository. It executes on the remote
388 repository once after all the refs have been updated.
389 It takes a variable number of parameters, each of which is the name of
391 ref that was actually updated.
392 This hook is meant primarily for notification, and cannot affect the
394 outcome of git receive-pack.
395 The post-update hook can tell what are the heads that were pushed, but
397 it does not know what their original and updated values are, so it is a
398 poor place to do log old..new. The post-receive hook does get both
399 original and updated values of the refs. You might consider it instead
400 if you need them.
401 When enabled, the default post-update hook runs git update-server-info
403 to keep the information used by dumb transports (e.g., HTTP) up to
404 date. If you are publishing a Git repository that is accessible via
405 HTTP, you should probably enable this hook.
406 Both standard output and standard error output are forwarded to git
408 send-pack on the other end, so you can simply echo messages for the
409 user.
410 reference-transaction
412 This hook is invoked by any Git command that performs reference
413 updates. It executes whenever a reference transaction is prepared,
414 committed or aborted and may thus get called multiple times.
415 The hook takes exactly one argument, which is the current state the
417 given reference transaction is in:
418 • "prepared": All reference updates have been queued to the
420 transaction and references were locked on disk.
421 • "committed": The reference transaction was committed and all
423 references now have their respective new value.
424 • "aborted": The reference transaction was aborted, no changes were
426 performed and the locks have been released.
427 For each reference update that was added to the transaction, the hook
429 receives on standard input a line of the format:
430 <old-value> SP <new-value> SP <ref-name> LF
432 The exit status of the hook is ignored for any state except for the
434 "prepared" state. In the "prepared" state, a non-zero exit status will
435 cause the transaction to be aborted. The hook will not be called with
436 "aborted" state in that case.
437 push-to-checkout
439 This hook is invoked by git-receive-pack(1) when it reacts to git push
440 and updates reference(s) in its repository, and when the push tries to
441 update the branch that is currently checked out and the
442 receive.denyCurrentBranch configuration variable is set to
443 updateInstead. Such a push by default is refused if the working tree
444 and the index of the remote repository has any difference from the
445 currently checked out commit; when both the working tree and the index
446 match the current commit, they are updated to match the newly pushed
447 tip of the branch. This hook is to be used to override the default
448 behaviour.
449 The hook receives the commit with which the tip of the current branch
451 is going to be updated. It can exit with a non-zero status to refuse
452 the push (when it does so, it must not modify the index or the working
453 tree). Or it can make any necessary changes to the working tree and to
454 the index to bring them to the desired state when the tip of the
455 current branch is updated to the new commit, and exit with a zero
456 status.
457 For example, the hook can simply run git read-tree -u -m HEAD "$1" in
459 order to emulate git fetch that is run in the reverse direction with
460 git push, as the two-tree form of git read-tree -u -m is essentially
461 the same as git switch or git checkout that switches branches while
462 keeping the local changes in the working tree that do not interfere
463 with the difference between the branches.
464 pre-auto-gc
466 This hook is invoked by git gc --auto (see git-gc(1)). It takes no
467 parameter, and exiting with non-zero status from this script causes the
468 git gc --auto to abort.
469 post-rewrite
471 This hook is invoked by commands that rewrite commits (git-commit(1)
472 when called with --amend and git-rebase(1); however, full-history
473 (re)writing tools like git-fast-import(1) or git-filter-repo[1]
474 typically do not call it!). Its first argument denotes the command it
475 was invoked by: currently one of amend or rebase. Further
476 command-dependent arguments may be passed in the future.
477 The hook receives a list of the rewritten commits on stdin, in the
479 format
480 <old-sha1> SP <new-sha1> [ SP <extra-info> ] LF
482 The extra-info is again command-dependent. If it is empty, the
484 preceding SP is also omitted. Currently, no commands pass any
485 extra-info.
486 The hook always runs after the automatic note copying (see
488 "notes.rewrite.<command>" in git-config(1)) has happened, and thus has
489 access to these notes.
490 The following command-specific comments apply:
492 rebase
494 For the squash and fixup operation, all commits that were squashed
495 are listed as being rewritten to the squashed commit. This means
496 that there will be several lines sharing the same new-sha1.
497 The commits are guaranteed to be listed in the order that they were
499 processed by rebase.
500 sendemail-validate
502 This hook is invoked by git-send-email(1). It takes a single parameter,
503 the name of the file that holds the e-mail to be sent. Exiting with a
504 non-zero status causes git send-email to abort before sending any
505 e-mails.
506 fsmonitor-watchman
508 This hook is invoked when the configuration option core.fsmonitor is
509 set to .git/hooks/fsmonitor-watchman or .git/hooks/fsmonitor-watchmanv2
510 depending on the version of the hook to use.
511 Version 1 takes two arguments, a version (1) and the time in elapsed
513 nanoseconds since midnight, January 1, 1970.
514 Version 2 takes two arguments, a version (2) and a token that is used
516 for identifying changes since the token. For watchman this would be a
517 clock id. This version must output to stdout the new token followed by
518 a NUL before the list of files.
519 The hook should output to stdout the list of all files in the working
521 directory that may have changed since the requested time. The logic
522 should be inclusive so that it does not miss any potential changes. The
523 paths should be relative to the root of the working directory and be
524 separated by a single NUL.
525 It is OK to include files which have not actually changed. All changes
527 including newly-created and deleted files should be included. When
528 files are renamed, both the old and the new name should be included.
529 Git will limit what files it checks for changes as well as which
531 directories are checked for untracked files based on the path names
532 given.
533 An optimized way to tell git "all files have changed" is to return the
535 filename /.
536 The exit status determines whether git will use the data from the hook
538 to limit its search. On error, it will fall back to verifying all files
539 and folders.
540 p4-changelist
542 This hook is invoked by git-p4 submit.
543 The p4-changelist hook is executed after the changelist message has
545 been edited by the user. It can be bypassed with the --no-verify
546 option. It takes a single parameter, the name of the file that holds
547 the proposed changelist text. Exiting with a non-zero status causes the
548 command to abort.
549 The hook is allowed to edit the changelist file and can be used to
551 normalize the text into some project standard format. It can also be
552 used to refuse the Submit after inspect the message file.
553 Run git-p4 submit --help for details.
555 p4-prepare-changelist
557 This hook is invoked by git-p4 submit.
558 The p4-prepare-changelist hook is executed right after preparing the
560 default changelist message and before the editor is started. It takes
561 one parameter, the name of the file that contains the changelist text.
562 Exiting with a non-zero status from the script will abort the process.
563 The purpose of the hook is to edit the message file in place, and it is
565 not suppressed by the --no-verify option. This hook is called even if
566 --prepare-p4-only is set.
567 Run git-p4 submit --help for details.
569 p4-post-changelist
571 This hook is invoked by git-p4 submit.
572 The p4-post-changelist hook is invoked after the submit has
574 successfully occurred in P4. It takes no parameters and is meant
575 primarily for notification and cannot affect the outcome of the git p4
576 submit action.
577 Run git-p4 submit --help for details.
579 p4-pre-submit
581 This hook is invoked by git-p4 submit. It takes no parameters and
582 nothing from standard input. Exiting with non-zero status from this
583 script prevent git-p4 submit from launching. It can be bypassed with
584 the --no-verify command line option. Run git-p4 submit --help for
585 details.
586 post-index-change
588 This hook is invoked when the index is written in read-cache.c
589 do_write_locked_index.
590 The first parameter passed to the hook is the indicator for the working
592 directory being updated. "1" meaning working directory was updated or
593 "0" when the working directory was not updated.
594 The second parameter passed to the hook is the indicator for whether or
596 not the index was updated and the skip-worktree bit could have changed.
597 "1" meaning skip-worktree bits could have been updated and "0" meaning
598 they were not.
599 Only one parameter should be set to "1" when the hook runs. The hook
601 running passing "1", "1" should not be possible.
602
604 Part of the git(1) suite
605
607 1. git-filter-repo
608 https://github.com/newren/git-filter-repo
609Git 2.31.1 2021-03-26 GITHOOKS(5)