diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..3c4e9f0
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,89 @@
+# From https://github.com/man-group/sparrow with sparrow-specific regexes removed.
+
+BasedOnStyle: Mozilla
+
+AccessModifierOffset: '-4'
+AlignAfterOpenBracket: BlockIndent
+AlignEscapedNewlines: Left
+AllowAllArgumentsOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+# Forbid one line lambdas because clang-format makes a weird split when
+# single instructions lambdas are too long.
+AllowShortLambdasOnASingleLine: Empty
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakTemplateDeclarations: Yes
+BinPackArguments: false
+BinPackParameters: false
+BreakBeforeBinaryOperators: NonAssignment
+BreakBeforeBraces: Allman
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: BeforeComma
+BreakInheritanceList: AfterComma
+BreakStringLiterals: false
+ColumnLimit: '110'
+ConstructorInitializerIndentWidth: '4'
+ContinuationIndentWidth: '4'
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat: false
+EmptyLineAfterAccessModifier: Always
+EmptyLineBeforeAccessModifier: Always
+ExperimentalAutoDetectBinPacking: true
+IncludeBlocks: Regroup
+IncludeCategories:
+- Regex: <[^.]+>
+  Priority: 1
+- Regex: <.+>
+  Priority: 2
+- Regex: '".+"'
+  Priority: 5
+IndentCaseLabels: true
+IndentPPDirectives: AfterHash
+IndentWidth: '4'
+IndentWrappedFunctionNames: false
+InsertBraces: true
+InsertTrailingCommas: Wrapped
+KeepEmptyLinesAtTheStartOfBlocks: false
+LambdaBodyIndentation: Signature
+Language: Cpp
+MaxEmptyLinesToKeep: '2'
+NamespaceIndentation: All
+ObjCBlockIndentWidth: '4'
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: false
+PackConstructorInitializers: Never
+PenaltyBreakAssignment: 100000
+PenaltyBreakBeforeFirstCallParameter: 0
+PenaltyBreakComment: 10
+PenaltyBreakOpenParenthesis: 0
+PenaltyBreakTemplateDeclaration: 0
+PenaltyExcessCharacter: 10
+PenaltyIndentedWhitespace: 0
+PenaltyReturnTypeOnItsOwnLine: 10
+PointerAlignment: Left
+QualifierAlignment: Custom  # Experimental
+QualifierOrder: [inline, static, constexpr, const, volatile, type]
+ReflowComments: true
+SeparateDefinitionBlocks: Always
+SortIncludes: CaseInsensitive
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: true
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: '2'
+SpacesInAngles: false
+SpacesInCStyleCastParentheses: false
+SpacesInContainerLiterals: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard: c++20
+TabWidth: '4'
+UseTab: Never
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..cc84447
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,31 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: check-merge-conflict
+      - id: check-toml
+      - id: check-yaml
+      - id: debug-statements
+      - id: end-of-file-fixer
+      - id: mixed-line-ending
+      - id: trailing-whitespace
+
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v3.21.2
+    hooks:
+      - id: pyupgrade
+        args: ['--py312-plus']
+
+  - repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: v21.1.2
+    hooks:
+      - id: clang-format
+        args: [--style=file]
+        exclude_types: [javascript,json]
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.14.0
+    hooks:
+      - id: ruff-check
+        args: [--fix]
+      - id: ruff-format
diff --git a/README.md b/README.md
index 9eff6b3..4ac0793 100644
--- a/README.md
+++ b/README.md
@@ -29,6 +29,12 @@ The CLI is tested using `python`. From the top-level directory:
 pytest -v
 ```
 
+`pre-commit` runs automatically on `git commit`. To run it manually use:
+
+```bash
+pre-commit run --all-files
+```
+
 # WebAssembly build and deployment
 
 The `wasm` directory contains everything needed to build the local `git2cpp` source code as an
diff --git a/dev-environment.yml b/dev-environment.yml
index c578ec0..288a620 100644
--- a/dev-environment.yml
+++ b/dev-environment.yml
@@ -6,6 +6,7 @@ dependencies:
   - libgit2
   - cmake
   - pkg-config
+  - pre-commit
   - python
   - pytest
   - termcolor-cpp
diff --git a/docs/create_markdown.py b/docs/create_markdown.py
index 7cb59fe..0c7bec2 100644
--- a/docs/create_markdown.py
+++ b/docs/create_markdown.py
@@ -26,7 +26,7 @@ def sanitise_line(line):
     return line
 
 
-# Process a single subcommand, adding new subcommands found to to_process.
+# Process a single subcommand, adding new subcommands found to to_process.
 def process(args, to_process):
     cmd = args + ["--help"]
     cmd_string = " ".join(cmd)
@@ -37,7 +37,7 @@ def process(args, to_process):
     p = subprocess.run(cmd, capture_output=True, text=True, check=True)
 
     # Write output markdown file, identifying subcommands at the same time to provide
-    # links to the subcommand markdown files.
+    # links to the subcommand markdown files.
     subcommands = []
     with open(filename, "w") as f:
         f.write(f"({filename})=\n")  # Target for links.
@@ -52,7 +52,9 @@ def process(args, to_process):
                 if match:
                     subcommand = match.group(2)
                     subcommand_filename = get_filename(args + [subcommand])
-                    line = match.group(1) + f"[{subcommand}]({subcommand_filename})" + match.group(3)
+                    line = (
+                        match.group(1) + f"[{subcommand}]({subcommand_filename})" + match.group(3)
+                    )
                     subcommands.append(subcommand)
             elif line.startswith("SUBCOMMANDS:"):
                 in_subcommand_section = True
@@ -74,10 +76,10 @@ def process(args, to_process):
 
 
 if __name__ == "__main__":
-    # Modify the PATH so that git2cpp is found by name, as using a full path will cause the help
+    # Modify the PATH so that git2cpp is found by name, as using a full path will cause the help
     # pages to write that full path.
-    git2cpp_dir = Path(__file__).parent.parent / 'build'
-    os.environ["PATH"] = f'{git2cpp_dir}{os.pathsep}{os.environ["PATH"]}'
+    git2cpp_dir = Path(__file__).parent.parent / "build"
+    os.environ["PATH"] = f"{git2cpp_dir}{os.pathsep}{os.environ['PATH']}"
 
     to_process = [["git2cpp"]]
     while len(to_process) > 0:
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..90d4005
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,6 @@
+# This is not a python project but it contains python tests so here are settings for python linting.
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+[tool.ruff.format]
+line-ending = "lf"
diff --git a/src/main.cpp b/src/main.cpp
index 5d0223a..712885e 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,10 +1,9 @@
-#include <CLI/CLI.hpp>
 #include <cmath>
-#include <git2.h>  // For version number only
 #include <iostream>
 
-#include "utils/git_exception.hpp"
-#include "version.hpp"
+#include <CLI/CLI.hpp>
+#include <git2.h>  // For version number only
+
 #include "subcommand/add_subcommand.hpp"
 #include "subcommand/branch_subcommand.hpp"
 #include "subcommand/checkout_subcommand.hpp"
@@ -21,12 +20,14 @@
 #include "subcommand/rebase_subcommand.hpp"
 #include "subcommand/remote_subcommand.hpp"
 #include "subcommand/reset_subcommand.hpp"
+#include "subcommand/revlist_subcommand.hpp"
+#include "subcommand/revparse_subcommand.hpp"
+#include "subcommand/rm_subcommand.hpp"
 #include "subcommand/stash_subcommand.hpp"
 #include "subcommand/status_subcommand.hpp"
 #include "subcommand/tag_subcommand.hpp"
-#include "subcommand/revparse_subcommand.hpp"
-#include "subcommand/revlist_subcommand.hpp"
-#include "subcommand/rm_subcommand.hpp"
+#include "utils/git_exception.hpp"
+#include "version.hpp"
 
 int main(int argc, char** argv)
 {
@@ -69,7 +70,8 @@ int main(int argc, char** argv)
 
         if (version->count())
         {
-            std::cout << "git2cpp version " << GIT2CPP_VERSION_STRING << " (libgit2 " << LIBGIT2_VERSION << ")" << std::endl;
+            std::cout << "git2cpp version " << GIT2CPP_VERSION_STRING << " (libgit2 " << LIBGIT2_VERSION
+                      << ")" << std::endl;
         }
         else if (app.get_subcommands().size() == 0)
         {
@@ -86,7 +88,8 @@ int main(int argc, char** argv)
         std::cerr << e.what() << std::endl;
         exit_code = e.error_code();
     }
-    catch (std::exception& e) {
+    catch (std::exception& e)
+    {
         std::cerr << e.what() << std::endl;
         exit_code = 1;
     }
diff --git a/src/subcommand/add_subcommand.cpp b/src/subcommand/add_subcommand.cpp
index e1aa4f4..ca52940 100644
--- a/src/subcommand/add_subcommand.cpp
+++ b/src/subcommand/add_subcommand.cpp
@@ -1,13 +1,13 @@
+#include "add_subcommand.hpp"
+
 #include <git2.h>
 
-#include "add_subcommand.hpp"
 #include "../wrapper/index_wrapper.hpp"
 #include "../wrapper/repository_wrapper.hpp"
 
-
 add_subcommand::add_subcommand(const libgit2_object&, CLI::App& app)
 {
-    auto *sub = app.add_subcommand("add", "Add file contents to the index");
+    auto* sub = app.add_subcommand("add", "Add file contents to the index");
 
     sub->add_option("<files>", m_add_files, "Files to add");
 
@@ -16,10 +16,14 @@ add_subcommand::add_subcommand(const libgit2_object&, CLI::App& app)
     // sub->add_flag("-u,--update", update_flag, "");
     // sub->add_flag("-v,--verbose", verbose_flag, "");
 
-    sub->callback([this]() { this->run(); });
+    sub->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 };
 
-
 void add_subcommand::run()
 {
     auto directory = get_current_git_path();
diff --git a/src/subcommand/add_subcommand.hpp b/src/subcommand/add_subcommand.hpp
index 6f31dff..0504799 100644
--- a/src/subcommand/add_subcommand.hpp
+++ b/src/subcommand/add_subcommand.hpp
@@ -12,6 +12,7 @@ class add_subcommand
     void run();
 
 private:
+
     bool m_all_flag = false;
     std::vector<std::string> m_add_files;
 };
diff --git a/src/subcommand/branch_subcommand.cpp b/src/subcommand/branch_subcommand.cpp
index f0ea9fa..3d233c4 100644
--- a/src/subcommand/branch_subcommand.cpp
+++ b/src/subcommand/branch_subcommand.cpp
@@ -1,6 +1,7 @@
+#include "../subcommand/branch_subcommand.hpp"
+
 #include <iostream>
 
-#include "../subcommand/branch_subcommand.hpp"
 #include "../wrapper/repository_wrapper.hpp"
 
 branch_subcommand::branch_subcommand(const libgit2_object&, CLI::App& app)
@@ -14,9 +15,18 @@ branch_subcommand::branch_subcommand(const libgit2_object&, CLI::App& app)
     sub->add_flag("-r,--remotes", m_remote_flag, "List or delete (if used with -d) the remote-tracking branches");
     sub->add_flag("-l,--list", m_list_flag, "List branches");
     sub->add_flag("-f,--force", m_force_flag, "Skips confirmation");
-    sub->add_flag("--show-current", m_show_current_flag, "Print the name of the current branch. In detached HEAD state, nothing is printed.");
+    sub->add_flag(
+        "--show-current",
+        m_show_current_flag,
+        "Print the name of the current branch. In detached HEAD state, nothing is printed."
+    );
 
-    sub->callback([this]() { this->run(); });
+    sub->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 }
 
 void branch_subcommand::run()
diff --git a/src/subcommand/checkout_subcommand.cpp b/src/subcommand/checkout_subcommand.cpp
index d3477a3..1c3dfdb 100644
--- a/src/subcommand/checkout_subcommand.cpp
+++ b/src/subcommand/checkout_subcommand.cpp
@@ -1,8 +1,9 @@
+#include "../subcommand/checkout_subcommand.hpp"
+
 #include <iostream>
-#include <sstream>
 #include <set>
+#include <sstream>
 
-#include "../subcommand/checkout_subcommand.hpp"
 #include "../subcommand/status_subcommand.hpp"
 #include "../utils/git_exception.hpp"
 #include "../wrapper/repository_wrapper.hpp"
@@ -15,9 +16,18 @@ checkout_subcommand::checkout_subcommand(const libgit2_object&, CLI::App& app)
     sub->add_option("<branch>", m_branch_name, "Branch to checkout");
     sub->add_flag("-b", m_create_flag, "Create a new branch before checking it out");
     sub->add_flag("-B", m_force_create_flag, "Create a new branch or reset it if it exists before checking it out");
-    sub->add_flag("-f, --force", m_force_checkout_flag, "When switching branches, proceed even if the index or the working tree differs from HEAD, and even if there are untracked files in the way");
-
-    sub->callback([this]() { this->run(); });
+    sub->add_flag(
+        "-f, --force",
+        m_force_checkout_flag,
+        "When switching branches, proceed even if the index or the working tree differs from HEAD, and even if there are untracked files in the way"
+    );
+
+    sub->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 }
 
 void print_no_switch(status_list_wrapper& sl)
@@ -44,7 +54,7 @@ void checkout_subcommand::run()
 
     if (repo.state() != GIT_REPOSITORY_STATE_NONE)
     {
-         throw std::runtime_error("Cannot checkout, repository is in unexpected state");
+        throw std::runtime_error("Cannot checkout, repository is in unexpected state");
     }
 
     git_checkout_options options;
@@ -112,19 +122,14 @@ void checkout_subcommand::run()
     }
 }
 
-annotated_commit_wrapper checkout_subcommand::create_local_branch
-(
-    repository_wrapper& repo,
-    const std::string_view target_name,
-    bool force
-)
+annotated_commit_wrapper
+checkout_subcommand::create_local_branch(repository_wrapper& repo, const std::string_view target_name, bool force)
 {
     auto branch = repo.create_branch(target_name, force);
     return repo.find_annotated_commit(branch);
 }
 
-void checkout_subcommand::checkout_tree
-(
+void checkout_subcommand::checkout_tree(
     const repository_wrapper& repo,
     const annotated_commit_wrapper& target_annotated_commit,
     const std::string_view target_name,
@@ -135,8 +140,7 @@ void checkout_subcommand::checkout_tree
     throw_if_error(git_checkout_tree(repo, target_commit, &options));
 }
 
-void checkout_subcommand::update_head
-(
+void checkout_subcommand::update_head(
     repository_wrapper& repo,
     const annotated_commit_wrapper& target_annotated_commit,
     const std::string_view target_name
diff --git a/src/subcommand/checkout_subcommand.hpp b/src/subcommand/checkout_subcommand.hpp
index e041174..99661d4 100644
--- a/src/subcommand/checkout_subcommand.hpp
+++ b/src/subcommand/checkout_subcommand.hpp
@@ -17,23 +17,17 @@ class checkout_subcommand
 
 private:
 
-    annotated_commit_wrapper create_local_branch
-    (
-        repository_wrapper& repo,
-        const std::string_view target_name,
-        bool force
-    );
+    annotated_commit_wrapper
+    create_local_branch(repository_wrapper& repo, const std::string_view target_name, bool force);
 
-    void checkout_tree
-    (
+    void checkout_tree(
         const repository_wrapper& repo,
         const annotated_commit_wrapper& target_annotated_commit,
         const std::string_view target_name,
         const git_checkout_options& options
     );
 
-    void update_head
-    (
+    void update_head(
         repository_wrapper& repo,
         const annotated_commit_wrapper& target_annotated_commit,
         const std::string_view target_name
diff --git a/src/subcommand/clone_subcommand.cpp b/src/subcommand/clone_subcommand.cpp
index 926628e..4d8ad08 100644
--- a/src/subcommand/clone_subcommand.cpp
+++ b/src/subcommand/clone_subcommand.cpp
@@ -1,6 +1,7 @@
+#include "../subcommand/clone_subcommand.hpp"
+
 #include <iostream>
 
-#include "../subcommand/clone_subcommand.hpp"
 #include "../utils/credentials.hpp"
 #include "../utils/input_output.hpp"
 #include "../utils/progress.hpp"
@@ -13,11 +14,17 @@ clone_subcommand::clone_subcommand(const libgit2_object&, CLI::App& app)
     sub->add_option("<repository>", m_repository, "The (possibly remote) repository to clone from.")->required();
     sub->add_option("<directory>", m_directory, "The name of a new directory to clone into.");
     sub->add_option("--depth", m_depth, "Create a shallow clone of that depth.");
-    // sub->add_option("--shallow-since", m_shallow_since, "<time>\ndeepen history of shallow repository based on time.");
-    // sub->add_option("--shallow-exclude", m_shallow_exclude, "<ref>\ndeepen history of shallow clone, excluding ref");
+    // sub->add_option("--shallow-since", m_shallow_since, "<time>\ndeepen history of shallow repository based
+    // on time."); sub->add_option("--shallow-exclude", m_shallow_exclude, "<ref>\ndeepen history of shallow
+    // clone, excluding ref");
     sub->add_flag("--bare", m_bare, "Create a bare Git repository.");
 
-    sub->callback([this]() { this->run(); });
+    sub->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 }
 
 void clone_subcommand::run()
diff --git a/src/subcommand/clone_subcommand.hpp b/src/subcommand/clone_subcommand.hpp
index ab61461..007c866 100644
--- a/src/subcommand/clone_subcommand.hpp
+++ b/src/subcommand/clone_subcommand.hpp
@@ -1,8 +1,9 @@
 #pragma once
 
-#include <CLI/CLI.hpp>
 #include <limits>
 
+#include <CLI/CLI.hpp>
+
 #include "../utils/common.hpp"
 
 class clone_subcommand
diff --git a/src/subcommand/commit_subcommand.cpp b/src/subcommand/commit_subcommand.cpp
index ceb4038..10379f9 100644
--- a/src/subcommand/commit_subcommand.cpp
+++ b/src/subcommand/commit_subcommand.cpp
@@ -1,22 +1,26 @@
+#include "../subcommand/commit_subcommand.hpp"
+
 #include <git2.h>
 #include <unistd.h>
 
-#include "../subcommand/commit_subcommand.hpp"
 #include "../utils/input_output.hpp"
 #include "../wrapper/index_wrapper.hpp"
 #include "../wrapper/repository_wrapper.hpp"
 
-
 commit_subcommand::commit_subcommand(const libgit2_object&, CLI::App& app)
 {
-    auto *sub = app.add_subcommand("commit", "Record changes to the repository");
+    auto* sub = app.add_subcommand("commit", "Record changes to the repository");
 
     sub->add_option("-m,--message", m_commit_message, "Commit message");
 
-    sub->callback([this]() { this->run(); });
+    sub->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 };
 
-
 void commit_subcommand::run()
 {
     auto directory = get_current_git_path();
diff --git a/src/subcommand/commit_subcommand.hpp b/src/subcommand/commit_subcommand.hpp
index 8b29ccb..489bd63 100644
--- a/src/subcommand/commit_subcommand.hpp
+++ b/src/subcommand/commit_subcommand.hpp
@@ -12,5 +12,6 @@ class commit_subcommand
     void run();
 
 private:
+
     std::string m_commit_message;
 };
diff --git a/src/subcommand/config_subcommand.cpp b/src/subcommand/config_subcommand.cpp
index 5cde788..de34472 100644
--- a/src/subcommand/config_subcommand.cpp
+++ b/src/subcommand/config_subcommand.cpp
@@ -1,11 +1,12 @@
-#include <git2/config.h>
-#include <git2/types.h>
+#include "../subcommand/config_subcommand.hpp"
+
 #include <iostream>
 
+#include <git2/config.h>
 #include <git2/remote.h>
+#include <git2/types.h>
 
 #include "../utils/git_exception.hpp"
-#include "../subcommand/config_subcommand.hpp"
 #include "../wrapper/config_wrapper.hpp"
 #include "../wrapper/repository_wrapper.hpp"
 
@@ -13,9 +14,18 @@ config_subcommand::config_subcommand(const libgit2_object&, CLI::App& app)
 {
     auto* config = app.add_subcommand("config", "Get and set repository or global options");
     auto* list = config->add_subcommand("list", "List all variables set in config file, along with their values.");
-    auto* get = config->add_subcommand("get", "Emits the value of the specified key. If key is present multiple times in the configuration, emits the last value. If --all is specified, emits all values associated with key. Returns error code 1 if key is not present.");
-    auto* set = config->add_subcommand("set", "Set value for one or more config options. By default, this command refuses to write multi-valued config options. Passing --all will replace all multi-valued config options with the new value, whereas --value= will replace all config options whose values match the given pattern.");
-    auto* unset = config->add_subcommand("unset", "Unset value for one or more config options. By default, this command refuses to unset multi-valued keys. Passing --all will unset all multi-valued config options, whereas --value will unset all config options whose values match the given pattern.");
+    auto* get = config->add_subcommand(
+        "get",
+        "Emits the value of the specified key. If key is present multiple times in the configuration, emits the last value. If --all is specified, emits all values associated with key. Returns error code 1 if key is not present."
+    );
+    auto* set = config->add_subcommand(
+        "set",
+        "Set value for one or more config options. By default, this command refuses to write multi-valued config options. Passing --all will replace all multi-valued config options with the new value, whereas --value= will replace all config options whose values match the given pattern."
+    );
+    auto* unset = config->add_subcommand(
+        "unset",
+        "Unset value for one or more config options. By default, this command refuses to unset multi-valued keys. Passing --all will unset all multi-valued config options, whereas --value will unset all config options whose values match the given pattern."
+    );
 
     get->add_option("<name>", m_name, "");
     set->add_option("<name>", m_name, "");
@@ -28,10 +38,30 @@ config_subcommand::config_subcommand(const libgit2_object&, CLI::App& app)
     // sub->add_flag("--system", m_system_flag, "");
     // sub->add_flag("--worktree", m_worktree_flag, "");
 
-    list->callback([this]() { this->run_list(); });
-    get->callback([this]() { this->run_get(); });
-    set->callback([this]() { this->run_set(); });
-    unset->callback([this]() { this->run_unset(); });
+    list->callback(
+        [this]()
+        {
+            this->run_list();
+        }
+    );
+    get->callback(
+        [this]()
+        {
+            this->run_get();
+        }
+    );
+    set->callback(
+        [this]()
+        {
+            this->run_set();
+        }
+    );
+    unset->callback(
+        [this]()
+        {
+            this->run_unset();
+        }
+    );
 }
 
 void config_subcommand::run_list()
@@ -64,9 +94,9 @@ void config_subcommand::run_get()
     auto cfg = repo.get_config();
 
     git_config_entry* entry = cfg.get_entry(m_name);
-	std::cout << entry->value << std::endl;
+    std::cout << entry->value << std::endl;
 
-	git_config_entry_free(entry);
+    git_config_entry_free(entry);
 }
 
 void config_subcommand::run_set()
diff --git a/src/subcommand/diff_subcommand.cpp b/src/subcommand/diff_subcommand.cpp
index 818825f..4527fec 100644
--- a/src/subcommand/diff_subcommand.cpp
+++ b/src/subcommand/diff_subcommand.cpp
@@ -1,10 +1,12 @@
-#include <git2.h>
+#include "../subcommand/diff_subcommand.hpp"
+
 #include <optional>
+
+#include <git2.h>
 #include <termcolor/termcolor.hpp>
 
 #include "../utils/common.hpp"
 #include "../utils/git_exception.hpp"
-#include "../subcommand/diff_subcommand.hpp"
 #include "../wrapper/patch_wrapper.hpp"
 #include "../wrapper/repository_wrapper.hpp"
 
@@ -12,8 +14,7 @@ diff_subcommand::diff_subcommand(const libgit2_object&, CLI::App& app)
 {
     auto* sub = app.add_subcommand("diff", "Show changes between commits, commit and working tree, etc");
 
-    sub->add_option("<files>", m_files, "tree-ish objects to compare")
-        ->expected(0, 2);
+    sub->add_option("<files>", m_files, "tree-ish objects to compare")->expected(0, 2);
 
     sub->add_flag("--stat", m_stat_flag, "Generate a diffstat");
     sub->add_flag("--shortstat", m_shortstat_flag, "Output only the last line of --stat");
@@ -35,35 +36,59 @@ diff_subcommand::diff_subcommand(const libgit2_object&, CLI::App& app)
     sub->add_flag("--minimal", m_minimal_flag, "Spend extra time to find smallest diff");
 
     sub->add_option("-M,--find-renames", m_rename_threshold, "Detect renames")
-        ->expected(0,1)
+        ->expected(0, 1)
         ->default_val(50)
-        ->each([this](const std::string&) { m_find_renames_flag = true; });
+        ->each(
+            [this](const std::string&)
+            {
+                m_find_renames_flag = true;
+            }
+        );
     sub->add_option("-C,--find-copies", m_copy_threshold, "Detect copies")
-        ->expected(0,1)
+        ->expected(0, 1)
         ->default_val(50)
-        ->each([this](const std::string&) { m_find_copies_flag = true; });
+        ->each(
+            [this](const std::string&)
+            {
+                m_find_copies_flag = true;
+            }
+        );
     sub->add_flag("--find-copies-harder", m_find_copies_harder_flag, "Detect copies from unmodified files");
     sub->add_flag("-B,--break-rewrites", m_break_rewrites_flag, "Detect file rewrites");
 
     sub->add_option("-U,--unified", m_context_lines, "Lines of context");
     sub->add_option("--inter-hunk-context", m_interhunk_lines, "Context between hunks");
-    sub->add_option("--abbrev", m_abbrev, "Abbreviation length for object names")
-        ->expected(0,1);
+    sub->add_option("--abbrev", m_abbrev, "Abbreviation length for object names")->expected(0, 1);
 
     sub->add_flag("--color", m_colour_flag, "Show colored diff");
     sub->add_flag("--no-color", m_no_colour_flag, "Turn off colored diff");
 
-    sub->callback([this]() { this->run(); });
+    sub->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 }
 
-void print_stats(const diff_wrapper& diff, bool use_colour, bool stat_flag, bool shortstat_flag, bool numstat_flag, bool summary_flag)
+void print_stats(
+    const diff_wrapper& diff,
+    bool use_colour,
+    bool stat_flag,
+    bool shortstat_flag,
+    bool numstat_flag,
+    bool summary_flag
+)
 {
     git_diff_stats_format_t format;
     if (stat_flag)
     {
         if (shortstat_flag || numstat_flag || summary_flag)
         {
-            throw git_exception("Only one of --stat, --shortstat, --numstat and --summary should be provided.", git2cpp_error_code::BAD_ARGUMENT);
+            throw git_exception(
+                "Only one of --stat, --shortstat, --numstat and --summary should be provided.",
+                git2cpp_error_code::BAD_ARGUMENT
+            );
         }
         else
         {
@@ -74,7 +99,10 @@ void print_stats(const diff_wrapper& diff, bool use_colour, bool stat_flag, bool
     {
         if (numstat_flag || summary_flag)
         {
-            throw git_exception("Only one of --stat, --shortstat, --numstat and --summary should be provided.", git2cpp_error_code::BAD_ARGUMENT);
+            throw git_exception(
+                "Only one of --stat, --shortstat, --numstat and --summary should be provided.",
+                git2cpp_error_code::BAD_ARGUMENT
+            );
         }
         else
         {
@@ -85,7 +113,10 @@ void print_stats(const diff_wrapper& diff, bool use_colour, bool stat_flag, bool
     {
         if (summary_flag)
         {
-            throw git_exception("Only one of --stat, --shortstat, --numstat and --summary should be provided.", git2cpp_error_code::BAD_ARGUMENT);
+            throw git_exception(
+                "Only one of --stat, --shortstat, --numstat and --summary should be provided.",
+                git2cpp_error_code::BAD_ARGUMENT
+            );
         }
         else
         {
@@ -139,74 +170,91 @@ void print_stats(const diff_wrapper& diff, bool use_colour, bool stat_flag, bool
     git_buf_dispose(&buf);
 }
 
-static int colour_printer([[maybe_unused]] const git_diff_delta* delta, [[maybe_unused]] const git_diff_hunk* hunk, const git_diff_line* line, void* payload)
+static int colour_printer(
+    [[maybe_unused]] const git_diff_delta* delta,
+    [[maybe_unused]] const git_diff_hunk* hunk,
+    const git_diff_line* line,
+    void* payload
+)
 {
-	bool use_colour = *reinterpret_cast<bool*>(payload);
-
-	// Only print origin for context/addition/deletion lines
-    bool print_origin = (line->origin == GIT_DIFF_LINE_CONTEXT ||
-                        line->origin == GIT_DIFF_LINE_ADDITION ||
-                        line->origin == GIT_DIFF_LINE_DELETION);
-
-	if (use_colour)
-	{
-		switch (line->origin) {
-		case GIT_DIFF_LINE_ADDITION:  std::cout << termcolor::green; break;
-		case GIT_DIFF_LINE_DELETION:  std::cout << termcolor::red; break;
-		case GIT_DIFF_LINE_ADD_EOFNL: std::cout << termcolor::green; break;
-		case GIT_DIFF_LINE_DEL_EOFNL: std::cout << termcolor::red; break;
-		case GIT_DIFF_LINE_FILE_HDR:  std::cout << termcolor::bold; break;
-		case GIT_DIFF_LINE_HUNK_HDR:  std::cout << termcolor::cyan; break;
-		default: break;
-		}
-	}
-
-	if (print_origin)
-	{
-	    std::cout << line->origin;
-	}
-
-	std::cout << std::string_view(line->content, line->content_len);
-
-	if (use_colour)
-	{
-	    std::cout << termcolor::reset;
-	}
-
-	// Print copy/rename headers ONLY after the "diff --git" line
+    bool use_colour = *reinterpret_cast<bool*>(payload);
+
+    // Only print origin for context/addition/deletion lines
+    bool print_origin = (line->origin == GIT_DIFF_LINE_CONTEXT || line->origin == GIT_DIFF_LINE_ADDITION || line->origin == GIT_DIFF_LINE_DELETION);
+
+    if (use_colour)
+    {
+        switch (line->origin)
+        {
+            case GIT_DIFF_LINE_ADDITION:
+                std::cout << termcolor::green;
+                break;
+            case GIT_DIFF_LINE_DELETION:
+                std::cout << termcolor::red;
+                break;
+            case GIT_DIFF_LINE_ADD_EOFNL:
+                std::cout << termcolor::green;
+                break;
+            case GIT_DIFF_LINE_DEL_EOFNL:
+                std::cout << termcolor::red;
+                break;
+            case GIT_DIFF_LINE_FILE_HDR:
+                std::cout << termcolor::bold;
+                break;
+            case GIT_DIFF_LINE_HUNK_HDR:
+                std::cout << termcolor::cyan;
+                break;
+            default:
+                break;
+        }
+    }
+
+    if (print_origin)
+    {
+        std::cout << line->origin;
+    }
+
+    std::cout << std::string_view(line->content, line->content_len);
+
+    if (use_colour)
+    {
+        std::cout << termcolor::reset;
+    }
+
+    // Print copy/rename headers ONLY after the "diff --git" line
     if (line->origin == GIT_DIFF_LINE_FILE_HDR)
     {
         if (delta->status == GIT_DELTA_COPIED)
         {
             if (use_colour)
             {
-                 std::cout << termcolor::bold;
+                std::cout << termcolor::bold;
             }
             std::cout << "similarity index " << delta->similarity << "%\n";
             std::cout << "copy from " << delta->old_file.path << "\n";
             std::cout << "copy to " << delta->new_file.path << "\n";
             if (use_colour)
             {
-                    std::cout << termcolor::reset;
+                std::cout << termcolor::reset;
             }
         }
         else if (delta->status == GIT_DELTA_RENAMED)
         {
             if (use_colour)
             {
-                    std::cout << termcolor::bold;
+                std::cout << termcolor::bold;
             }
             std::cout << "similarity index " << delta->similarity << "%\n";
             std::cout << "rename from " << delta->old_file.path << "\n";
             std::cout << "rename to " << delta->new_file.path << "\n";
             if (use_colour)
             {
-                 std::cout << termcolor::reset;
+                std::cout << termcolor::reset;
             }
         }
     }
 
-	return 0;
+    return 0;
 }
 
 void diff_subcommand::print_diff(diff_wrapper& diff, bool use_colour)
@@ -261,9 +309,12 @@ void diff_subcommand::print_diff(diff_wrapper& diff, bool use_colour)
 
 diff_wrapper compute_diff_no_index(std::vector<std::string> files, git_diff_options& diffopts)
 {
-	if (files.size() != 2)
+    if (files.size() != 2)
     {
-        throw git_exception("usage: git diff --no-index [<options>] <path> <path> [<pathspec>...]", git2cpp_error_code::BAD_ARGUMENT);
+        throw git_exception(
+            "usage: git diff --no-index [<options>] <path> <path> [<pathspec>...]",
+            git2cpp_error_code::BAD_ARGUMENT
+        );
     }
 
     git_diff_options_init(&diffopts, GIT_DIFF_OPTIONS_VERSION);
@@ -281,12 +332,12 @@ diff_wrapper compute_diff_no_index(std::vector<std::string> files, git_diff_opti
     }
 
     auto patch = patch_wrapper::patch_from_files(files[0], file1_str, files[1], file2_str, &diffopts);
-	auto buf = patch.to_buf();
-	auto diff = diff_wrapper::diff_from_buffer(buf);
+    auto buf = patch.to_buf();
+    auto diff = diff_wrapper::diff_from_buffer(buf);
 
-	git_buf_dispose(&buf);
+    git_buf_dispose(&buf);
 
-	return diff;
+    return diff;
 }
 
 void diff_subcommand::run()
@@ -299,7 +350,10 @@ void diff_subcommand::run()
     {
         if (m_colour_flag)
         {
-            throw git_exception("Only one of --color and --no-color should be provided.", git2cpp_error_code::BAD_ARGUMENT);
+            throw git_exception(
+                "Only one of --color and --no-color should be provided.",
+                git2cpp_error_code::BAD_ARGUMENT
+            );
         }
         else
         {
@@ -311,7 +365,7 @@ void diff_subcommand::run()
         use_colour = true;
     }
 
-    if (m_cached_flag  && m_no_index_flag)
+    if (m_cached_flag && m_no_index_flag)
     {
         throw git_exception("--cached and --no-index are incompatible", git2cpp_error_code::BAD_ARGUMENT);
     }
@@ -330,18 +384,42 @@ void diff_subcommand::run()
         diffopts.interhunk_lines = m_interhunk_lines;
         diffopts.id_abbrev = m_abbrev;
 
-        if (m_reverse_flag) { diffopts.flags |= GIT_DIFF_REVERSE; }
-        if (m_text_flag) { diffopts.flags |= GIT_DIFF_FORCE_TEXT; }
-        if (m_ignore_space_at_eol_flag) { diffopts.flags |= GIT_DIFF_IGNORE_WHITESPACE_EOL; }
-        if (m_ignore_space_change_flag) { diffopts.flags |= GIT_DIFF_IGNORE_WHITESPACE_CHANGE; }
-        if (m_ignore_all_space_flag) { diffopts.flags |= GIT_DIFF_IGNORE_WHITESPACE; }
-        if (m_untracked_flag) { diffopts.flags |= GIT_DIFF_INCLUDE_UNTRACKED; }
-        if (m_patience_flag) { diffopts.flags |= GIT_DIFF_PATIENCE; }
-        if (m_minimal_flag) { diffopts.flags |= GIT_DIFF_MINIMAL; }
+        if (m_reverse_flag)
+        {
+            diffopts.flags |= GIT_DIFF_REVERSE;
+        }
+        if (m_text_flag)
+        {
+            diffopts.flags |= GIT_DIFF_FORCE_TEXT;
+        }
+        if (m_ignore_space_at_eol_flag)
+        {
+            diffopts.flags |= GIT_DIFF_IGNORE_WHITESPACE_EOL;
+        }
+        if (m_ignore_space_change_flag)
+        {
+            diffopts.flags |= GIT_DIFF_IGNORE_WHITESPACE_CHANGE;
+        }
+        if (m_ignore_all_space_flag)
+        {
+            diffopts.flags |= GIT_DIFF_IGNORE_WHITESPACE;
+        }
+        if (m_untracked_flag)
+        {
+            diffopts.flags |= GIT_DIFF_INCLUDE_UNTRACKED;
+        }
+        if (m_patience_flag)
+        {
+            diffopts.flags |= GIT_DIFF_PATIENCE;
+        }
+        if (m_minimal_flag)
+        {
+            diffopts.flags |= GIT_DIFF_MINIMAL;
+        }
         if (m_find_copies_flag || m_find_copies_harder_flag || m_find_renames_flag)
-                {
-                    diffopts.flags |= GIT_DIFF_INCLUDE_UNMODIFIED;
-                }
+        {
+            diffopts.flags |= GIT_DIFF_INCLUDE_UNMODIFIED;
+        }
 
         std::optional<tree_wrapper> tree1;
         std::optional<tree_wrapper> tree2;
@@ -350,7 +428,7 @@ void diff_subcommand::run()
         {
             tree1 = repo.treeish_to_tree(m_files[0]);
         }
-        if (m_files.size() ==2)
+        if (m_files.size() == 2)
         {
             tree2 = repo.treeish_to_tree(m_files[1]);
         }
diff --git a/src/subcommand/diff_subcommand.hpp b/src/subcommand/diff_subcommand.hpp
index 62e0947..d43cba1 100644
--- a/src/subcommand/diff_subcommand.hpp
+++ b/src/subcommand/diff_subcommand.hpp
@@ -1,8 +1,9 @@
 #pragma once
 
-#include <CLI/CLI.hpp>
 #include <string>
 
+#include <CLI/CLI.hpp>
+
 #include "../utils/common.hpp"
 #include "../wrapper/diff_wrapper.hpp"
 
@@ -53,4 +54,11 @@ class diff_subcommand
     bool m_no_colour_flag = false;
 };
 
-void print_stats(const diff_wrapper& diff, bool use_colour, bool stat_flag, bool shortstat_flag, bool numstat_flag, bool summary_flag);
+void print_stats(
+    const diff_wrapper& diff,
+    bool use_colour,
+    bool stat_flag,
+    bool shortstat_flag,
+    bool numstat_flag,
+    bool summary_flag
+);
diff --git a/src/subcommand/fetch_subcommand.cpp b/src/subcommand/fetch_subcommand.cpp
index 77d0bc3..8cbcf4d 100644
--- a/src/subcommand/fetch_subcommand.cpp
+++ b/src/subcommand/fetch_subcommand.cpp
@@ -1,8 +1,9 @@
+#include "../subcommand/fetch_subcommand.hpp"
+
 #include <iostream>
 
 #include <git2/remote.h>
 
-#include "../subcommand/fetch_subcommand.hpp"
 #include "../utils/credentials.hpp"
 #include "../utils/input_output.hpp"
 #include "../utils/progress.hpp"
@@ -12,16 +13,21 @@ fetch_subcommand::fetch_subcommand(const libgit2_object&, CLI::App& app)
 {
     auto* sub = app.add_subcommand("fetch", "Download objects and refs from another repository");
 
-    sub->add_option("<remote>", m_remote_name, "The remote to fetch from")
-        ->default_val("origin");
+    sub->add_option("<remote>", m_remote_name, "The remote to fetch from")->default_val("origin");
     sub->add_option("--depth", m_depth, "deepen or shorten history of shallow clone");
     sub->add_option("--deepen", m_deepen, "deepen history of shallow clone");
-    // sub->add_option("--shallow-since", m_shallow_since, "<time>\ndeepen history of shallow repository based on time.");
-    // sub->add_option("--shallow-exclude", m_shallow_exclude, "<ref>\ndeepen history of shallow clone, excluding ref");
+    // sub->add_option("--shallow-since", m_shallow_since, "<time>\ndeepen history of shallow repository based
+    // on time."); sub->add_option("--shallow-exclude", m_shallow_exclude, "<ref>\ndeepen history of shallow
+    // clone, excluding ref");
     sub->add_flag("--unshallow", m_unshallow, "convert to a complete repository");
     // sub->add_flag("--update-shallow", m_update_shallow, "accept refs that update .git/shallow");
 
-    sub->callback([this]() { this->run(); });
+    sub->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 }
 
 void fetch_subcommand::run()
@@ -72,13 +78,13 @@ void fetch_subcommand::run()
     const git_indexer_progress* stats = git_remote_stats(remote);
     if (stats->local_objects > 0)
     {
-        std::cout << "\rReceived " << stats->indexed_objects << "/" << stats->total_objects
-            << " objects in " << stats->received_bytes << " bytes (used "
-            << stats->local_objects << " local objects)" << std::endl;
+        std::cout << "\rReceived " << stats->indexed_objects << "/" << stats->total_objects << " objects in "
+                  << stats->received_bytes << " bytes (used " << stats->local_objects << " local objects)"
+                  << std::endl;
     }
     else
     {
-        std::cout << "\rReceived " << stats->indexed_objects << "/" << stats->total_objects
-            << " objects in " << stats->received_bytes << " bytes" << std::endl;
+        std::cout << "\rReceived " << stats->indexed_objects << "/" << stats->total_objects << " objects in "
+                  << stats->received_bytes << " bytes" << std::endl;
     }
 }
diff --git a/src/subcommand/init_subcommand.cpp b/src/subcommand/init_subcommand.cpp
index bd1c238..c69e9a2 100644
--- a/src/subcommand/init_subcommand.cpp
+++ b/src/subcommand/init_subcommand.cpp
@@ -1,10 +1,12 @@
-#include <filesystem>
 #include "init_subcommand.hpp"
+
+#include <filesystem>
+
 #include "../wrapper/repository_wrapper.hpp"
 
 init_subcommand::init_subcommand(const libgit2_object&, CLI::App& app)
 {
-    auto *sub = app.add_subcommand("init", "Explanation of init here");
+    auto* sub = app.add_subcommand("init", "Explanation of init here");
 
     sub->add_flag("--bare", m_bare, "info about bare arg");
 
@@ -12,9 +14,18 @@ init_subcommand::init_subcommand(const libgit2_object&, CLI::App& app)
     sub->add_option("directory", m_directory, "info about directory arg")
         ->check(CLI::ExistingDirectory | CLI::NonexistentPath)
         ->default_val(get_current_git_path());
-    sub->add_option("-b,--initial-branch", m_branch, "Use <branch-name> for the initial branch in the newly created repository. If not specified, fall back to the default name.");
+    sub->add_option(
+        "-b,--initial-branch",
+        m_branch,
+        "Use <branch-name> for the initial branch in the newly created repository. If not specified, fall back to the default name."
+    );
 
-    sub->callback([this]() { this->run(); });
+    sub->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 }
 
 void init_subcommand::run()
@@ -22,7 +33,8 @@ void init_subcommand::run()
     std::filesystem::path target_dir = m_directory;
     bool reinit = std::filesystem::exists(target_dir / ".git" / "HEAD");
 
-    repository_wrapper repo = [this]() {
+    repository_wrapper repo = [this]()
+    {
         if (m_branch.empty())
         {
             return repository_wrapper::init(m_directory, m_bare);
@@ -30,7 +42,10 @@ void init_subcommand::run()
         else
         {
             git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT;
-            if (m_bare) { opts.flags |= GIT_REPOSITORY_INIT_BARE; }
+            if (m_bare)
+            {
+                opts.flags |= GIT_REPOSITORY_INIT_BARE;
+            }
             opts.initial_head = m_branch.c_str();
 
             return repository_wrapper::init_ext(m_directory, &opts);
@@ -41,10 +56,10 @@ void init_subcommand::run()
 
     if (reinit)
     {
-        std::cout << "Reinitialized existing Git repository in " << path <<std::endl;
+        std::cout << "Reinitialized existing Git repository in " << path << std::endl;
     }
     else
     {
-        std::cout << "Initialized empty Git repository in " << path <<std::endl;
+        std::cout << "Initialized empty Git repository in " << path << std::endl;
     }
 }
diff --git a/src/subcommand/init_subcommand.hpp b/src/subcommand/init_subcommand.hpp
index b625436..345a73d 100644
--- a/src/subcommand/init_subcommand.hpp
+++ b/src/subcommand/init_subcommand.hpp
@@ -14,6 +14,7 @@ class init_subcommand
     void run();
 
 private:
+
     bool m_bare = false;
     std::string m_directory;
     std::string m_branch;
diff --git a/src/subcommand/log_subcommand.cpp b/src/subcommand/log_subcommand.cpp
index e0eac66..98e50d8 100644
--- a/src/subcommand/log_subcommand.cpp
+++ b/src/subcommand/log_subcommand.cpp
@@ -1,57 +1,85 @@
+#include "log_subcommand.hpp"
+
 #include <format>
-#include <git2.h>
-#include <git2/oid.h>
-#include <git2/refs.h>
-#include <git2/types.h>
 #include <sstream>
 #include <string_view>
 #include <vector>
 
+#include <git2.h>
+#include <git2/oid.h>
+#include <git2/refs.h>
+#include <git2/types.h>
 #include <termcolor/termcolor.hpp>
 
-#include "log_subcommand.hpp"
 #include "../utils/terminal_pager.hpp"
 
 log_subcommand::log_subcommand(const libgit2_object&, CLI::App& app)
 {
-    auto *sub = app.add_subcommand("log", "Shows commit logs");
+    auto* sub = app.add_subcommand("log", "Shows commit logs");
 
-    sub->add_option("--format", m_format_flag, "Pretty-print the contents of the commit logs in a given format, where <format> can be one of full, fuller or oneline");
+    sub->add_option(
+        "--format",
+        m_format_flag,
+        "Pretty-print the contents of the commit logs in a given format, where <format> can be one of full, fuller or oneline"
+    );
     sub->add_option("-n,--max-count", m_max_count_flag, "Limit the output to <number> commits.");
-    sub->add_flag("--abbrev-commit", m_abbrev_commit_flag, "Instead of showing the full 40-byte hexadecimal commit object name, show a prefix that names the object uniquely. --abbrev=<n> (which also modifies diff output, if it is displayed) option can be used to specify the minimum length of the prefix.");
-    sub->add_option("--abbrev", m_abbrev, "Instead of showing the full 40-byte hexadecimal object name in diff-raw format output and diff-tree header lines, show the shortest prefix that is at least <n> hexdigits long that uniquely refers the object.");
-    sub->add_flag("--no-abbrev-commit", m_no_abbrev_commit_flag, "Show the full 40-byte hexadecimal commit object name. This negates --abbrev-commit, either explicit or implied by other options such as --oneline.");
-    sub->add_flag("--oneline", m_oneline_flag, "This is a shorthand for --format=oneline --abbrev-commit used together.");
-
-    sub->callback([this]() { this->run(); });
+    sub->add_flag(
+        "--abbrev-commit",
+        m_abbrev_commit_flag,
+        "Instead of showing the full 40-byte hexadecimal commit object name, show a prefix that names the object uniquely. --abbrev=<n> (which also modifies diff output, if it is displayed) option can be used to specify the minimum length of the prefix."
+    );
+    sub->add_option(
+        "--abbrev",
+        m_abbrev,
+        "Instead of showing the full 40-byte hexadecimal object name in diff-raw format output and diff-tree header lines, show the shortest prefix that is at least <n> hexdigits long that uniquely refers the object."
+    );
+    sub->add_flag(
+        "--no-abbrev-commit",
+        m_no_abbrev_commit_flag,
+        "Show the full 40-byte hexadecimal commit object name. This negates --abbrev-commit, either explicit or implied by other options such as --oneline."
+    );
+    sub->add_flag(
+        "--oneline",
+        m_oneline_flag,
+        "This is a shorthand for --format=oneline --abbrev-commit used together."
+    );
+
+    sub->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 };
 
 void print_time(git_time intime, std::string prefix)
 {
-	char sign, out[32];
-	struct tm *intm;
-	int offset, hours, minutes;
-	time_t t;
-
-	offset = intime.offset;
-	if (offset < 0) {
-		sign = '-';
-		offset = -offset;
-	}
-	else
-	{
-		sign = '+';
-	}
-
-	hours   = offset / 60;
-	minutes = offset % 60;
-
-	t = (time_t)intime.time + (intime.offset * 60);
-
-	intm = gmtime(&t);
-	strftime(out, sizeof(out), "%a %b %e %T %Y", intm);
-
-	std::cout << prefix << out << " " << sign << std::format("{:02d}", hours) << std::format("{:02d}", minutes) <<std::endl;
+    char sign, out[32];
+    struct tm* intm;
+    int offset, hours, minutes;
+    time_t t;
+
+    offset = intime.offset;
+    if (offset < 0)
+    {
+        sign = '-';
+        offset = -offset;
+    }
+    else
+    {
+        sign = '+';
+    }
+
+    hours = offset / 60;
+    minutes = offset % 60;
+
+    t = (time_t) intime.time + (intime.offset * 60);
+
+    intm = gmtime(&t);
+    strftime(out, sizeof(out), "%a %b %e %T %Y", intm);
+
+    std::cout << prefix << out << " " << sign << std::format("{:02d}", hours)
+              << std::format("{:02d}", minutes) << std::endl;
 }
 
 std::vector<std::string> get_tags_for_commit(repository_wrapper& repo, const git_oid& commit_oid)
@@ -78,11 +106,16 @@ std::vector<std::string> get_tags_for_commit(repository_wrapper& repo, const git
         }
     }
 
-    git_strarray_dispose(&tag_names);   // TODO: refactor git_strarray_wrapper to use it here
+    git_strarray_dispose(&tag_names);  // TODO: refactor git_strarray_wrapper to use it here
     return tags;
 }
 
-std::vector<std::string> get_branches_for_commit(repository_wrapper& repo, git_branch_t type, const git_oid& commit_oid, const std::string exclude_branch)
+std::vector<std::string> get_branches_for_commit(
+    repository_wrapper& repo,
+    git_branch_t type,
+    const git_oid& commit_oid,
+    const std::string exclude_branch
+)
 {
     std::vector<std::string> branches;
 
@@ -133,9 +166,9 @@ struct commit_refs
     std::vector<std::string> local_branches;
     std::vector<std::string> remote_branches;
 
-    bool has_refs() const {
-        return !head_branch.empty() || !tags.empty() ||
-               !local_branches.empty() || !remote_branches.empty();
+    bool has_refs() const
+    {
+        return !head_branch.empty() || !tags.empty() || !local_branches.empty() || !remote_branches.empty();
     }
 };
 
@@ -174,10 +207,9 @@ void print_refs(const commit_refs& refs)
 
     if (!refs.head_branch.empty())
     {
-        std::cout << termcolor::bold << termcolor::cyan << "HEAD" << termcolor::reset
-                  << termcolor::yellow << " -> " << termcolor::reset
-                  << termcolor::bold << termcolor::green << refs.head_branch << termcolor::reset
-                  << termcolor::yellow;
+        std::cout << termcolor::bold << termcolor::cyan << "HEAD" << termcolor::reset << termcolor::yellow
+                  << " -> " << termcolor::reset << termcolor::bold << termcolor::green << refs.head_branch
+                  << termcolor::reset << termcolor::yellow;
         first = false;
     }
 
@@ -261,19 +293,19 @@ void log_subcommand::print_commit(repository_wrapper& repo, const commit_wrapper
 
     std::cout << termcolor::reset << std::endl;
 
-    if (m_format_flag=="fuller")
+    if (m_format_flag == "fuller")
     {
-        std::cout << "Author:\t    " <<  author.name() << " " << author.email() << std::endl;
+        std::cout << "Author:\t    " << author.name() << " " << author.email() << std::endl;
         print_time(author.when(), "AuthorDate: ");
-        std::cout << "Commit:\t    " <<  committer.name() << " " << committer.email() << std::endl;
+        std::cout << "Commit:\t    " << committer.name() << " " << committer.email() << std::endl;
         print_time(committer.when(), "CommitDate: ");
     }
     else
     {
-        std::cout << "Author:\t" <<  author.name() << " " << author.email() << std::endl;
-        if (m_format_flag=="full")
+        std::cout << "Author:\t" << author.name() << " " << author.email() << std::endl;
+        if (m_format_flag == "full")
         {
-            std::cout << "Commit:\t" <<  committer.name() << " " << committer.email() << std::endl;
+            std::cout << "Commit:\t" << committer.name() << " " << committer.email() << std::endl;
         }
         else
         {
@@ -307,9 +339,9 @@ void log_subcommand::run()
 
     terminal_pager pager;
 
-    std::size_t i=0;
+    std::size_t i = 0;
     git_oid commit_oid;
-    while (!walker.next(commit_oid) && i<m_max_count_flag)
+    while (!walker.next(commit_oid) && i < m_max_count_flag)
     {
         if (i != 0)
         {
diff --git a/src/subcommand/log_subcommand.hpp b/src/subcommand/log_subcommand.hpp
index ec0922d..3f27043 100644
--- a/src/subcommand/log_subcommand.hpp
+++ b/src/subcommand/log_subcommand.hpp
@@ -1,13 +1,13 @@
 #pragma once
 
-#include <CLI/CLI.hpp>
 #include <limits>
 
+#include <CLI/CLI.hpp>
+
 #include "../utils/common.hpp"
 #include "../wrapper/commit_wrapper.hpp"
 #include "../wrapper/repository_wrapper.hpp"
 
-
 class log_subcommand
 {
 public:
@@ -20,7 +20,7 @@ class log_subcommand
     void print_commit(repository_wrapper& repo, const commit_wrapper& commit);
 
     std::string m_format_flag;
-    int m_max_count_flag=std::numeric_limits<int>::max();
+    int m_max_count_flag = std::numeric_limits<int>::max();
     size_t m_abbrev = 7;
     bool m_abbrev_commit_flag = false;
     bool m_no_abbrev_commit_flag = false;
diff --git a/src/subcommand/merge_subcommand.cpp b/src/subcommand/merge_subcommand.cpp
index fa704df..c481ee3 100644
--- a/src/subcommand/merge_subcommand.cpp
+++ b/src/subcommand/merge_subcommand.cpp
@@ -1,26 +1,49 @@
+#include "merge_subcommand.hpp"
+
 #include <cassert>
+#include <iostream>
+
 #include <git2/reset.h>
 #include <git2/types.h>
-#include <iostream>
 #include <termcolor/termcolor.hpp>
 
-#include "merge_subcommand.hpp"
 #include "../wrapper/status_wrapper.hpp"
 
-
 merge_subcommand::merge_subcommand(const libgit2_object&, CLI::App& app)
 {
-    auto *sub = app.add_subcommand("merge", "Join two or more development histories together");
+    auto* sub = app.add_subcommand("merge", "Join two or more development histories together");
 
     sub->add_option("<branch>", m_branches_to_merge, "Branch(es) to merge");
-    // sub->add_flag("--no-ff", m_no_ff, "Create a merge commit in all cases, even when the merge could instead be resolved as a fast-forward.");
-    // sub->add_flag("--commit", m_commit, "Perform the merge and commit the result. This option can be used to override --no-commit.");
-    sub->add_flag("--no-commit", m_no_commit, "With --no-commit perform the merge and stop just before creating a merge commit, to give the user a chance to inspect and further tweak the merge result before committing. \nNote that fast-forward updates do not create a merge commit and therefore there is no way to stop those merges with --no-commit. Thus, if you want to ensure your branch is not changed or updated by the merge command, use --no-ff with --no-commit.");
-    sub->add_flag("--abort", m_abort, "Abort the current conflict resolution process, and try to reconstruct the pre-merge state. If an autostash entry is present, apply it to the worktree.\nIf there were uncommitted worktree changes present when the merge started, git merge --abort will in some cases be unable to reconstruct these changes. It is therefore recommended to always commit or stash your changes before running git merge.\ngit merge --abort is equivalent to git reset --merge when MERGE_HEAD is present unless MERGE_AUTOSTASH is also present in which case git merge --abort applies the stash entry to the worktree whereas git reset --merge will save the stashed changes in the stash list.");
-    sub->add_flag("--quit", m_quit, "Forget about the current merge in progress. Leave the index and the working tree as-is. If MERGE_AUTOSTASH is present, the stash entry will be saved to the stash list.");
-    sub->add_flag("--continue", m_continue, "After a git merge stops due to conflicts you can conclude the merge by running git merge --continue");   //  (see "HOW TO RESOLVE CONFLICTS" section below).
-
-    sub->callback([this]() { this->run(); });
+    // sub->add_flag("--no-ff", m_no_ff, "Create a merge commit in all cases, even when the merge could
+    // instead be resolved as a fast-forward."); sub->add_flag("--commit", m_commit, "Perform the merge and
+    // commit the result. This option can be used to override --no-commit.");
+    sub->add_flag(
+        "--no-commit",
+        m_no_commit,
+        "With --no-commit perform the merge and stop just before creating a merge commit, to give the user a chance to inspect and further tweak the merge result before committing. \nNote that fast-forward updates do not create a merge commit and therefore there is no way to stop those merges with --no-commit. Thus, if you want to ensure your branch is not changed or updated by the merge command, use --no-ff with --no-commit."
+    );
+    sub->add_flag(
+        "--abort",
+        m_abort,
+        "Abort the current conflict resolution process, and try to reconstruct the pre-merge state. If an autostash entry is present, apply it to the worktree.\nIf there were uncommitted worktree changes present when the merge started, git merge --abort will in some cases be unable to reconstruct these changes. It is therefore recommended to always commit or stash your changes before running git merge.\ngit merge --abort is equivalent to git reset --merge when MERGE_HEAD is present unless MERGE_AUTOSTASH is also present in which case git merge --abort applies the stash entry to the worktree whereas git reset --merge will save the stashed changes in the stash list."
+    );
+    sub->add_flag(
+        "--quit",
+        m_quit,
+        "Forget about the current merge in progress. Leave the index and the working tree as-is. If MERGE_AUTOSTASH is present, the stash entry will be saved to the stash list."
+    );
+    sub->add_flag(
+        "--continue",
+        m_continue,
+        "After a git merge stops due to conflicts you can conclude the merge by running git merge --continue"
+    );  //  (see "HOW TO RESOLVE CONFLICTS" section below).
+
+    sub->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 }
 
 annotated_commit_list_wrapper merge_subcommand::resolve_heads(const repository_wrapper& repo)
@@ -28,7 +51,7 @@ annotated_commit_list_wrapper merge_subcommand::resolve_heads(const repository_w
     std::vector<annotated_commit_wrapper> commits_to_merge;
     commits_to_merge.reserve(m_branches_to_merge.size());
 
-    for (const auto branch_name:m_branches_to_merge)
+    for (const auto branch_name : m_branches_to_merge)
     {
         std::optional<annotated_commit_wrapper> commit = repo.resolve_local_ref(branch_name);
         if (commit.has_value())
@@ -39,12 +62,13 @@ annotated_commit_list_wrapper merge_subcommand::resolve_heads(const repository_w
     return annotated_commit_list_wrapper(std::move(commits_to_merge));
 }
 
-annotated_commit_list_wrapper resolve_mergeheads(const repository_wrapper& repo, const std::vector<git_oid>& oid_list)
+annotated_commit_list_wrapper
+resolve_mergeheads(const repository_wrapper& repo, const std::vector<git_oid>& oid_list)
 {
     std::vector<annotated_commit_wrapper> commits_to_merge;
     commits_to_merge.reserve(oid_list.size());
 
-    for (const auto& id:oid_list)
+    for (const auto& id : oid_list)
     {
         std::optional<annotated_commit_wrapper> commit = repo.find_annotated_commit(id);
         if (commit.has_value())
@@ -59,7 +83,7 @@ void perform_fastforward(repository_wrapper& repo, const git_oid& target_oid, in
 {
     const git_checkout_options ff_checkout_options = GIT_CHECKOUT_OPTIONS_INIT;
 
-    auto lambda_get_target_ref = [] (auto repo, auto is_unborn)
+    auto lambda_get_target_ref = [](auto repo, auto is_unborn)
     {
         if (!is_unborn)
         {
@@ -84,7 +108,8 @@ void merge_subcommand::create_merge_commit(
     const index_wrapper& index,
     const std::vector<std::string>& branches_to_merge,
     const annotated_commit_list_wrapper& commits_to_merge,
-    size_t num_commits_to_merge)
+    size_t num_commits_to_merge
+)
 {
     auto head_ref = repo.head();
     auto merge_ref = repo.find_reference_dwim(branches_to_merge.front());
@@ -93,7 +118,7 @@ void merge_subcommand::create_merge_commit(
     std::vector<commit_wrapper> parents_list;
     parents_list.reserve(num_commits_to_merge + 1);
     parents_list.push_back(std::move(head_ref.peel<commit_wrapper>()));
-    for (size_t i=0; i<num_commits_to_merge; ++i)
+    for (size_t i = 0; i < num_commits_to_merge; ++i)
     {
         parents_list.push_back(repo.find_commit(commits_to_merge[i].oid()));
     }
@@ -104,20 +129,26 @@ void merge_subcommand::create_merge_commit(
     author_name = author_committer_sign.first.name();
     std::string author_email;
     author_email = author_committer_sign.first.email();
-    auto author_committer_sign_now = signature_wrapper::signature_now(author_name, author_email, author_name, author_email);
+    auto author_committer_sign_now = signature_wrapper::signature_now(
+        author_name,
+        author_email,
+        author_name,
+        author_email
+    );
 
     // TODO: add a prompt to edit the merge message
     std::string msg_target = merge_ref ? merge_ref->short_name() : git_oid_tostr_s(&(merge_commit.oid()));
     msg_target = "\'" + msg_target + "\'";
-	std::string msg = merge_ref ? "Merge branch " : "Merge commit ";
-	msg.append(msg_target);
+    std::string msg = merge_ref ? "Merge branch " : "Merge commit ";
+    msg.append(msg_target);
 
-	repo.create_commit(author_committer_sign_now, msg, std::optional<commit_list_wrapper>(std::move(parents)));
+    repo.create_commit(author_committer_sign_now, msg, std::optional<commit_list_wrapper>(std::move(parents)));
 
-	repo.state_cleanup();
+    repo.state_cleanup();
 }
 
-// This function is used as a callback in git_repository_mergehead_foreach and therefore its type must be git_repository_mergehead_foreach_cb.
+// This function is used as a callback in git_repository_mergehead_foreach and therefore its type must be
+// git_repository_mergehead_foreach_cb.
 int populate_list(const git_oid* oid, void* payload)
 {
     auto* l = reinterpret_cast<std::vector<git_oid>*>(payload);
@@ -144,11 +175,12 @@ void merge_subcommand::run()
 
             if (m_quit | m_continue)
             {
-                std::cout << "fatal: --abort expects no arguments" << std::endl;   // TODO: add the help info
+                std::cout << "fatal: --abort expects no arguments" << std::endl;  // TODO: add the help info
                 return;
             }
 
-            std::cout << "Warning: 'merge --abort' is not implemented yet. A 'reset --hard HEAD' will be executed." << std::endl;
+            std::cout << "Warning: 'merge --abort' is not implemented yet. A 'reset --hard HEAD' will be executed."
+                      << std::endl;
             std::cout << "Do you want to continue [y/N] ?" << std::endl;
             std::string answer;
             std::cin >> answer;
@@ -164,7 +196,7 @@ void merge_subcommand::run()
             }
             else
             {
-                std::cout << "Abort." << std::endl;   // maybe another message would be more clear?
+                std::cout << "Abort." << std::endl;  // maybe another message would be more clear?
             }
             return;
         }
@@ -176,8 +208,8 @@ void merge_subcommand::run()
 
             // if (m_continue)
             // {
-            //     std::cout << "fatal: --abort expects no arguments" << std::endl;   // TODO: add the help info
-            //     return;
+            //     std::cout << "fatal: --abort expects no arguments" << std::endl;   // TODO: add the help
+            //     info return;
             // }
 
             // problem: can't do a reset if the state is not cleaned up, but it shouldn't be.
@@ -195,12 +227,13 @@ void merge_subcommand::run()
             return;
         }
         else if (m_continue)
-		{
-		    auto sl = status_list_wrapper::status_list(repo);
-		    if (!sl.has_unmerged_header())
-			{
-			    // std::string commit_message = "Merge branch ";    // how to get the name of the branch the merge was started on ?
- 			    // auto author_committer_signatures = signature_wrapper::get_default_signature_from_env(repo);
+        {
+            auto sl = status_list_wrapper::status_list(repo);
+            if (!sl.has_unmerged_header())
+            {
+                // std::string commit_message = "Merge branch ";    // how to get the name of the branch the
+                // merge was started on ? auto author_committer_signatures =
+                // signature_wrapper::get_default_signature_from_env(repo);
                 // repo.create_commit(author_committer_signatures, commit_message, std::nullopt);
 
                 std::vector<git_oid> oid_list;
@@ -210,46 +243,49 @@ void merge_subcommand::run()
                 size_t num_commits_to_merge = commits_to_merge.size();
 
                 std::vector<std::string> branches_to_merge_names;
-                for (const auto& id:oid_list)
-				{
-				    git_reference_iterator* iter;
-					git_reference_iterator_new(&iter, repo);
-					git_reference* ref;
-					git_reference_next(&ref, iter);
-					if (git_oid_equal(git_reference_target(ref), &id))
-					{
-	                    auto name = git_reference_name(ref);
-						branches_to_merge_names.push_back(name);
-					}
-					git_reference_free(ref);
-				}
+                for (const auto& id : oid_list)
+                {
+                    git_reference_iterator* iter;
+                    git_reference_iterator_new(&iter, repo);
+                    git_reference* ref;
+                    git_reference_next(&ref, iter);
+                    if (git_oid_equal(git_reference_target(ref), &id))
+                    {
+                        auto name = git_reference_name(ref);
+                        branches_to_merge_names.push_back(name);
+                    }
+                    git_reference_free(ref);
+                }
 
                 create_merge_commit(repo, index, branches_to_merge_names, commits_to_merge, num_commits_to_merge);
-                std::cout << "Merge made" << std::endl;     // TODO: change the outpout to something like this: 3c22161 (HEAD -> master) Merge branch 'foregone'
+                std::cout << "Merge made" << std::endl;  // TODO: change the outpout to something like this:
+                                                         // 3c22161 (HEAD -> master) Merge branch 'foregone'
 
                 repo.state_cleanup();
                 index.conflict_cleanup();
-			    return;
-			}
-			else
-			{
-			    auto entry_status = get_status_msg(GIT_STATUS_CONFLICTED).short_mod;
+                return;
+            }
+            else
+            {
+                auto entry_status = get_status_msg(GIT_STATUS_CONFLICTED).short_mod;
                 const auto& entry_list = sl.get_entry_list(GIT_STATUS_CONFLICTED);
                 for (auto* entry : entry_list)
-			    {
-					git_diff_delta* diff_delta = entry->head_to_index; //ou entry->index_to_workdir ???
+                {
+                    git_diff_delta* diff_delta = entry->head_to_index;  // ou entry->index_to_workdir ???
                     const char* old_path = diff_delta->old_file.path;
                     std::cout << entry_status << "\t" << old_path << std::endl;
-				}
-			    std::cout << "error: Committing is not possible because you have unmerged files." << std::endl;
-			}
-		}
+                }
+                std::cout << "error: Committing is not possible because you have unmerged files." << std::endl;
+            }
+        }
         else
         {
             std::cout << "error: Merging is not possible because you have unmerged files." << std::endl;
         }
-        std::cout << yellow << "hint: Fix them up in the work tree, and then use 'git add/rm <file>'" << std::endl;
-        std::cout << "hint: as appropriate to mark resolution and make a commit." << termcolor::reset << std::endl;
+        std::cout << yellow << "hint: Fix them up in the work tree, and then use 'git add/rm <file>'"
+                  << std::endl;
+        std::cout << "hint: as appropriate to mark resolution and make a commit." << termcolor::reset
+                  << std::endl;
         std::cout << "fatal: Exiting because of an unresolved conflict." << std::endl;
         return;
     }
@@ -268,27 +304,29 @@ void merge_subcommand::run()
     }
 
     if (state != GIT_REPOSITORY_STATE_NONE)  // Could this be a "else if before the "else" above ?
-     {
-        std::cout << "repository is in unexpected state " << state <<std::endl;
+    {
+        std::cout << "repository is in unexpected state " << state << std::endl;
     }
 
     git_merge_analysis_t analysis;
-	git_merge_preference_t preference;
-	annotated_commit_list_wrapper commits_to_merge = resolve_heads(repo);
-	size_t num_commits_to_merge = commits_to_merge.size();
-	git_annotated_commit** c_commits_to_merge = commits_to_merge;
-	auto commits_to_merge_const = const_cast<const git_annotated_commit**>(c_commits_to_merge);
+    git_merge_preference_t preference;
+    annotated_commit_list_wrapper commits_to_merge = resolve_heads(repo);
+    size_t num_commits_to_merge = commits_to_merge.size();
+    git_annotated_commit** c_commits_to_merge = commits_to_merge;
+    auto commits_to_merge_const = const_cast<const git_annotated_commit**>(c_commits_to_merge);
 
-    throw_if_error(git_merge_analysis(&analysis, &preference, repo, commits_to_merge_const, num_commits_to_merge));
+    throw_if_error(
+        git_merge_analysis(&analysis, &preference, repo, commits_to_merge_const, num_commits_to_merge)
+    );
 
     if (analysis & GIT_MERGE_ANALYSIS_UP_TO_DATE)
     {
         std::cout << "Already up-to-date" << std::endl;
         return;
     }
-    else if (analysis & GIT_MERGE_ANALYSIS_UNBORN ||
-             (analysis & GIT_MERGE_ANALYSIS_FASTFORWARD &&
-             !(preference & GIT_MERGE_PREFERENCE_NO_FASTFORWARD)))
+    else if (analysis & GIT_MERGE_ANALYSIS_UNBORN
+             || (analysis & GIT_MERGE_ANALYSIS_FASTFORWARD
+                 && !(preference & GIT_MERGE_PREFERENCE_NO_FASTFORWARD)))
     {
         if (analysis & GIT_MERGE_ANALYSIS_UNBORN)
         {
@@ -307,32 +345,34 @@ void merge_subcommand::run()
     else if (analysis & GIT_MERGE_ANALYSIS_NORMAL)
     {
         git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
-		git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
+        git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
 
-		merge_opts.flags = 0;
-		merge_opts.file_flags = GIT_MERGE_FILE_STYLE_DIFF3;
+        merge_opts.flags = 0;
+        merge_opts.file_flags = GIT_MERGE_FILE_STYLE_DIFF3;
 
-		checkout_opts.checkout_strategy = GIT_CHECKOUT_FORCE|GIT_CHECKOUT_ALLOW_CONFLICTS;
+        checkout_opts.checkout_strategy = GIT_CHECKOUT_FORCE | GIT_CHECKOUT_ALLOW_CONFLICTS;
 
-		if (preference & GIT_MERGE_PREFERENCE_FASTFORWARD_ONLY)
-		{
-			std::cout << "Fast-forward is preferred, but only a merge is possible\n" << std::endl;
-		}
+        if (preference & GIT_MERGE_PREFERENCE_FASTFORWARD_ONLY)
+        {
+            std::cout << "Fast-forward is preferred, but only a merge is possible\n" << std::endl;
+        }
 
-		throw_if_error(git_merge(repo,
-		                         (const git_annotated_commit**)c_commits_to_merge,
-								 num_commits_to_merge,
-	                             &merge_opts,
-								 &checkout_opts));
+        throw_if_error(git_merge(
+            repo,
+            (const git_annotated_commit**) c_commits_to_merge,
+            num_commits_to_merge,
+            &merge_opts,
+            &checkout_opts
+        ));
     }
 
     if (index.has_conflict())
     {
-		index.output_conflicts();
-	}
-	else if (!m_no_commit)
-	{
-	    create_merge_commit(repo, index, m_branches_to_merge, commits_to_merge, num_commits_to_merge);
-		std::cout << "Merge made" << std::endl;
-	}
+        index.output_conflicts();
+    }
+    else if (!m_no_commit)
+    {
+        create_merge_commit(repo, index, m_branches_to_merge, commits_to_merge, num_commits_to_merge);
+        std::cout << "Merge made" << std::endl;
+    }
 }
diff --git a/src/subcommand/merge_subcommand.hpp b/src/subcommand/merge_subcommand.hpp
index e5b2f4a..26de460 100644
--- a/src/subcommand/merge_subcommand.hpp
+++ b/src/subcommand/merge_subcommand.hpp
@@ -20,7 +20,8 @@ class merge_subcommand
         const index_wrapper& index,
         const std::vector<std::string>& branches_to_merge,
         const annotated_commit_list_wrapper& commits_to_merge,
-        size_t num_commits_to_merge);
+        size_t num_commits_to_merge
+    );
 
     std::vector<std::string> m_branches_to_merge;
     // bool m_no_ff = false;
diff --git a/src/subcommand/mv_subcommand.cpp b/src/subcommand/mv_subcommand.cpp
index 176c874..72333e7 100644
--- a/src/subcommand/mv_subcommand.cpp
+++ b/src/subcommand/mv_subcommand.cpp
@@ -1,6 +1,7 @@
+#include "mv_subcommand.hpp"
+
 #include <filesystem>
 #include <system_error>
-#include "mv_subcommand.hpp"
 
 #include "../utils/git_exception.hpp"
 #include "../wrapper/index_wrapper.hpp"
@@ -10,12 +11,17 @@ namespace fs = std::filesystem;
 
 mv_subcommand::mv_subcommand(const libgit2_object&, CLI::App& app)
 {
-    auto* sub = app.add_subcommand("mv" , "Move or rename a file, a directory, or a symlink");
+    auto* sub = app.add_subcommand("mv", "Move or rename a file, a directory, or a symlink");
     sub->add_option("<source>", m_source_path, "The path of the source to move")->required()->check(CLI::ExistingFile);
     sub->add_option("<destination>", m_destination_path, "The path of the destination")->required();
     sub->add_flag("-f,--force", m_force, "Force renaming or moving of a file even if the <destination> exists.");
 
-    sub->callback([this]() { this->run(); });
+    sub->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 }
 
 void mv_subcommand::run()
@@ -33,7 +39,7 @@ void mv_subcommand::run()
     std::error_code ec;
     fs::rename(m_source_path, m_destination_path, ec);
 
-    if(ec)
+    if (ec)
     {
         throw git_exception("Could not move file", ec.value());
     }
diff --git a/src/subcommand/mv_subcommand.hpp b/src/subcommand/mv_subcommand.hpp
index dc74032..1509957 100644
--- a/src/subcommand/mv_subcommand.hpp
+++ b/src/subcommand/mv_subcommand.hpp
@@ -1,8 +1,9 @@
 #pragma once
 
-#include <CLI/CLI.hpp>
 #include <string>
 
+#include <CLI/CLI.hpp>
+
 #include "../utils/common.hpp"
 
 class mv_subcommand
@@ -18,4 +19,3 @@ class mv_subcommand
     std::string m_destination_path;
     bool m_force = false;
 };
-
diff --git a/src/subcommand/push_subcommand.cpp b/src/subcommand/push_subcommand.cpp
index 56b4346..9e2af17 100644
--- a/src/subcommand/push_subcommand.cpp
+++ b/src/subcommand/push_subcommand.cpp
@@ -1,8 +1,9 @@
+#include "../subcommand/push_subcommand.hpp"
+
 #include <iostream>
 
 #include <git2/remote.h>
 
-#include "../subcommand/push_subcommand.hpp"
 #include "../utils/credentials.hpp"
 #include "../utils/progress.hpp"
 #include "../wrapper/repository_wrapper.hpp"
@@ -11,12 +12,16 @@ push_subcommand::push_subcommand(const libgit2_object&, CLI::App& app)
 {
     auto* sub = app.add_subcommand("push", "Update remote refs along with associated objects");
 
-    sub->add_option("<remote>", m_remote_name, "The remote to push to")
-        ->default_val("origin");
+    sub->add_option("<remote>", m_remote_name, "The remote to push to")->default_val("origin");
 
     sub->add_option("<refspec>", m_refspecs, "The refspec(s) to push");
 
-    sub->callback([this]() { this->run(); });
+    sub->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 }
 
 void push_subcommand::run()
diff --git a/src/subcommand/rebase_subcommand.cpp b/src/subcommand/rebase_subcommand.cpp
index 8db2a9c..4bedcc5 100644
--- a/src/subcommand/rebase_subcommand.cpp
+++ b/src/subcommand/rebase_subcommand.cpp
@@ -1,16 +1,18 @@
+#include "rebase_subcommand.hpp"
+
 #include <iostream>
+
 #include <git2.h>
 #include <termcolor/termcolor.hpp>
 
-#include "rebase_subcommand.hpp"
 #include "../utils/git_exception.hpp"
+#include "../wrapper/index_wrapper.hpp"
 #include "../wrapper/repository_wrapper.hpp"
 #include "../wrapper/signature_wrapper.hpp"
-#include "../wrapper/index_wrapper.hpp"
 
 rebase_subcommand::rebase_subcommand(const libgit2_object&, CLI::App& app)
 {
-    auto *sub = app.add_subcommand("rebase", "Reapply commits on top of another base tip");
+    auto* sub = app.add_subcommand("rebase", "Reapply commits on top of another base tip");
 
     sub->add_option("upstream", m_upstream, "Upstream branch to rebase onto");
     sub->add_option("branch", m_branch, "Working branch; defaults to HEAD");
@@ -21,13 +23,17 @@ rebase_subcommand::rebase_subcommand(const libgit2_object&, CLI::App& app)
     sub->add_flag("--skip", m_skip, "Restart the rebasing process by skipping the current patch");
     sub->add_flag("--quit", m_quit, "Abort the rebase operation but HEAD is not reset back to the original branch");
 
-    sub->callback([this]() { this->run(); });
+    sub->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 }
 
 void ensure_rebase_in_progress(git_repository_state_t state)
 {
-    if (state != GIT_REPOSITORY_STATE_REBASE_INTERACTIVE && 
-        state != GIT_REPOSITORY_STATE_REBASE_MERGE)
+    if (state != GIT_REPOSITORY_STATE_REBASE_INTERACTIVE && state != GIT_REPOSITORY_STATE_REBASE_MERGE)
     {
         throw std::runtime_error("No rebase in progress");
     }
@@ -68,8 +74,7 @@ void rebase_subcommand::run()
         return;
     }
 
-    if (state == GIT_REPOSITORY_STATE_REBASE_INTERACTIVE || 
-        state == GIT_REPOSITORY_STATE_REBASE_MERGE)
+    if (state == GIT_REPOSITORY_STATE_REBASE_INTERACTIVE || state == GIT_REPOSITORY_STATE_REBASE_MERGE)
     {
         throw std::runtime_error("A rebase is already in progress");
     }
@@ -82,9 +87,8 @@ void rebase_subcommand::run()
     run_rebase(repo);
 }
 
-annotated_commit_wrapper rebase_subcommand::resolve_ref(
-    const repository_wrapper& repo, 
-    const std::string& ref_name) const
+annotated_commit_wrapper
+rebase_subcommand::resolve_ref(const repository_wrapper& repo, const std::string& ref_name) const
 {
     if (!ref_name.empty())
     {
@@ -117,18 +121,18 @@ void rebase_subcommand::perform_rebase(repository_wrapper& repo, rebase_wrapper&
         commit_wrapper original_commit = repo.find_commit(rebase.current_operation_id());
         std::string commit_summary = original_commit.summary();
 
-        std::cout << "Applying:  " << commit_summary << " (" 
-                    << (current_idx + 1) << "/" << total_operations << ")" << std::endl;
+        std::cout << "Applying:  " << commit_summary << " (" << (current_idx + 1) << "/" << total_operations
+                  << ")" << std::endl;
 
         index_wrapper index = repo.make_index();
         if (index.has_conflict())
         {
-            std:: cout << termcolor::red << "Conflicts detected!" << termcolor::reset << std::endl;
+            std::cout << termcolor::red << "Conflicts detected!" << termcolor::reset << std::endl;
             std::cout << "Resolve conflicts and run:" << std::endl;
             std::cout << "  git2cpp rebase --continue" << std::endl;
             std::cout << "or skip this commit with:" << std::endl;
-            std::cout << "  git2cpp rebase --skip" << std:: endl;
-            std::cout << "or abort the rebase with:" << std:: endl;
+            std::cout << "  git2cpp rebase --skip" << std::endl;
+            std::cout << "or abort the rebase with:" << std::endl;
             std::cout << "  git2cpp rebase --abort" << std::endl;
             return;
         }
@@ -137,8 +141,8 @@ void rebase_subcommand::perform_rebase(repository_wrapper& repo, rebase_wrapper&
 
         if (commit_result == GIT_EAPPLIED)
         {
-            std::cout << termcolor::yellow << "Skipping commit (already applied)" 
-                        << termcolor::reset << std::endl;
+            std::cout << termcolor::yellow << "Skipping commit (already applied)" << termcolor::reset
+                      << std::endl;
         }
         else
         {
@@ -148,8 +152,7 @@ void rebase_subcommand::perform_rebase(repository_wrapper& repo, rebase_wrapper&
 
     rebase.finish(signatures.second);
 
-    std::cout << termcolor::green << "Successfully rebased and updated HEAD." 
-                << termcolor::reset << std::endl;
+    std::cout << termcolor::green << "Successfully rebased and updated HEAD." << termcolor::reset << std::endl;
 }
 
 void rebase_subcommand::run_rebase(repository_wrapper& repo)
@@ -171,7 +174,7 @@ void rebase_subcommand::run_rebase(repository_wrapper& repo)
     {
         onto_ptr = std::make_unique<annotated_commit_wrapper>(resolve_ref(repo, m_onto));
     }
-    git_rebase_options rebase_opts ;
+    git_rebase_options rebase_opts;
     throw_if_error(git_rebase_options_init(&rebase_opts, GIT_REBASE_OPTIONS_VERSION));
 
     auto rebase = rebase_wrapper::init(repo, branch, upstream.value(), onto_ptr.get(), rebase_opts);
@@ -206,8 +209,7 @@ void rebase_subcommand::run_continue(repository_wrapper& repo)
 
     if (commit_result == GIT_EAPPLIED)
     {
-        std::cout << termcolor::yellow << "Skipping commit (already applied)" 
-                    << termcolor::reset << std::endl;
+        std::cout << termcolor::yellow << "Skipping commit (already applied)" << termcolor::reset << std::endl;
     }
     else
     {
@@ -228,9 +230,8 @@ void rebase_subcommand::run_skip(repository_wrapper& repo)
     perform_rebase(repo, rebase);
 }
 
-void rebase_subcommand:: run_quit(repository_wrapper& repo)
+void rebase_subcommand::run_quit(repository_wrapper& repo)
 {
     repo.state_cleanup();
     std::cout << "Rebase state cleaned up (HEAD not reset)" << std::endl;
 }
-
diff --git a/src/subcommand/rebase_subcommand.hpp b/src/subcommand/rebase_subcommand.hpp
index 6b86da2..179dd3d 100644
--- a/src/subcommand/rebase_subcommand.hpp
+++ b/src/subcommand/rebase_subcommand.hpp
@@ -10,7 +10,7 @@
 
 class rebase_subcommand
 {
-public: 
+public:
 
     explicit rebase_subcommand(const libgit2_object&, CLI::App& app);
     void run();
@@ -23,7 +23,7 @@ class rebase_subcommand
     void run_skip(repository_wrapper& repo);
     void run_quit(repository_wrapper& repo);
 
-    annotated_commit_wrapper resolve_ref(const repository_wrapper& repo, const std:: string& ref_name) const;
+    annotated_commit_wrapper resolve_ref(const repository_wrapper& repo, const std::string& ref_name) const;
 
     void perform_rebase(repository_wrapper& repo, rebase_wrapper& rebase);
 
diff --git a/src/subcommand/remote_subcommand.cpp b/src/subcommand/remote_subcommand.cpp
index f76ad70..a67bddb 100644
--- a/src/subcommand/remote_subcommand.cpp
+++ b/src/subcommand/remote_subcommand.cpp
@@ -1,7 +1,8 @@
+#include "../subcommand/remote_subcommand.hpp"
+
 #include <iostream>
 #include <stdexcept>
 
-#include "../subcommand/remote_subcommand.hpp"
 #include "../wrapper/repository_wrapper.hpp"
 
 remote_subcommand::remote_subcommand(const libgit2_object&, CLI::App& app)
@@ -17,7 +18,12 @@ remote_subcommand::remote_subcommand(const libgit2_object&, CLI::App& app)
     // Allow positional arguments after operation
     m_subcommand->allow_extras();
 
-    m_subcommand->callback([this]() { this->run(); });
+    m_subcommand->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 }
 
 void remote_subcommand::run()
@@ -93,7 +99,8 @@ void remote_subcommand::run_add(repository_wrapper& repo)
 {
     if (m_remote_name.empty())
     {
-        throw std::runtime_error("usage: git remote add <name> <url>");   // TODO: add [<options>] when implemented
+        throw std::runtime_error("usage: git remote add <name> <url>");  // TODO: add [<options>] when
+                                                                         // implemented
     }
     repo.create_remote(m_remote_name, m_url);
 }
@@ -111,7 +118,8 @@ void remote_subcommand::run_rename(repository_wrapper& repo)
 {
     if (m_old_name.empty())
     {
-        throw std::runtime_error("usage: git remote rename <old> <new>");   // TODO: add  [--[no-]progress] when implemented
+        throw std::runtime_error("usage: git remote rename <old> <new>");  // TODO: add  [--[no-]progress]
+                                                                           // when implemented
     }
     repo.rename_remote(m_old_name, m_new_name);
 }
diff --git a/src/subcommand/reset_subcommand.cpp b/src/subcommand/reset_subcommand.cpp
index 61fa0ae..783a05e 100644
--- a/src/subcommand/reset_subcommand.cpp
+++ b/src/subcommand/reset_subcommand.cpp
@@ -1,8 +1,9 @@
 #include "reset_subcommand.hpp"
 // #include "../wrapper/index_wrapper.hpp"
-#include "../wrapper/repository_wrapper.hpp"
 #include <stdexcept>
 
+#include "../wrapper/repository_wrapper.hpp"
+
 enum class reset_type
 {
     GIT_RESET_SOFT = 1,
@@ -12,7 +13,7 @@ enum class reset_type
 
 reset_subcommand::reset_subcommand(const libgit2_object&, CLI::App& app)
 {
-    auto *sub = app.add_subcommand("reset", "Reset current HEAD to the specified state");
+    auto* sub = app.add_subcommand("reset", "Reset current HEAD to the specified state");
 
     sub->add_option("<commit>", m_commit, "The ID of the commit that will become HEAD");
 
@@ -20,10 +21,14 @@ reset_subcommand::reset_subcommand(const libgit2_object&, CLI::App& app)
     sub->add_flag("--mixed", m_mixed_flag, "");
     sub->add_flag("--hard", m_hard_flag, "");
 
-    sub->callback([this]() { this->run(); });
+    sub->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 };
 
-
 void reset_subcommand::run()
 {
     auto directory = get_current_git_path();
diff --git a/src/subcommand/reset_subcommand.hpp b/src/subcommand/reset_subcommand.hpp
index bfddd43..7cfe9c7 100644
--- a/src/subcommand/reset_subcommand.hpp
+++ b/src/subcommand/reset_subcommand.hpp
@@ -12,6 +12,7 @@ class reset_subcommand
     void run();
 
 private:
+
     std::string m_commit;
     bool m_soft_flag = false;
     bool m_mixed_flag = false;
diff --git a/src/subcommand/revlist_subcommand.cpp b/src/subcommand/revlist_subcommand.cpp
index fafa830..bd2fe55 100644
--- a/src/subcommand/revlist_subcommand.cpp
+++ b/src/subcommand/revlist_subcommand.cpp
@@ -1,4 +1,5 @@
 #include "revlist_subcommand.hpp"
+
 #include "../wrapper/repository_wrapper.hpp"
 #include "../wrapper/revwalk_wrapper.hpp"
 
@@ -9,14 +10,21 @@ revlist_subcommand::revlist_subcommand(const libgit2_object&, CLI::App& app)
     sub->add_option("<commit>", m_commit, "");
     sub->add_option("-n,--max-count", m_max_count_flag, "Limit the output to <number> commits.");
 
-    sub->callback([this]() { this->run(); });
+    sub->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 }
 
 void revlist_subcommand::run()
 {
     if (m_commit.empty())
     {
-        throw std::runtime_error("usage: git rev-list [<options>] <commit>... [--] [<path>...]");   // TODO: add  help info
+        throw std::runtime_error("usage: git rev-list [<options>] <commit>... [--] [<path>...]");  // TODO:
+                                                                                                   // add help
+                                                                                                   // info
     }
 
     auto directory = get_current_git_path();
@@ -32,14 +40,14 @@ void revlist_subcommand::run()
     revwalk_wrapper walker = repo.new_walker();
     walker.push(start_commit_oid);
 
-    std::size_t i=0;
+    std::size_t i = 0;
     git_oid commit_oid;
     char buf[GIT_OID_SHA1_HEXSIZE + 1];
-    while (!walker.next(commit_oid) && i<m_max_count_flag)
+    while (!walker.next(commit_oid) && i < m_max_count_flag)
     {
         git_oid_fmt(buf, &commit_oid);
-		buf[GIT_OID_SHA1_HEXSIZE] = '\0';
-		std::cout << buf << std::endl;
-		++i;
+        buf[GIT_OID_SHA1_HEXSIZE] = '\0';
+        std::cout << buf << std::endl;
+        ++i;
     }
 }
diff --git a/src/subcommand/revlist_subcommand.hpp b/src/subcommand/revlist_subcommand.hpp
index 977f20d..335d99e 100644
--- a/src/subcommand/revlist_subcommand.hpp
+++ b/src/subcommand/revlist_subcommand.hpp
@@ -1,8 +1,9 @@
 #pragma once
 
-#include <CLI/CLI.hpp>
 #include <string>
 
+#include <CLI/CLI.hpp>
+
 #include "../utils/common.hpp"
 
 class revlist_subcommand
@@ -15,6 +16,5 @@ class revlist_subcommand
 private:
 
     std::string m_commit;
-    int m_max_count_flag=std::numeric_limits<int>::max();
-
+    int m_max_count_flag = std::numeric_limits<int>::max();
 };
diff --git a/src/subcommand/revparse_subcommand.cpp b/src/subcommand/revparse_subcommand.cpp
index a866d90..8c417e5 100644
--- a/src/subcommand/revparse_subcommand.cpp
+++ b/src/subcommand/revparse_subcommand.cpp
@@ -1,4 +1,5 @@
 #include "revparse_subcommand.hpp"
+
 #include "../utils/git_exception.hpp"
 #include "../wrapper/repository_wrapper.hpp"
 
@@ -6,29 +7,49 @@ revparse_subcommand::revparse_subcommand(const libgit2_object&, CLI::App& app)
 {
     auto* sub = app.add_subcommand("rev-parse", "Pick out and message parameters");
 
-    auto* bare_opt = sub->add_flag("--is-bare-repository", m_is_bare_repository_flag, "When the repository is bare print \"true\", otherwise \"false\".");
-    auto* shallow_opt = sub->add_flag("--is-shallow-repository", m_is_shallow_repository_flag, "When the repository is shallow print \"true\", otherwise \"false\".");
-    auto* rev_opt = sub->add_option("<rev>", m_revisions, "Revision(s) to parse (e.g. HEAD, main, HEAD~1, dae86e, ...)");
+    auto* bare_opt = sub->add_flag(
+        "--is-bare-repository",
+        m_is_bare_repository_flag,
+        "When the repository is bare print \"true\", otherwise \"false\"."
+    );
+    auto* shallow_opt = sub->add_flag(
+        "--is-shallow-repository",
+        m_is_shallow_repository_flag,
+        "When the repository is shallow print \"true\", otherwise \"false\"."
+    );
+    auto* rev_opt = sub->add_option(
+        "<rev>",
+        m_revisions,
+        "Revision(s) to parse (e.g. HEAD, main, HEAD~1, dae86e, ...)"
+    );
 
-    sub->parse_complete_callback([this, sub, bare_opt, shallow_opt, rev_opt]() {
-        for (CLI::Option* opt : sub->parse_order())
+    sub->parse_complete_callback(
+        [this, sub, bare_opt, shallow_opt, rev_opt]()
         {
-            if (opt == bare_opt)
-            {
-                m_queries_in_order.push_back("is_bare");
-            }
-            else if (opt == shallow_opt)
+            for (CLI::Option* opt : sub->parse_order())
             {
-                m_queries_in_order.push_back("is_shallow");
-            }
-            else if (opt == rev_opt)
-            {
-                m_queries_in_order.push_back("is_rev");
+                if (opt == bare_opt)
+                {
+                    m_queries_in_order.push_back("is_bare");
+                }
+                else if (opt == shallow_opt)
+                {
+                    m_queries_in_order.push_back("is_shallow");
+                }
+                else if (opt == rev_opt)
+                {
+                    m_queries_in_order.push_back("is_rev");
+                }
             }
         }
-    });
+    );
 
-    sub->callback([this]() { this->run(); });
+    sub->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 }
 
 void revparse_subcommand::run()
diff --git a/src/subcommand/rm_subcommand.cpp b/src/subcommand/rm_subcommand.cpp
index b9bf1c6..115dda6 100644
--- a/src/subcommand/rm_subcommand.cpp
+++ b/src/subcommand/rm_subcommand.cpp
@@ -1,6 +1,8 @@
+#include "rm_subcommand.hpp"
+
 #include <filesystem>
 #include <ranges>
-#include "rm_subcommand.hpp"
+
 #include "../utils/common.hpp"
 #include "../utils/git_exception.hpp"
 #include "../wrapper/index_wrapper.hpp"
@@ -14,7 +16,12 @@ rm_subcommand::rm_subcommand(const libgit2_object&, CLI::App& app)
     rm->add_option("<pathspec>", m_pathspec, "Files to remove");
     rm->add_flag("-r", m_recursive, "Allow recursive removal when a leading directory name is given");
 
-    rm->callback([this]() { this->run(); });
+    rm->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 }
 
 void rm_subcommand::run()
@@ -27,27 +34,30 @@ void rm_subcommand::run()
     std::vector<std::string> files;
     std::vector<std::string> directories;
 
-    std::ranges::for_each(m_pathspec, [&](const std::string& path)
-    {
-        if (!fs::exists(path))
+    std::ranges::for_each(
+        m_pathspec,
+        [&](const std::string& path)
         {
-            std::string msg = "fatal: pathspec '" + path + "' did not math any file";
-            throw git_exception(msg, git2cpp_error_code::FILESYSTEM_ERROR);
-        }
-        if (fs::is_directory(path))
-        {
-            directories.push_back(path);
-        }
-        else
-        {
-            if (!repo.does_track(path))
+            if (!fs::exists(path))
             {
-                std::string msg = "fatal: pathsspec '" + path + "'is not tracked";
+                std::string msg = "fatal: pathspec '" + path + "' did not math any file";
                 throw git_exception(msg, git2cpp_error_code::FILESYSTEM_ERROR);
             }
-            files.push_back(path);
+            if (fs::is_directory(path))
+            {
+                directories.push_back(path);
+            }
+            else
+            {
+                if (!repo.does_track(path))
+                {
+                    std::string msg = "fatal: pathsspec '" + path + "'is not tracked";
+                    throw git_exception(msg, git2cpp_error_code::FILESYSTEM_ERROR);
+                }
+                files.push_back(path);
+            }
         }
-    });
+    );
 
     if (!directories.empty() && !m_recursive)
     {
@@ -59,6 +69,18 @@ void rm_subcommand::run()
     index.remove_directories(directories);
     index.write();
 
-    std::ranges::for_each(files, [](const std::string& path) { fs::remove(path); });
-    std::ranges::for_each(directories, [](const std::string& path) { fs::remove_all(path); });
+    std::ranges::for_each(
+        files,
+        [](const std::string& path)
+        {
+            fs::remove(path);
+        }
+    );
+    std::ranges::for_each(
+        directories,
+        [](const std::string& path)
+        {
+            fs::remove_all(path);
+        }
+    );
 }
diff --git a/src/subcommand/rm_subcommand.hpp b/src/subcommand/rm_subcommand.hpp
index 1f575fc..13a0e57 100644
--- a/src/subcommand/rm_subcommand.hpp
+++ b/src/subcommand/rm_subcommand.hpp
@@ -1,9 +1,10 @@
 #pragma once
 
-#include <CLI/CLI.hpp>
 #include <string>
 #include <vector>
 
+#include <CLI/CLI.hpp>
+
 #include "../utils/common.hpp"
 
 class rm_subcommand
@@ -18,4 +19,3 @@ class rm_subcommand
     std::vector<std::string> m_pathspec;
     bool m_recursive = false;
 };
-
diff --git a/src/subcommand/stash_subcommand.cpp b/src/subcommand/stash_subcommand.cpp
index 04bce61..9fc0cc8 100644
--- a/src/subcommand/stash_subcommand.cpp
+++ b/src/subcommand/stash_subcommand.cpp
@@ -1,18 +1,26 @@
-#include <git2/deprecated.h>
-#include <git2/oid.h>
-#include <git2/stash.h>
+#include "../subcommand/stash_subcommand.hpp"
+
 #include <iostream>
 
+#include <git2/deprecated.h>
+#include <git2/oid.h>
 #include <git2/remote.h>
+#include <git2/stash.h>
 
 #include "../subcommand/diff_subcommand.hpp"
-#include "../subcommand/stash_subcommand.hpp"
 #include "../subcommand/status_subcommand.hpp"
 
 bool has_subcommand(CLI::App* cmd)
 {
-    std::vector<std::string> subs = { "push", "pop", "list", "apply", "show" };
-    return std::any_of(subs.begin(), subs.end(), [cmd](const std::string& s) { return cmd->got_subcommand(s); });
+    std::vector<std::string> subs = {"push", "pop", "list", "apply", "show"};
+    return std::any_of(
+        subs.begin(),
+        subs.end(),
+        [cmd](const std::string& s)
+        {
+            return cmd->got_subcommand(s);
+        }
+    );
 }
 
 stash_subcommand::stash_subcommand(const libgit2_object&, CLI::App& app)
@@ -32,18 +40,45 @@ stash_subcommand::stash_subcommand(const libgit2_object&, CLI::App& app)
     show->add_flag("--numstat", m_numstat_flag, "Machine-friendly --stat");
     show->add_flag("--summary", m_summary_flag, "Output a condensed summary");
 
-    stash->callback([this,stash]()
-       {
-           if (!has_subcommand(stash))
-           {
-               this->run_push();
-           }
-       });
-    push->callback([this]() { this->run_push(); });
-    list->callback([this]() { this->run_list(); });
-    pop->callback([this]() { this->run_pop(); });
-    apply->callback([this]() { this->run_apply(); });
-    show->callback([this]() { this->run_show(); });
+    stash->callback(
+        [this, stash]()
+        {
+            if (!has_subcommand(stash))
+            {
+                this->run_push();
+            }
+        }
+    );
+    push->callback(
+        [this]()
+        {
+            this->run_push();
+        }
+    );
+    list->callback(
+        [this]()
+        {
+            this->run_list();
+        }
+    );
+    pop->callback(
+        [this]()
+        {
+            this->run_pop();
+        }
+    );
+    apply->callback(
+        [this]()
+        {
+            this->run_apply();
+        }
+    );
+    show->callback(
+        [this]()
+        {
+            this->run_show();
+        }
+    );
 }
 
 void stash_subcommand::run_push()
@@ -52,16 +87,18 @@ void stash_subcommand::run_push()
     auto repo = repository_wrapper::open(directory);
     auto author_committer_signatures = signature_wrapper::get_default_signature_from_env(repo);
 
-	git_oid stash_id;
-    throw_if_error(git_stash_save(&stash_id, repo, author_committer_signatures.first, m_message.c_str(), GIT_STASH_DEFAULT));
+    git_oid stash_id;
+    throw_if_error(
+        git_stash_save(&stash_id, repo, author_committer_signatures.first, m_message.c_str(), GIT_STASH_DEFAULT)
+    );
     auto stash = repo.find_commit(stash_id);
     std::cout << "Saved working directory and index state " << stash.summary() << std::endl;
 }
 
 static int list_stash_cb(size_t index, const char* message, const git_oid* stash_id, void* payload)
 {
-	std::cout << "stash@{" << index << "}: " << message << std::endl;
-	return 0;
+    std::cout << "stash@{" << index << "}: " << message << std::endl;
+    return 0;
 }
 
 void stash_subcommand::run_list()
diff --git a/src/subcommand/status_subcommand.cpp b/src/subcommand/status_subcommand.cpp
index 8a95d20..43cc9e8 100644
--- a/src/subcommand/status_subcommand.cpp
+++ b/src/subcommand/status_subcommand.cpp
@@ -1,3 +1,5 @@
+#include "status_subcommand.hpp"
+
 #include <iostream>
 #include <ostream>
 #include <set>
@@ -6,29 +8,39 @@
 #include <git2.h>
 #include <termcolor/termcolor.hpp>
 
-#include "status_subcommand.hpp"
-
-
 status_subcommand::status_subcommand(const libgit2_object&, CLI::App& app)
 {
-    auto *sub = app.add_subcommand("status", "Show modified files in working directory, staged for your next commit");
+    auto* sub = app.add_subcommand(
+        "status",
+        "Show modified files in working directory, staged for your next commit"
+    );
 
     sub->add_flag("-s,--short", m_options.m_short_flag, "Give the output in the short-format.");
     sub->add_flag("--long", m_options.m_long_flag, "Give the output in the long-format. This is the default.");
-    // sub->add_flag("--porcelain[=<version>]", porcelain, "Give the output in an easy-to-parse format for scripts.
-    //     This is similar to the short output, but will remain stable across Git versions and regardless of user configuration.
-    //     See below for details. The version parameter is used to specify the format version. This is optional and defaults
-    //     to the original version v1 format.");
+    // sub->add_flag("--porcelain[=<version>]", porcelain, "Give the output in an easy-to-parse format for
+    // scripts.
+    //     This is similar to the short output, but will remain stable across Git versions and regardless of
+    //     user configuration. See below for details. The version parameter is used to specify the format
+    //     version. This is optional and defaults to the original version v1 format.");
     sub->add_flag("-b,--branch", m_options.m_branch_flag, "Show the branch and tracking info even in short-format.");
 
-    sub->callback([this]() { this->run(); });
+    sub->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 };
 
-const std::string untracked_header = "Untracked files:\n  (use \"git add <file>...\" to include in what will be committed)\n";
+const std::string
+    untracked_header = "Untracked files:\n  (use \"git add <file>...\" to include in what will be committed)\n";
 const std::string tobecommited_header = "Changes to be committed:\n  (use \"git reset HEAD <file>...\" to unstage)\n";
-const std::string ignored_header = "Ignored files:\n  (use \"git add -f <file>...\" to include in what will be committed)\n";
-const std::string notstagged_header = "Changes not staged for commit:\n  (use \"git add <file>...\" to update what will be committed)\n";
-// TODO: add the following ot notstagged_header after "checkout <file>" is implemented: (use \"git checkout -- <file>...\" to discard changes in working directory)\n";
+const std::string
+    ignored_header = "Ignored files:\n  (use \"git add -f <file>...\" to include in what will be committed)\n";
+const std::string
+    notstagged_header = "Changes not staged for commit:\n  (use \"git add <file>...\" to update what will be committed)\n";
+// TODO: add the following ot notstagged_header after "checkout <file>" is implemented: (use \"git checkout --
+// <file>...\" to discard changes in working directory)\n";
 const std::string unmerged_header = "Unmerged paths:\n  (use \"git add <file>...\" to mark resolution)\n";
 const std::string nothingtocommit_message = "no changes added to commit  (use \"git add\" and/or \"git commit -a\")";
 const std::string treeclean_message = "Nothing to commit, working tree clean";
@@ -87,8 +99,13 @@ std::string get_print_item(const char* old_path, const char* new_path)
     return entry_item;
 }
 
-std::vector<print_entry> get_entries_to_print(git_status_t status, status_list_wrapper& sl,
-    bool head_selector, bool is_long, std::set<std::string>* tracked_dir_set = nullptr)
+std::vector<print_entry> get_entries_to_print(
+    git_status_t status,
+    status_list_wrapper& sl,
+    bool head_selector,
+    bool is_long,
+    std::set<std::string>* tracked_dir_set = nullptr
+)
 {
     std::vector<print_entry> entries_to_print{};
     const auto& entry_list = sl.get_entry_list(status);
@@ -105,7 +122,7 @@ std::vector<print_entry> get_entries_to_print(git_status_t status, status_list_w
 
         update_tracked_dir_set(old_path, tracked_dir_set);
 
-        print_entry e = { get_print_status(status, is_long), get_print_item(old_path, new_path)};
+        print_entry e = {get_print_status(status, is_long), get_print_item(old_path, new_path)};
 
         entries_to_print.push_back(std::move(e));
     }
@@ -114,7 +131,7 @@ std::vector<print_entry> get_entries_to_print(git_status_t status, status_list_w
 
 void print_entries(std::vector<print_entry> entries_to_print, bool is_long, stream_colour_fn colour)
 {
-    for (auto e: entries_to_print)
+    for (auto e : entries_to_print)
     {
         if (is_long)
         {
@@ -127,11 +144,16 @@ void print_entries(std::vector<print_entry> entries_to_print, bool is_long, stre
     }
 }
 
-void print_not_tracked(const std::vector<print_entry>& entries_to_print, const std::set<std::string>& tracked_dir_set,
-        std::set<std::string>& untracked_dir_set, bool is_long, stream_colour_fn colour)
+void print_not_tracked(
+    const std::vector<print_entry>& entries_to_print,
+    const std::set<std::string>& tracked_dir_set,
+    std::set<std::string>& untracked_dir_set,
+    bool is_long,
+    stream_colour_fn colour
+)
 {
     std::vector<print_entry> not_tracked_entries_to_print{};
-    for (auto e: entries_to_print)
+    for (auto e : entries_to_print)
     {
         const size_t first_slash_idx = e.item.find('/');
         if (std::string::npos != first_slash_idx)
@@ -144,7 +166,8 @@ void print_not_tracked(const std::vector<print_entry>& entries_to_print, const s
             else
             {
                 if (untracked_dir_set.contains(directory))
-                {}
+                {
+                }
                 else
                 {
                     not_tracked_entries_to_print.push_back({e.status, directory});
@@ -168,33 +191,34 @@ void print_tracking_info(repository_wrapper& repo, status_list_wrapper& sl, bool
     {
         if (tracking_info.has_upstream)
         {
-            if(tracking_info.ahead > 0 && tracking_info.behind == 0)
+            if (tracking_info.ahead > 0 && tracking_info.behind == 0)
             {
                 std::cout << "Your branch is ahead of '" << tracking_info.upstream_name << "' by "
-                        << tracking_info.ahead << " commit"
-                        << (tracking_info.ahead > 1 ? "s" : "") << "." << std::endl;
+                          << tracking_info.ahead << " commit" << (tracking_info.ahead > 1 ? "s" : "") << "."
+                          << std::endl;
                 std::cout << "  (use \"git push\" to publish your local commits)" << std::endl;
             }
             else if (tracking_info.ahead == 0 && tracking_info.behind > 0)
             {
                 std::cout << "Your branch is behind '" << tracking_info.upstream_name << "' by "
-                        << tracking_info.behind << " commit"
-                        << (tracking_info.behind > 1 ? "s" : "") << "." << std::endl;
+                          << tracking_info.behind << " commit" << (tracking_info.behind > 1 ? "s" : "") << "."
+                          << std::endl;
                 std::cout << "  (use \"git pull\" to update your local branch)" << std::endl;
             }
             else if (tracking_info.ahead > 0 && tracking_info.behind > 0)
             {
-                std::cout << "Your branch and '" << tracking_info.upstream_name
-                        << "' have diverged," << std::endl;
-                std::cout << "and have " << tracking_info.ahead << " and "
-                        << tracking_info.behind << " different commit"
-                        << ((tracking_info.ahead + tracking_info.behind) > 2 ? "s" : "")
-                        << " each, respectively." << std::endl;
+                std::cout << "Your branch and '" << tracking_info.upstream_name << "' have diverged,"
+                          << std::endl;
+                std::cout << "and have " << tracking_info.ahead << " and " << tracking_info.behind
+                          << " different commit"
+                          << ((tracking_info.ahead + tracking_info.behind) > 2 ? "s" : "")
+                          << " each, respectively." << std::endl;
                 std::cout << "  (use \"git pull\" to merge the remote branch into yours)" << std::endl;
             }
             else  // ahead == 0 && behind == 0
             {
-                std::cout << "Your branch is up to date with '" << tracking_info.upstream_name << "'." << std::endl;
+                std::cout << "Your branch is up to date with '" << tracking_info.upstream_name << "'."
+                          << std::endl;
             }
             std::cout << std::endl;
         }
@@ -206,7 +230,8 @@ void print_tracking_info(repository_wrapper& repo, status_list_wrapper& sl, bool
 
         if (sl.has_unmerged_header())
         {
-            std::cout << "You have unmerged paths.\n  (fix conflicts and run \"git commit\")\n  (use \"git merge --abort\" to abort the merge)\n" << std::endl;
+            std::cout << "You have unmerged paths.\n  (fix conflicts and run \"git commit\")\n  (use \"git merge --abort\" to abort the merge)\n"
+                      << std::endl;
         }
     }
     else
@@ -239,7 +264,6 @@ void print_tracking_info(repository_wrapper& repo, status_list_wrapper& sl, bool
 
 void print_tobecommited(status_list_wrapper& sl, std::set<std::string> tracked_dir_set, bool is_long, bool is_coloured)
 {
-
     stream_colour_fn colour;
     if (is_coloured)
     {
@@ -255,10 +279,26 @@ void print_tobecommited(status_list_wrapper& sl, std::set<std::string> tracked_d
         std::cout << tobecommited_header;
     }
     print_entries(get_entries_to_print(GIT_STATUS_INDEX_NEW, sl, true, is_long, &tracked_dir_set), is_long, colour);
-    print_entries(get_entries_to_print(GIT_STATUS_INDEX_MODIFIED, sl, true, is_long, &tracked_dir_set), is_long, colour);
-    print_entries(get_entries_to_print(GIT_STATUS_INDEX_DELETED, sl, true, is_long, &tracked_dir_set), is_long, colour);
-    print_entries(get_entries_to_print(GIT_STATUS_INDEX_RENAMED, sl, true, is_long, &tracked_dir_set), is_long, colour);
-    print_entries(get_entries_to_print(GIT_STATUS_INDEX_TYPECHANGE, sl, true, is_long, &tracked_dir_set), is_long, colour);
+    print_entries(
+        get_entries_to_print(GIT_STATUS_INDEX_MODIFIED, sl, true, is_long, &tracked_dir_set),
+        is_long,
+        colour
+    );
+    print_entries(
+        get_entries_to_print(GIT_STATUS_INDEX_DELETED, sl, true, is_long, &tracked_dir_set),
+        is_long,
+        colour
+    );
+    print_entries(
+        get_entries_to_print(GIT_STATUS_INDEX_RENAMED, sl, true, is_long, &tracked_dir_set),
+        is_long,
+        colour
+    );
+    print_entries(
+        get_entries_to_print(GIT_STATUS_INDEX_TYPECHANGE, sl, true, is_long, &tracked_dir_set),
+        is_long,
+        colour
+    );
     if (is_long)
     {
         std::cout << std::endl;
@@ -281,17 +321,39 @@ void print_notstagged(status_list_wrapper& sl, std::set<std::string> tracked_dir
     {
         std::cout << notstagged_header;
     }
-    print_entries(get_entries_to_print(GIT_STATUS_WT_MODIFIED, sl, false, is_long, &tracked_dir_set), is_long, colour);
-    print_entries(get_entries_to_print(GIT_STATUS_WT_DELETED, sl, false, is_long, &tracked_dir_set), is_long, colour);
-    print_entries(get_entries_to_print(GIT_STATUS_WT_TYPECHANGE, sl, false, is_long, &tracked_dir_set), is_long, colour);
-    print_entries(get_entries_to_print(GIT_STATUS_WT_RENAMED, sl, false, is_long, &tracked_dir_set), is_long, colour);
+    print_entries(
+        get_entries_to_print(GIT_STATUS_WT_MODIFIED, sl, false, is_long, &tracked_dir_set),
+        is_long,
+        colour
+    );
+    print_entries(
+        get_entries_to_print(GIT_STATUS_WT_DELETED, sl, false, is_long, &tracked_dir_set),
+        is_long,
+        colour
+    );
+    print_entries(
+        get_entries_to_print(GIT_STATUS_WT_TYPECHANGE, sl, false, is_long, &tracked_dir_set),
+        is_long,
+        colour
+    );
+    print_entries(
+        get_entries_to_print(GIT_STATUS_WT_RENAMED, sl, false, is_long, &tracked_dir_set),
+        is_long,
+        colour
+    );
     if (is_long)
     {
         std::cout << std::endl;
     }
 }
 
-void print_unmerged(status_list_wrapper& sl, std::set<std::string> tracked_dir_set, std::set<std::string> untracked_dir_set, bool is_long, bool is_coloured)
+void print_unmerged(
+    status_list_wrapper& sl,
+    std::set<std::string> tracked_dir_set,
+    std::set<std::string> untracked_dir_set,
+    bool is_long,
+    bool is_coloured
+)
 {
     stream_colour_fn colour;
     if (is_coloured)
@@ -307,14 +369,26 @@ void print_unmerged(status_list_wrapper& sl, std::set<std::string> tracked_dir_s
     {
         std::cout << unmerged_header;
     }
-    print_not_tracked(get_entries_to_print(GIT_STATUS_CONFLICTED, sl, false, is_long), tracked_dir_set, untracked_dir_set, is_long, colour);
+    print_not_tracked(
+        get_entries_to_print(GIT_STATUS_CONFLICTED, sl, false, is_long),
+        tracked_dir_set,
+        untracked_dir_set,
+        is_long,
+        colour
+    );
     if (is_long)
     {
         std::cout << std::endl;
     }
 }
 
-void print_untracked(status_list_wrapper& sl, std::set<std::string> tracked_dir_set, std::set<std::string> untracked_dir_set, bool is_long, bool is_coloured)
+void print_untracked(
+    status_list_wrapper& sl,
+    std::set<std::string> tracked_dir_set,
+    std::set<std::string> untracked_dir_set,
+    bool is_long,
+    bool is_coloured
+)
 {
     stream_colour_fn colour;
     if (is_coloured)
@@ -330,7 +404,13 @@ void print_untracked(status_list_wrapper& sl, std::set<std::string> tracked_dir_
     {
         std::cout << untracked_header;
     }
-    print_not_tracked(get_entries_to_print(GIT_STATUS_WT_NEW, sl, false, is_long), tracked_dir_set, untracked_dir_set, is_long, colour);
+    print_not_tracked(
+        get_entries_to_print(GIT_STATUS_WT_NEW, sl, false, is_long),
+        tracked_dir_set,
+        untracked_dir_set,
+        is_long,
+        colour
+    );
     if (is_long)
     {
         std::cout << std::endl;
@@ -373,11 +453,11 @@ void status_run(status_subcommand_options options)
     auto branch_name = repo.head_short_name();
     if (is_long)
     {
-        std::cout  << "On branch " << branch_name << std::endl;
+        std::cout << "On branch " << branch_name << std::endl;
     }
     else if (options.m_branch_flag)
     {
-        std::cout  << "## " << branch_name << std::endl;
+        std::cout << "## " << branch_name << std::endl;
     }
     bool is_coloured = true;
     print_tracking_info(repo, sl, is_long);
@@ -404,7 +484,11 @@ void status_run(status_subcommand_options options)
     }
 
     // TODO: check if this message should be displayed even if there are untracked files
-    if (is_long && !(sl.has_tobecommited_header() || sl.has_notstagged_header() || sl.has_unmerged_header() || sl.has_untracked_header()))
+    if (is_long
+        && !(
+            sl.has_tobecommited_header() || sl.has_notstagged_header() || sl.has_unmerged_header()
+            || sl.has_untracked_header()
+        ))
     {
         std::cout << treeclean_message << std::endl;
     }
diff --git a/src/subcommand/status_subcommand.hpp b/src/subcommand/status_subcommand.hpp
index 064a09f..3d64480 100644
--- a/src/subcommand/status_subcommand.hpp
+++ b/src/subcommand/status_subcommand.hpp
@@ -20,6 +20,7 @@ class status_subcommand
     void run();
 
 private:
+
     status_subcommand_options m_options;
 };
 
diff --git a/src/subcommand/tag_subcommand.cpp b/src/subcommand/tag_subcommand.cpp
index a64fdca..192b0d1 100644
--- a/src/subcommand/tag_subcommand.cpp
+++ b/src/subcommand/tag_subcommand.cpp
@@ -1,7 +1,7 @@
-#include <git2.h>
-
 #include "../subcommand/tag_subcommand.hpp"
 
+#include <git2.h>
+
 tag_subcommand::tag_subcommand(const libgit2_object&, CLI::App& app)
 {
     auto* sub = app.add_subcommand("tag", "Create, list, delete or verify tags");
@@ -9,13 +9,22 @@ tag_subcommand::tag_subcommand(const libgit2_object&, CLI::App& app)
     sub->add_flag("-l,--list", m_list_flag, "List tags. With optional <pattern>.");
     sub->add_flag("-f,--force", m_force_flag, "Replace an existing tag with the given name (instead of failing)");
     sub->add_option("-d,--delete", m_delete, "Delete existing tags with the given names.");
-    sub->add_option("-n", m_num_lines, "<num> specifies how many lines from the annotation, if any, are printed when using -l. Implies --list.");
+    sub->add_option(
+        "-n",
+        m_num_lines,
+        "<num> specifies how many lines from the annotation, if any, are printed when using -l. Implies --list."
+    );
     sub->add_flag("-a,--annotate", m_annotate_flag, "Make an annotated tag.");
     sub->add_option("-m,--message", m_message, "Tag message for annotated tags");
     sub->add_option("<tagname>", m_tag_name, "Tag name");
     sub->add_option("<commit>", m_target, "Target commit (defaults to HEAD)");
 
-    sub->callback([this]() { this->run(); });
+    sub->callback(
+        [this]()
+        {
+            this->run();
+        }
+    );
 }
 
 // Tag listing: Print individual message lines
@@ -38,7 +47,7 @@ void print_list_lines(const std::string& message, int num_lines)
     }
     else
     {
-        for (size_t i = 1; i < lines.size() ; i++)
+        for (size_t i = 1; i < lines.size(); i++)
         {
             if (i < num_lines)
             {
@@ -51,72 +60,72 @@ void print_list_lines(const std::string& message, int num_lines)
 // Tag listing: Print an actual tag object
 void print_tag(git_tag* tag, int num_lines)
 {
-	std::cout << std::left << std::setw(16) << git_tag_name(tag);
-
-	if (num_lines)
-	{
-		std::string msg = git_tag_message(tag);
-		if (!msg.empty())
-		{
-		    print_list_lines(msg, num_lines);
-		}
-		else
-		{
-			std::cout << std::endl;
-		}
-	}
-	else
-	{
-		std::cout << std::endl;
-	}
+    std::cout << std::left << std::setw(16) << git_tag_name(tag);
+
+    if (num_lines)
+    {
+        std::string msg = git_tag_message(tag);
+        if (!msg.empty())
+        {
+            print_list_lines(msg, num_lines);
+        }
+        else
+        {
+            std::cout << std::endl;
+        }
+    }
+    else
+    {
+        std::cout << std::endl;
+    }
 }
 
 // Tag listing: Print a commit (target of a lightweight tag)
 void print_commit(git_commit* commit, std::string name, int num_lines)
 {
-	std::cout << std::left << std::setw(16) << name;
-
-	if (num_lines)
-	{
-		std::string msg = git_commit_message(commit);
-		if (!msg.empty())
-		{
-		    print_list_lines(msg, num_lines);
-		}
-		else
-		{
-			std::cout <<std::endl;
-		}
-	}
-	else
-	{
-		std::cout <<std::endl;
-	}
+    std::cout << std::left << std::setw(16) << name;
+
+    if (num_lines)
+    {
+        std::string msg = git_commit_message(commit);
+        if (!msg.empty())
+        {
+            print_list_lines(msg, num_lines);
+        }
+        else
+        {
+            std::cout << std::endl;
+        }
+    }
+    else
+    {
+        std::cout << std::endl;
+    }
 }
 
 // Tag listing: Lookup tags based on ref name and dispatch to print
 void each_tag(repository_wrapper& repo, const std::string& name, int num_lines)
 {
-	auto obj = repo.revparse_single(name);
-
-	if (obj.has_value())
-	{
-	    switch (git_object_type(obj.value()))
-    	{
-    		case GIT_OBJECT_TAG:
-    			print_tag(obj.value(), num_lines);
-    			break;
-    		case GIT_OBJECT_COMMIT:
-    			print_commit(obj.value(), name, num_lines);
-    			break;
-    		default:
-    			std::cout << name << std::endl;
-    	}
-	}
-	else
-	{
-	    std::cout << name << std::endl;
-	}
+    auto obj = repo.revparse_single(name);
+
+    if (obj.has_value())
+    {
+        switch (git_object_type(obj.value()))
+        {
+            case GIT_OBJECT_TAG:
+                print_tag(obj.value(), num_lines);
+                break;
+            case GIT_OBJECT_COMMIT:
+                print_commit(obj.value(), name, num_lines);
+                break;
+            default:
+                std::cout << name << std::endl;
+        }
+    }
+    else
+    {
+        std::cout << name << std::endl;
+    }
 }
 
 void tag_subcommand::list_tags(repository_wrapper& repo)
@@ -124,7 +133,7 @@ void tag_subcommand::list_tags(repository_wrapper& repo)
     std::string pattern = m_tag_name.empty() ? "*" : m_tag_name;
     auto tag_names = repo.tag_list_match(pattern);
 
-    for (const auto& tag_name: tag_names)
+    for (const auto& tag_name : tag_names)
     {
         each_tag(repo, tag_name, m_num_lines);
     }
@@ -202,7 +211,15 @@ void tag_subcommand::create_tag(repository_wrapper& repo)
 
     git_oid oid;
     size_t force = m_force_flag ? 1 : 0;
-    int error = git_tag_create(&oid, repo, m_tag_name.c_str(), target_obj.value(), tagger.first, m_message.c_str(), force);
+    int error = git_tag_create(
+        &oid,
+        repo,
+        m_tag_name.c_str(),
+        target_obj.value(),
+        tagger.first,
+        m_message.c_str(),
+        force
+    );
 
     handle_error(error);
 }
@@ -240,5 +257,4 @@ void tag_subcommand::run()
     {
         list_tags(repo);
     }
-
 }
diff --git a/src/utils/common.cpp b/src/utils/common.cpp
index 0d918f2..3467751 100644
--- a/src/utils/common.cpp
+++ b/src/utils/common.cpp
@@ -1,14 +1,15 @@
+#include "common.hpp"
+
 #include <filesystem>
-#include <iostream>
 #include <fstream>
-#include <sstream>
-#include <unistd.h>
+#include <iostream>
 #include <map>
 #include <ranges>
+#include <sstream>
 
 #include <git2.h>
+#include <unistd.h>
 
-#include "common.hpp"
 #include "git_exception.hpp"
 
 libgit2_object::libgit2_object()
@@ -33,23 +34,23 @@ std::string get_current_git_path()
 
 const std::map<git_status_t, status_messages>& get_status_msg_map()
 {
-    static std::map<git_status_t, status_messages> status_msg_map =   //TODO : check spaces in short_mod
-    {
-        { GIT_STATUS_CURRENT, {"", ""} },
-        { GIT_STATUS_INDEX_NEW, {"A  ", "\tnew file:   "} },
-        { GIT_STATUS_INDEX_MODIFIED, {"M  ", "\tmodified:   "} },
-        { GIT_STATUS_INDEX_DELETED, {"D  ", "\tdeleted:   "} },
-        { GIT_STATUS_INDEX_RENAMED, {"R  ", "\trenamed:   "} },
-        { GIT_STATUS_INDEX_TYPECHANGE, {"T  ", "\ttypechange:   "} },
-        { GIT_STATUS_WT_NEW, {"?? ", "\t"} },
-        { GIT_STATUS_WT_MODIFIED, {" M " , "\tmodified:   "} },
-        { GIT_STATUS_WT_DELETED, {" D ", "\tdeleted:   "} },
-        { GIT_STATUS_WT_TYPECHANGE, {" T ", "\ttypechange:   "} },
-        { GIT_STATUS_WT_RENAMED, {" R ", "\trenamed:   "} },
-        { GIT_STATUS_WT_UNREADABLE, {"", ""} },
-        { GIT_STATUS_IGNORED, {"!! ", ""} },
-        { GIT_STATUS_CONFLICTED, {"AA ", "\tboth added:   "} },
-    };
+    static std::map<git_status_t, status_messages> status_msg_map =  // TODO : check spaces in short_mod
+        {
+            {GIT_STATUS_CURRENT, {"", ""}},
+            {GIT_STATUS_INDEX_NEW, {"A  ", "\tnew file:   "}},
+            {GIT_STATUS_INDEX_MODIFIED, {"M  ", "\tmodified:   "}},
+            {GIT_STATUS_INDEX_DELETED, {"D  ", "\tdeleted:   "}},
+            {GIT_STATUS_INDEX_RENAMED, {"R  ", "\trenamed:   "}},
+            {GIT_STATUS_INDEX_TYPECHANGE, {"T  ", "\ttypechange:   "}},
+            {GIT_STATUS_WT_NEW, {"?? ", "\t"}},
+            {GIT_STATUS_WT_MODIFIED, {" M ", "\tmodified:   "}},
+            {GIT_STATUS_WT_DELETED, {" D ", "\tdeleted:   "}},
+            {GIT_STATUS_WT_TYPECHANGE, {" T ", "\ttypechange:   "}},
+            {GIT_STATUS_WT_RENAMED, {" R ", "\trenamed:   "}},
+            {GIT_STATUS_WT_UNREADABLE, {"", ""}},
+            {GIT_STATUS_IGNORED, {"!! ", ""}},
+            {GIT_STATUS_CONFLICTED, {"AA ", "\tboth added:   "}},
+        };
     return status_msg_map;
 }
 
@@ -93,14 +94,14 @@ git_strarray_wrapper::operator git_strarray*()
 void git_strarray_wrapper::reset_str_array()
 {
     delete[] m_array.strings;
-    m_array={nullptr, 0};
+    m_array = {nullptr, 0};
 }
 
 void git_strarray_wrapper::init_str_array()
 {
     m_array.strings = new char*[m_patterns.size()];
     m_array.count = m_patterns.size();
-    for (size_t i=0; i<m_patterns.size(); ++i)
+    for (size_t i = 0; i < m_patterns.size(); ++i)
     {
         m_array.strings[i] = const_cast<char*>(m_patterns[i].c_str());
     }
@@ -126,8 +127,11 @@ std::string read_file(const std::string& path)
 std::vector<std::string> split_input_at_newlines(std::string_view str)
 {
     auto split = str | std::ranges::views::split('\n')
-                     | std::ranges::views::transform([](auto&& range) {
+                 | std::ranges::views::transform(
+                     [](auto&& range)
+                     {
                          return std::string(range.begin(), range.end());
-                     });
+                     }
+                 );
     return std::vector<std::string>{split.begin(), split.end()};
 }
diff --git a/src/utils/common.hpp b/src/utils/common.hpp
index bd77845..6c6e52f 100644
--- a/src/utils/common.hpp
+++ b/src/utils/common.hpp
@@ -8,12 +8,14 @@
 class noncopyable_nonmovable
 {
 public:
+
     noncopyable_nonmovable(const noncopyable_nonmovable&) = delete;
     noncopyable_nonmovable& operator=(const noncopyable_nonmovable&) = delete;
     noncopyable_nonmovable(noncopyable_nonmovable&&) = delete;
     noncopyable_nonmovable& operator=(noncopyable_nonmovable&&) = delete;
 
 protected:
+
     noncopyable_nonmovable() = default;
     ~noncopyable_nonmovable() = default;
 };
@@ -36,15 +38,18 @@ struct status_messages
 
 status_messages get_status_msg(git_status_t);
 
-using stream_colour_fn = std::ostream& (*)(std::ostream&);
+using stream_colour_fn = std::ostream& (*) (std::ostream&);
 
 class git_strarray_wrapper
 {
 public:
+
     git_strarray_wrapper()
         : m_patterns{}
         , m_array{nullptr, 0}
-    {}
+    {
+    }
+
     git_strarray_wrapper(std::vector<std::string> patterns);
 
     git_strarray_wrapper(const git_strarray_wrapper&) = delete;
@@ -60,6 +65,7 @@ class git_strarray_wrapper
     size_t size();
 
 private:
+
     std::vector<std::string> m_patterns;
     git_strarray m_array;
 
diff --git a/src/utils/credentials.cpp b/src/utils/credentials.cpp
index 9506275..c8d43e3 100644
--- a/src/utils/credentials.cpp
+++ b/src/utils/credentials.cpp
@@ -1,34 +1,41 @@
-#include <git2/credential.h>
+#include "credentials.hpp"
+
 #include <iostream>
 
-#include "credentials.hpp"
+#include <git2/credential.h>
+
 #include "input_output.hpp"
 
 // git_credential_acquire_cb
 int user_credentials(
     git_credential** out,
-	const char* url,
-	const char* username_from_url,
-	unsigned int allowed_types,
-	void* payload)
+    const char* url,
+    const char* username_from_url,
+    unsigned int allowed_types,
+    void* payload
+)
 {
     // Check for cached credentials here, if desired.
     // It might be necessary to make this function stateful to avoid repeating unnecessary checks.
 
     *out = nullptr;
 
-    if (allowed_types & GIT_CREDENTIAL_USERPASS_PLAINTEXT) {
+    if (allowed_types & GIT_CREDENTIAL_USERPASS_PLAINTEXT)
+    {
         std::string username = username_from_url ? username_from_url : "";
-        if (username.empty()) {
+        if (username.empty())
+        {
             username = prompt_input("Username: ");
         }
-        if (username.empty()) {
+        if (username.empty())
+        {
             giterr_set_str(GIT_ERROR_HTTP, "No username specified");
             return GIT_EAUTH;
         }
 
         std::string password = prompt_input("Password: ", false);
-        if (password.empty()) {
+        if (password.empty())
+        {
             giterr_set_str(GIT_ERROR_HTTP, "No password specified");
             return GIT_EAUTH;
         }
diff --git a/src/utils/credentials.hpp b/src/utils/credentials.hpp
index 452195b..ba970e6 100644
--- a/src/utils/credentials.hpp
+++ b/src/utils/credentials.hpp
@@ -6,8 +6,8 @@
 // (username and password) to authenticate remote https access.
 int user_credentials(
     git_credential** out,
-	const char* url,
-	const char* username_from_url,
-	unsigned int allowed_types,
-	void* payload
+    const char* url,
+    const char* username_from_url,
+    unsigned int allowed_types,
+    void* payload
 );
diff --git a/src/utils/git_exception.cpp b/src/utils/git_exception.cpp
index 8426d45..d16e5da 100644
--- a/src/utils/git_exception.cpp
+++ b/src/utils/git_exception.cpp
@@ -1,7 +1,7 @@
-#include <git2.h>
-
 #include "git_exception.hpp"
 
+#include <git2.h>
+
 void throw_if_error(int exit_code)
 {
     if (exit_code < 0)
@@ -11,12 +11,15 @@ void throw_if_error(int exit_code)
 }
 
 git_exception::git_exception(const std::string_view message, int error_code)
-    : m_message(message), m_error_code(error_code)
-{}
+    : m_message(message)
+    , m_error_code(error_code)
+{
+}
 
 git_exception::git_exception(const std::string_view message, git2cpp_error_code error_code)
     : git_exception(message, static_cast<int>(error_code))
-{}
+{
+}
 
 int git_exception::error_code() const
 {
diff --git a/src/utils/input_output.cpp b/src/utils/input_output.cpp
index 3225f4d..9e0ac45 100644
--- a/src/utils/input_output.cpp
+++ b/src/utils/input_output.cpp
@@ -1,6 +1,7 @@
-#include "ansi_code.hpp"
 #include "input_output.hpp"
 
+#include "ansi_code.hpp"
+
 // OS-specific libraries.
 #include <sys/ioctl.h>
 
@@ -12,10 +13,9 @@ cursor_hider::cursor_hider(bool hide /* = true */)
 
 cursor_hider::~cursor_hider()
 {
-    std::cout << (m_hide ? ansi_code::show_cursor :  ansi_code::hide_cursor);
+    std::cout << (m_hide ? ansi_code::show_cursor : ansi_code::hide_cursor);
 }
 
-
 alternative_buffer::alternative_buffer()
 {
     tcgetattr(fileno(stdin), &m_previous_termios);
@@ -38,7 +38,8 @@ alternative_buffer::~alternative_buffer()
 echo_control::echo_control(bool echo)
     : m_echo(echo)
 {
-    if (!m_echo) {
+    if (!m_echo)
+    {
         tcgetattr(fileno(stdin), &m_previous_termios);
         auto new_termios = m_previous_termios;
         new_termios.c_lflag &= ~ECHO;
@@ -48,13 +49,13 @@ echo_control::echo_control(bool echo)
 
 echo_control::~echo_control()
 {
-    if (!m_echo) {
+    if (!m_echo)
+    {
         // Restore previous termios settings.
         tcsetattr(fileno(stdin), TCSANOW, &m_previous_termios);
     }
 }
 
-
 std::string prompt_input(const std::string_view prompt, bool echo /* = true */)
 {
     std::cout << prompt;
@@ -65,7 +66,8 @@ std::string prompt_input(const std::string_view prompt, bool echo /* = true */)
     cursor_hider ch(false);  // Re-enable cursor if currently hidden.
     std::getline(std::cin, input);
 
-    if (!echo) {
+    if (!echo)
+    {
         std::cout << std::endl;
     }
 
diff --git a/src/utils/input_output.hpp b/src/utils/input_output.hpp
index fabc27d..bb11ae1 100644
--- a/src/utils/input_output.hpp
+++ b/src/utils/input_output.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <iostream>
+
 #include "common.hpp"
 
 // OS-specific libraries.
@@ -14,11 +15,13 @@
 class cursor_hider : noncopyable_nonmovable
 {
 public:
+
     cursor_hider(bool hide = true);
 
     ~cursor_hider();
 
 private:
+
     bool m_hide;
 };
 
@@ -27,11 +30,13 @@ class cursor_hider : noncopyable_nonmovable
 class alternative_buffer : noncopyable_nonmovable
 {
 public:
+
     alternative_buffer();
 
     ~alternative_buffer();
 
 private:
+
     struct termios m_previous_termios;
 };
 
@@ -40,11 +45,13 @@ class alternative_buffer : noncopyable_nonmovable
 class echo_control : noncopyable_nonmovable
 {
 public:
+
     echo_control(bool echo);
 
     ~echo_control();
 
 private:
+
     bool m_echo;
     struct termios m_previous_termios;
 };
diff --git a/src/utils/progress.cpp b/src/utils/progress.cpp
index bdb3a23..12b7c63 100644
--- a/src/utils/progress.cpp
+++ b/src/utils/progress.cpp
@@ -1,9 +1,9 @@
+#include "../utils/progress.hpp"
+
 #include <iomanip>
 #include <iostream>
 #include <string_view>
 
-#include "../utils/progress.hpp"
-
 int sideband_progress(const char* str, int len, void*)
 {
     printf("remote: %.*s", len, str);
@@ -26,19 +26,17 @@ int fetch_progress(const git_indexer_progress* stats, void* payload)
         return 0;
     }
 
-    int network_percent = pr->total_objects > 0 ?
-        (100 * pr->received_objects / pr->total_objects)
-        : 0;
+    int network_percent = pr->total_objects > 0 ? (100 * pr->received_objects / pr->total_objects) : 0;
     size_t kbytes = pr->received_bytes / 1024;
     size_t mbytes = kbytes / 1024;
 
-    std::cout << "Receiving objects: " << std::setw(4) << network_percent
-        << "% (" << pr->received_objects << "/" << pr->total_objects << "), ";
+    std::cout << "Receiving objects: " << std::setw(4) << network_percent << "% (" << pr->received_objects
+              << "/" << pr->total_objects << "), ";
     if (mbytes != 0)
     {
         std::cout << mbytes << " MiB";
     }
-    else if  (kbytes != 0)
+    else if (kbytes != 0)
     {
         std::cout << kbytes << " KiB";
     }
@@ -68,12 +66,10 @@ void checkout_progress(const char* path, size_t cur, size_t tot, void* payload)
         return;
     }
     auto* pr = reinterpret_cast<git_indexer_progress*>(payload);
-    int deltas_percent = pr->total_deltas > 0 ?
-        (100 * pr->indexed_deltas / pr->total_deltas)
-        : 0;
+    int deltas_percent = pr->total_deltas > 0 ? (100 * pr->indexed_deltas / pr->total_deltas) : 0;
 
-    std::cout << "Resolving deltas: " << std::setw(4) << deltas_percent
-        << "% (" << pr->indexed_deltas << "/" << pr->total_deltas << ")";
+    std::cout << "Resolving deltas: " << std::setw(4) << deltas_percent << "% (" << pr->indexed_deltas << "/"
+              << pr->total_deltas << ")";
     if (pr->indexed_deltas == pr->total_deltas)
     {
         std::cout << ", done." << std::endl;
@@ -87,7 +83,7 @@ void checkout_progress(const char* path, size_t cur, size_t tot, void* payload)
 
 int update_refs(const char* refname, const git_oid* a, const git_oid* b, git_refspec*, void*)
 {
-    char a_str[GIT_OID_SHA1_HEXSIZE+1], b_str[GIT_OID_SHA1_HEXSIZE+1];
+    char a_str[GIT_OID_SHA1_HEXSIZE + 1], b_str[GIT_OID_SHA1_HEXSIZE + 1];
 
     git_oid_fmt(b_str, b);
     b_str[GIT_OID_SHA1_HEXSIZE] = '\0';
@@ -97,10 +93,11 @@ int update_refs(const char* refname, const git_oid* a, const git_oid* b, git_ref
         std::string n, name, ref;
         const size_t last_slash_idx = std::string_view(refname).find_last_of('/');
         name = std::string_view(refname).substr(last_slash_idx + 1, -1);
-        if (std::string_view(refname).find("remote") != std::string::npos)   // maybe will string_view need the size of the string
+        if (std::string_view(refname).find("remote") != std::string::npos)  // maybe will string_view need the
+                                                                            // size of the string
         {
             n = " * [new branch]      ";
-            auto new_refname =  std::string_view(refname).substr(0, last_slash_idx - 1);
+            auto new_refname = std::string_view(refname).substr(0, last_slash_idx - 1);
             const size_t second_to_last_slash_idx = std::string_view(new_refname).find_last_of('/');
             ref = std::string_view(refname).substr(second_to_last_slash_idx + 1, -1);
         }
@@ -120,11 +117,8 @@ int update_refs(const char* refname, const git_oid* a, const git_oid* b, git_ref
         git_oid_fmt(a_str, a);
         a_str[GIT_OID_SHA1_HEXSIZE] = '\0';
 
-        std::cout << "[updated] "
-                  << std::string(a_str, 10)
-                  << ".."
-                  << std::string(b_str, 10)
-                  << " " << refname << std::endl;
+        std::cout << "[updated] " << std::string(a_str, 10) << ".." << std::string(b_str, 10) << " "
+                  << refname << std::endl;
     }
 
     return 0;
@@ -135,8 +129,8 @@ int push_transfer_progress(unsigned int current, unsigned int total, size_t byte
     if (total > 0)
     {
         int percent = (100 * current) / total;
-        std::cout << "Writing objects: " << percent << "% (" << current
-            << "/" << total << "), " << bytes << " bytes\r";
+        std::cout << "Writing objects: " << percent << "% (" << current << "/" << total << "), " << bytes
+                  << " bytes\r";
     }
     return 0;
 }
diff --git a/src/utils/terminal_pager.cpp b/src/utils/terminal_pager.cpp
index 7b5dcc7..8f8f3b3 100644
--- a/src/utils/terminal_pager.cpp
+++ b/src/utils/terminal_pager.cpp
@@ -6,16 +6,17 @@
 
 // OS-specific libraries.
 #include <sys/ioctl.h>
-
 #include <termcolor/termcolor.hpp>
 
 #include "ansi_code.hpp"
+#include "common.hpp"
 #include "input_output.hpp"
 #include "terminal_pager.hpp"
-#include "common.hpp"
 
 terminal_pager::terminal_pager()
-    : m_rows(0), m_columns(0), m_start_row_index(0)
+    : m_rows(0)
+    , m_columns(0)
+    , m_start_row_index(0)
 {
     maybe_grab_cout();
 }
diff --git a/src/utils/terminal_pager.hpp b/src/utils/terminal_pager.hpp
index ea02865..9beb766 100644
--- a/src/utils/terminal_pager.hpp
+++ b/src/utils/terminal_pager.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
-#include <vector>
 #include <sstream>
+#include <vector>
 
 /**
  * Terminal pager that displays output written to stdout one page at a time, allowing the user to
@@ -29,6 +29,7 @@
 class terminal_pager
 {
 public:
+
     terminal_pager();
 
     ~terminal_pager();
@@ -36,6 +37,7 @@ class terminal_pager
     void show();
 
 private:
+
     std::string get_input() const;
 
     void maybe_grab_cout();
diff --git a/src/version.hpp b/src/version.hpp
index 52e98e1..33de28b 100644
--- a/src/version.hpp
+++ b/src/version.hpp
@@ -9,4 +9,6 @@
 
 #define STR_HELPER(x) #x
 #define STR(x) STR_HELPER(x)
-#define GIT2CPP_VERSION_STRING (STR(GIT2CPP_VERSION_MAJOR) "." STR(GIT2CPP_VERSION_MINOR) "." STR(GIT2CPP_VERSION_PATCH) GIT2CPP_VERSION_SUFFIX)
+#define GIT2CPP_VERSION_STRING                                                                \
+    (STR(GIT2CPP_VERSION_MAJOR) "." STR(GIT2CPP_VERSION_MINOR) "." STR(GIT2CPP_VERSION_PATCH) \
+         GIT2CPP_VERSION_SUFFIX)
diff --git a/src/wrapper/branch_wrapper.cpp b/src/wrapper/branch_wrapper.cpp
index b4fc906..6ba30dd 100644
--- a/src/wrapper/branch_wrapper.cpp
+++ b/src/wrapper/branch_wrapper.cpp
@@ -1,13 +1,14 @@
-#include "../utils/git_exception.hpp"
 #include "../wrapper/branch_wrapper.hpp"
-#include "../wrapper/commit_wrapper.hpp"
-#include "../wrapper/repository_wrapper.hpp"
 
 #include <iostream>
 
+#include "../utils/git_exception.hpp"
+#include "../wrapper/commit_wrapper.hpp"
+#include "../wrapper/repository_wrapper.hpp"
+
 branch_wrapper::branch_wrapper(git_reference* ref)
     : base_type(ref)
-{    
+{
 }
 
 branch_wrapper::~branch_wrapper()
@@ -45,7 +46,6 @@ branch_iterator::~branch_iterator()
     p_resource = nullptr;
 }
 
-
 std::optional<branch_wrapper> branch_iterator::next()
 {
     git_reference* ref = nullptr;
diff --git a/src/wrapper/branch_wrapper.hpp b/src/wrapper/branch_wrapper.hpp
index d73bad0..0161533 100644
--- a/src/wrapper/branch_wrapper.hpp
+++ b/src/wrapper/branch_wrapper.hpp
@@ -24,7 +24,7 @@ class branch_wrapper : public wrapper_base<git_reference>
     std::string_view reference_name() const;
 
 private:
-    
+
     explicit branch_wrapper(git_reference* ref);
 
     friend class repository_wrapper;
diff --git a/src/wrapper/commit_wrapper.cpp b/src/wrapper/commit_wrapper.cpp
index aa4cae3..3bee5ef 100644
--- a/src/wrapper/commit_wrapper.cpp
+++ b/src/wrapper/commit_wrapper.cpp
@@ -1,8 +1,9 @@
+#include "../wrapper/commit_wrapper.hpp"
+
 #include <git2/commit.h>
 
 #include "../utils/git_exception.hpp"
 #include "tree_wrapper.hpp"
-#include "../wrapper/commit_wrapper.hpp"
 
 commit_wrapper::commit_wrapper(git_commit* commit)
     : base_type(commit)
@@ -54,7 +55,7 @@ commit_list_wrapper commit_wrapper::get_parents_list() const
     std::vector<commit_wrapper> parents_list;
     parents_list.reserve(parent_count);
 
-    for (size_t i=0; i < parent_count; ++i)
+    for (size_t i = 0; i < parent_count; ++i)
     {
         git_commit* parent;
         git_commit_parent(&parent, *this, i);
diff --git a/src/wrapper/commit_wrapper.hpp b/src/wrapper/commit_wrapper.hpp
index c50b389..98268da 100644
--- a/src/wrapper/commit_wrapper.hpp
+++ b/src/wrapper/commit_wrapper.hpp
@@ -1,10 +1,11 @@
 #pragma once
 
-#include <git2.h>
 #include <string>
 
-#include "../wrapper/wrapper_base.hpp"
+#include <git2.h>
+
 #include "../wrapper/tree_wrapper.hpp"
+#include "../wrapper/wrapper_base.hpp"
 
 class commit_wrapper;
 using commit_list_wrapper = list_wrapper<commit_wrapper>;
diff --git a/src/wrapper/config_wrapper.cpp b/src/wrapper/config_wrapper.cpp
index 4d947a7..ff6e9b0 100644
--- a/src/wrapper/config_wrapper.cpp
+++ b/src/wrapper/config_wrapper.cpp
@@ -1,4 +1,5 @@
 #include "../wrapper/config_wrapper.hpp"
+
 #include "../utils/git_exception.hpp"
 
 config_wrapper::config_wrapper(git_config* cfg)
@@ -9,7 +10,7 @@ config_wrapper::config_wrapper(git_config* cfg)
 config_wrapper::~config_wrapper()
 {
     git_config_free(p_resource);
-    p_resource=nullptr;
+    p_resource = nullptr;
 }
 
 git_config_entry* config_wrapper::get_entry(std::string name)
@@ -26,5 +27,5 @@ void config_wrapper::set_entry(std::string name, std::string value)
 
 void config_wrapper::delete_entry(std::string name)
 {
-     throw_if_error(git_config_delete_entry(*this, name.c_str()));
+    throw_if_error(git_config_delete_entry(*this, name.c_str()));
 }
diff --git a/src/wrapper/diff_wrapper.cpp b/src/wrapper/diff_wrapper.cpp
index 37e4cd7..5408fe6 100644
--- a/src/wrapper/diff_wrapper.cpp
+++ b/src/wrapper/diff_wrapper.cpp
@@ -1,6 +1,7 @@
-#include "../utils/git_exception.hpp"
 #include "../wrapper/diff_wrapper.hpp"
 
+#include "../utils/git_exception.hpp"
+
 diff_wrapper::diff_wrapper(git_diff* diff)
     : base_type(diff)
 {
diff --git a/src/wrapper/diff_wrapper.hpp b/src/wrapper/diff_wrapper.hpp
index b82b497..28262a6 100644
--- a/src/wrapper/diff_wrapper.hpp
+++ b/src/wrapper/diff_wrapper.hpp
@@ -2,8 +2,8 @@
 
 #include <git2.h>
 
-#include "../wrapper/wrapper_base.hpp"
 #include "../wrapper/diffstats_wrapper.hpp"
+#include "../wrapper/wrapper_base.hpp"
 
 class diff_wrapper : public wrapper_base<git_diff>
 {
diff --git a/src/wrapper/diffstats_wrapper.cpp b/src/wrapper/diffstats_wrapper.cpp
index 6dea273..7f405bf 100644
--- a/src/wrapper/diffstats_wrapper.cpp
+++ b/src/wrapper/diffstats_wrapper.cpp
@@ -1,6 +1,7 @@
-#include "../utils/git_exception.hpp"
 #include "../wrapper/diffstats_wrapper.hpp"
 
+#include "../utils/git_exception.hpp"
+
 diffstats_wrapper::diffstats_wrapper(git_diff_stats* stats)
     : base_type(stats)
 {
diff --git a/src/wrapper/index_wrapper.cpp b/src/wrapper/index_wrapper.cpp
index 701aab1..d34ce20 100644
--- a/src/wrapper/index_wrapper.cpp
+++ b/src/wrapper/index_wrapper.cpp
@@ -1,18 +1,19 @@
-#include <git2/index.h>
+#include "index_wrapper.hpp"
+
 #include <algorithm>
 #include <iostream>
 #include <vector>
 
-#include "index_wrapper.hpp"
+#include <git2/index.h>
+
 #include "../utils/common.hpp"
 #include "../utils/git_exception.hpp"
 #include "../wrapper/repository_wrapper.hpp"
 
-
 index_wrapper::~index_wrapper()
 {
     git_index_free(p_resource);
-    p_resource=nullptr;
+    p_resource = nullptr;
 }
 
 index_wrapper index_wrapper::init(repository_wrapper& rw)
@@ -56,10 +57,14 @@ void index_wrapper::remove_entries(std::vector<std::string> paths)
 
 void index_wrapper::remove_directories(std::vector<std::string> entries)
 {
-    std::for_each(entries.cbegin(), entries.cend(), [this](const std::string& path)
-    {
-        throw_if_error(git_index_remove_directory(*this, path.c_str(), 0));
-    });
+    std::for_each(
+        entries.cbegin(),
+        entries.cend(),
+        [this](const std::string& path)
+        {
+            throw_if_error(git_index_remove_directory(*this, path.c_str(), 0));
+        }
+    );
 }
 
 void index_wrapper::write()
@@ -88,33 +93,33 @@ git_index_conflict_iterator* index_wrapper::create_conflict_iterator()
 
 void index_wrapper::output_conflicts()
 {
-	git_index_conflict_iterator* conflicts = create_conflict_iterator();
-
-	const git_index_entry* ancestor;
-	const git_index_entry* our;
-	const git_index_entry* their;
-	int err = 0;
-	std::string msg_conflict;
-
-	while ((err = git_index_conflict_next(&ancestor, &our, &their, conflicts)) == 0)
-	{
-	    std::string ancestor_path = ancestor ? ancestor->path : "";
-		std::string our_path = our->path ? our->path : "NULL";
-	    std::string their_path = their->path ? their->path : "NULL";
-		msg_conflict  = "conflict: " + ancestor_path + " " + our_path + " " + their_path;
-		std::cout << msg_conflict << std::endl;
-// Message with git is a bit different:
-// Auto-merging mook_file.txt
-// CONFLICT (add/add): Merge conflict in mook_file.txt
-// Automatic merge failed; fix conflicts and then commit the result.
-	}
-
-	if (err != GIT_ITEROVER)
-	{
-		std::cout << "error iterating conflicts" << std::endl;
-	}
-
-	git_index_conflict_iterator_free(conflicts);
+    git_index_conflict_iterator* conflicts = create_conflict_iterator();
+
+    const git_index_entry* ancestor;
+    const git_index_entry* our;
+    const git_index_entry* their;
+    int err = 0;
+    std::string msg_conflict;
+
+    while ((err = git_index_conflict_next(&ancestor, &our, &their, conflicts)) == 0)
+    {
+        std::string ancestor_path = ancestor ? ancestor->path : "";
+        std::string our_path = our->path ? our->path : "NULL";
+        std::string their_path = their->path ? their->path : "NULL";
+        msg_conflict = "conflict: " + ancestor_path + " " + our_path + " " + their_path;
+        std::cout << msg_conflict << std::endl;
+        // Message with git is a bit different:
+        // Auto-merging mook_file.txt
+        // CONFLICT (add/add): Merge conflict in mook_file.txt
+        // Automatic merge failed; fix conflicts and then commit the result.
+    }
+
+    if (err != GIT_ITEROVER)
+    {
+        std::cout << "error iterating conflicts" << std::endl;
+    }
+
+    git_index_conflict_iterator_free(conflicts);
 }
 
 void index_wrapper::conflict_cleanup()
diff --git a/src/wrapper/object_wrapper.cpp b/src/wrapper/object_wrapper.cpp
index 7649540..02eb51f 100644
--- a/src/wrapper/object_wrapper.cpp
+++ b/src/wrapper/object_wrapper.cpp
@@ -18,10 +18,10 @@ const git_oid& object_wrapper::oid() const
 
 object_wrapper::operator git_commit*() const noexcept
 {
-     return reinterpret_cast<git_commit*>(p_resource);
+    return reinterpret_cast<git_commit*>(p_resource);
 }
 
 object_wrapper::operator git_tag*() const noexcept
 {
-     return reinterpret_cast<git_tag*>(p_resource);
+    return reinterpret_cast<git_tag*>(p_resource);
 }
diff --git a/src/wrapper/patch_wrapper.cpp b/src/wrapper/patch_wrapper.cpp
index d75a450..8eae47f 100644
--- a/src/wrapper/patch_wrapper.cpp
+++ b/src/wrapper/patch_wrapper.cpp
@@ -1,6 +1,7 @@
-#include "../utils/git_exception.hpp"
 #include "../wrapper/patch_wrapper.hpp"
 
+#include "../utils/git_exception.hpp"
+
 patch_wrapper::patch_wrapper(git_patch* patch)
     : base_type(patch)
 {
@@ -19,9 +20,24 @@ git_buf patch_wrapper::to_buf()
     return buf;
 }
 
-patch_wrapper patch_wrapper::patch_from_files(const std::string& path1, const std::string& file1_str, const std::string& path2, const std::string& file2_str, git_diff_options* diffopts)
+patch_wrapper patch_wrapper::patch_from_files(
+    const std::string& path1,
+    const std::string& file1_str,
+    const std::string& path2,
+    const std::string& file2_str,
+    git_diff_options* diffopts
+)
 {
     git_patch* patch;
-    throw_if_error(git_patch_from_buffers(&patch, file1_str.c_str(), file1_str.length(), path1.c_str(), file2_str.c_str(), file2_str.length(), path2.c_str(), diffopts));
+    throw_if_error(git_patch_from_buffers(
+        &patch,
+        file1_str.c_str(),
+        file1_str.length(),
+        path1.c_str(),
+        file2_str.c_str(),
+        file2_str.length(),
+        path2.c_str(),
+        diffopts
+    ));
     return patch_wrapper(patch);
 }
diff --git a/src/wrapper/patch_wrapper.hpp b/src/wrapper/patch_wrapper.hpp
index 4f15dc4..76febe7 100644
--- a/src/wrapper/patch_wrapper.hpp
+++ b/src/wrapper/patch_wrapper.hpp
@@ -1,8 +1,9 @@
 #pragma once
 
-#include <git2.h>
 #include <string>
 
+#include <git2.h>
+
 #include "../wrapper/wrapper_base.hpp"
 
 class patch_wrapper : public wrapper_base<git_patch>
@@ -17,7 +18,13 @@ class patch_wrapper : public wrapper_base<git_patch>
     patch_wrapper& operator=(patch_wrapper&&) noexcept = default;
 
     git_buf to_buf();
-    static patch_wrapper patch_from_files(const std::string& path1, const std::string& file1_str, const std::string& path2, const std::string& file2_str, git_diff_options* diffopts);
+    static patch_wrapper patch_from_files(
+        const std::string& path1,
+        const std::string& file1_str,
+        const std::string& path2,
+        const std::string& file2_str,
+        git_diff_options* diffopts
+    );
 
 private:
 
diff --git a/src/wrapper/rebase_wrapper.cpp b/src/wrapper/rebase_wrapper.cpp
index dab9fac..dc3bdfa 100644
--- a/src/wrapper/rebase_wrapper.cpp
+++ b/src/wrapper/rebase_wrapper.cpp
@@ -1,8 +1,9 @@
 #include "rebase_wrapper.hpp"
-#include "../utils/git_exception.hpp"
 
 #include <iostream>
 
+#include "../utils/git_exception.hpp"
+
 rebase_wrapper::~rebase_wrapper()
 {
     git_rebase_free(p_resource);
@@ -19,6 +20,7 @@ git_oid rebase_wrapper::current_operation_id() const
 {
     return p_operation->id;
 }
+
 std::size_t rebase_wrapper::current_operation_index() const
 {
     return git_rebase_operation_current(p_resource);
@@ -38,7 +40,8 @@ int rebase_wrapper::commit(const signature_wrapper& author, const signature_wrap
         author,
         committer,
         nullptr,  // message encoding (NULL for default)
-        nullptr); // message (NULL to use original)
+        nullptr
+    );  // message (NULL to use original)
     return res;
 }
 
@@ -53,10 +56,9 @@ void rebase_wrapper::abort()
     throw_if_error(git_rebase_abort(p_resource));
 }
 
-rebase_wrapper rebase_wrapper::init
-(
+rebase_wrapper rebase_wrapper::init(
     repository_wrapper& repo,
-    const annotated_commit_wrapper& branch, 
+    const annotated_commit_wrapper& branch,
     const annotated_commit_wrapper& upstream,
     const annotated_commit_wrapper* onto,
     const git_rebase_options& opts
diff --git a/src/wrapper/rebase_wrapper.hpp b/src/wrapper/rebase_wrapper.hpp
index 8bdaecc..c7cbe2f 100644
--- a/src/wrapper/rebase_wrapper.hpp
+++ b/src/wrapper/rebase_wrapper.hpp
@@ -1,12 +1,12 @@
 #pragma once
 
-#include <git2.h>
-
 #include <optional>
 
+#include <git2.h>
+
 #include "../wrapper/annotated_commit_wrapper.hpp"
-#include "../wrapper/signature_wrapper.hpp"
 #include "../wrapper/repository_wrapper.hpp"
+#include "../wrapper/signature_wrapper.hpp"
 #include "../wrapper/wrapper_base.hpp"
 
 class rebase_wrapper : public wrapper_base<git_rebase>
@@ -29,10 +29,9 @@ class rebase_wrapper : public wrapper_base<git_rebase>
     void finish(const signature_wrapper& committer);
     void abort();
 
-    static rebase_wrapper init
-    (
+    static rebase_wrapper init(
         repository_wrapper& repo,
-        const annotated_commit_wrapper& branch, 
+        const annotated_commit_wrapper& branch,
         const annotated_commit_wrapper& upstream,
         const annotated_commit_wrapper* onto,
         const git_rebase_options& opts
@@ -45,4 +44,3 @@ class rebase_wrapper : public wrapper_base<git_rebase>
 
     git_rebase_operation* p_operation = nullptr;
 };
-
diff --git a/src/wrapper/refs_wrapper.cpp b/src/wrapper/refs_wrapper.cpp
index 4af5906..691f07a 100644
--- a/src/wrapper/refs_wrapper.cpp
+++ b/src/wrapper/refs_wrapper.cpp
@@ -1,8 +1,10 @@
-#include "../utils/git_exception.hpp"
-#include "object_wrapper.hpp"
+#include "../wrapper/refs_wrapper.hpp"
+
 #include <git2/refs.h>
 #include <git2/types.h>
-#include "../wrapper/refs_wrapper.hpp"
+
+#include "../utils/git_exception.hpp"
+#include "object_wrapper.hpp"
 
 reference_wrapper::reference_wrapper(git_reference* ref)
     : base_type(ref)
@@ -12,7 +14,7 @@ reference_wrapper::reference_wrapper(git_reference* ref)
 reference_wrapper::~reference_wrapper()
 {
     git_reference_free(p_resource);
-    p_resource=nullptr;
+    p_resource = nullptr;
 }
 
 std::string reference_wrapper::short_name() const
diff --git a/src/wrapper/refs_wrapper.hpp b/src/wrapper/refs_wrapper.hpp
index d7645ca..dddc6b0 100644
--- a/src/wrapper/refs_wrapper.hpp
+++ b/src/wrapper/refs_wrapper.hpp
@@ -6,8 +6,8 @@
 #include <git2.h>
 
 #include "../utils/git_exception.hpp"
-#include "../wrapper/wrapper_base.hpp"
 #include "../wrapper/object_wrapper.hpp"
+#include "../wrapper/wrapper_base.hpp"
 
 class reference_wrapper : public wrapper_base<git_reference>
 {
@@ -49,7 +49,7 @@ W reference_wrapper::peel() const
         {
             return GIT_OBJECT_COMMIT;
         }
-        else // Default case
+        else  // Default case
         {
             return GIT_OBJECT_ANY;
         }
diff --git a/src/wrapper/remote_wrapper.cpp b/src/wrapper/remote_wrapper.cpp
index 08420ca..3f603dd 100644
--- a/src/wrapper/remote_wrapper.cpp
+++ b/src/wrapper/remote_wrapper.cpp
@@ -1,10 +1,11 @@
-#include <vector>
+#include "../wrapper/remote_wrapper.hpp"
+
 #include <string>
+#include <vector>
 
 #include <git2/remote.h>
 
 #include "../utils/git_exception.hpp"
-#include "../wrapper/remote_wrapper.hpp"
 
 remote_wrapper::remote_wrapper(git_remote* remote)
     : base_type(remote)
diff --git a/src/wrapper/remote_wrapper.hpp b/src/wrapper/remote_wrapper.hpp
index 1fa1632..a933fb8 100644
--- a/src/wrapper/remote_wrapper.hpp
+++ b/src/wrapper/remote_wrapper.hpp
@@ -1,10 +1,10 @@
 #pragma once
 
-#include <git2/remote.h>
 #include <string_view>
 #include <vector>
 
 #include <git2.h>
+#include <git2/remote.h>
 
 #include "../wrapper/wrapper_base.hpp"
 
diff --git a/src/wrapper/repository_wrapper.cpp b/src/wrapper/repository_wrapper.cpp
index b1d2b24..ccc0408 100644
--- a/src/wrapper/repository_wrapper.cpp
+++ b/src/wrapper/repository_wrapper.cpp
@@ -1,20 +1,21 @@
+#include "../wrapper/repository_wrapper.hpp"
+
 #include <algorithm>
 #include <fstream>
 #include <iostream>
 
 #include "../utils/git_exception.hpp"
+#include "../wrapper/commit_wrapper.hpp"
 #include "../wrapper/index_wrapper.hpp"
 #include "../wrapper/object_wrapper.hpp"
-#include "../wrapper/commit_wrapper.hpp"
 #include "../wrapper/remote_wrapper.hpp"
-#include "../wrapper/repository_wrapper.hpp"
 #include "config_wrapper.hpp"
 #include "diff_wrapper.hpp"
 
 repository_wrapper::~repository_wrapper()
 {
     git_repository_free(p_resource);
-    p_resource=nullptr;
+    p_resource = nullptr;
 }
 
 repository_wrapper repository_wrapper::open(std::string_view directory)
@@ -38,7 +39,8 @@ repository_wrapper repository_wrapper::init_ext(std::string_view directory, git_
     return rw;
 }
 
-repository_wrapper repository_wrapper::clone(std::string_view url, std::string_view path, const git_clone_options& opts)
+repository_wrapper
+repository_wrapper::clone(std::string_view url, std::string_view path, const git_clone_options& opts)
 {
     repository_wrapper rw;
     throw_if_error(git_clone(&(rw.p_resource), url.data(), path.data(), &opts));
@@ -105,7 +107,7 @@ std::string repository_wrapper::head_short_name() const
     throw_if_error(git_reference_lookup(&ref, *this, "HEAD"));
     if (git_reference_type(ref) == GIT_REFERENCE_DIRECT)
     {
-         name = git_reference_shorthand(ref);
+        name = git_reference_shorthand(ref);
     }
     else
     {
@@ -147,14 +149,16 @@ branch_wrapper repository_wrapper::create_branch(std::string_view name, bool for
     return create_branch(name, find_commit(), force);
 }
 
-branch_wrapper repository_wrapper::create_branch(std::string_view name, const commit_wrapper& commit, bool force)
+branch_wrapper
+repository_wrapper::create_branch(std::string_view name, const commit_wrapper& commit, bool force)
 {
     git_reference* branch = nullptr;
     throw_if_error(git_branch_create(&branch, *this, name.data(), commit, force));
     return branch_wrapper(branch);
 }
 
-branch_wrapper repository_wrapper::create_branch(std::string_view name, const annotated_commit_wrapper& commit, bool force)
+branch_wrapper
+repository_wrapper::create_branch(std::string_view name, const annotated_commit_wrapper& commit, bool force)
 {
     git_reference* branch = nullptr;
     throw_if_error(git_branch_create_from_annotated(&branch, *this, name.data(), commit, force));
@@ -238,8 +242,11 @@ commit_wrapper repository_wrapper::find_commit(const git_oid& id) const
     return commit_wrapper(commit);
 }
 
-void repository_wrapper::create_commit(const signature_wrapper::author_committer_signatures& author_committer_signatures,
-    const std::string_view message, const std::optional<commit_list_wrapper>& parents_list)
+void repository_wrapper::create_commit(
+    const signature_wrapper::author_committer_signatures& author_committer_signatures,
+    const std::string_view message,
+    const std::optional<commit_list_wrapper>& parents_list
+)
 {
     const char* message_encoding = "UTF-8";
     git_oid commit_id;
@@ -276,14 +283,22 @@ void repository_wrapper::create_commit(const signature_wrapper::author_committer
 
     auto tree = this->tree_lookup(&tree_id);
 
-    throw_if_error(git_commit_create(&commit_id, *this, update_ref.c_str(), author_committer_signatures.first, author_committer_signatures.second,
-        message_encoding, message.data(), tree, parents_count, parents));
+    throw_if_error(git_commit_create(
+        &commit_id,
+        *this,
+        update_ref.c_str(),
+        author_committer_signatures.first,
+        author_committer_signatures.second,
+        message_encoding,
+        message.data(),
+        tree,
+        parents_count,
+        parents
+    ));
 }
 
-std::optional<annotated_commit_wrapper> repository_wrapper::resolve_local_ref
-(
-    const std::string_view target_name
-) const
+std::optional<annotated_commit_wrapper>
+repository_wrapper::resolve_local_ref(const std::string_view target_name) const
 {
     if (auto ref = this->find_reference_dwim(target_name))
     {
@@ -336,7 +351,11 @@ void repository_wrapper::set_head_detached(const annotated_commit_wrapper& commi
     throw_if_error(git_repository_set_head_detached_from_annotated(*this, commit));
 }
 
-void repository_wrapper::reset(const object_wrapper& target, git_reset_t reset_type, const git_checkout_options& checkout_options)
+void repository_wrapper::reset(
+    const object_wrapper& target,
+    git_reset_t reset_type,
+    const git_checkout_options& checkout_options
+)
 {
     // TODO: gerer l'index
 
@@ -388,7 +407,15 @@ size_t repository_wrapper::shallow_depth_from_head() const
             const commit_wrapper& commit = commits_list[i];
             size_t depth = depth_list[i];
             const git_oid& oid = commit.oid();
-            bool is_boundary = std::find_if(boundaries_list.cbegin(), boundaries_list.cend(), [oid](const git_oid& val) {return git_oid_equal(&oid, &val);}) != boundaries_list.cend();
+            bool is_boundary = std::find_if(
+                                   boundaries_list.cbegin(),
+                                   boundaries_list.cend(),
+                                   [oid](const git_oid& val)
+                                   {
+                                       return git_oid_equal(&oid, &val);
+                                   }
+                               )
+                               != boundaries_list.cend();
             if (is_boundary)
             {
                 final_depths.push_back(depth + 1u);
@@ -502,7 +529,6 @@ std::vector<std::string> repository_wrapper::list_remotes() const
     return result;
 }
 
-
 // Config
 
 config_wrapper repository_wrapper::get_config()
@@ -514,7 +540,11 @@ config_wrapper repository_wrapper::get_config()
 
 // Diff
 
-diff_wrapper repository_wrapper::diff_tree_to_index(const tree_wrapper& old_tree, std::optional<index_wrapper> index, git_diff_options* diffopts)
+diff_wrapper repository_wrapper::diff_tree_to_index(
+    const tree_wrapper& old_tree,
+    std::optional<index_wrapper> index,
+    git_diff_options* diffopts
+)
 {
     git_diff* diff;
     git_index* idx = nullptr;
@@ -526,7 +556,11 @@ diff_wrapper repository_wrapper::diff_tree_to_index(const tree_wrapper& old_tree
     return diff_wrapper(diff);
 }
 
-diff_wrapper repository_wrapper::diff_tree_to_tree(const tree_wrapper& old_tree, const tree_wrapper& new_tree, git_diff_options* diffopts)
+diff_wrapper repository_wrapper::diff_tree_to_tree(
+    const tree_wrapper& old_tree,
+    const tree_wrapper& new_tree,
+    git_diff_options* diffopts
+)
 {
     git_diff* diff;
     throw_if_error(git_diff_tree_to_tree(&diff, *this, old_tree, new_tree, diffopts));
@@ -540,14 +574,16 @@ diff_wrapper repository_wrapper::diff_tree_to_workdir(const tree_wrapper& old_tr
     return diff_wrapper(diff);
 }
 
-diff_wrapper repository_wrapper::diff_tree_to_workdir_with_index(const tree_wrapper& old_tree, git_diff_options* diffopts)
+diff_wrapper
+repository_wrapper::diff_tree_to_workdir_with_index(const tree_wrapper& old_tree, git_diff_options* diffopts)
 {
     git_diff* diff;
     throw_if_error(git_diff_tree_to_workdir_with_index(&diff, *this, old_tree, diffopts));
     return diff_wrapper(diff);
 }
 
-diff_wrapper repository_wrapper::diff_index_to_workdir(std::optional<index_wrapper> index, git_diff_options* diffopts)
+diff_wrapper
+repository_wrapper::diff_index_to_workdir(std::optional<index_wrapper> index, git_diff_options* diffopts)
 {
     git_diff* diff;
     git_index* idx = nullptr;
diff --git a/src/wrapper/repository_wrapper.hpp b/src/wrapper/repository_wrapper.hpp
index a62f8c2..d630343 100644
--- a/src/wrapper/repository_wrapper.hpp
+++ b/src/wrapper/repository_wrapper.hpp
@@ -79,7 +79,11 @@ class repository_wrapper : public wrapper_base<git_repository>
     // Commits
     commit_wrapper find_commit(std::string_view ref_name = "HEAD") const;
     commit_wrapper find_commit(const git_oid& id) const;
-    void create_commit(const signature_wrapper::author_committer_signatures&, const std::string_view, const std::optional<commit_list_wrapper>& parents_list);
+    void create_commit(
+        const signature_wrapper::author_committer_signatures&,
+        const std::string_view,
+        const std::optional<commit_list_wrapper>& parents_list
+    );
     std::optional<annotated_commit_wrapper> resolve_local_ref(const std::string_view target_name) const;
 
     // Annotated commits
@@ -95,7 +99,8 @@ class repository_wrapper : public wrapper_base<git_repository>
     // Head manipulations
     void set_head(std::string_view ref_name);
     void set_head_detached(const annotated_commit_wrapper& commit);
-    void reset(const object_wrapper& target, git_reset_t reset_type, const git_checkout_options& checkout_options);
+    void
+    reset(const object_wrapper& target, git_reset_t reset_type, const git_checkout_options& checkout_options);
 
     // TODO: check if it's the right place to put the following
     size_t shallow_depth_from_head() const;
@@ -117,14 +122,16 @@ class repository_wrapper : public wrapper_base<git_repository>
     config_wrapper get_config();
 
     // Diff
-    diff_wrapper diff_tree_to_index(const tree_wrapper& old_tree, std::optional<index_wrapper> index, git_diff_options* diffopts);
-    diff_wrapper diff_tree_to_tree(const tree_wrapper& old_tree, const tree_wrapper& new_tree, git_diff_options* diffopts);
+    diff_wrapper
+    diff_tree_to_index(const tree_wrapper& old_tree, std::optional<index_wrapper> index, git_diff_options* diffopts);
+    diff_wrapper
+    diff_tree_to_tree(const tree_wrapper& old_tree, const tree_wrapper& new_tree, git_diff_options* diffopts);
     diff_wrapper diff_tree_to_workdir(const tree_wrapper& old_tree, git_diff_options* diffopts);
     diff_wrapper diff_tree_to_workdir_with_index(const tree_wrapper& old_tree, git_diff_options* diffopts);
     diff_wrapper diff_index_to_workdir(std::optional<index_wrapper> index, git_diff_options* diffopts);
 
-    //Tags
-    // git_strarray_wrapper tag_list_match(std::string pattern);
+    // Tags
+    //  git_strarray_wrapper tag_list_match(std::string pattern);
     std::vector<std::string> tag_list_match(std::string pattern);
 
 private:
diff --git a/src/wrapper/revwalk_wrapper.cpp b/src/wrapper/revwalk_wrapper.cpp
index 65ef0e5..d7e114a 100644
--- a/src/wrapper/revwalk_wrapper.cpp
+++ b/src/wrapper/revwalk_wrapper.cpp
@@ -1,7 +1,8 @@
+#include "revwalk_wrapper.hpp"
+
 #include <git2/index.h>
 #include <git2/types.h>
 
-#include "revwalk_wrapper.hpp"
 #include "../utils/git_exception.hpp"
 
 revwalk_wrapper::revwalk_wrapper(git_revwalk* walker)
@@ -12,7 +13,7 @@ revwalk_wrapper::revwalk_wrapper(git_revwalk* walker)
 revwalk_wrapper::~revwalk_wrapper()
 {
     git_revwalk_free(p_resource);
-    p_resource=nullptr;
+    p_resource = nullptr;
 }
 
 void revwalk_wrapper::push_head()
diff --git a/src/wrapper/revwalk_wrapper.hpp b/src/wrapper/revwalk_wrapper.hpp
index cd1c08f..22918e3 100644
--- a/src/wrapper/revwalk_wrapper.hpp
+++ b/src/wrapper/revwalk_wrapper.hpp
@@ -3,8 +3,8 @@
 #include <git2.h>
 #include <git2/types.h>
 
-#include "../wrapper/wrapper_base.hpp"
 #include "../wrapper/commit_wrapper.hpp"
+#include "../wrapper/wrapper_base.hpp"
 
 class revwalk_wrapper : public wrapper_base<git_revwalk>
 {
diff --git a/src/wrapper/signature_wrapper.cpp b/src/wrapper/signature_wrapper.cpp
index b6148d9..4e56325 100644
--- a/src/wrapper/signature_wrapper.cpp
+++ b/src/wrapper/signature_wrapper.cpp
@@ -1,15 +1,17 @@
-#include "../wrapper/repository_wrapper.hpp"
 #include "../wrapper/signature_wrapper.hpp"
-#include "../utils/git_exception.hpp"
+
 #include <git2/types.h>
 
+#include "../utils/git_exception.hpp"
+#include "../wrapper/repository_wrapper.hpp"
+
 signature_wrapper::~signature_wrapper()
 {
     if (m_ownership)
     {
         git_signature_free(p_resource);
     }
-    p_resource=nullptr;
+    p_resource = nullptr;
 }
 
 std::string_view signature_wrapper::name() const
@@ -27,7 +29,8 @@ git_time signature_wrapper::when() const
     return p_resource->when;
 }
 
-signature_wrapper::author_committer_signatures signature_wrapper::get_default_signature_from_env(repository_wrapper& rw)
+signature_wrapper::author_committer_signatures
+signature_wrapper::get_default_signature_from_env(repository_wrapper& rw)
 {
     signature_wrapper author;
     signature_wrapper committer;
@@ -62,7 +65,11 @@ signature_wrapper signature_wrapper::signature_now(std::string_view name, std::s
 }
 
 signature_wrapper::author_committer_signatures signature_wrapper::signature_now(
-    std::string_view author_name, std::string_view author_email, std::string_view committer_name, std::string_view committer_email)
+    std::string_view author_name,
+    std::string_view author_email,
+    std::string_view committer_name,
+    std::string_view committer_email
+)
 {
     signature_wrapper author_sig = signature_now(author_name.data(), author_email.data());
     signature_wrapper cmt_sig = signature_now(committer_name.data(), committer_email.data());
diff --git a/src/wrapper/signature_wrapper.hpp b/src/wrapper/signature_wrapper.hpp
index 68d9caa..28d8be5 100644
--- a/src/wrapper/signature_wrapper.hpp
+++ b/src/wrapper/signature_wrapper.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
-#include <utility>
 #include <string_view>
+#include <utility>
 
 #include <git2.h>
 
@@ -29,8 +29,7 @@ class signature_wrapper : public wrapper_base<git_signature>
     static signature_wrapper get_commit_author(const commit_wrapper&);
     static signature_wrapper get_commit_committer(const commit_wrapper&);
     static signature_wrapper signature_now(std::string_view name, std::string_view email);
-    static author_committer_signatures signature_now
-    (
+    static author_committer_signatures signature_now(
         std::string_view author_name,
         std::string_view author_email,
         std::string_view committer_name,
@@ -40,5 +39,5 @@ class signature_wrapper : public wrapper_base<git_signature>
 private:
 
     signature_wrapper() = default;
-    bool m_ownership=true;
+    bool m_ownership = true;
 };
diff --git a/src/wrapper/status_wrapper.cpp b/src/wrapper/status_wrapper.cpp
index 8f68e1c..410651a 100644
--- a/src/wrapper/status_wrapper.cpp
+++ b/src/wrapper/status_wrapper.cpp
@@ -1,6 +1,7 @@
-#include "../utils/git_exception.hpp"
 #include "../wrapper/status_wrapper.hpp"
 
+#include "../utils/git_exception.hpp"
+
 status_list_wrapper::~status_list_wrapper()
 {
     git_status_list_free(p_resource);
@@ -11,10 +12,8 @@ status_list_wrapper status_list_wrapper::status_list(const repository_wrapper& r
 {
     git_status_options opts = GIT_STATUS_OPTIONS_INIT;
     opts.show = GIT_STATUS_SHOW_INDEX_AND_WORKDIR;
-    opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED |
-                 GIT_STATUS_OPT_RENAMES_HEAD_TO_INDEX |
-                 GIT_STATUS_OPT_RENAMES_INDEX_TO_WORKDIR |
-                 GIT_STATUS_OPT_SORT_CASE_SENSITIVELY;
+    opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED | GIT_STATUS_OPT_RENAMES_HEAD_TO_INDEX
+                 | GIT_STATUS_OPT_RENAMES_INDEX_TO_WORKDIR | GIT_STATUS_OPT_SORT_CASE_SENSITIVELY;
     opts.rename_threshold = 50;
 
     status_list_wrapper res;
@@ -27,7 +26,11 @@ status_list_wrapper status_list_wrapper::status_list(const repository_wrapper& r
         res.m_entries[entry->status].push_back(entry);
     }
 
-    if (!res.get_entry_list(GIT_STATUS_INDEX_NEW).empty() || !res.get_entry_list(GIT_STATUS_INDEX_MODIFIED).empty() || !res.get_entry_list(GIT_STATUS_INDEX_DELETED).empty() || !res.get_entry_list(GIT_STATUS_INDEX_RENAMED).empty() || !res.get_entry_list(GIT_STATUS_INDEX_TYPECHANGE).empty())
+    if (!res.get_entry_list(GIT_STATUS_INDEX_NEW).empty()
+        || !res.get_entry_list(GIT_STATUS_INDEX_MODIFIED).empty()
+        || !res.get_entry_list(GIT_STATUS_INDEX_DELETED).empty()
+        || !res.get_entry_list(GIT_STATUS_INDEX_RENAMED).empty()
+        || !res.get_entry_list(GIT_STATUS_INDEX_TYPECHANGE).empty())
     {
         res.m_tobecommited_header_flag = true;
     }
@@ -35,7 +38,10 @@ status_list_wrapper status_list_wrapper::status_list(const repository_wrapper& r
     {
         res.m_untracked_header_flag = true;
     }
-    if (!res.get_entry_list(GIT_STATUS_WT_MODIFIED).empty() || !res.get_entry_list(GIT_STATUS_WT_DELETED).empty() || !res.get_entry_list(GIT_STATUS_WT_TYPECHANGE).empty() || !res.get_entry_list(GIT_STATUS_WT_RENAMED).empty())
+    if (!res.get_entry_list(GIT_STATUS_WT_MODIFIED).empty()
+        || !res.get_entry_list(GIT_STATUS_WT_DELETED).empty()
+        || !res.get_entry_list(GIT_STATUS_WT_TYPECHANGE).empty()
+        || !res.get_entry_list(GIT_STATUS_WT_RENAMED).empty())
     {
         res.m_notstagged_header_flag = true;
     }
@@ -59,22 +65,27 @@ bool status_list_wrapper::has_untracked_header() const
 {
     return m_untracked_header_flag;
 }
+
 bool status_list_wrapper::has_tobecommited_header() const
 {
     return m_tobecommited_header_flag;
 }
+
 bool status_list_wrapper::has_ignored_header() const
 {
     return m_ignored_header_flag;
 }
+
 bool status_list_wrapper::has_notstagged_header() const
 {
     return m_notstagged_header_flag;
 }
+
 bool status_list_wrapper::has_unmerged_header() const
 {
     return m_unmerged_header_flag;
 }
+
 bool status_list_wrapper::has_nothingtocommit_message() const
 {
     return m_nothingtocommit_message_flag;
diff --git a/src/wrapper/status_wrapper.hpp b/src/wrapper/status_wrapper.hpp
index b20e18a..4574561 100644
--- a/src/wrapper/status_wrapper.hpp
+++ b/src/wrapper/status_wrapper.hpp
@@ -11,6 +11,7 @@
 class status_list_wrapper : public wrapper_base<git_status_list>
 {
 public:
+
     using status_entry_list = std::vector<const git_status_entry*>;
 
     ~status_list_wrapper();
diff --git a/src/wrapper/tag_wrapper.cpp b/src/wrapper/tag_wrapper.cpp
index e385dd4..055f3f0 100644
--- a/src/wrapper/tag_wrapper.cpp
+++ b/src/wrapper/tag_wrapper.cpp
@@ -1,4 +1,5 @@
 #include "../wrapper/tag_wrapper.hpp"
+
 #include <git2/tag.h>
 
 tag_wrapper::tag_wrapper(git_tag* tag)
diff --git a/src/wrapper/tag_wrapper.hpp b/src/wrapper/tag_wrapper.hpp
index fb78eee..b6f9fcd 100644
--- a/src/wrapper/tag_wrapper.hpp
+++ b/src/wrapper/tag_wrapper.hpp
@@ -1,8 +1,9 @@
 #pragma once
 
-#include <git2.h>
 #include <string>
 
+#include <git2.h>
+
 #include "../wrapper/wrapper_base.hpp"
 
 class tag_wrapper : public wrapper_base<git_tag>
@@ -21,5 +22,5 @@ class tag_wrapper : public wrapper_base<git_tag>
 
 private:
 
-     tag_wrapper(git_tag* tag);
+    tag_wrapper(git_tag* tag);
 };
diff --git a/src/wrapper/tree_wrapper.hpp b/src/wrapper/tree_wrapper.hpp
index 0b22638..e49010e 100644
--- a/src/wrapper/tree_wrapper.hpp
+++ b/src/wrapper/tree_wrapper.hpp
@@ -17,8 +17,8 @@ class tree_wrapper : public wrapper_base<git_tree>
 
 private:
 
-     tree_wrapper(git_tree* tree);
+    tree_wrapper(git_tree* tree);
 
-     friend class commit_wrapper;
-     friend class repository_wrapper;
+    friend class commit_wrapper;
+    friend class repository_wrapper;
 };
diff --git a/src/wrapper/wrapper_base.hpp b/src/wrapper/wrapper_base.hpp
index def9b69..3d33f40 100644
--- a/src/wrapper/wrapper_base.hpp
+++ b/src/wrapper/wrapper_base.hpp
@@ -7,6 +7,7 @@ template <class T>
 class wrapper_base
 {
 public:
+
     using resource_type = T;
 
     wrapper_base(const wrapper_base&) = delete;
@@ -17,6 +18,7 @@ class wrapper_base
     {
         rhs.p_resource = nullptr;
     }
+
     wrapper_base& operator=(wrapper_base&& rhs) noexcept
     {
         std::swap(p_resource, rhs.p_resource);
@@ -29,6 +31,7 @@ class wrapper_base
     }
 
 protected:
+
     // Allocation and deletion of p_resource must be handled by inheriting class.
     explicit wrapper_base(resource_type* resource = nullptr)
         : p_resource(resource)
@@ -51,7 +54,7 @@ class list_wrapper : public wrapper_base<typename T::resource_type*>
         : m_list(std::move(list))
     {
         this->p_resource = new base_type::resource_type[m_list.size()];
-        for (size_t i=0; i< m_list.size(); ++i)
+        for (size_t i = 0; i < m_list.size(); ++i)
         {
             this->p_resource[i] = m_list[i];
         }
diff --git a/test/conftest.py b/test/conftest.py
index 138f87d..d824ed0 100644
--- a/test/conftest.py
+++ b/test/conftest.py
@@ -7,7 +7,7 @@
 GIT2CPP_TEST_WASM = os.getenv("GIT2CPP_TEST_WASM") == "1"
 
 if GIT2CPP_TEST_WASM:
-    from .conftest_wasm import *
+    from .conftest_wasm import *  # noqa: F403
 
 
 # Fixture to run test in current tmp_path
diff --git a/test/conftest_wasm.py b/test/conftest_wasm.py
index 2292918..ae183da 100644
--- a/test/conftest_wasm.py
+++ b/test/conftest_wasm.py
@@ -15,7 +15,7 @@ def pytest_ignore_collect(collection_path: pathlib.Path) -> bool:
     return collection_path.name not in [
         "test_add.py",
         "test_branch.py",
-        "test_checkout.py"
+        "test_checkout.py",
         "test_clone.py",
         "test_commit.py",
         "test_config.py",
@@ -38,11 +38,9 @@ def pytest_ignore_collect(collection_path: pathlib.Path) -> bool:
 
 @pytest.fixture(scope="session", autouse=True)
 def run_web_server():
-    with open('serve.log', 'w') as f:
-        cwd = pathlib.Path(__file__).parent.parent / 'wasm/test'
-        proc = subprocess.Popen(
-            ['npm', 'run', 'serve'], stdout=f, stderr=f, cwd=cwd
-        )
+    with open("serve.log", "w") as f:
+        cwd = pathlib.Path(__file__).parent.parent / "wasm/test"
+        proc = subprocess.Popen(["npm", "run", "serve"], stdout=f, stderr=f, cwd=cwd)
         # Wait a bit until server ready to receive connections.
         time.sleep(0.3)
         yield
@@ -73,20 +71,22 @@ def __init__(self, path: str = ""):
         super().__init__(path)
 
     def exists(self) -> bool:
-        p = subprocess.run(['stat', str(self)])
+        p = subprocess.run(["stat", str(self)])
         return p.returncode == 0
 
     def is_dir(self) -> bool:
-        p = subprocess.run(['stat', '-c', '%F', str(self)], capture_output=True, text=True)
-        return p.returncode == 0 and p.stdout.strip() == 'directory'
+        p = subprocess.run(["stat", "-c", "%F", str(self)], capture_output=True, text=True)
+        return p.returncode == 0 and p.stdout.strip() == "directory"
 
     def is_file(self) -> bool:
-        p = subprocess.run(['stat', '-c', '%F', str(self)], capture_output=True, text=True)
-        return p.returncode == 0 and p.stdout.strip() == 'regular file'
+        p = subprocess.run(["stat", "-c", "%F", str(self)], capture_output=True, text=True)
+        return p.returncode == 0 and p.stdout.strip() == "regular file"
 
     def iterdir(self):
-        p = subprocess.run(["ls", str(self), '-a', '-1'], capture_output=True, text=True, check=True)
-        for f in filter(lambda f: f not in ['', '.', '..'], re.split(r"\r?\n", p.stdout)):
+        p = subprocess.run(
+            ["ls", str(self), "-a", "-1"], capture_output=True, text=True, check=True
+        )
+        for f in filter(lambda f: f not in ["", ".", ".."], re.split(r"\r?\n", p.stdout)):
             yield MockPath(self / f)
 
     def mkdir(self, *, parents=False):
@@ -123,22 +123,22 @@ def subprocess_run(
     check: bool = False,
     cwd: str | MockPath | None = None,
     input: str | None = None,
-    text: bool | None = None
+    text: bool | None = None,
 ) -> subprocess.CompletedProcess:
     shell_run = "async obj => await window.cockle.shellRun(obj.cmd, obj.input)"
 
-    # Set cwd.
+    # Set cwd.
     if cwd is not None:
-        proc = page.evaluate(shell_run, { "cmd": "pwd" } )
-        if proc['returncode'] != 0:
+        proc = page.evaluate(shell_run, {"cmd": "pwd"})
+        if proc["returncode"] != 0:
             raise RuntimeError("Error getting pwd")
-        old_cwd = proc['stdout'].strip()
+        old_cwd = proc["stdout"].strip()
         if old_cwd == str(cwd):
             # cwd is already correct.
             cwd = None
         else:
-            proc = page.evaluate(shell_run, { "cmd": f"cd {cwd}" } )
-            if proc['returncode'] != 0:
+            proc = page.evaluate(shell_run, {"cmd": f"cd {cwd}"})
+            if proc["returncode"] != 0:
                 raise RuntimeError(f"Error setting cwd to {cwd}")
 
     def maybe_wrap_arg(s: str | MockPath) -> str:
@@ -146,47 +146,41 @@ def maybe_wrap_arg(s: str | MockPath) -> str:
         # to how the command is passed to cockle as a single string.
         # Could do better here.
         s = str(s)
-        if ' ' in s and not s.endswith("'"):
+        if " " in s and not s.endswith("'"):
             return "'" + s + "'"
         return s
 
-    shell_run_args = {
-        "cmd": " ".join([maybe_wrap_arg(s) for s in cmd]),
-        "input": input
-    }
+    shell_run_args = {"cmd": " ".join([maybe_wrap_arg(s) for s in cmd]), "input": input}
     proc = page.evaluate(shell_run, shell_run_args)
 
     # TypeScript object is auto converted to Python dict.
     # Want to return subprocess.CompletedProcess, consider namedtuple if this fails in future.
-    returncode = proc['returncode']
-    stdout = proc['stdout'] if capture_output else ''
-    stderr = proc['stderr'] if capture_output else ''
+    returncode = proc["returncode"]
+    stdout = proc["stdout"] if capture_output else ""
+    stderr = proc["stderr"] if capture_output else ""
     if not text:
         stdout = stdout.encode("utf-8")
         stderr = stderr.encode("utf-8")
 
     # Reset cwd.
     if cwd is not None:
-        proc = page.evaluate(shell_run, { "cmd": "cd " + old_cwd } )
-        if proc['returncode'] != 0:
+        proc = page.evaluate(shell_run, {"cmd": "cd " + old_cwd})
+        if proc["returncode"] != 0:
             raise RuntimeError(f"Error setting cwd to {old_cwd}")
 
     if check and returncode != 0:
         raise subprocess.CalledProcessError(returncode, cmd, stdout, stderr)
 
     return subprocess.CompletedProcess(
-        args=cmd,
-        returncode=returncode,
-        stdout=stdout,
-        stderr=stderr
+        args=cmd, returncode=returncode, stdout=stdout, stderr=stderr
     )
 
 
 @pytest.fixture(scope="function")
 def tmp_path() -> MockPath:
     # Assumes only one tmp_path needed per test.
-    path = MockPath('/drive/tmp0')
-    subprocess.run(['mkdir', str(path)], check=True)
+    path = MockPath("/drive/tmp0")
+    subprocess.run(["mkdir", str(path)], check=True)
     assert path.exists()
     assert path.is_dir()
     return path
diff --git a/test/test_branch.py b/test/test_branch.py
index 8c32cb6..967cf91 100644
--- a/test/test_branch.py
+++ b/test/test_branch.py
@@ -1,7 +1,5 @@
 import subprocess
 
-import pytest
-
 
 def test_branch_list(repo_init_with_commit, git2cpp_path, tmp_path):
     assert (tmp_path / "initial.txt").exists()
@@ -112,9 +110,7 @@ def test_branch_create_force_overwrite(
     # Add a second commit so HEAD moves forward
     (tmp_path / "second.txt").write_text("second")
     subprocess.run([git2cpp_path, "add", "second.txt"], cwd=tmp_path, check=True)
-    subprocess.run(
-        [git2cpp_path, "commit", "-m", "Second commit"], cwd=tmp_path, check=True
-    )
+    subprocess.run([git2cpp_path, "commit", "-m", "Second commit"], cwd=tmp_path, check=True)
 
     # Without --force this would fail; with -f it should reset the branch to current HEAD
     cmd = [git2cpp_path, "branch", "-f", "my-branch"]
@@ -163,15 +159,11 @@ def test_branch_show_current(repo_init_with_commit, git2cpp_path, tmp_path):
     assert p.stdout.strip() == "main"
 
 
-def test_branch_show_current_after_create_and_switch(
-    repo_init_with_commit, git2cpp_path, tmp_path
-):
+def test_branch_show_current_after_create_and_switch(repo_init_with_commit, git2cpp_path, tmp_path):
     """--show-current reflects the branch we switched to."""
     assert (tmp_path / "initial.txt").exists()
 
-    subprocess.run(
-        [git2cpp_path, "checkout", "-b", "new-feature"], cwd=tmp_path, check=True
-    )
+    subprocess.run([git2cpp_path, "checkout", "-b", "new-feature"], cwd=tmp_path, check=True)
 
     cmd = [git2cpp_path, "branch", "--show-current"]
     p = subprocess.run(cmd, capture_output=True, cwd=tmp_path, text=True)
@@ -179,9 +171,7 @@ def test_branch_show_current_after_create_and_switch(
     assert p.stdout == "new-feature\n"
 
 
-def test_branch_show_current_detached_head(
-    repo_init_with_commit, git2cpp_path, tmp_path
-):
+def test_branch_show_current_detached_head(repo_init_with_commit, git2cpp_path, tmp_path):
     """--show-current prints nothing when HEAD is detached."""
     assert (tmp_path / "initial.txt").exists()
 
diff --git a/test/test_checkout.py b/test/test_checkout.py
index 3383c9a..8f7c740 100644
--- a/test/test_checkout.py
+++ b/test/test_checkout.py
@@ -11,9 +11,7 @@ def test_checkout(repo_init_with_commit, git2cpp_path, tmp_path):
     assert p_create.returncode == 0
 
     checkout_cmd = [git2cpp_path, "checkout", "foregone"]
-    p_checkout = subprocess.run(
-        checkout_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_checkout = subprocess.run(checkout_cmd, capture_output=True, cwd=tmp_path, text=True)
     assert p_checkout.returncode == 0
     assert "Switched to branch 'foregone'" in p_checkout.stdout
 
@@ -23,9 +21,7 @@ def test_checkout(repo_init_with_commit, git2cpp_path, tmp_path):
     assert p_branch.stdout == "* foregone\n  main\n"
 
     checkout_cmd[2] = "main"
-    p_checkout2 = subprocess.run(
-        checkout_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_checkout2 = subprocess.run(checkout_cmd, capture_output=True, cwd=tmp_path, text=True)
     assert p_checkout2.returncode == 0
     assert "Switched to branch 'main'" in p_checkout2.stdout
 
@@ -34,9 +30,7 @@ def test_checkout_b(repo_init_with_commit, git2cpp_path, tmp_path):
     assert (tmp_path / "initial.txt").exists()
 
     checkout_cmd = [git2cpp_path, "checkout", "-b", "foregone"]
-    p_checkout = subprocess.run(
-        checkout_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_checkout = subprocess.run(checkout_cmd, capture_output=True, cwd=tmp_path, text=True)
     assert p_checkout.returncode == 0
     assert "Switched to a new branch 'foregone'" in p_checkout.stdout
 
@@ -66,9 +60,7 @@ def test_checkout_B_force_create(repo_init_with_commit, git2cpp_path, tmp_path):
 
     # Use -B to reset it (should not fail even if branch exists)
     checkout_cmd = [git2cpp_path, "checkout", "-B", "resetme"]
-    p_checkout = subprocess.run(
-        checkout_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_checkout = subprocess.run(checkout_cmd, capture_output=True, cwd=tmp_path, text=True)
     assert p_checkout.returncode == 0
     assert "Switched to a new branch 'resetme'" in p_checkout.stdout
 
@@ -85,9 +77,7 @@ def test_checkout_invalid_branch(repo_init_with_commit, git2cpp_path, tmp_path):
 
     # Try to checkout non-existent branch
     checkout_cmd = [git2cpp_path, "checkout", "nonexistent"]
-    p_checkout = subprocess.run(
-        checkout_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_checkout = subprocess.run(checkout_cmd, capture_output=True, cwd=tmp_path, text=True)
 
     # Should fail with error message
     assert p_checkout.returncode != 0
@@ -109,9 +99,7 @@ def test_checkout_with_unstaged_changes(repo_init_with_commit, git2cpp_path, tmp
 
     # Checkout - should succeed and show the modified file status
     checkout_cmd = [git2cpp_path, "checkout", "newbranch"]
-    p_checkout = subprocess.run(
-        checkout_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_checkout = subprocess.run(checkout_cmd, capture_output=True, cwd=tmp_path, text=True)
 
     # Should succeed and show status
     assert p_checkout.returncode == 0
@@ -143,9 +131,7 @@ def test_checkout_refuses_overwrite(
 
     # Switch back to default branch
     checkout_default_cmd = [git2cpp_path, "checkout", "main"]
-    p_default = subprocess.run(
-        checkout_default_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_default = subprocess.run(checkout_default_cmd, capture_output=True, cwd=tmp_path, text=True)
     assert p_default.returncode == 0
 
     # Now modify initial.txt locally (unstaged) on default branch
@@ -156,9 +142,7 @@ def test_checkout_refuses_overwrite(
     if force_flag != "":
         checkout_cmd.append(force_flag)
     checkout_cmd.append("newbranch")
-    p_checkout = subprocess.run(
-        checkout_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_checkout = subprocess.run(checkout_cmd, capture_output=True, cwd=tmp_path, text=True)
 
     if force_flag == "":
         assert p_checkout.returncode != 0
@@ -174,16 +158,12 @@ def test_checkout_refuses_overwrite(
 
         # Verify we're still on default branch (didn't switch)
         branch_cmd = [git2cpp_path, "branch"]
-        p_branch = subprocess.run(
-            branch_cmd, capture_output=True, cwd=tmp_path, text=True
-        )
+        p_branch = subprocess.run(branch_cmd, capture_output=True, cwd=tmp_path, text=True)
         assert "* main" in p_branch.stdout
     else:
         assert "Switched to branch 'newbranch'" in p_checkout.stdout
 
         # Verify we switched to newbranch
         branch_cmd = [git2cpp_path, "branch"]
-        p_branch = subprocess.run(
-            branch_cmd, capture_output=True, cwd=tmp_path, text=True
-        )
+        p_branch = subprocess.run(branch_cmd, capture_output=True, cwd=tmp_path, text=True)
         assert "* newbranch" in p_branch.stdout
diff --git a/test/test_clone.py b/test/test_clone.py
index 63cb405..eaa4422 100644
--- a/test/test_clone.py
+++ b/test/test_clone.py
@@ -48,12 +48,12 @@ def test_clone_shallow(git2cpp_path, tmp_path, run_in_tmp_path):
 @pytest.mark.parametrize("protocol", ["http", "https"])
 def test_clone_private_repo(git2cpp_path, tmp_path, run_in_tmp_path, private_test_repo, protocol):
     # Succeeds with correct credentials.
-    # Note that http succeeds by redirecting to https.
+    # Note that http succeeds by redirecting to https.
     username = "abc"  # Can be any non-empty string.
-    password = private_test_repo['token']
+    password = private_test_repo["token"]
     input = f"{username}\n{password}"
-    repo_path = tmp_path / private_test_repo['repo_name']
-    url = private_test_repo['https_url' if protocol == 'https' else 'http_url']
+    repo_path = tmp_path / private_test_repo["repo_name"]
+    url = private_test_repo["https_url" if protocol == "https" else "http_url"]
 
     clone_cmd = [git2cpp_path, "clone", url]
     p_clone = subprocess.run(clone_cmd, capture_output=True, text=True, input=input)
@@ -71,15 +71,15 @@ def test_clone_private_repo(git2cpp_path, tmp_path, run_in_tmp_path, private_tes
 
 
 def test_clone_private_repo_fails_then_succeeds(
-        git2cpp_path, tmp_path, run_in_tmp_path, private_test_repo
+    git2cpp_path, tmp_path, run_in_tmp_path, private_test_repo
 ):
     # Fails with wrong credentials, then succeeds with correct ones.
     username = "xyz"  # Can be any non-empty string.
-    password = private_test_repo['token']
+    password = private_test_repo["token"]
     input = "\n".join(["wrong1", "wrong2", username, password])
-    repo_path = tmp_path / private_test_repo['repo_name']
+    repo_path = tmp_path / private_test_repo["repo_name"]
 
-    clone_cmd = [git2cpp_path, "clone", private_test_repo['https_url']]
+    clone_cmd = [git2cpp_path, "clone", private_test_repo["https_url"]]
     p_clone = subprocess.run(clone_cmd, capture_output=True, text=True, input=input)
     assert p_clone.returncode == 0
     assert repo_path.exists()
@@ -98,9 +98,9 @@ def test_clone_private_repo_fails_on_no_username(
     git2cpp_path, tmp_path, run_in_tmp_path, private_test_repo
 ):
     input = ""
-    repo_path = tmp_path / private_test_repo['repo_name']
+    repo_path = tmp_path / private_test_repo["repo_name"]
 
-    clone_cmd = [git2cpp_path, "clone", private_test_repo['https_url']]
+    clone_cmd = [git2cpp_path, "clone", private_test_repo["https_url"]]
     p_clone = subprocess.run(clone_cmd, capture_output=True, text=True, input=input)
 
     assert p_clone.returncode != 0
@@ -114,9 +114,9 @@ def test_clone_private_repo_fails_on_no_password(
     git2cpp_path, tmp_path, run_in_tmp_path, private_test_repo
 ):
     input = "username\n"  # Note no password after the \n
-    repo_path = tmp_path / private_test_repo['repo_name']
+    repo_path = tmp_path / private_test_repo["repo_name"]
 
-    clone_cmd = [git2cpp_path, "clone", private_test_repo['https_url']]
+    clone_cmd = [git2cpp_path, "clone", private_test_repo["https_url"]]
     p_clone = subprocess.run(clone_cmd, capture_output=True, text=True, input=input)
 
     assert p_clone.returncode != 0
diff --git a/test/test_commit.py b/test/test_commit.py
index 1e1c4a0..91c67b5 100644
--- a/test/test_commit.py
+++ b/test/test_commit.py
@@ -28,9 +28,7 @@ def test_commit(commit_env_config, git2cpp_path, tmp_path, all_flag):
     assert p_commit.returncode == 0
 
     cmd_status_2 = [git2cpp_path, "status", "--long"]
-    p_status_2 = subprocess.run(
-        cmd_status_2, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_status_2 = subprocess.run(cmd_status_2, capture_output=True, cwd=tmp_path, text=True)
     assert p_status_2.returncode == 0
     assert "mook_file" not in p_status_2.stdout
 
@@ -50,9 +48,7 @@ def test_commit_message_via_stdin(
     assert p_add.returncode == 0
 
     cmd_commit = [git2cpp_path, "commit"]
-    p_commit = subprocess.run(
-        cmd_commit, text=True, capture_output=True, input=commit_msg
-    )
+    p_commit = subprocess.run(cmd_commit, text=True, capture_output=True, input=commit_msg)
 
     if commit_msg == "":
         # No commit message
diff --git a/test/test_config.py b/test/test_config.py
index f734042..0c5b7f6 100644
--- a/test/test_config.py
+++ b/test/test_config.py
@@ -1,7 +1,5 @@
 import subprocess
 
-import pytest
-
 
 def test_config_list(commit_env_config, git2cpp_path, tmp_path):
     cmd_init = [git2cpp_path, "init", "--bare", str(tmp_path)]
diff --git a/test/test_diff.py b/test/test_diff.py
index c0f907f..e17686d 100644
--- a/test/test_diff.py
+++ b/test/test_diff.py
@@ -1,6 +1,5 @@
 import re
 import subprocess
-from sys import stderr
 
 import pytest
 
@@ -43,9 +42,7 @@ def test_diff_cached(repo_init_with_commit, git2cpp_path, tmp_path, cached_flag)
     assert "+Hello, world!" in p_diff.stdout
 
 
-def test_diff_two_commits(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
-):
+def test_diff_two_commits(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
     assert (tmp_path / "initial.txt").exists()
 
     new_file = tmp_path / "new_file.txt"
@@ -192,17 +189,13 @@ def test_diff_reverse(repo_init_with_commit, git2cpp_path, tmp_path):
     assert "+Added line" in p_normal.stdout
 
     cmd_reverse = [git2cpp_path, "diff", "-R"]
-    p_reverse = subprocess.run(
-        cmd_reverse, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_reverse = subprocess.run(cmd_reverse, capture_output=True, cwd=tmp_path, text=True)
     assert p_reverse.returncode == 0
     assert "-Added line" in p_reverse.stdout
 
 
 @pytest.mark.parametrize("text_flag", ["-a", "--text"])
-def test_diff_text(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path, text_flag
-):
+def test_diff_text(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path, text_flag):
     """Test diff with -a/--text (treat all files as text)"""
     assert (tmp_path / "initial.txt").exists()
 
@@ -372,9 +365,7 @@ def test_diff_unified_context(
         assert "Line 8" not in p.stdout or p.stdout.count("Line 8") == 0
 
 
-def test_diff_inter_hunk_context(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
-):
+def test_diff_inter_hunk_context(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
     """Test diff with --inter-hunk-context"""
     assert (tmp_path / "initial.txt").exists()
 
@@ -404,9 +395,9 @@ def test_diff_inter_hunk_context(
     # Count hunks in small context output
     hunk_count_small = len(
         [
-            l
-            for l in p_small.stdout.split("\n")
-            if l.startswith("@@") and l.endswith("@@")
+            line
+            for line in p_small.stdout.split("\n")
+            if line.startswith("@@") and line.endswith("@@")
         ]
     )
 
@@ -421,9 +412,9 @@ def test_diff_inter_hunk_context(
     # Count hunks in large context output
     hunk_count_large = len(
         [
-            l
-            for l in p_large.stdout.split("\n")
-            if l.startswith("@@") and l.endswith("@@")
+            line
+            for line in p_large.stdout.split("\n")
+            if line.startswith("@@") and line.endswith("@@")
         ]
     )
 
@@ -455,9 +446,7 @@ def test_diff_abbrev(repo_init_with_commit, commit_env_config, git2cpp_path, tmp
 
     # Test default --abbrev
     cmd_default = [git2cpp_path, "diff", "--abbrev"]
-    p_default = subprocess.run(
-        cmd_default, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_default = subprocess.run(cmd_default, capture_output=True, cwd=tmp_path, text=True)
     assert p_default.returncode == 0
     assert "test.txt" in p_default.stdout
 
@@ -489,9 +478,7 @@ def test_diff_abbrev(repo_init_with_commit, commit_env_config, git2cpp_path, tmp
 
 
 # Note: only checking if the output is a diff
-def test_diff_patience(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
-):
+def test_diff_patience(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
     """Test diff with --patience algorithm"""
     assert (tmp_path / "initial.txt").exists()
 
@@ -573,9 +560,7 @@ def test_diff_find_renames(repo_init_with_commit, git2cpp_path, tmp_path, rename
     assert "rename to new.txt" in p.stdout
 
 
-def test_diff_find_renames_with_threshold(
-    repo_init_with_commit, git2cpp_path, tmp_path
-):
+def test_diff_find_renames_with_threshold(repo_init_with_commit, git2cpp_path, tmp_path):
     """Test diff with -M with threshold value"""
     assert (tmp_path / "initial.txt").exists()
 
@@ -724,9 +709,7 @@ def test_diff_find_copies_with_threshold(
 #     assert p.returncode == 0
 
 
-def test_diff_refuses_more_than_two_treeish(
-    repo_init_with_commit, git2cpp_path, tmp_path
-):
+def test_diff_refuses_more_than_two_treeish(repo_init_with_commit, git2cpp_path, tmp_path):
     # HEAD exists thanks to repo_init_with_commit
     p = subprocess.run(
         [git2cpp_path, "diff", "HEAD", "HEAD", "HEAD"],
diff --git a/test/test_fetch.py b/test/test_fetch.py
index 6cfb9a5..4e30a14 100644
--- a/test/test_fetch.py
+++ b/test/test_fetch.py
@@ -4,20 +4,20 @@
 
 @pytest.mark.parametrize("protocol", ["http", "https"])
 def test_fetch_private_repo(git2cpp_path, tmp_path, run_in_tmp_path, private_test_repo, protocol):
-    # Note that http succeeds by redirecting to https.
+    # Note that http succeeds by redirecting to https.
     init_cmd = [git2cpp_path, "init", "."]
     p_init = subprocess.run(init_cmd, capture_output=True, text=True)
     assert p_init.returncode == 0
     assert (tmp_path / ".git").exists()
 
-    url = private_test_repo['https_url' if protocol == 'https' else 'http_url']
+    url = private_test_repo["https_url" if protocol == "https" else "http_url"]
     remote_cmd = [git2cpp_path, "remote", "add", "origin", url]
     p_remote = subprocess.run(remote_cmd, capture_output=True, text=True)
     assert p_remote.returncode == 0
 
     # First fetch with wrong password which fails, then correct password which succeeds.
     username = "abc"  # Can be any non-empty string.
-    password = private_test_repo['token']
+    password = private_test_repo["token"]
     input = f"{username}\nwrong_password\n{username}\n{password}"
     fetch_cmd = [git2cpp_path, "fetch", "origin"]
     p_fetch = subprocess.run(fetch_cmd, capture_output=True, text=True, input=input)
diff --git a/test/test_fixtures.py b/test/test_fixtures.py
index c8c0c04..a982d45 100644
--- a/test/test_fixtures.py
+++ b/test/test_fixtures.py
@@ -6,12 +6,12 @@
 
 
 def test_run_in_tmp_path(tmp_path, run_in_tmp_path):
-    p = subprocess.run(['pwd'], capture_output=True, text=True, check=True)
+    p = subprocess.run(["pwd"], capture_output=True, text=True, check=True)
     assert p.stdout.strip() == str(tmp_path)
 
 
 def test_tmp_path(tmp_path):
-    p = subprocess.run(['pwd'], capture_output=True, text=True, check=True, cwd=str(tmp_path))
+    p = subprocess.run(["pwd"], capture_output=True, text=True, check=True, cwd=str(tmp_path))
     assert p.stdout.strip() == str(tmp_path)
 
     assert tmp_path.exists()
@@ -19,19 +19,19 @@ def test_tmp_path(tmp_path):
     assert not tmp_path.is_file()
 
     assert sorted(tmp_path.iterdir()) == []
-    subprocess.run(['mkdir', f"{tmp_path}/def"], capture_output=True, text=True, check=True)
-    assert sorted(tmp_path.iterdir()) == [tmp_path / 'def']
-    subprocess.run(['mkdir', f"{tmp_path}/abc"], capture_output=True, text=True, check=True)
-    assert sorted(tmp_path.iterdir()) == [tmp_path / 'abc', tmp_path / 'def']
+    subprocess.run(["mkdir", f"{tmp_path}/def"], capture_output=True, text=True, check=True)
+    assert sorted(tmp_path.iterdir()) == [tmp_path / "def"]
+    subprocess.run(["mkdir", f"{tmp_path}/abc"], capture_output=True, text=True, check=True)
+    assert sorted(tmp_path.iterdir()) == [tmp_path / "abc", tmp_path / "def"]
 
-    p = subprocess.run(['pwd'], capture_output=True, text=True, check=True, cwd=tmp_path.parent)
+    p = subprocess.run(["pwd"], capture_output=True, text=True, check=True, cwd=tmp_path.parent)
     assert p.stdout.strip() == str(tmp_path.parent)
     assert tmp_path in list(tmp_path.parent.iterdir())
 
 
 def test_env_vars():
     # By default there should be not GIT_* env vars set.
-    p = subprocess.run(['env'], capture_output=True, text=True, check=True)
+    p = subprocess.run(["env"], capture_output=True, text=True, check=True)
     git_lines = sorted(filter(lambda f: f.startswith("GIT_"), re.split(r"\r?\n", p.stdout)))
     if GIT2CPP_TEST_WASM:
         assert git_lines == ["GIT_CORS_PROXY=http://localhost:8881/"]
diff --git a/test/test_git.py b/test/test_git.py
index 50a954e..212ae94 100644
--- a/test/test_git.py
+++ b/test/test_git.py
@@ -4,21 +4,21 @@
 from .conftest import GIT2CPP_TEST_WASM
 
 
-@pytest.mark.parametrize("arg", ['-v', '--version'])
+@pytest.mark.parametrize("arg", ["-v", "--version"])
 def test_version(git2cpp_path, arg):
     cmd = [git2cpp_path, arg]
     p = subprocess.run(cmd, capture_output=True)
     assert p.returncode == 0
-    assert p.stderr == b''
-    assert p.stdout.startswith(b'git2cpp version ')
-    assert p.stdout.count(b'\n') == 1
+    assert p.stderr == b""
+    assert p.stdout.startswith(b"git2cpp version ")
+    assert p.stdout.count(b"\n") == 1
 
 
 def test_error_on_unknown_option(git2cpp_path):
-    cmd = [git2cpp_path, '--unknown']
+    cmd = [git2cpp_path, "--unknown"]
     p = subprocess.run(cmd, capture_output=True)
     assert p.returncode == 109
-    assert p.stdout == b''
+    assert p.stdout == b""
     assert p.stderr.startswith(b"The following argument was not expected: --unknown")
 
 
diff --git a/test/test_log.py b/test/test_log.py
index 5cc3eb1..7a33609 100644
--- a/test/test_log.py
+++ b/test/test_log.py
@@ -59,9 +59,7 @@ def test_max_count(
     subprocess.run(cmd_add2, capture_output=True, cwd=tmp_path, text=True, check=True)
 
     cmd_commit2 = [git2cpp_path, "commit", "-m", "Second commit"]
-    subprocess.run(
-        cmd_commit2, capture_output=True, cwd=tmp_path, text=True, check=True
-    )
+    subprocess.run(cmd_commit2, capture_output=True, cwd=tmp_path, text=True, check=True)
 
     p3 = tmp_path / "third.txt"
     p3.write_text("third file")
@@ -70,9 +68,7 @@ def test_max_count(
     subprocess.run(cmd_add3, capture_output=True, cwd=tmp_path, text=True, check=True)
 
     cmd_commit3 = [git2cpp_path, "commit", "-m", "Third commit"]
-    subprocess.run(
-        cmd_commit3, capture_output=True, cwd=tmp_path, text=True, check=True
-    )
+    subprocess.run(cmd_commit3, capture_output=True, cwd=tmp_path, text=True, check=True)
 
     cmd_log = [git2cpp_path, "log"]
     if max_count_flag != "":
@@ -87,9 +83,7 @@ def test_max_count(
         assert p_log.stdout.count("Author") == 2
 
 
-def test_log_with_head_reference(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
-):
+def test_log_with_head_reference(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
     """Test that HEAD reference is shown on the latest commit."""
     assert (tmp_path / "initial.txt").exists()
 
@@ -98,9 +92,7 @@ def test_log_with_head_reference(
     p.write_text("test content")
 
     subprocess.run([git2cpp_path, "add", "test_file.txt"], cwd=tmp_path, check=True)
-    subprocess.run(
-        [git2cpp_path, "commit", "-m", "test commit"], cwd=tmp_path, check=True
-    )
+    subprocess.run([git2cpp_path, "commit", "-m", "test commit"], cwd=tmp_path, check=True)
 
     # Run log with max count 1 to get only the latest commit
     p_log = subprocess.run(
@@ -124,9 +116,7 @@ def test_log_with_tag(commit_env_config, git2cpp_path, tmp_path):
     p.write_text("tagged content")
 
     subprocess.run([git2cpp_path, "add", "tagged_file.txt"], cwd=tmp_path, check=True)
-    subprocess.run(
-        [git2cpp_path, "commit", "-m", "tagged commit"], cwd=tmp_path, check=True
-    )
+    subprocess.run([git2cpp_path, "commit", "-m", "tagged commit"], cwd=tmp_path, check=True)
 
     # Create a tag (using git command since git2cpp might not have tag creation yet)
     subprocess.run([git2cpp_path, "tag", "v1.0.0"], cwd=tmp_path, check=True)
@@ -151,12 +141,8 @@ def test_log_with_multiple_tags(commit_env_config, git2cpp_path, tmp_path):
     p = tmp_path / "multi_tag_file.txt"
     p.write_text("content")
 
-    subprocess.run(
-        [git2cpp_path, "add", "multi_tag_file.txt"], cwd=tmp_path, check=True
-    )
-    subprocess.run(
-        [git2cpp_path, "commit", "-m", "multi tag commit"], cwd=tmp_path, check=True
-    )
+    subprocess.run([git2cpp_path, "add", "multi_tag_file.txt"], cwd=tmp_path, check=True)
+    subprocess.run([git2cpp_path, "commit", "-m", "multi tag commit"], cwd=tmp_path, check=True)
 
     # Create multiple tags
     subprocess.run([git2cpp_path, "tag", "v1.0.0"], cwd=tmp_path, check=True)
@@ -185,12 +171,8 @@ def test_log_with_annotated_tag(commit_env_config, git2cpp_path, tmp_path):
     p = tmp_path / "annotated_tag_file.txt"
     p.write_text("content")
 
-    subprocess.run(
-        [git2cpp_path, "add", "annotated_tag_file.txt"], cwd=tmp_path, check=True
-    )
-    subprocess.run(
-        [git2cpp_path, "commit", "-m", "annotated tag commit"], cwd=tmp_path, check=True
-    )
+    subprocess.run([git2cpp_path, "add", "annotated_tag_file.txt"], cwd=tmp_path, check=True)
+    subprocess.run([git2cpp_path, "commit", "-m", "annotated tag commit"], cwd=tmp_path, check=True)
 
     # Create an annotated tag
     subprocess.run(
@@ -220,9 +202,7 @@ def test_log_with_branch(commit_env_config, git2cpp_path, tmp_path):
     p.write_text("content")
 
     subprocess.run([git2cpp_path, "add", "branch_file.txt"], cwd=tmp_path, check=True)
-    subprocess.run(
-        [git2cpp_path, "commit", "-m", "branch commit"], cwd=tmp_path, check=True
-    )
+    subprocess.run([git2cpp_path, "commit", "-m", "branch commit"], cwd=tmp_path, check=True)
 
     # Create a new branch pointing to HEAD
     subprocess.run([git2cpp_path, "branch", "feature-branch"], cwd=tmp_path, check=True)
@@ -264,9 +244,7 @@ def test_log_commit_without_references(commit_env_config, git2cpp_path, tmp_path
         p = tmp_path / f"file_{i}.txt"
         p.write_text(f"content {i}")
         subprocess.run([git2cpp_path, "add", f"file_{i}.txt"], cwd=tmp_path, check=True)
-        subprocess.run(
-            [git2cpp_path, "commit", "-m", f"commit {i}"], cwd=tmp_path, check=True
-        )
+        subprocess.run([git2cpp_path, "commit", "-m", f"commit {i}"], cwd=tmp_path, check=True)
 
     # Run log with 2 commits
     p_log = subprocess.run(
@@ -276,20 +254,18 @@ def test_log_commit_without_references(commit_env_config, git2cpp_path, tmp_path
 
     # First commit line should have references
     lines = p_log.stdout.split("\n")
-    first_commit_line = [l for l in lines if l.startswith("commit")][0]
+    first_commit_line = [line for line in lines if line.startswith("commit")][0]
     assert "(" in first_commit_line  # Has references
 
     # Second commit (older one) should not have empty parentheses
-    second_commit_line = [l for l in lines if l.startswith("commit")][1]
+    second_commit_line = [line for line in lines if line.startswith("commit")][1]
     # Should either have no parentheses or have actual references
     if "(" in second_commit_line:
         # If it has parentheses, they shouldn't be empty
         assert "()" not in second_commit_line
 
 
-@pytest.mark.parametrize(
-    "abbrev_commit_flag", ["", "--abbrev-commit", "--no-abbrev-commit"]
-)
+@pytest.mark.parametrize("abbrev_commit_flag", ["", "--abbrev-commit", "--no-abbrev-commit"])
 @pytest.mark.parametrize("abbrev_flag", ["", "--abbrev=10"])
 def test_log_abbrev_commit_flags(
     repo_init_with_commit,
@@ -360,9 +336,7 @@ def test_log_oneline(repo_init_with_commit, git2cpp_path, tmp_path):
     full_sha = str(p.stdout.strip())
     abbrev7 = full_sha[:7]
 
-    subprocess.run(
-        [git2cpp_path, "tag", "v1"], capture_output=True, cwd=tmp_path, check=True
-    )
+    subprocess.run([git2cpp_path, "tag", "v1"], capture_output=True, cwd=tmp_path, check=True)
 
     p = subprocess.run(
         [git2cpp_path, "log", "--oneline", "-n", "1"],
diff --git a/test/test_merge.py b/test/test_merge.py
index f6d36a3..4540e2c 100644
--- a/test/test_merge.py
+++ b/test/test_merge.py
@@ -5,15 +5,11 @@
 
 # TODO: Have a different "person" for the commit and for the merge
 # TODO: Test "unborn" case, but how ?
-def test_merge_fast_forward(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
-):
+def test_merge_fast_forward(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
     assert (tmp_path / "initial.txt").exists()
 
     checkout_cmd = [git2cpp_path, "checkout", "-b", "foregone"]
-    p_checkout = subprocess.run(
-        checkout_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_checkout = subprocess.run(checkout_cmd, capture_output=True, cwd=tmp_path, text=True)
     assert p_checkout.returncode == 0
 
     file_path = tmp_path / "mook_file.txt"
@@ -28,9 +24,7 @@ def test_merge_fast_forward(
     assert p_commit.returncode == 0
 
     checkout_cmd_2 = [git2cpp_path, "checkout", "main"]
-    p_checkout_2 = subprocess.run(
-        checkout_cmd_2, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_checkout_2 = subprocess.run(checkout_cmd_2, capture_output=True, cwd=tmp_path, text=True)
     assert p_checkout_2.returncode == 0
 
     merge_cmd = [git2cpp_path, "merge", "foregone"]
@@ -46,9 +40,7 @@ def test_merge_fast_forward(
     assert (tmp_path / "mook_file.txt").exists()
 
     merge_cmd_2 = [git2cpp_path, "merge", "foregone"]
-    p_merge_2 = subprocess.run(
-        merge_cmd_2, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_merge_2 = subprocess.run(merge_cmd_2, capture_output=True, cwd=tmp_path, text=True)
     assert p_merge_2.returncode == 0
     assert p_merge_2.stdout == "Already up-to-date\n"
 
@@ -57,9 +49,7 @@ def test_merge_commit(repo_init_with_commit, commit_env_config, git2cpp_path, tm
     assert (tmp_path / "initial.txt").exists()
 
     checkout_cmd = [git2cpp_path, "checkout", "-b", "foregone"]
-    p_checkout = subprocess.run(
-        checkout_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_checkout = subprocess.run(checkout_cmd, capture_output=True, cwd=tmp_path, text=True)
     assert p_checkout.returncode == 0
 
     file_path = tmp_path / "mook_file.txt"
@@ -74,9 +64,7 @@ def test_merge_commit(repo_init_with_commit, commit_env_config, git2cpp_path, tm
     assert p_commit.returncode == 0
 
     checkout_cmd_2 = [git2cpp_path, "checkout", "main"]
-    p_checkout_2 = subprocess.run(
-        checkout_cmd_2, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_checkout_2 = subprocess.run(checkout_cmd_2, capture_output=True, cwd=tmp_path, text=True)
     assert p_checkout_2.returncode == 0
 
     file_path_2 = tmp_path / "mook_file_2.txt"
@@ -87,9 +75,7 @@ def test_merge_commit(repo_init_with_commit, commit_env_config, git2cpp_path, tm
     assert p_add_2.returncode == 0
 
     commit_cmd_2 = [git2cpp_path, "commit", "-m", "test commit master"]
-    p_commit_2 = subprocess.run(
-        commit_cmd_2, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_commit_2 = subprocess.run(commit_cmd_2, capture_output=True, cwd=tmp_path, text=True)
     assert p_commit_2.returncode == 0
 
     merge_cmd = [git2cpp_path, "merge", "foregone"]
@@ -106,23 +92,17 @@ def test_merge_commit(repo_init_with_commit, commit_env_config, git2cpp_path, tm
     assert (tmp_path / "mook_file_2.txt").exists()
 
     merge_cmd_2 = [git2cpp_path, "merge", "foregone"]
-    p_merge_2 = subprocess.run(
-        merge_cmd_2, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_merge_2 = subprocess.run(merge_cmd_2, capture_output=True, cwd=tmp_path, text=True)
     assert p_merge_2.returncode == 0
     assert p_merge_2.stdout == "Already up-to-date\n"
 
 
 @pytest.mark.parametrize("flag", ["--abort", "--quit", "--continue"])
-def test_merge_conflict(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path, flag
-):
+def test_merge_conflict(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path, flag):
     assert (tmp_path / "initial.txt").exists()
 
     checkout_cmd = [git2cpp_path, "checkout", "-b", "foregone"]
-    p_checkout = subprocess.run(
-        checkout_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_checkout = subprocess.run(checkout_cmd, capture_output=True, cwd=tmp_path, text=True)
     assert p_checkout.returncode == 0
 
     file_path = tmp_path / "mook_file.txt"
@@ -140,9 +120,7 @@ def test_merge_conflict(
     assert p_commit.returncode == 0
 
     checkout_cmd_2 = [git2cpp_path, "checkout", "main"]
-    p_checkout_2 = subprocess.run(
-        checkout_cmd_2, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_checkout_2 = subprocess.run(checkout_cmd_2, capture_output=True, cwd=tmp_path, text=True)
     assert p_checkout_2.returncode == 0
 
     file_path.write_text("BLABLABLA")
@@ -152,9 +130,7 @@ def test_merge_conflict(
     assert p_add_2.returncode == 0
 
     commit_cmd_2 = [git2cpp_path, "commit", "-m", "test commit master"]
-    p_commit_2 = subprocess.run(
-        commit_cmd_2, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_commit_2 = subprocess.run(commit_cmd_2, capture_output=True, cwd=tmp_path, text=True)
     assert p_commit_2.returncode == 0
 
     merge_cmd = [git2cpp_path, "merge", "foregone"]
@@ -209,9 +185,7 @@ def test_merge_conflict(
         p_add = subprocess.run(cmd_add, cwd=tmp_path, text=True)
         assert p_add.returncode == 0
 
-        p_continue = subprocess.run(
-            flag_cmd, capture_output=True, cwd=tmp_path, text=True
-        )
+        p_continue = subprocess.run(flag_cmd, capture_output=True, cwd=tmp_path, text=True)
         assert p_continue.returncode == 0
 
         log_cmd = [git2cpp_path, "log", "--format=full", "--max-count", "2"]
@@ -224,8 +198,6 @@ def test_merge_conflict(
         assert (tmp_path / "mook_file_2.txt").exists()
 
         merge_cmd_2 = [git2cpp_path, "merge", "foregone"]
-        p_merge_2 = subprocess.run(
-            merge_cmd_2, capture_output=True, cwd=tmp_path, text=True
-        )
+        p_merge_2 = subprocess.run(merge_cmd_2, capture_output=True, cwd=tmp_path, text=True)
         assert p_merge_2.returncode == 0
         assert p_merge_2.stdout == "Already up-to-date\n"
diff --git a/test/test_mv.py b/test/test_mv.py
index 86a0835..d491587 100644
--- a/test/test_mv.py
+++ b/test/test_mv.py
@@ -213,9 +213,7 @@ def test_mv_and_commit(commit_env_config, git2cpp_path, tmp_path):
 
     # Commit the move
     commit_cmd2 = [git2cpp_path, "commit", "-m", "Move file"]
-    p_commit2 = subprocess.run(
-        commit_cmd2, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_commit2 = subprocess.run(commit_cmd2, capture_output=True, cwd=tmp_path, text=True)
     assert p_commit2.returncode == 0
 
     # Verify the file is in the new location
diff --git a/test/test_push.py b/test/test_push.py
index 036ec16..313f201 100644
--- a/test/test_push.py
+++ b/test/test_push.py
@@ -2,17 +2,19 @@
 from uuid import uuid4
 
 
-def test_push_private_repo(git2cpp_path, tmp_path, run_in_tmp_path, private_test_repo, commit_env_config):
-    # Unique branch name to avoid branch name collisions on remote repo.
+def test_push_private_repo(
+    git2cpp_path, tmp_path, run_in_tmp_path, private_test_repo, commit_env_config
+):
+    # Unique branch name to avoid branch name collisions on remote repo.
     branch_name = f"test-{uuid4()}"
 
     # Start of test follows test_clone_private_repo, then creates a new local branch and pushes
     # that to the remote.
     username = "abc"  # Can be any non-empty string.
-    password = private_test_repo['token']
+    password = private_test_repo["token"]
     input = f"{username}\n{password}"
-    repo_path = tmp_path / private_test_repo['repo_name']
-    url = private_test_repo['https_url']
+    repo_path = tmp_path / private_test_repo["repo_name"]
+    url = private_test_repo["https_url"]
 
     clone_cmd = [git2cpp_path, "clone", url]
     p_clone = subprocess.run(clone_cmd, capture_output=True, text=True, input=input)
diff --git a/test/test_rebase.py b/test/test_rebase.py
index add183b..3a342ac 100644
--- a/test/test_rebase.py
+++ b/test/test_rebase.py
@@ -1,7 +1,5 @@
 import subprocess
 
-import pytest
-
 
 def test_rebase_basic(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
     """Test basic rebase operation with fast-forward"""
@@ -9,9 +7,7 @@ def test_rebase_basic(repo_init_with_commit, commit_env_config, git2cpp_path, tm
 
     # Create a feature branch
     checkout_cmd = [git2cpp_path, "checkout", "-b", "feature"]
-    p_checkout = subprocess.run(
-        checkout_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_checkout = subprocess.run(checkout_cmd, capture_output=True, cwd=tmp_path, text=True)
     assert p_checkout.returncode == 0
 
     # Create a commit on feature branch
@@ -41,9 +37,7 @@ def test_rebase_basic(repo_init_with_commit, commit_env_config, git2cpp_path, tm
     assert p_add_2.returncode == 0
 
     commit_cmd_2 = [git2cpp_path, "commit", "-m", "master commit"]
-    p_commit_2 = subprocess.run(
-        commit_cmd_2, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_commit_2 = subprocess.run(commit_cmd_2, capture_output=True, cwd=tmp_path, text=True)
     assert p_commit_2.returncode == 0
 
     # Switch to feature and rebase onto master
@@ -64,17 +58,13 @@ def test_rebase_basic(repo_init_with_commit, commit_env_config, git2cpp_path, tm
     assert (tmp_path / "master_file.txt").exists()
 
 
-def test_rebase_multiple_commits(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
-):
+def test_rebase_multiple_commits(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
     """Test rebase with multiple commits"""
     assert (tmp_path / "initial.txt").exists()
 
     # Create feature branch with multiple commits
     checkout_cmd = [git2cpp_path, "checkout", "-b", "feature"]
-    p_checkout = subprocess.run(
-        checkout_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_checkout = subprocess.run(checkout_cmd, capture_output=True, cwd=tmp_path, text=True)
     assert p_checkout.returncode == 0
 
     # First commit
@@ -127,9 +117,7 @@ def test_rebase_multiple_commits(
     assert (tmp_path / "master_file.txt").exists()
 
 
-def test_rebase_with_conflicts(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
-):
+def test_rebase_with_conflicts(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
     """Test rebase with conflicts"""
     assert (tmp_path / "initial.txt").exists()
 
@@ -198,9 +186,7 @@ def test_rebase_abort(repo_init_with_commit, commit_env_config, git2cpp_path, tm
     assert conflict_file.read_text() == "feature content"
 
 
-def test_rebase_continue(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
-):
+def test_rebase_continue(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
     """Test rebase continue after resolving conflicts"""
     assert (tmp_path / "initial.txt").exists()
 
@@ -229,9 +215,7 @@ def test_rebase_continue(
 
     # Continue rebase
     continue_cmd = [git2cpp_path, "rebase", "--continue"]
-    p_continue = subprocess.run(
-        continue_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_continue = subprocess.run(continue_cmd, capture_output=True, cwd=tmp_path, text=True)
     assert p_continue.returncode == 0
     assert "Successfully rebased" in p_continue.stdout
 
@@ -336,9 +320,7 @@ def test_rebase_onto(repo_init_with_commit, commit_env_config, git2cpp_path, tmp
     assert (tmp_path / "file2.txt").exists()
 
 
-def test_rebase_no_upstream_error(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
-):
+def test_rebase_no_upstream_error(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
     """Test that rebase without upstream argument fails"""
     assert (tmp_path / "initial.txt").exists()
 
@@ -403,13 +385,10 @@ def test_rebase_continue_without_rebase_error(
     assert (tmp_path / "initial.txt").exists()
 
     continue_cmd = [git2cpp_path, "rebase", "--continue"]
-    p_continue = subprocess.run(
-        continue_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_continue = subprocess.run(continue_cmd, capture_output=True, cwd=tmp_path, text=True)
     assert p_continue.returncode != 0
     assert (
-        "No rebase in progress" in p_continue.stderr
-        or "No rebase in progress" in p_continue.stdout
+        "No rebase in progress" in p_continue.stderr or "No rebase in progress" in p_continue.stdout
     )
 
 
@@ -437,11 +416,6 @@ def test_rebase_continue_with_unresolved_conflicts(
 
     # Try to continue without resolving
     continue_cmd = [git2cpp_path, "rebase", "--continue"]
-    p_continue = subprocess.run(
-        continue_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_continue = subprocess.run(continue_cmd, capture_output=True, cwd=tmp_path, text=True)
     assert p_continue.returncode != 0
-    assert (
-        "resolve conflicts" in p_continue.stderr
-        or "resolve conflicts" in p_continue.stdout
-    )
+    assert "resolve conflicts" in p_continue.stderr or "resolve conflicts" in p_continue.stdout
diff --git a/test/test_remote.py b/test/test_remote.py
index 3a83532..b818676 100644
--- a/test/test_remote.py
+++ b/test/test_remote.py
@@ -363,9 +363,7 @@ def test_unshallow(git2cpp_path, tmp_path, run_in_tmp_path):
     assert p_log.stdout.count("Author") == 1
 
     unshallow_cmd = [git2cpp_path, "fetch", "--unshallow"]
-    p_unshallow = subprocess.run(
-        unshallow_cmd, capture_output=True, cwd=xtl_path, text=True
-    )
+    p_unshallow = subprocess.run(unshallow_cmd, capture_output=True, cwd=xtl_path, text=True)
     assert p_unshallow.returncode == 0
 
     p_log_2 = subprocess.run(cmd_log, capture_output=True, cwd=xtl_path, text=True)
@@ -426,9 +424,7 @@ def test_push_local(xtl_clone, commit_env_config, git2cpp_path, tmp_path):
     xtl_path = tmp_path / "xtl"
 
     checkout_cmd = [git2cpp_path, "checkout", "-b", "foregone"]
-    p_checkout = subprocess.run(
-        checkout_cmd, capture_output=True, check=True, cwd=xtl_path
-    )
+    p_checkout = subprocess.run(checkout_cmd, capture_output=True, check=True, cwd=xtl_path)
     assert p_checkout.returncode == 0
 
     p = xtl_path / "mook_file.txt"
diff --git a/test/test_reset.py b/test/test_reset.py
index 12b52c7..fa4861e 100644
--- a/test/test_reset.py
+++ b/test/test_reset.py
@@ -1,7 +1,5 @@
 import subprocess
 
-import pytest
-
 
 def test_reset(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
     assert (tmp_path / "initial.txt").exists()
diff --git a/test/test_revlist.py b/test/test_revlist.py
index 56693a8..6b92b0e 100644
--- a/test/test_revlist.py
+++ b/test/test_revlist.py
@@ -1,7 +1,5 @@
 import subprocess
 
-import pytest
-
 
 def test_revlist(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
     assert (tmp_path / "initial.txt").exists()
@@ -19,7 +17,7 @@ def test_revlist(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_pat
     p = subprocess.run(cmd, capture_output=True, cwd=tmp_path, text=True)
     assert p.returncode == 0
 
-    lines = [l for l in p.stdout.splitlines() if l.strip()]
+    lines = [line for line in p.stdout.splitlines() if line.strip()]
     assert len(lines) == 2
     assert all(len(oid) == 40 for oid in lines)
     assert lines[0] != lines[1]
diff --git a/test/test_revparse.py b/test/test_revparse.py
index 5b72ab7..2e1bf24 100644
--- a/test/test_revparse.py
+++ b/test/test_revparse.py
@@ -1,7 +1,5 @@
 import subprocess
 
-import pytest
-
 
 def test_revparse_bare(git2cpp_path, tmp_path, run_in_tmp_path):
     # tmp_path exists and is empty.
diff --git a/test/test_rm.py b/test/test_rm.py
index 1fc1d52..718ca72 100644
--- a/test/test_rm.py
+++ b/test/test_rm.py
@@ -1,8 +1,5 @@
-import pathlib
 import subprocess
 
-import pytest
-
 
 def test_rm_basic_file(commit_env_config, git2cpp_path, tmp_path):
     """Test basic rm operation to remove a file"""
@@ -178,9 +175,7 @@ def test_rm_and_commit(commit_env_config, git2cpp_path, tmp_path):
 
     # Commit the removal
     commit_cmd2 = [git2cpp_path, "commit", "-m", "Remove file"]
-    p_commit2 = subprocess.run(
-        commit_cmd2, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_commit2 = subprocess.run(commit_cmd2, capture_output=True, cwd=tmp_path, text=True)
     assert p_commit2.returncode == 0
 
     # Verify the file is gone
@@ -188,9 +183,7 @@ def test_rm_and_commit(commit_env_config, git2cpp_path, tmp_path):
 
     # Check status after commit
     status_cmd2 = [git2cpp_path, "status", "--long"]
-    p_status2 = subprocess.run(
-        status_cmd2, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_status2 = subprocess.run(status_cmd2, capture_output=True, cwd=tmp_path, text=True)
     assert p_status2.returncode == 0
     assert "to_remove.txt" not in p_status2.stdout
 
diff --git a/test/test_stash.py b/test/test_stash.py
index b4b161c..d99813b 100644
--- a/test/test_stash.py
+++ b/test/test_stash.py
@@ -47,9 +47,7 @@ def test_stash_list(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_
 
 
 @pytest.mark.parametrize("index_flag", ["", "--index"])
-def test_stash_pop(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path, index_flag
-):
+def test_stash_pop(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path, index_flag):
     assert (tmp_path / "initial.txt").exists()
 
     index = 0 if index_flag == "" else 1
@@ -63,15 +61,11 @@ def test_stash_pop(
         assert p_add.returncode == 0
 
         cmd_stash = [git2cpp_path, "stash"]
-        p_stash = subprocess.run(
-            cmd_stash, capture_output=True, cwd=tmp_path, text=True
-        )
+        p_stash = subprocess.run(cmd_stash, capture_output=True, cwd=tmp_path, text=True)
         assert p_stash.returncode == 0
 
         cmd_status = [git2cpp_path, "status"]
-        p_status = subprocess.run(
-            cmd_status, capture_output=True, cwd=tmp_path, text=True
-        )
+        p_status = subprocess.run(cmd_status, capture_output=True, cwd=tmp_path, text=True)
         assert p_status.returncode == 0
         assert "mook_file" not in p_status.stdout
 
@@ -95,9 +89,7 @@ def test_stash_pop(
 
 
 @pytest.mark.parametrize("index_flag", ["", "--index"])
-def test_stash_apply(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path, index_flag
-):
+def test_stash_apply(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path, index_flag):
     assert (tmp_path / "initial.txt").exists()
 
     index = 0 if index_flag == "" else 1
@@ -111,15 +103,11 @@ def test_stash_apply(
         assert p_add.returncode == 0
 
         cmd_stash = [git2cpp_path, "stash"]
-        p_stash = subprocess.run(
-            cmd_stash, capture_output=True, cwd=tmp_path, text=True
-        )
+        p_stash = subprocess.run(cmd_stash, capture_output=True, cwd=tmp_path, text=True)
         assert p_stash.returncode == 0
 
         cmd_status = [git2cpp_path, "status"]
-        p_status = subprocess.run(
-            cmd_status, capture_output=True, cwd=tmp_path, text=True
-        )
+        p_status = subprocess.run(cmd_status, capture_output=True, cwd=tmp_path, text=True)
         assert p_status.returncode == 0
         assert "mook_file" not in p_status.stdout
 
diff --git a/test/test_status.py b/test/test_status.py
index d7a02a0..8030a90 100644
--- a/test/test_status.py
+++ b/test/test_status.py
@@ -7,9 +7,7 @@
 
 @pytest.mark.parametrize("short_flag", ["", "-s", "--short"])
 @pytest.mark.parametrize("long_flag", ["", "--long"])
-def test_status_new_file(
-    repo_init_with_commit, git2cpp_path, tmp_path, short_flag, long_flag
-):
+def test_status_new_file(repo_init_with_commit, git2cpp_path, tmp_path, short_flag, long_flag):
     assert (tmp_path / "initial.txt").exists()
 
     p = tmp_path / "mook_file.txt"  # Untracked files
@@ -21,9 +19,7 @@ def test_status_new_file(
     deletable = tmp_path / "to_delete.txt"
     deletable.write_text("delete me")
     subprocess.run([git2cpp_path, "add", "to_delete.txt"], cwd=tmp_path, check=True)
-    subprocess.run(
-        [git2cpp_path, "commit", "-m", "Add deletable"], cwd=tmp_path, check=True
-    )
+    subprocess.run([git2cpp_path, "commit", "-m", "Add deletable"], cwd=tmp_path, check=True)
     os.remove(deletable)  # Changes not staged for commit / deleted
 
     cmd = [git2cpp_path, "status"]
@@ -55,9 +51,7 @@ def test_status_nogit(git2cpp_path, tmp_path):
 
 @pytest.mark.parametrize("short_flag", ["", "-s", "--short"])
 @pytest.mark.parametrize("long_flag", ["", "--long"])
-def test_status_add_file(
-    repo_init_with_commit, git2cpp_path, tmp_path, short_flag, long_flag
-):
+def test_status_add_file(repo_init_with_commit, git2cpp_path, tmp_path, short_flag, long_flag):
     assert (tmp_path / "initial.txt").exists()
 
     p = tmp_path / "mook_file.txt"  # Changes to be committed / new file
@@ -118,9 +112,7 @@ def test_status_clean_tree(repo_init_with_commit, git2cpp_path, tmp_path):
 
 
 @pytest.mark.parametrize("short_flag", ["", "-s"])
-def test_status_rename_detection(
-    repo_init_with_commit, git2cpp_path, tmp_path, short_flag
-):
+def test_status_rename_detection(repo_init_with_commit, git2cpp_path, tmp_path, short_flag):
     """Test that renamed files are detected correctly"""
     assert (tmp_path / "initial.txt").exists()
 
@@ -128,9 +120,7 @@ def test_status_rename_detection(
     new_file = tmp_path / "other_file.txt"
     new_file.write_text("Another file")
     subprocess.run([git2cpp_path, "add", "other_file.txt"], cwd=tmp_path, check=True)
-    subprocess.run(
-        [git2cpp_path, "commit", "-m", "Add file to rename"], cwd=tmp_path, check=True
-    )
+    subprocess.run([git2cpp_path, "commit", "-m", "Add file to rename"], cwd=tmp_path, check=True)
 
     # Rename a file by moving and staging
     # Move the initial file
@@ -163,9 +153,7 @@ def test_status_rename_detection(
 
 
 @pytest.mark.parametrize("short_flag", ["", "-s"])
-def test_status_mixed_changes(
-    repo_init_with_commit, git2cpp_path, tmp_path, short_flag
-):
+def test_status_mixed_changes(repo_init_with_commit, git2cpp_path, tmp_path, short_flag):
     """Test status with both staged and unstaged changes"""
     assert (tmp_path / "initial.txt").exists()
 
@@ -177,15 +165,11 @@ def test_status_mixed_changes(
     del_file = tmp_path / "to_delete.txt"
     del_file.write_text("delete me")
     subprocess.run([git2cpp_path, "add", "to_delete.txt"], cwd=tmp_path, check=True)
-    subprocess.run(
-        [git2cpp_path, "commit", "-m", "Add deletable"], cwd=tmp_path, check=True
-    )
+    subprocess.run([git2cpp_path, "commit", "-m", "Add deletable"], cwd=tmp_path, check=True)
     os.remove(del_file)
 
     # Stage the two previous files
-    subprocess.run(
-        [git2cpp_path, "add", "staged.txt", "to_delete.txt"], cwd=tmp_path, check=True
-    )
+    subprocess.run([git2cpp_path, "add", "staged.txt", "to_delete.txt"], cwd=tmp_path, check=True)
 
     # Modify an existing file without staging
     unstaged_file = tmp_path / "initial.txt"
@@ -225,9 +209,7 @@ def test_status_typechange(repo_init_with_commit, git2cpp_path, tmp_path, short_
     test_file = tmp_path / "typechange"
     test_file.write_text("regular file")
     subprocess.run([git2cpp_path, "add", "typechange"], cwd=tmp_path, check=True)
-    subprocess.run(
-        [git2cpp_path, "commit", "-m", "Add typechange"], cwd=tmp_path, check=True
-    )
+    subprocess.run([git2cpp_path, "commit", "-m", "Add typechange"], cwd=tmp_path, check=True)
     os.remove(test_file)
     os.symlink("initial.txt", test_file)
 
@@ -245,9 +227,7 @@ def test_status_typechange(repo_init_with_commit, git2cpp_path, tmp_path, short_
 
 
 @pytest.mark.parametrize("short_flag", ["", "-s"])
-def test_status_untracked_directory(
-    repo_init_with_commit, git2cpp_path, tmp_path, short_flag
-):
+def test_status_untracked_directory(repo_init_with_commit, git2cpp_path, tmp_path, short_flag):
     """Test that untracked directories are shown with trailing slash"""
     assert (tmp_path / "initial.txt").exists()
 
@@ -274,9 +254,7 @@ def test_status_untracked_directory(
 
 
 @pytest.mark.parametrize("short_flag", ["", "-s"])
-def test_status_ahead_of_upstream(
-    commit_env_config, git2cpp_path, tmp_path, short_flag
-):
+def test_status_ahead_of_upstream(commit_env_config, git2cpp_path, tmp_path, short_flag):
     """Test status when local branch is ahead of upstream"""
     # Create a repository with remote tracking
     repo_path = tmp_path / "repo"
@@ -299,9 +277,7 @@ def test_status_ahead_of_upstream(
     clone_file = clone_path / "file2.txt"
     clone_file.write_text("new file")
     subprocess.run([git2cpp_path, "add", "file2.txt"], cwd=clone_path, check=True)
-    subprocess.run(
-        [git2cpp_path, "commit", "-m", "second commit"], cwd=clone_path, check=True
-    )
+    subprocess.run([git2cpp_path, "commit", "-m", "second commit"], cwd=clone_path, check=True)
 
     # Check status
     cmd_status = [git2cpp_path, "status"]
diff --git a/test/test_tag.py b/test/test_tag.py
index bcb1c30..d02caf5 100644
--- a/test/test_tag.py
+++ b/test/test_tag.py
@@ -13,9 +13,7 @@ def test_tag_list_empty(repo_init_with_commit, git2cpp_path, tmp_path):
     assert p.stdout == ""
 
 
-def test_tag_create_lightweight(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
-):
+def test_tag_create_lightweight(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
     """Test creating a lightweight tag."""
     assert (tmp_path / "initial.txt").exists()
 
@@ -30,9 +28,7 @@ def test_tag_create_lightweight(
     assert "v1.0.0" in p_list.stdout
 
 
-def test_tag_create_annotated(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
-):
+def test_tag_create_annotated(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
     """Test creating an annotated tag."""
     assert (tmp_path / "initial.txt").exists()
 
@@ -56,9 +52,7 @@ def test_tag_create_on_specific_commit(
 
     # Get the commit SHA before creating new commit
     old_head_cmd = [git2cpp_path, "rev-parse", "HEAD"]
-    p_old_head = subprocess.run(
-        old_head_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_old_head = subprocess.run(old_head_cmd, capture_output=True, cwd=tmp_path, text=True)
     old_head_sha = p_old_head.stdout.strip()
 
     # Create a commit first
@@ -73,9 +67,7 @@ def test_tag_create_on_specific_commit(
 
     # Get new HEAD commit SHA
     new_head_cmd = [git2cpp_path, "rev-parse", "HEAD"]
-    p_new_head = subprocess.run(
-        new_head_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_new_head = subprocess.run(new_head_cmd, capture_output=True, cwd=tmp_path, text=True)
     new_head_sha = p_new_head.stdout.strip()
 
     # Verify we actually created a new commit
@@ -93,9 +85,7 @@ def test_tag_create_on_specific_commit(
 
     # Get commit SHA that the tag points to
     tag_sha_cmd = [git2cpp_path, "rev-parse", "v1.0.0^{commit}"]
-    p_tag_sha = subprocess.run(
-        tag_sha_cmd, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_tag_sha = subprocess.run(tag_sha_cmd, capture_output=True, cwd=tmp_path, text=True)
     tag_sha = p_tag_sha.stdout.strip()
 
     # Verify tag points to new HEAD, not old HEAD
@@ -136,9 +126,7 @@ def test_tag_delete_nonexistent(repo_init_with_commit, git2cpp_path, tmp_path):
 
 
 @pytest.mark.parametrize("list_flag", ["", "-l", "--list"])
-def test_tag_list(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path, list_flag
-):
+def test_tag_list(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path, list_flag):
     """Test listing tags with -l or --list flag."""
     assert (tmp_path / "initial.txt").exists()
 
@@ -153,9 +141,7 @@ def test_tag_list(
     assert "v1.0.0" in p_list.stdout
 
 
-def test_tag_list_with_pattern(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
-):
+def test_tag_list_with_pattern(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
     """Test listing tags with a pattern."""
     assert (tmp_path / "initial.txt").exists()
 
@@ -215,9 +201,7 @@ def test_tag_force_replace(
 
     # Create initial tag
     create_cmd_1 = [git2cpp_path, "tag", "v1.0.0"]
-    subprocess.run(
-        create_cmd_1, capture_output=True, cwd=tmp_path, text=True, check=True
-    )
+    subprocess.run(create_cmd_1, capture_output=True, cwd=tmp_path, text=True, check=True)
 
     # Try to create same tag without force (should fail)
     create_cmd_2 = [git2cpp_path, "tag", "v1.0.0"]
@@ -226,9 +210,7 @@ def test_tag_force_replace(
 
     # Create same tag with force (should succeed)
     create_cmd_3 = [git2cpp_path, "tag", force_flag, "v1.0.0"]
-    p_create_3 = subprocess.run(
-        create_cmd_3, capture_output=True, cwd=tmp_path, text=True
-    )
+    p_create_3 = subprocess.run(create_cmd_3, capture_output=True, cwd=tmp_path, text=True)
     assert p_create_3.returncode == 0
 
 
@@ -239,9 +221,7 @@ def test_tag_nogit(git2cpp_path, tmp_path):
     assert p.returncode != 0
 
 
-def test_tag_annotated_no_message(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
-):
+def test_tag_annotated_no_message(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
     """Test creating an annotated tag without a message should fail."""
     assert (tmp_path / "initial.txt").exists()
 
@@ -290,9 +270,7 @@ def test_tag_multiple_create_and_list(
         assert tag in p_list.stdout
 
 
-def test_tag_on_new_commit(
-    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
-):
+def test_tag_on_new_commit(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
     """Test creating tags on new commits."""
     assert (tmp_path / "initial.txt").exists()
 
diff --git a/wasm/recipe/modify-recipe.py b/wasm/recipe/modify-recipe.py
index 5cd105d..9f85be1 100644
--- a/wasm/recipe/modify-recipe.py
+++ b/wasm/recipe/modify-recipe.py
@@ -8,20 +8,20 @@
 
 
 parser = argparse.ArgumentParser()
-parser.add_argument('input_directory', type=Path)
-parser.add_argument('--no-patches', action='store_true')
+parser.add_argument("input_directory", type=Path)
+parser.add_argument("--no-patches", action="store_true")
 args = parser.parse_args()
 
 input_dir = args.input_directory
 if not input_dir.is_dir():
-    quit(f'{input_dir} should exist and be a directory')
+    quit(f"{input_dir} should exist and be a directory")
 
-input_filename = input_dir / 'recipe.yaml'
+input_filename = input_dir / "recipe.yaml"
 if not input_filename.is_file():
-    quit(f'{input_filename} should exist and be a file')
+    quit(f"{input_filename} should exist and be a file")
 
 # If backup does not exist create it.
-input_backup = input_dir / 'recipe_original.yaml'
+input_backup = input_dir / "recipe_original.yaml"
 backup_exists = input_backup.exists()
 if not backup_exists:
     shutil.copy(input_filename, input_backup)
@@ -30,22 +30,22 @@
 with open(input_backup) as f:
     recipe = yaml.safe_load(f)
 
-build_number = recipe['build']['number']
-print(f'  Changing build number from {build_number} to {build_number+1}')
-recipe['build']['number'] = build_number+1
+build_number = recipe["build"]["number"]
+print(f"  Changing build number from {build_number} to {build_number + 1}")
+recipe["build"]["number"] = build_number + 1
 
-source = recipe['source']
-if not ('sha256' in source and 'url' in source):
-    raise RuntimeError('Expected recipe to have both a source sha256 and url')
-del source['sha256']
-del source['url']
-print('  Changing source to point to local git2cpp repo')
-source['path'] = '../../../../../../'
+source = recipe["source"]
+if not ("sha256" in source and "url" in source):
+    raise RuntimeError("Expected recipe to have both a source sha256 and url")
+del source["sha256"]
+del source["url"]
+print("  Changing source to point to local git2cpp repo")
+source["path"] = "../../../../../../"
 
 if args.no_patches:
-    print('  Deleting patches')
-    del source['patches']
+    print("  Deleting patches")
+    del source["patches"]
 
 # Overwrite recipe file.
-with open(input_filename, 'w') as f:
+with open(input_filename, "w") as f:
     yaml.dump(recipe, f)
diff --git a/wasm/wasm-environment.yml b/wasm/wasm-environment.yml
index a28c4dc..f2cf5b0 100644
--- a/wasm/wasm-environment.yml
+++ b/wasm/wasm-environment.yml
@@ -3,6 +3,7 @@ name: git2cpp-wasm
 channels:
   - conda-forge
 dependencies:
+  - pre-commit
   # To modify emscripten-forge recipe
   - python
   - pyyaml