diff --git a/src/subcommand/clone_subcommand.cpp b/src/subcommand/clone_subcommand.cpp
index d660ae1..acc6f14 100644
--- a/src/subcommand/clone_subcommand.cpp
+++ b/src/subcommand/clone_subcommand.cpp
@@ -21,6 +21,20 @@ clone_subcommand::clone_subcommand(const libgit2_object&, CLI::App& app)
 
 void clone_subcommand::run()
 {
+    // m_depth = 0 means no shallow clone in libgit2, while
+    // it is forbidden with git. Therefore we use another
+    // sentinel value to detect full clone.
+    if (m_depth == 0)
+    {
+        std::cout << "fatal: depth 0 is not a positive number" << std::endl;
+        return;
+    }
+
+    if (m_depth == std::numeric_limits<size_t>::max())
+    {
+        m_depth = 0;
+    }
+
     git_indexer_progress pd;
     git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT;
     git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
@@ -34,8 +48,6 @@ void clone_subcommand::run()
     clone_opts.fetch_opts.depth = m_depth;
     clone_opts.bare = m_bare ? 1 : 0;
 
-
-
     std::string short_name = m_directory;
     if (m_directory.empty())
     {
diff --git a/src/subcommand/clone_subcommand.hpp b/src/subcommand/clone_subcommand.hpp
index 76e6074..ab61461 100644
--- a/src/subcommand/clone_subcommand.hpp
+++ b/src/subcommand/clone_subcommand.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <CLI/CLI.hpp>
+#include <limits>
 
 #include "../utils/common.hpp"
 
@@ -16,7 +17,7 @@ class clone_subcommand
     std::string m_repository = {};
     std::string m_directory = {};
     bool m_bare = false;
-    size_t m_depth = 0;
+    size_t m_depth = std::numeric_limits<size_t>::max();
     // std::string m_shallow_since;
     // std::vector<std::string> m_shallow_exclude;
 };
diff --git a/src/subcommand/fetch_subcommand.cpp b/src/subcommand/fetch_subcommand.cpp
index b5e26c6..0662970 100644
--- a/src/subcommand/fetch_subcommand.cpp
+++ b/src/subcommand/fetch_subcommand.cpp
@@ -14,7 +14,7 @@ fetch_subcommand::fetch_subcommand(const libgit2_object&, CLI::App& app)
     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("--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_flag("--unshallow", m_unshallow, "convert to a complete repository");
@@ -45,6 +45,11 @@ void fetch_subcommand::run()
         {
             fetch_opts.depth = GIT_FETCH_DEPTH_UNSHALLOW;
         }
+        else if (m_deepen > 0)
+        {
+            size_t shallow_size = repo.shallow_depth_from_head();
+            fetch_opts.depth = shallow_size + m_deepen;
+        }
         else
         {
             fetch_opts.depth = m_depth;
diff --git a/src/subcommand/fetch_subcommand.hpp b/src/subcommand/fetch_subcommand.hpp
index 2088eb6..41bc069 100644
--- a/src/subcommand/fetch_subcommand.hpp
+++ b/src/subcommand/fetch_subcommand.hpp
@@ -16,7 +16,7 @@ class fetch_subcommand
 
     std::string m_remote_name;
     size_t m_depth = 0;
-    // size_t m_deepen = 0;
+    size_t m_deepen = 0;
     // std::string m_shallow_since;
     // std::string m_shallow_exclude;
     bool m_unshallow = false;
diff --git a/src/wrapper/commit_wrapper.cpp b/src/wrapper/commit_wrapper.cpp
index a5996fc..92f57df 100644
--- a/src/wrapper/commit_wrapper.cpp
+++ b/src/wrapper/commit_wrapper.cpp
@@ -26,3 +26,18 @@ std::string commit_wrapper::commit_oid_tostr() const
     char buf[GIT_OID_SHA1_HEXSIZE + 1];
     return git_oid_tostr(buf, sizeof(buf), &this->oid());
 }
+
+commit_list_wrapper commit_wrapper::get_parents_list() const
+{
+    size_t parent_count = git_commit_parentcount(*this);
+    std::vector<commit_wrapper> parents_list;
+    parents_list.reserve(parent_count);
+
+    for (size_t i=0; i < parent_count; ++i)
+    {
+        git_commit* parent;
+        git_commit_parent(&parent, *this, i);
+        parents_list.push_back(commit_wrapper(parent));
+    }
+    return commit_list_wrapper(std::move(parents_list));
+}
diff --git a/src/wrapper/commit_wrapper.hpp b/src/wrapper/commit_wrapper.hpp
index 1327beb..84b35d1 100644
--- a/src/wrapper/commit_wrapper.hpp
+++ b/src/wrapper/commit_wrapper.hpp
@@ -1,11 +1,13 @@
 #pragma once
 
 #include <git2.h>
-#include <vector>
 #include <string>
 
 #include "../wrapper/wrapper_base.hpp"
 
+class commit_wrapper;
+using commit_list_wrapper = list_wrapper<commit_wrapper>;
+
 class commit_wrapper : public wrapper_base<git_commit>
 {
 public:
@@ -22,6 +24,8 @@ class commit_wrapper : public wrapper_base<git_commit>
     const git_oid& oid() const;
     std::string commit_oid_tostr() const;
 
+    commit_list_wrapper get_parents_list() const;
+
 private:
 
     commit_wrapper(git_commit* commit);
@@ -29,5 +33,3 @@ class commit_wrapper : public wrapper_base<git_commit>
     friend class repository_wrapper;
     friend class reference_wrapper;
 };
-
-using commit_list_wrapper = list_wrapper<commit_wrapper>;
diff --git a/src/wrapper/repository_wrapper.cpp b/src/wrapper/repository_wrapper.cpp
index c945800..e7b2413 100644
--- a/src/wrapper/repository_wrapper.cpp
+++ b/src/wrapper/repository_wrapper.cpp
@@ -1,5 +1,12 @@
+#include <algorithm>
+#include <fstream>
 #include <iostream>
 
+#include "../utils/git_exception.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"
 
 repository_wrapper::~repository_wrapper()
@@ -29,6 +36,11 @@ repository_wrapper repository_wrapper::clone(std::string_view url, std::string_v
     return rw;
 }
 
+std::string repository_wrapper::git_path() const
+{
+    return git_repository_path(*this);
+}
+
 git_repository_state_t repository_wrapper::state() const
 {
     return git_repository_state_t(git_repository_state(*this));
@@ -271,6 +283,79 @@ void repository_wrapper::reset(const object_wrapper& target, git_reset_t reset_t
     throw_if_error(git_reset(*this, target, reset_type, &checkout_options));
 }
 
+size_t repository_wrapper::shallow_depth_from_head() const
+{
+    if (!this->is_shallow())
+    {
+        return 0u;
+    }
+
+    std::string git_path = this->git_path();
+    std::string shallow_path = git_path + "shallow";
+
+    std::vector<git_oid> boundaries_list;
+    std::ifstream f(shallow_path);
+    std::string line;
+    while (std::getline(f, line))
+    {
+        if (!line.empty())
+        {
+            git_oid commit_oid;
+            git_oid_fromstrp(&commit_oid, line.c_str());
+            boundaries_list.push_back(commit_oid);
+        }
+    }
+
+    if (boundaries_list.size() == 0u)
+    {
+        return 0u;
+    }
+
+    commit_wrapper head_commit = this->find_commit("HEAD");
+    commit_list_wrapper commits_list = head_commit.get_parents_list();
+    std::vector<size_t> depth_list(commits_list.size(), 1u);
+    std::vector<size_t> final_depths(boundaries_list.size(), 1u);
+    bool has_parent = commits_list.size() > 0u;
+    while (has_parent)
+    {
+        has_parent = false;
+        std::vector<commit_wrapper> temp_commits_list;
+        std::vector<size_t> temp_depth_list;
+        commit_list_wrapper parent_list({});
+
+        for (size_t i = 0u; i < commits_list.size(); i++)
+        {
+            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();
+            if (is_boundary)
+            {
+                final_depths.push_back(depth + 1u);
+            }
+            else
+            {
+                parent_list = commit.get_parents_list();
+                if (parent_list.size() > 0u)
+                {
+                    has_parent = true;
+                    for (size_t j = 0u; parent_list.size(); j++)
+                    {
+                        const commit_wrapper& c = parent_list[j];
+                        temp_commits_list.push_back(std::move(const_cast<commit_wrapper&>(c)));
+                        temp_depth_list.push_back(depth + 1u);
+                    }
+                }
+            }
+        }
+        depth_list = temp_depth_list;
+        commits_list = commit_list_wrapper(std::move(temp_commits_list));
+    }
+
+    std::size_t depth = *std::max_element(final_depths.begin(), final_depths.end());
+    return depth;
+}
+
 // Trees
 
 void repository_wrapper::checkout_tree(const object_wrapper& target, const git_checkout_options opts)
diff --git a/src/wrapper/repository_wrapper.hpp b/src/wrapper/repository_wrapper.hpp
index 74e5eaa..2751194 100644
--- a/src/wrapper/repository_wrapper.hpp
+++ b/src/wrapper/repository_wrapper.hpp
@@ -31,6 +31,7 @@ class repository_wrapper : public wrapper_base<git_repository>
     static repository_wrapper open(std::string_view directory);
     static repository_wrapper clone(std::string_view url, std::string_view path, const git_clone_options& opts);
 
+    std::string git_path() const;
     git_repository_state_t state() const;
     void state_cleanup();
 
@@ -81,6 +82,9 @@ class repository_wrapper : public wrapper_base<git_repository>
     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);
 
+    // TODO: check if it's the right place to put the following
+    size_t shallow_depth_from_head() const;
+
     // Trees
     void checkout_tree(const object_wrapper& target, const git_checkout_options opts);
 
diff --git a/test/test_remote.py b/test/test_remote.py
index 6b302fb..e66cee0 100644
--- a/test/test_remote.py
+++ b/test/test_remote.py
@@ -300,7 +300,7 @@ def test_fetch_from_remote(git2cpp_path, repo_with_remote):
     local_path, remote_path = repo_with_remote
 
     # Note: This is a bare repo with no refs, so fetch will fail gracefully
-    # For now, just test that fetch command runs (it will fail gracefully if no refs)
+    # For now, just test that  /stdofetch command runs (it will fail gracefully if no refs)
     cmd = [git2cpp_path, "fetch", "origin"]
     p = subprocess.run(cmd, capture_output=True, text=True, cwd=local_path)
     # Fetch might succeed (empty) or fail (no refs), but shouldn't crash
@@ -319,6 +319,12 @@ def test_fetch_default_origin(git2cpp_path, repo_with_remote):
 
 def test_fetch_depth(git2cpp_path, tmp_path, run_in_tmp_path):
     url = "https://github.com/xtensor-stack/xtl.git"
+
+    invalid_clone_cmd = [git2cpp_path, "clone", "--depth", "0", url]
+    p_invalid_clone = subprocess.run(invalid_clone_cmd, capture_output=True, cwd=tmp_path, text=True)
+    assert p_invalid_clone.returncode == 0
+    assert p_invalid_clone.stdout.startswith(b"fatal: depth 0 is not a positive number")
+
     clone_cmd = [git2cpp_path, "clone", "--depth", "1", url]
     p_clone = subprocess.run(clone_cmd, capture_output=True, cwd=tmp_path, text=True)
     assert p_clone.returncode == 0
@@ -365,6 +371,29 @@ def test_unshallow(git2cpp_path, tmp_path, run_in_tmp_path):
     assert p_log_2.stdout.count("Author") > 1
 
 
+def test_fetch_deepen(git2cpp_path, tmp_path, run_in_tmp_path):
+    url = "https://github.com/xtensor-stack/xtl.git"
+    clone_cmd = [git2cpp_path, "clone", "--depth", "1", url]
+    p_clone = subprocess.run(clone_cmd, capture_output=True, cwd=tmp_path, text=True)
+    assert p_clone.returncode == 0
+    assert (tmp_path / "xtl").exists()
+
+    xtl_path = tmp_path / "xtl"
+
+    cmd_log = [git2cpp_path, "log"]
+    p_log = subprocess.run(cmd_log, capture_output=True, cwd=xtl_path, text=True)
+    assert p_log.returncode == 0
+    assert p_log.stdout.count("Author") == 1
+
+    deepen_cmd = [git2cpp_path, "fetch", "--deepen", "2"]
+    p_deepen = subprocess.run(deepen_cmd, capture_output=True, cwd=xtl_path, text=True)
+    assert p_deepen.returncode == 0
+
+    p_log_2 = subprocess.run(cmd_log, capture_output=True, cwd=xtl_path, text=True)
+    assert p_log_2.returncode == 0
+    assert p_log_2.stdout.count("Author") > 1
+
+
 def test_remote_in_cloned_repo(xtl_clone, git2cpp_path, tmp_path):
     """Test that cloned repos have remotes configured."""
     assert (tmp_path / "xtl").exists()