git-format-staged 3.1.1 → 4.0.0

package/README.md

@@ -1,7 +1,5 @@
 # git-format-staged
 
-[![Build Status](https://travis-ci.org/hallettj/git-format-staged.svg?branch=master)](https://travis-ci.org/hallettj/git-format-staged)
-
 Consider a project where you want all code formatted consistently. So you use
 a formatting command. (For example I use [prettier][] in my Javascript and
 Typescript projects.) You want to make sure that everyone working on the project
@@ -39,13 +37,13 @@ patch step can be disabled with the `--no-update-working-tree` option.
 
 Install via the CLI:
 
-    $ nix profile add github:hallettj/git-format-staged
+    $ nix profile install github:hallettj/git-format-staged
 
 Or add to your flake imports, and use the `default` package output.
 
 ### Install with NPM
 
-Requires Python version 3 or 2.7.
+Requires Python 3.8 or later.
 
 Install as a development dependency in a project that uses npm packages:
 
@@ -57,7 +55,7 @@ Or install globally:
 
 ### Or just copy the script
 
-Requires Python version 3 or 2.7.
+Requires Python 3.8 or later.
 
 If you do not use the above methods you can copy the
 [`git-format-staged`](./git-format-staged) script from this repository and
@@ -73,7 +71,7 @@ For detailed information run:
 The command expects a shell command to run a formatter, and one or more file
 patterns to identify which files should be formatted. For example:
 
-    $ git-format-staged --formatter 'prettier --stdin-filepath "{}"' 'src/*.js'
+    $ git-format-staged --formatter 'prettier --stdin-filepath {}' 'src/*.js'
 
 That will format all files under `src/` and its subdirectories using
 `prettier`. The file pattern is tested against staged files using Python's
@@ -90,11 +88,11 @@ normal shell globbing. So if you need to match multiple patterns, you should
 pass multiple arguments with different patterns, and they will be grouped.
 So instead of e.g. `'src/**/*.{js,jsx,ts}'`, you would use:
 
-    $ git-format-staged --formatter 'prettier --stdin-filepath "{}"' 'src/*.js' 'src/*.jsx' 'src/*.ts'
+    $ git-format-staged --formatter 'prettier --stdin-filepath {}' 'src/*.js' 'src/*.jsx' 'src/*.ts'
 
 Files can be excluded by prefixing a pattern with `!`. For example:
 
-    $ git-format-staged --formatter 'prettier --stdin-filepath "{}"' '*.js' '!flow-typed/*'
+    $ git-format-staged --formatter 'prettier --stdin-filepath {}' '*.js' '!flow-typed/*'
 
 Patterns are evaluated from left-to-right: if a file matches multiple patterns
 the right-most pattern determines whether the file is included or excluded.
@@ -104,11 +102,11 @@ control. So it is not necessary to explicitly exclude stuff like
 `node_modules/`.
 
 The formatter command may include a placeholder, `{}`, which will be replaced
-with the path of the file that is being formatted. This is useful if your
-formatter needs to know the file extension to determine how to format or to
-lint each file. For example:
+with the path of the file that is being formatted (with appropriate quoting).
+This is useful if your formatter needs to know the file extension to determine
+how to format or to lint each file. For example:
 
-    $ git-format-staged -f 'prettier --stdin-filepath "{}"' '*.js' '*.css'
+    $ git-format-staged -f 'prettier --stdin-filepath {}' '*.js' '*.css'
 
 Do not attempt to read or write to `{}` in your formatter command! The
 placeholder exists only for referencing the file name and path.
@@ -120,7 +118,7 @@ prevent files from being committed if they do not conform to style rules. You
 can use git-format-staged with the `--no-write` option, and supply a lint
 command instead of a format command. Here is an example using ESLint:
 
-    $ git-format-staged --no-write -f 'eslint --stdin --stdin-filename "{}" >&2' 'src/*.js'
+    $ git-format-staged --no-write -f 'eslint --stdin --stdin-filename {} >&2' 'src/*.js'
 
 If this command is run in a pre-commit hook, and the lint command fails the
 commit will be aborted and error messages will be displayed. The lint command
@@ -146,7 +144,7 @@ Add a `prepare` script to install husky when running `npm install`:
 
 Add the pre-commit hook:
 
-    $ npx husky add .husky/pre-commit "git-format-staged --formatter 'prettier --stdin-filepath \"{}\"' '*.js' '*.ts'"
+    $ npx husky add .husky/pre-commit "git-format-staged --formatter 'prettier --stdin-filepath {}' '*.js' '*.ts'"
     $ git add .husky/pre-commit
 
 Once again note that the formatter command and the `'*.js'` and `'*.ts'`

package/git-format-staged

@@ -7,63 +7,106 @@
 # ignoring unstaged changes.
 #
 # Usage: git-format-staged [OPTION]... [FILE]...
-# Example: git-format-staged --formatter 'prettier --stdin-filepath "{}"' '*.js'
+# Example: git-format-staged --formatter 'prettier --stdin-filepath {}' '*.js'
 #
-# Tested with Python 3.10 and Python 2.7.
+# Tested with Python versions 3.8 - 3.15.
 #
 # Original author: Jesse Hallett <jesse@sitr.us>
 
-from __future__ import print_function
+from __future__ import annotations
 import argparse
+from collections.abc import Sequence
 from fnmatch import fnmatch
 from gettext import gettext as _
-import os
 import re
+import shlex
 import subprocess
 import sys
+from typing import NoReturn, Protocol, cast
 
-# The string 3.1.1 is replaced during the publish process.
-VERSION = '3.1.1'
+
+# The string 4.0.0 is replaced during the publish process.
+VERSION = "4.0.0"
 PROG = sys.argv[0]
 
-def info(msg):
+
+def info(msg: str):
     print(msg, file=sys.stdout)
 
-def warn(msg):
-    print('{}: warning: {}'.format(PROG, msg), file=sys.stderr)
 
-def fatal(msg):
-    print('{}: error: {}'.format(PROG, msg), file=sys.stderr)
+def warn(msg: str):
+    print("{}: warning: {}".format(PROG, msg), file=sys.stderr)
+
+
+def fatal(msg: str):
+    print("{}: error: {}".format(PROG, msg), file=sys.stderr)
     exit(1)
 
-def format_staged_files(file_patterns, formatter, git_root, update_working_tree=True, write=True, verbose=False):
+
+def format_staged_files(
+    file_patterns: Sequence[str],
+    formatter: str,
+    update_working_tree: bool = True,
+    write: bool = True,
+    verbose: bool = False,
+):
+    common_opts = [
+        "--cached",
+        "--diff-filter=AM",  # select only file additions and modifications
+        "--no-renames",
+        "HEAD",
+    ]
+
     try:
-        output = subprocess.check_output([
-            'git', 'diff-index',
-            '--cached',
-            '--diff-filter=AM', # select only file additions and modifications
-            '--no-renames',
-            'HEAD'
-            ])
+        staged_files = {
+            path.decode("utf-8")
+            for path in subprocess.check_output(
+                ["git", "diff", "--name-only"] + common_opts
+            ).splitlines()
+        }
+
+        output = subprocess.check_output(["git", "diff-index"] + common_opts)
         for line in output.splitlines():
-            entry = parse_diff(line.decode('utf-8'))
-            entry_path = normalize_path(entry['src_path'], relative_to=git_root)
-            if entry['dst_mode'] == '120000':
+            entry = DiffIndexEntry(line.decode("utf-8"))
+            if entry.dst_mode == "120000":
                 # Do not process symlinks
                 continue
-            if not (matches_some_path(file_patterns, entry_path)):
+            if not (matches_some_path(file_patterns, entry.src_path)):
                 continue
-            if format_file_in_index(formatter, entry, update_working_tree=update_working_tree, write=write, verbose=verbose):
-                info('Reformatted {} with {}'.format(entry['src_path'], formatter))
+            if (
+                entry.src_mode is None
+                and (not entry.dst_hash or object_is_empty(entry.dst_hash))
+                and entry.src_path not in staged_files
+            ):
+                # File is not staged, it's tracked only with `--intent-to-add` and won't get committed
+                continue
+            if format_file_in_index(
+                formatter,
+                entry,
+                update_working_tree=update_working_tree,
+                write=write,
+                verbose=verbose,
+            ):
+                info("Reformatted {} with {}".format(entry.src_path, formatter))
     except Exception as err:
         fatal(str(err))
 
+
 # Run formatter on file in the git index. Creates a new git object with the
 # result, and replaces the content of the file in the index with that object.
 # Returns hash of the new object if formatting produced any changes.
-def format_file_in_index(formatter, diff_entry, update_working_tree=True, write=True, verbose=False):
-    orig_hash = diff_entry['dst_hash']
-    new_hash = format_object(formatter, orig_hash, diff_entry['src_path'], verbose=verbose)
+def format_file_in_index(
+    formatter: str,
+    diff_entry: "DiffIndexEntry",
+    update_working_tree: bool = True,
+    write: bool = True,
+    verbose: bool = False,
+):
+    orig_hash = diff_entry.dst_hash
+    if not orig_hash:
+        return None
+
+    new_hash = format_object(formatter, orig_hash, diff_entry.src_path, verbose=verbose)
 
     # If the new hash is the same then the formatter did not make any changes.
     if not write or new_hash == orig_hash:
@@ -79,201 +122,238 @@ def format_file_in_index(formatter, diff_entry, update_working_tree=True, write=
 
     if update_working_tree:
         try:
-            patch_working_file(diff_entry['src_path'], orig_hash, new_hash)
+            patch_working_file(diff_entry.src_path, orig_hash, new_hash)
         except Exception as err:
             # Errors patching working tree files are not fatal
             warn(str(err))
 
     return new_hash
 
-file_path_placeholder = re.compile(r'\{\}')
+
+# Match {}, and to avoid breaking quoting from shlex also match and remove surrounding quotes. This
+# is important for backward compatibility because previous version of git-format-staged did not use
+# shlex quoting, and required manual quoting.
+file_path_placeholder = re.compile(r"(['\"]?)\{\}(\1)")
+
 
 # Run formatter on a git blob identified by its hash. Writes output to a new git
 # blob, and returns the hash of the new blob.
-def format_object(formatter, object_hash, file_path, verbose=False):
+def format_object(
+    formatter: str, object_hash: str, file_path: str, verbose: bool = False
+) -> str:
     get_content = subprocess.Popen(
-            ['git', 'cat-file', '-p', object_hash],
-            stdout=subprocess.PIPE
-            )
-    command = re.sub(file_path_placeholder, file_path, formatter)
+        ["git", "cat-file", "-p", object_hash], stdout=subprocess.PIPE
+    )
+    command = re.sub(file_path_placeholder, shlex.quote(file_path), formatter)
     if verbose:
         info(command)
     format_content = subprocess.Popen(
-            command,
-            shell=True,
-            stdin=get_content.stdout,
-            stdout=subprocess.PIPE
-            )
+        command, shell=True, stdin=get_content.stdout, stdout=subprocess.PIPE
+    )
     write_object = subprocess.Popen(
-            ['git', 'hash-object', '-w', '--stdin'],
-            stdin=format_content.stdout,
-            stdout=subprocess.PIPE
-            )
+        ["git", "hash-object", "-w", "--stdin"],
+        stdin=format_content.stdout,
+        stdout=subprocess.PIPE,
+    )
 
-    get_content.stdout.close()
-    format_content.stdout.close()
+    # Read output from the final process first to avoid deadlock if intermediate processes produce
+    # large outputs that would fill pipe buffers
+    new_hash, _err = write_object.communicate()
 
     if get_content.wait() != 0:
-        raise ValueError('unable to read file content from object database: ' + object_hash)
+        raise ValueError(
+            "unable to read file content from object database: " + object_hash
+        )
 
     if format_content.wait() != 0:
-        raise Exception('formatter exited with non-zero status') # TODO: capture stderr from format command
-
-    new_hash, err = write_object.communicate()
+        raise Exception("formatter exited with non-zero status")
 
     if write_object.returncode != 0:
-        raise Exception('unable to write formatted content to object database')
+        raise Exception("unable to write formatted content to object database")
+
+    return new_hash.decode("utf-8").rstrip()
 
-    return new_hash.decode('utf-8').rstrip()
 
-def object_is_empty(object_hash):
+def object_is_empty(object_hash: str) -> bool:
     get_content = subprocess.Popen(
-            ['git', 'cat-file', '-p', object_hash],
-            stdout=subprocess.PIPE
-        )
-    content, err = get_content.communicate()
+        ["git", "cat-file", "-p", object_hash], stdout=subprocess.PIPE
+    )
+    content, _err = get_content.communicate()
 
     if get_content.returncode != 0:
-        raise Exception('unable to verify content of formatted object')
+        raise Exception("unable to verify content of formatted object")
 
     return not content
 
-def replace_file_in_index(diff_entry, new_object_hash):
-    subprocess.check_call(['git', 'update-index',
-        '--cacheinfo', '{},{},{}'.format(
-            diff_entry['dst_mode'],
-            new_object_hash,
-            diff_entry['src_path']
-            )])
 
-def patch_working_file(path, orig_object_hash, new_object_hash):
+def replace_file_in_index(diff_entry: "DiffIndexEntry", new_object_hash: str):
+    _ = subprocess.check_call(
+        [
+            "git",
+            "update-index",
+            "--cacheinfo",
+            "{},{},{}".format(
+                diff_entry.dst_mode, new_object_hash, diff_entry.src_path
+            ),
+        ]
+    )
+
+
+def patch_working_file(path: str, orig_object_hash: str, new_object_hash: str):
     patch = subprocess.check_output(
-            ['git', 'diff', '--no-ext-diff', '--color=never', orig_object_hash, new_object_hash]
-            )
+        [
+            "git",
+            "diff",
+            "--no-ext-diff",
+            "--color=never",
+            orig_object_hash,
+            new_object_hash,
+        ]
+    )
 
     # Substitute object hashes in patch header with path to working tree file
-    patch_b = patch.replace(orig_object_hash.encode(), path.encode()).replace(new_object_hash.encode(), path.encode())
+    patch_b = patch.replace(orig_object_hash.encode(), path.encode()).replace(
+        new_object_hash.encode(), path.encode()
+    )
 
     apply_patch = subprocess.Popen(
-            ['git', 'apply', '-'],
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE
-            )
+        ["git", "apply", "-"],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
 
-    output, err = apply_patch.communicate(input=patch_b)
+    _output, _err = apply_patch.communicate(input=patch_b)
 
     if apply_patch.returncode != 0:
-        raise Exception('could not apply formatting changes to working tree file {}'.format(path))
+        raise Exception(
+            "could not apply formatting changes to working tree file {}".format(path)
+        )
+
 
 # Format: src_mode dst_mode src_hash dst_hash status/score? src_path dst_path?
-diff_pat = re.compile(r'^:(\d+) (\d+) ([a-f0-9]+) ([a-f0-9]+) ([A-Z])(\d+)?\t([^\t]+)(?:\t([^\t]+))?$')
-
-# Parse output from `git diff-index`
-def parse_diff(diff):
-    m = diff_pat.match(diff)
-    if not m:
-        raise ValueError('Failed to parse diff-index line: ' + diff)
-    return {
-            'src_mode': unless_zeroed(m.group(1)),
-            'dst_mode': unless_zeroed(m.group(2)),
-            'src_hash': unless_zeroed(m.group(3)),
-            'dst_hash': unless_zeroed(m.group(4)),
-            'status': m.group(5),
-            'score': int(m.group(6)) if m.group(6) else None,
-            'src_path': m.group(7),
-            'dst_path': m.group(8)
-            }
-
-zeroed_pat = re.compile(r'^0+$')
+diff_pat = re.compile(
+    r"^:(?P<src_mode>\d+) (?P<dst_mode>\d+) (?P<src_hash>[a-f0-9]+) (?P<dst_hash>[a-f0-9]+) (?P<status>[A-Z])(?P<score>\d+)?\t(?P<src_path>[^\t]+)(?:\t(?P<dst_path>[^\t]+))?$"
+)
+
+
+class DiffIndexEntry:
+    src_mode: str | None
+    dst_mode: str | None
+    src_hash: str | None
+    dst_hash: str | None
+    status: str
+    score: int | None
+    src_path: str
+    dst_path: str | None
+
+    def __init__(self, diff_index_output_line: str):
+        "Parse a line of output from `git diff-index`"
+        m = diff_pat.match(diff_index_output_line)
+        if not m:
+            raise ValueError(
+                "Failed to parse diff-index line: " + diff_index_output_line
+            )
+        self.src_mode = unless_zeroed(m.group("src_mode"))
+        self.dst_mode = unless_zeroed(m.group("dst_mode"))
+        self.src_hash = unless_zeroed(m.group("src_hash"))
+        self.dst_hash = unless_zeroed(m.group("dst_hash"))
+        self.status = m.group("status")
+        self.score = int(m.group("score")) if m.group("score") else None
+        self.src_path = m.group("src_path")
+        self.dst_path = m.group("dst_path")
+
+
+zeroed_pat = re.compile(r"^0+$")
+
 
 # Returns the argument unless the argument is a string of zeroes, in which case
 # returns `None`
-def unless_zeroed(s):
+def unless_zeroed(s: str) -> str | None:
     return s if not zeroed_pat.match(s) else None
 
-def get_git_root():
-    return subprocess.check_output(
-            ['git', 'rev-parse', '--show-toplevel']
-            ).decode('utf-8').rstrip()
-
-def normalize_path(p, relative_to=None):
-    return os.path.abspath(
-            os.path.join(relative_to, p) if relative_to else p
-            )
 
-def matches_some_path(patterns, target):
+def matches_some_path(patterns: Sequence[str], target: str) -> bool:
     is_match = False
     for signed_pattern in patterns:
         (is_pattern_positive, pattern) = from_signed_pattern(signed_pattern)
-        if fnmatch(target, normalize_path(pattern)):
+        if fnmatch(target, pattern):
             is_match = is_pattern_positive
     return is_match
 
+
 # Checks for a '!' as the first character of a pattern, returns the rest of the
 # pattern in a tuple. The tuple takes the form (is_pattern_positive, pattern).
 # For example:
 #     from_signed_pattern('!pat') == (False, 'pat')
 #     from_signed_pattern('pat') == (True, 'pat')
-def from_signed_pattern(pattern):
-    if pattern[0] == '!':
+def from_signed_pattern(pattern: str) -> tuple[bool, str]:
+    if pattern[0] == "!":
         return (False, pattern[1:])
     else:
         return (True, pattern)
 
+
 class CustomArgumentParser(argparse.ArgumentParser):
-    def parse_args(self, args=None, namespace=None):
-        args, argv = self.parse_known_args(args, namespace)
-        if argv:
-            msg = argparse._(
-                    'unrecognized arguments: %s. Do you need to quote your formatter command?'
-                    )
-            self.error(msg % ' '.join(argv))
-        return args
-
-if __name__ == '__main__':
+    def error(  # pyright: ignore[reportImplicitOverride]
+        self, message: str
+    ) -> NoReturn:
+        if message.startswith("unrecognized arguments:"):
+            message += " Do you need to quote your formatter command?"
+        super().error(message)
+
+
+class Args(Protocol):
+    formatter: str
+    no_update_working_tree: bool
+    no_write: bool
+    verbose: bool
+    files: Sequence[str]
+
+
+if __name__ == "__main__":
     parser = CustomArgumentParser(
-            description='Transform staged files using a formatting command that accepts content via stdin and produces a result via stdout.',
-            epilog='Example: %(prog)s --formatter "prettier --stdin-filepath \'{}\'" "src/*.js" "test/*.js"'
-            )
-    parser.add_argument(
-            '--formatter', '-f',
-            required=True,
-            help='Shell command to format files, will run once per file. Occurrences of the placeholder `{}` will be replaced with a path to the file being formatted. (Example: "prettier --stdin-filepath \'{}\'")'
-            )
-    parser.add_argument(
-            '--no-update-working-tree',
-            action='store_true',
-            help='By default formatting changes made to staged file content will also be applied to working tree files via a patch. This option disables that behavior, leaving working tree files untouched.'
-            )
-    parser.add_argument(
-            '--no-write',
-            action='store_true',
-            help='Prevents %(prog)s from modifying staged or working tree files. You can use this option to check staged changes with a linter instead of formatting. With this option stdout from the formatter command is ignored. Example: %(prog)s --no-write -f "eslint --stdin --stdin-filename \'{}\' >&2" "*.js"'
-            )
-    parser.add_argument(
-            '--version',
-            action='version',
-            version='%(prog)s version {}'.format(VERSION),
-            help='Display version of %(prog)s'
-            )
-    parser.add_argument(
-            '--verbose',
-            help='Show the formatting commands that are running',
-            action='store_true'
-            )
-    parser.add_argument(
-            'files',
-            nargs='+',
-            help='Patterns that specify files to format. The formatter will only transform staged files that are given here. Patterns may be literal file paths, or globs which will be tested against staged file paths using Python\'s fnmatch function. For example "src/*.js" will match all files with a .js extension in src/ and its subdirectories. Patterns may be negated to exclude files using a "!" character. Patterns are evaluated left-to-right. (Example: "main.js" "src/*.js" "test/*.js" "!test/todo/*")'
-            )
-    args = parser.parse_args()
-    files = vars(args)['files']
+        description="Transform staged files using a formatting command that accepts content via stdin and produces a result via stdout.",
+        epilog='Example: %(prog)s --formatter "prettier --stdin-filepath {}" "src/*.js" "test/*.js"',
+    )
+    _ = parser.add_argument(
+        "--formatter",
+        "-f",
+        required=True,
+        help='Shell command to format files, will run once per file. Occurrences of the placeholder `{}` will be replaced with a path to the file being formatted (with appropriate quoting). (Example: "prettier --stdin-filepath {}")',
+    )
+    _ = parser.add_argument(
+        "--no-update-working-tree",
+        action="store_true",
+        help="By default formatting changes made to staged file content will also be applied to working tree files via a patch. This option disables that behavior, leaving working tree files untouched.",
+    )
+    _ = parser.add_argument(
+        "--no-write",
+        action="store_true",
+        help='Prevents %(prog)s from modifying staged or working tree files. You can use this option to check staged changes with a linter instead of formatting. With this option stdout from the formatter command is ignored. Example: %(prog)s --no-write -f "eslint --stdin --stdin-filename {} >&2" "*.js"',
+    )
+    _ = parser.add_argument(
+        "--version",
+        action="version",
+        version="%(prog)s version {}".format(VERSION),
+        help="Display version of %(prog)s",
+    )
+    _ = parser.add_argument(
+        "--verbose",
+        help="Show the formatting commands that are running",
+        action="store_true",
+    )
+    _ = parser.add_argument(
+        "files",
+        nargs="+",
+        help='Patterns that specify files to format. The formatter will only transform staged files that are given here. Patterns may be literal file paths, or globs which will be tested against staged file paths using Python\'s fnmatch function. Patterns must be relative to the git repository root. For example "src/*.js" will match all files with a .js extension in src/ and its subdirectories. Patterns may be negated to exclude files using a "!" character. Patterns are evaluated left-to-right. (Example: "main.js" "src/*.js" "test/*.js" "!test/todo/*")',
+    )
+    args = cast(Args, parser.parse_args())  # pyright: ignore[reportInvalidCast]
+    files = args.files
     format_staged_files(
-            file_patterns=files,
-            formatter=vars(args)['formatter'],
-            git_root=get_git_root(),
-            update_working_tree=not vars(args)['no_update_working_tree'],
-            write=not vars(args)['no_write'],
-            verbose=vars(args)['verbose']
-            )
+        file_patterns=files,
+        formatter=args.formatter,
+        update_working_tree=not args.no_update_working_tree,
+        write=not args.no_write,
+        verbose=args.verbose,
+    )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-format-staged",
-  "version": "3.1.1",
+  "version": "4.0.0",
   "description": "Git command to transform staged files according to a command that accepts file content on stdin and produces output on stdout.",
   "scripts": {
     "test": "ava",
@@ -29,17 +29,16 @@
     "git-format-staged"
   ],
   "devDependencies": {
-    "@commitlint/cli": "^8.3.5",
-    "@commitlint/config-conventional": "^8.3.4",
+    "@commitlint/cli": "^19.0.3",
+    "@commitlint/config-conventional": "^19.0.3",
     "@types/fs-extra": "^8.1.0",
     "@types/tmp": "^0.1.0",
     "ava": "^3.8.1",
     "eslint": "^5.16.0",
     "fs-extra": "^9.0.0",
-    "husky": "^4.2.5",
     "micromatch": "^4.0.2",
     "prettier-standard": "^9.1.1",
-    "semantic-release": "^19.0.2",
+    "semantic-release": "^23.0.2",
     "strip-indent": "^3.0.0",
     "tmp": "0.2.0",
     "ts-node": "^8.9.1",
@@ -55,11 +54,5 @@
     "files": [
       "test/**/*_test.ts"
     ]
-  },
-  "husky": {
-    "hooks": {
-      "commit-msg": "commitlint -e $HUSKY_GIT_PARAMS",
-      "pre-commit": "./git-format-staged --formatter prettier-standard '*.js'"
-    }
   }
 }